0)\\n\\n np.testing.assert_almost_equal(\\n sum_wgt[idx_not_nans], \\n np.ones(idx_not_nans.sum().values)\\n )\\n\\n nontime_vars = set([v for v in ds.variables if 'time' not in ds[v].dims]) - set(ds.coords)\\n dsop = ds.drop_vars(nontime_vars)\\n\\n if time_bnds_varname is not None:\\n dsop = dsop.drop_vars(time_bnds_varname) \\n \\n def weighted_mean_arr(darr, wgts=None):\\n # if NaN are present, we need to use individual weights\\n cond = darr.isnull()\\n ones = xr.where(cond, 0.0, 1.0)\\n if season is None:\\n mask = (\\n darr.resample({'time': 'A'}, restore_coord_dims=False).mean(dim='time').notnull()\\n )\\n da_sum = (\\n (darr * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n ones_out = (\\n (ones * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n count = (\\n (ones * wgts.notnull()).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n else:\\n mask = (\\n darr.groupby(group_by_year, restore_coord_dims=False).mean(dim='time').notnull()\\n ).rename(rename)\\n \\n da_sum = (\\n (darr * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n ones_out = (\\n (ones * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n count = (\\n (ones * wgts.notnull()).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n\\n ones_out = ones_out.where(ones_out > 0.0)\\n da_weighted_mean = da_sum / ones_out\\n\\n return da_weighted_mean.where(mask).where(count >= n_req) \\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n ds_ann = dsop.map(weighted_mean_arr, wgts=time_wgt)\\n\\n # copy attrs\\n for v in ds_ann:\\n ds_ann[v].attrs = ds[v].attrs\\n\\n # restore coords\\n ds_ann = xr.merge((ds_ann, ds[list(nontime_vars)]))\\n\\n # eliminate partials\\n ndx = (time_wgt_grouped.count(dim=xr.ALL_DIMS) >= n_req).values\\n if not ndx.all():\\n ds_ann = ds_ann.isel(time=ndx)\\n\\n return ds_ann\",\n \"def by_season(self, season):\\n return self.get_queryset().filter(season=season)\",\n \"def compute_stage4(lon, lat, year):\\n nc = netCDF4.Dataset(\\\"/mesonet/data/stage4/%s_stage4_hourly.nc\\\" % (year,))\\n lons = nc.variables[\\\"lon\\\"][:]\\n lats = nc.variables[\\\"lat\\\"][:]\\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\\n (yidx, xidx) = np.unravel_index(dist.argmin(), dist.shape)\\n print(\\n (\\\"Computed stage4 nclon:%.2f nclat:%.2f yidx:%s xidx:%s \\\")\\n % (lons[yidx, xidx], lats[yidx, xidx], yidx, xidx)\\n )\\n p01i = mm2inch(nc.variables[\\\"p01m\\\"][:, yidx, xidx])\\n nc.close()\\n df = pd.DataFrame(\\n {\\\"precip\\\": 0.0},\\n index=pd.date_range(\\n \\\"%s-01-01\\\" % (year,), \\\"%s-12-31\\\" % (year,), tz=\\\"America/Chicago\\\"\\n ),\\n )\\n for date in df.index.values:\\n date2 = datetime.datetime.utcfromtimestamp(date.tolist() / 1e9)\\n ts = datetime.datetime(date2.year, date2.month, date2.day, 6)\\n ts = ts.replace(tzinfo=pytz.utc)\\n ts = ts.astimezone(pytz.timezone(\\\"America/Chicago\\\"))\\n ts = ts.replace(hour=0)\\n ts = ts.astimezone(pytz.utc)\\n tidx = hourly_offset(ts)\\n # values are in the rears\\n val = np.ma.sum(p01i[tidx + 1 : tidx + 25])\\n if val > 0:\\n df.at[date, \\\"precip\\\"] = val # close enough\\n return df\",\n \"def test_time_only_conversion_disagg(self, months, seasons):\\n adaptor = IntervalAdaptor(\\\"test-season-month\\\")\\n from_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"seasons\\\"],\\n coords={\\\"seasons\\\": seasons},\\n )\\n adaptor.add_input(from_spec)\\n to_spec = Spec(\\n name=\\\"test-var\\\", dtype=\\\"float\\\", dims=[\\\"months\\\"], coords={\\\"months\\\": months}\\n )\\n adaptor.add_output(to_spec)\\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\\n\\n data = np.array([3, 3, 3, 3])\\n data_array = DataArray(from_spec, data)\\n data_handle = Mock()\\n data_handle.get_data = Mock(return_value=data_array)\\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\\n\\n adaptor.simulate(data_handle)\\n actual = data_handle.set_results.call_args[0][1]\\n expected = np.array(\\n [\\n 1.033333,\\n 0.933333,\\n 1.01087,\\n 0.978261,\\n 1.01087,\\n 0.978261,\\n 1.01087,\\n 1.01087,\\n 0.989011,\\n 1.021978,\\n 0.989011,\\n 1.033333,\\n ]\\n )\\n np.testing.assert_allclose(actual, expected, rtol=1e-3)\",\n \"def add_LonghurstProvince2NetCDF(ds=None, res='4x5', LatVar='lat', LonVar='lon',\\n CoordVar='Province', ExStr=''):\\n # Get xml data for provinces\\n provinces, tree = ParseLonghurstProvinceFile()\\n # Just use 4x5 as an example\\n if isinstance(ds, type(None)):\\n ds = utils.get_feature_variables_as_ds(res=res)\\n # get dictionary of province numbers\\n Rnum2prov = RosieLonghurstProvinceFileNum2Province(\\n None, invert=True, rtn_dict=True)\\n # Get latitudes\\n DSlats = ds[LatVar].values\\n # Get longitudes\\n DSlons = ds[LonVar].values\\n # Get all lats and make a long form of the coords.\\n lats = []\\n lons = []\\n coords = []\\n for lat in DSlats:\\n for lon in DSlons:\\n lats += [lat]\\n lons += [lon]\\n # Make into a DataFrame\\n df = pd.DataFrame()\\n df[LatVar] = lats\\n df[LonVar] = lons\\n # Add a single variable for the coordinate\\n\\n def f(x):\\n return (x[LonVar], x[LatVar])\\n df[CoordVar] = df.apply(f, axis=1)\\n # map the calculation of provinces\\n\\n def GetProv(x):\\n return Get_LonghurstProvince4coord(x[CoordVar], provinces=provinces,\\n num2prov=Rnum2prov, tree=tree, verbose=False)\\n df[CoordVar] = df.apply(GetProv, axis=1)\\n # Construct DataFrame by unstacking\\n lat = df[LatVar].values\\n lon = df[LonVar].values\\n vals = df[CoordVar].values\\n df = pd.DataFrame(vals, index=[lat, lon]).unstack()\\n df.to_csv('Intial_test_{}_processed_{}.csv'.format(res, ExStr))\\n # Convert to Dataset\\n ds = xr.Dataset(data_vars={CoordVar: (['lat', 'lon', ], df.values)},\\n coords={'lat': DSlats, 'lon': DSlons, })\\n\\n # Save as NetCDF file\\n ds.to_netcdf('Intial_test_{}_netCDF_{}.nc'.format(res, ExStr))\",\n \"def Seasons(year):\\n mar_equinox = _FindSeasonChange(0, year, 3, 19)\\n jun_solstice = _FindSeasonChange(90, year, 6, 19)\\n sep_equinox = _FindSeasonChange(180, year, 9, 21)\\n dec_solstice = _FindSeasonChange(270, year, 12, 20)\\n return SeasonInfo(mar_equinox, jun_solstice, sep_equinox, dec_solstice)\",\n \"def get_dryspells_perseason(dryspells, seasons=((12, 1, 2), (3, 4, 5),\\n (6, 7, 8), (9, 10, 11))):\\n dryspells_seasons = []\\n for season in seasons:\\n eveSeas = []\\n for eveLand in dryspells:\\n eves = [e for e in eveLand if e.start_date().month in season]\\n eveSeas.append(eves)\\n dryspells_seasons.append(eveSeas)\\n\\n return dryspells_seasons\",\n \"def season_games(year):\\n\\tLOG.debug('Getting season %d', year)\\n\\tdata = read_html(io=season_games_url(year),\\n\\t\\t\\t\\t\\t attrs={'id': 'games'},\\n\\t\\t\\t\\t\\t infer_types=False,\\n\\t\\t\\t\\t\\t header=0)\\n\\tif len(data) != 1:\\n\\t\\traise CantFindTheRightTable\\n\\tdata = data.pop()\\n\\n\\t# Cleaning.\\n\\tdel data[\\\"Unnamed: 3\\\"]\\n\\t# The code below issues \\\"UserWarning: \\\" So we catch UserWarnings.\\n\\twith warnings.catch_warnings():\\n\\t\\twarnings.filterwarnings(action='ignore', category=UserWarning,\\n\\t\\t\\t\\t\\t\\t\\t\\tmodule=r'pandas\\\\.core\\\\.frame',\\n\\t\\t\\t\\t\\t\\t\\t\\tmessage=(r\\\"Boolean Series key will be reindexed\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t r\\\" to match DataFrame index\\\\.\\\"))\\n\\t\\t# These rows are mid-table header rows.\\n\\t\\tdata = data[data.Week != \\\"Week\\\"][data.Week != \\\"nan\\\"]\\n\\n\\tdata['week'] = (data.Week\\n\\t\\t\\t\\t\\t.replace(\\\"WildCard\\\", \\\"wild-card\\\")\\n\\t\\t\\t\\t\\t.replace(\\\"Division\\\", \\\"divisional\\\")\\n\\t\\t\\t\\t\\t.replace(\\\"ConfChamp\\\", \\\"conference\\\")\\n\\t\\t\\t\\t\\t.replace(\\\"SuperBowl\\\", \\\"super-bowl\\\")\\n\\t\\t\\t\\t\\t.apply(\\n\\t\\t\\t\\t\\t\\tlambda s: (int(s)\\n\\t\\t\\t\\t\\t\\t\\t\\t if all(c in '1234567890' for c in s)\\n\\t\\t\\t\\t\\t\\t\\t\\t else s)))\\n\\tdel data['Week']\\n\\n\\tdata['season'] = year\\n\\tdata['game_date'] = pd.to_datetime(\\n\\t\\tdata.Date\\n\\t\\t.replace(r\\\"$\\\", r\\\", %d\\\" % year, regex=True)\\n\\t\\t.replace(r\\\"^(January|February) (\\\\d+), \\\\d+$\\\", r\\\"\\\\1 \\\\2, %d\\\" % (year + 1),\\n\\t\\t\\t\\t regex=True))\\n\\tdel data['Date']\\n\\n\\tfor column in \\\"PtsW\\\", \\\"PtsL\\\", \\\"YdsW\\\", \\\"TOW\\\", \\\"YdsL\\\", \\\"TOL\\\":\\n\\t data[column] = data[column].apply(int)\\n\\n\\tdata['WatL'] = data['Unnamed: 5'].apply(lambda x: x == '@')\\n\\tdel data['Unnamed: 5']\\n\\tdata['hometeam'] = (~data.WatL * data['Winner/tie'] +\\n\\t\\t\\t\\t\\t\\tdata.WatL * data['Loser/tie'])\\n\\tdata['awayteam'] = (data.WatL * data['Winner/tie'] +\\n\\t\\t\\t\\t\\t\\t~data.WatL * data['Loser/tie'])\\n\\tdata['winner'] = data['Winner/tie']\\n\\tfor column in 'Winner/tie', 'Loser/tie', \\\"WatL\\\":\\n\\t\\tdel data[column]\\n\\tfor column in 'hometeam', 'awayteam', 'winner':\\n\\t\\tdata[column] = data[column].apply(lambda s: s.split()[-1].lower())\\n\\n\\treturn data\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def get_seasons(seasons):\\n if '-to-' in seasons[0]:\\n from_, to = map(int, seasons[0].split('-to-'))\\n years = list(range(from_, to+1))\\n seasons = []\\n for i in range(0, len(years)-1):\\n season = \\\"-\\\".join(map(str, [years[i], years[i+1]]))\\n seasons.append(season)\\n return seasons\",\n \"def get_pvp_season(self, region, namespace, season_id, **filters):\\n filters['namespace'] = namespace\\n return self.get_resource('data/wow/pvp-season/{0}', region, *[season_id], **filters)\",\n \"def __get_season_data(season_num: int, max_episode: int, training_data: bool) -> List[TrainSample]:\\n season = EXAM_DATA[season_num]\\n drop_players = season.get_drop_mapping(DropType.EXECUTION_DROP, max_episode)\\n all_answers = season.get_all_answers(set(drop_players.keys()), max_episode)\\n season_data = []\\n for answer in all_answers:\\n exam_episode = answer.episode\\n drop_episodes = drop_players[answer.player]\\n drop_episodes = [episode for episode in drop_episodes if exam_episode <= episode]\\n if drop_episodes:\\n if training_data:\\n for player in exam_episode.players:\\n season_data.append(TrainSample(answer.player, season_num, min(drop_episodes), answer.episode,\\n answer.question, answer.answer, player))\\n else:\\n for answer_on in [False, True]:\\n season_data.append(TrainSample(answer.player, season_num, min(drop_episodes), answer.episode,\\n answer.question, answer.answer, answer_on))\\n return season_data\",\n \"def winter_avg(var_nc,lat_slice=None,lon_slice=None): \\n #\\n # accumulate in shape [plev,lat,lon]\\n #\\n # use the whole array if slice objects are missing\\n #\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n print \\\"in winter avg: \\\",lat_slice,lon_slice\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n #\\n # year 0 is special case since it doesn't have a december\\n #\\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\\n accumulate+=the_slice\\n num_years=var_nc.shape[0]//12\\n #\\n # now year 1 has year 0's december\\n #\\n djf=np.array([11,12,13],dtype=np.int32)\\n #\\n # iterate one year less because we've alread\\n # done year zero as a special case\\n #\\n for the_year in np.arange(0,num_years-1):\\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n djf=djf+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def get_schedules_for_season(self, season, season_type=\\\"REG\\\"):\\n try:\\n season = int(season)\\n if season_type not in [\\\"REG\\\", \\\"PRE\\\", \\\"POST\\\"]:\\n raise ValueError\\n except (ValueError, TypeError):\\n raise FantasyDataError('Error: Invalid method parameters')\\n\\n season_param = \\\"{0}{1}\\\".format(season, season_type)\\n result = self._method_call(\\\"Schedules/{season}\\\", season=season_param)\\n return result\",\n \"def change_season(self, season: str) -> dict:\\n\\n # Check if the season exists\\n if season not in [\\\"plant_off\\\", \\\"summer\\\", \\\"winter\\\"]:\\n raise RequestError\\n\\n # Create the requests' parameters\\n param = ('command={'\\n '\\\"sl_appl_msg\\\":{'\\n '\\\"client\\\":\\\"' + self.id + '\\\",'\\n '\\\"cmd_name\\\":\\\"thermo_season_req\\\",'\\n '\\\"cseq\\\":' + str(self._cseq) + ','\\n '\\\"season\\\":\\\"' + season + '\\\"'\\n '},'\\n '\\\"sl_appl_msg_type\\\":\\\"domo\\\",'\\n '\\\"sl_client_id\\\":\\\"' + self.id + '\\\",'\\n '\\\"sl_cmd\\\":\\\"sl_data_req\\\"'\\n '}')\\n \\n # Send the post request\\n response = requests.post(self._host, params=param, headers=self.header)\\n\\n # Increment the cseq counter\\n self._cseq += 1\\n\\n # Check if the response is valid\\n if not response.json()['sl_data_ack_reason'] == 0:\\n raise RequestError\\n\\n # After every action performed we update the list of items\\n self.update_lists()\\n\\n # Return the json of the response\\n return response.json()\",\n \"def get_time_series(this_lat, this_lon, case, varnames):\\n\\n cesmdir = '/gpfs/fs1/collections/cdg/data/cesmLE/CESM-CAM5-BGC-LE/atm/proc/tseries/monthly'\\n\\n if 'LE' in case:\\n\\n from observational_large_ensemble.params import karen_params_cesm\\n\\n mode_lag = karen_params_cesm.mode_lag\\n cvdp_loc = karen_params_cesm.cvdp_loc\\n AMO_cutoff_freq = karen_params_cesm.AMO_cutoff_freq\\n\\n name_conversion = {'tas': 'TREFHT', 'pr': 'PRECC', 'slp': 'PSL'}\\n cesm_names = [name_conversion[v] for v in varnames]\\n this_member = int((case).split('-')[-1])\\n cvdp_file = '%s/CESM1-CAM5-BGC-LE_#%i.cvdp_data.1920-2018.nc' % (cvdp_loc, this_member)\\n\\n # Historical filenames for CESM. Will need to append part of RCP8.5 to get full period\\n filenames = []\\n for var in cesm_names:\\n file_str = '%s/%s/b.e11.B20TRC5CNBDRD.f09_g16.%03d.cam.h0.%s.??????-200512.nc' % (cesmdir, var,\\n this_member, var)\\n this_file = glob(file_str)[0]\\n filenames.append(this_file)\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames,\\n karen_params_cesm.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n else:\\n\\n from observational_large_ensemble.params import karen_params_obs\\n\\n mode_lag = karen_params_obs.mode_lag\\n cvdp_loc = karen_params_obs.cvdp_loc\\n AMO_cutoff_freq = karen_params_obs.AMO_cutoff_freq\\n\\n tas_dir = karen_params_obs.tas_dir\\n pr_dir = karen_params_obs.pr_dir\\n slp_dir = karen_params_obs.slp_dir\\n cvdp_file = '%s/HadISST.cvdp_data.1920-2018.nc' % cvdp_loc\\n file_dict = {'tas': '%s/Complete_TAVG_LatLong1.nc' % tas_dir,\\n 'pr': '%s/full_data_monthly_v2020.nc' % pr_dir,\\n 'slp': '%s/prmsl.mon.mean.nc' % slp_dir}\\n\\n filenames = []\\n for var in varnames:\\n filenames.append(file_dict[var])\\n\\n name_conversion = {'tas': 'temperature', 'pr': 'precip', 'slp': 'prmsl'}\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames[0],\\n karen_params_obs.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n return this_ts, df_shifted\",\n \"def season_rounds(cls, season):\\r\\n\\t\\t\\r\\n\\t\\tfolder_name = cls.season_folder(season)\\r\\n\\t\\tround_list = os.listdir(f'Data/{folder_name}')\\r\\n\\r\\n\\t\\tall_rounds = []\\r\\n\\r\\n\\t\\tfor round_file in round_list:\\r\\n\\t\\t\\twith open(f'Data/{folder_name}/{round_file}', 'r', encoding='utf-8') as f:\\r\\n\\t\\t\\t\\tround_info = f.read().splitlines()\\r\\n\\r\\n\\t\\t\\tround_number = round_file[:-4]\\r\\n\\t\\t\\tfull_round_name = f\\\"{season} R{round_number}\\\"\\r\\n\\r\\n\\t\\t\\tround_date = int(round_info[0])\\r\\n\\t\\t\\tlookup_ind = DATES.month_diff(round_date, DATES.MIN_DATE)\\r\\n\\r\\n\\t\\t\\t# If the round isn't actually counted for TWOW Glicko\\r\\n\\t\\t\\tif full_round_name not in cls.ROUNDS[lookup_ind].keys():\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\r\\n\\t\\t\\tcontestant_count = len(round_info) - 1\\r\\n\\r\\n\\t\\t\\tstrength = cls.ROUNDS[lookup_ind][full_round_name][0]\\r\\n\\r\\n\\t\\t\\tall_rounds.append([\\r\\n\\t\\t\\t\\tround_number,\\r\\n\\t\\t\\t\\tround_date,\\r\\n\\t\\t\\t\\tcontestant_count,\\r\\n\\t\\t\\t\\tstrength\\r\\n\\t\\t\\t])\\r\\n\\t\\t\\r\\n\\t\\treturn all_rounds\",\n \"def convert_coords(date, time_steps, azs, els, obs):\\n coord_start_day = datetime(date.year, date.month, date.day)\\n \\n strategy = []\\n for time_step, az, el in zip(time_steps, azs, els):\\n if az % np.pi == 0.0: \\n az += EPS\\n \\n ra, dec = sphere.altaz_to_ra_dec(coord_start_day + timedelta(hours=time_step), az, el, obs)\\n strategy.append([ra, dec])\\n \\n return np.array(strategy)\",\n \"def is_valid_season(cls, season):\\r\\n\\r\\n\\t\\tseason = season.lower()\\r\\n\\t\\tdataset = cls.all_seasons()\\r\\n\\r\\n\\t\\ttry:\\t# Check in the all_seasons dataset\\r\\n\\t\\t\\tind = [s.lower() for s in dataset].index(season)\\r\\n\\t\\texcept ValueError:\\r\\n\\t\\t\\treturn False\\r\\n\\t\\t\\r\\n\\t\\treturn dataset[ind]\",\n \"def broadcast_lonlat(ds, verbose=True):\\n if 'lon' not in ds.variables:\\n ds.coords['lon'] = ds['x']\\n if 'lat' not in ds.variables:\\n ds.coords['lat'] = ds['y']\\n \\n if len(ds['lon'].dims) < 2:\\n ds.coords[\\\"lon\\\"] = ds[\\\"lon\\\"] * xr.ones_like(ds[\\\"lat\\\"])\\n if len(ds['lat'].dims) < 2:\\n ds.coords[\\\"lat\\\"] = xr.ones_like(ds[\\\"lon\\\"]) * ds[\\\"lat\\\"]\\n return ds\",\n \"def season_type(self, season_type):\\n\\n self._season_type = season_type\",\n \"def get_time_series(self, tile, year, loc, px, py, cols=1, rows=1, step=1, save_dir='txt/'):\\n\\n # keys = ['sza', 'saa', 'vza', 'vaa', 'qa', 'b01', 'b02', 'b03', 'b04', 'b05', 'b06', 'b07']\\n\\n timeBefore = time.clock()\\n\\n f_list = np.array(glob.glob(loc + '%s_%d_*_1km.nc' % (tile, year)))\\n\\n # if there are no files for this year\\n if f_list.shape[0] == 0:\\n print 'Data for year %d and tile %s not found' % (year, tile)\\n return -1\\n\\n # get DOYs from file name\\n doys0 = np.sort([int(s.split('_')[4]) for s in f_list])\\n # print 'doys0', doys0\\n\\n # arrange DOYs according to step. I.e. we assume that...\\n # step = 7\\n doys = np.zeros(doys0.shape).astype(int)\\n doys_real = np.zeros(doys0.shape).astype(int)\\n\\n for jj, ii in enumerate(xrange(0, doys0.shape[0], step)):\\n # doys = np.append(doys, doys0[ii:ii+7])\\n doys[ii:ii+step] = jj + 1#doys0[ii]\\n doys_real[ii:ii+step] = doys0[ii]\\n\\n ind = np.argsort([int(s.split('_')[4]) for s in f_list])\\n f_list = f_list[ind]\\n\\n # print 'loc:', loc\\n # print 'tile:', tile\\n # print 'year:', year\\n # print 'f_list:', f_list[0]\\n\\n output = {}\\n for f in f_list:\\n print 'f:', f\\n try:\\n ds = nc.Dataset(f)\\n except:\\n print 'something wrong with %s' % f\\n continue\\n\\n # if a dataset is empty\\n # i.e. if it has less than 2 bands\\n # i.e. vza, vaa, sza, saa, proj, geo, qa, b1, b2\\n if len(ds.variables.keys()) < 9:\\n print 'Dataset exists but empty:'\\n print 'loc:', loc\\n print 'tile:', tile\\n print 'year:', year\\n print 'f_list:', f_list[0]\\n print ''\\n # return -1\\n else:\\n break\\n if f == f_list[-1]:\\n print 'all datasets are empty'\\n return -1\\n\\n for key in ds.variables.keys():\\n if len(ds.variables[key].shape) == 2:\\n # output[key] = np.zeros((f_list.shape[0], ds.variables[key].shape[0], ds.variables[key].shape[1]))\\n output[key] = np.zeros((f_list.shape[0], cols, rows))\\n if len(ds.variables[key].shape) == 1:\\n output[key] = np.zeros(ds.variables[key].shape[0]).astype(str)\\n\\n for i, fname in enumerate(f_list):\\n #print fname\\n ds = nc.Dataset(fname)\\n for key in ds.variables.keys():\\n if len(ds.variables[key].shape) == 2:\\n\\n try:\\n # print ds.variables[key][px:px+cols, py:py+rows]\\n output[key][i, :, :] = ds.variables[key][px:px+cols, py:py+rows]\\n except:\\n print 'something wrong in output[%s][%d, :, :]' % (key, i)\\n print 'output:', output[key][i, :, :].shape\\n print 'ds.variables:', ds.variables[key][px:px+cols, py:py+rows].shape\\n\\n if len(ds.variables[key].shape) == 1:\\n output[key][:] = ds.variables[key][:]\\n\\n # print 'output.keys:', output.keys()\\n\\n QA_OK = np.array([8, 72, 136, 200, 1288, 2056, 2120, 2184, 2248])\\n qa_passer = np.logical_or.reduce([output['qa'] == x for x in QA_OK])\\n\\n for b in [1,2,3,4,5,7]:\\n\\n qa_passer[output[\\\"b0%d\\\" % b] <= 0] = 0.\\n qa_passer[output[\\\"b0%d\\\" % b] >= 10000] = 0.\\n\\n # if, for this pixel, we have just a few observations we don't need them\\n if np.sum(qa_passer) < 2:\\n qa_passer[:] = 0\\n\\n output['qa_passer'] = qa_passer\\n [bin(b) for b in QA_OK]\\n\\n #doys = np.array([int(g.GetRasterBand(b+1).GetMetadata()['DoY']) for b in xrange(g.RasterCount)])\\n #years = np.array([int(g.GetRasterBand(b + 1).GetMetadata()['Year']) for b in xrange(g.RasterCount)])\\n output['doys'] = doys\\n output['doys_real'] = np.unique(doys_real)\\n output['years'] = np.ones(doys.shape) * year\\n\\n output[\\\"sza\\\"] = output[\\\"sza\\\"] / 100.\\n output[\\\"saa\\\"] = output[\\\"saa\\\"] / 100.\\n output[\\\"vza\\\"] = output[\\\"vza\\\"] / 100.\\n output[\\\"vaa\\\"] = output[\\\"vaa\\\"] / 100.\\n output['b01'] = output['b01'] / 10000.\\n output['b02'] = output['b02'] / 10000.\\n output['b03'] = output['b03'] / 10000.\\n output['b04'] = output['b04'] / 10000.\\n output['b05'] = output['b05'] / 10000.\\n output['b06'] = output['b06'] / 10000.\\n output['b07'] = output['b07'] / 10000.\\n\\n # print 'qa_passer:', output['qa_passer']\\n #print output['b01']\\n\\n #pkl.dump(output, open(f_out, 'wb'))\\n\\n timeAfter = time.clock()\\n elapsed_time = timeAfter - timeBefore\\n print 'read time series time (s): ', elapsed_time\\n\\n print 'Read MODIS for year %d data is done' % year\\n return output\",\n \"def equinox(year, season):\\r\\n estimate = estimateEquinox(year, season) # Initial estimate of date of event\\r\\n t = (estimate - 2451545.0) / 36525\\r\\n w = 35999.373 * t - 2.47\\r\\n dL = 1 + 0.0334 * cosFromDeg(w) + 0.0007 * cosFromDeg(2 * w)\\r\\n s = periodic24(t)\\r\\n julianEmphemerisDays = estimate + ((0.00001 * s) / dL)\\r\\n tdt = fromJDtoUtc(julianEmphemerisDays)\\r\\n return fromTdTtoUtc(tdt)\",\n \"def get_seasons_information():\\n\\n #getting the guidebox_id variable from show_page.html\\n guidebox_id = request.args.get(\\\"guidebox_id\\\")\\n\\n #make API to get season information, gets back list of season information\\n seasons_results = guidebox_season_info(guidebox_id)\\n\\n for season in seasons_results:\\n date = season[\\\"first_airdate\\\"]\\n year = str(date)[0:4]\\n season[\\\"first_airdate\\\"] = year\\n\\n return jsonify(seasons_results)\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def get_result(dataset=None):\\n if dataset is None:\\n data = gen_dataset()\\n else:\\n data = pd.DataFrame(data=dataset)\\n\\n data['SEASON'] = data.apply(lambda x: set_season(str_2_date(x['ORD_DT'])), axis=1)\\n\\n data.drop('ORD_DT', axis=1, inplace=True)\\n data.drop('QT_ORDD', axis=1, inplace=True)\\n\\n return data.to_dict('records')\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def F_interp_geos_mat(sounding_lon,sounding_lat,sounding_datenum,\\\\\\n geos_dir='/mnt/Data2/GEOS/s5p_interp/',\\\\\\n interp_fields=['TROPPT']):\\n from scipy.io import loadmat\\n from scipy.interpolate import RegularGridInterpolator\\n \\n start_datenum = np.amin(sounding_datenum)\\n end_datenum = np.amax(sounding_datenum)\\n start_datetime = datedev_py(start_datenum)\\n start_year = start_datetime.year\\n start_month = start_datetime.month\\n start_day = start_datetime.day\\n start_hour = start_datetime.hour\\n \\n end_datetime = datedev_py(end_datenum)\\n end_year = end_datetime.year\\n end_month = end_datetime.month\\n end_day = end_datetime.day\\n end_hour = end_datetime.hour\\n end_minute = end_datetime.minute\\n end_second = end_datetime.second\\n \\n step_hour = 3 # geos fp data are 3-hourly\\n \\n geos_start_hour = start_hour-start_hour%step_hour\\n geos_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=geos_start_hour)\\n if end_hour > 24-step_hour or (end_hour == 24-step_hour and (end_minute > 0 or end_second > 0)):\\n geos_end_hour = 0\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour) +datetime.timedelta(days=1)\\n elif end_hour%step_hour == 0 and end_minute == 0 and end_second == 0:\\n geos_end_hour = end_hour\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n else:\\n geos_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n \\n nstep = (geos_end_datetime-geos_start_datetime).total_seconds()/3600/step_hour+1\\n nstep = int(nstep)\\n \\n geos_data = {}\\n # load narr data\\n for istep in range(nstep):\\n file_datetime = geos_start_datetime+datetime.timedelta(hours=step_hour*istep)\\n file_dir = os.path.join(geos_dir,file_datetime.strftime('Y%Y'),\\\\\\n file_datetime.strftime('M%m'),\\\\\\n file_datetime.strftime('D%d'))\\n file_path = os.path.join(file_dir,'subset_'+file_datetime.strftime('%Y%m%d_%H')+'.mat')\\n if not geos_data:\\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],interp_fields)))\\n geos_data['lon'] = mat_data['lon'].flatten()\\n geos_data['lat'] = mat_data['lat'].flatten()\\n geos_data['datenum'] = np.zeros((nstep),dtype=np.float64)\\n for fn in interp_fields:\\n geos_data[fn] = np.zeros((len(geos_data['lon']),len(geos_data['lat']),nstep))\\n geos_data[fn][...,istep] = mat_data[fn]\\n else:\\n mat_data = loadmat(file_path,variable_names=interp_fields)\\n for fn in interp_fields:\\n geos_data[fn][...,istep] = mat_data[fn]\\n \\n geos_data['datenum'][istep] = (file_datetime.toordinal()\\\\\\n +file_datetime.hour/24.\\\\\\n +file_datetime.minute/1440.\\\\\\n +file_datetime.second/86400.+366.)\\n # interpolate\\n sounding_interp = {}\\n for fn in interp_fields:\\n my_interpolating_function = \\\\\\n RegularGridInterpolator((geos_data['lon'],geos_data['lat'],geos_data['datenum']),\\\\\\n geos_data[fn],bounds_error=False,fill_value=np.nan)\\n sounding_interp[fn] = my_interpolating_function((sounding_lon,sounding_lat,sounding_datenum))\\n return sounding_interp\",\n \"def _solar_time(date, lon, lat):\\n # IDL is computing time_t as hours and fractional minutes\\n time_t = ee.Date(date).get('hour').add(\\n ee.Date(date).get('minute').divide(60))\\n\\n # This will return the hour floating point value\\n # time_t = ee.Date(date).get('hour').add(ee.Date(date).getFraction('hour'))\\n\\n # CGM - DOY and hour could be images in order to make these expressions\\n julian = _to_jd(date)\\n\\n # Sunrise time\\n julian_ = time_t.divide(24.0).add(julian)\\n j_cen = julian_.add(0.5 - 2451545.0).divide(36525.0)\\n # CGM - Does the mod happen before or after the multiply\\n lon_sun = j_cen.multiply(0.0003032).add(36000.76983) \\\\\\n .multiply(j_cen).mod(360.0).add(280.46646).subtract(360)\\n an_sun = j_cen.multiply(-0.0001537).add(35999.05029) \\\\\\n .multiply(j_cen).add(357.52911)\\n ecc = j_cen.multiply(0.0000001267).add(0.000042037) \\\\\\n .multiply(j_cen).multiply(-1).add(0.016708634)\\n ob_ecl = j_cen.multiply(-0.001813).add(0.00059) \\\\\\n .multiply(j_cen).add(46.815) \\\\\\n .multiply(j_cen).multiply(-1).add(21.448) \\\\\\n .divide(60.0).add(26).divide(60).add(23)\\n ob_corr = j_cen.multiply(-1934.136).add(125.04).multiply(deg2rad).cos() \\\\\\n .multiply(0.00256).add(ob_ecl)\\n var_y = ob_corr.divide(2.0).multiply(deg2rad).tan().multiply(\\n ob_corr.divide(2.0).multiply(deg2rad).tan())\\n eq_t = (\\n lon_sun.multiply(2.0).multiply(deg2rad).sin().multiply(var_y)\\n .subtract(an_sun.multiply(deg2rad).sin().multiply(ecc).multiply(2.0))\\n .add(an_sun.multiply(deg2rad).sin()\\n .multiply(lon_sun.multiply(2.0).multiply(deg2rad).cos())\\n .multiply(var_y).multiply(ecc).multiply(4.0))\\n .subtract(lon_sun.multiply(4.0).multiply(deg2rad).sin()\\n .multiply(var_y).multiply(var_y).multiply(0.5))\\n .subtract(an_sun.multiply(2.0).multiply(deg2rad).sin()\\n .multiply(ecc).multiply(ecc).multiply(1.25))\\n .multiply(4.0).multiply(rad2deg))\\n sun_eq = (\\n an_sun.multiply(deg2rad).sin().multiply(\\n j_cen.multiply(0.000014).add(0.004817)\\n .multiply(j_cen).multiply(-1).add(1.914602))\\n .add(an_sun.multiply(2.0).multiply(deg2rad).sin()\\n .multiply(j_cen.multiply(-0.000101).add(0.019993)))\\n .add(an_sun.multiply(3.0).multiply(deg2rad).sin().multiply(0.000289)))\\n sun_true = sun_eq.add(lon_sun)\\n sun_app = j_cen.multiply(-1934.136).add(125.04).multiply(deg2rad).sin() \\\\\\n .multiply(-0.00478).subtract(0.00569).add(sun_true)\\n\\n # CGM - Intentionally not converting back to degrees\\n d = ob_corr.multiply(deg2rad).sin() \\\\\\n .multiply(sun_app.multiply(deg2rad).sin()) \\\\\\n .asin()\\n\\n # CGM - Functions below are lat/lon dependent and can be written as\\n # ee.Image expressions\\n # CGM - d is still in radians, not converting\\n ha_t = lat.expression(\\n 'acos((cos(90.833 * pi / 180) / (cos(lat) * cos(d))) - tan(lat) * tan(d))'\\n ' * (180 / pi)',\\n {'lat': lat, 'd': d, 'pi': math.pi})\\n\\n # print('\\\\n{:10s} {:.12f}'.format('julian_', julian_.getInfo()))\\n # print('{:10s} {:.12f}'.format('time_t', time_t.getInfo()))\\n # print('{:10s} {:.12f}'.format('j_cen', j_cen.getInfo()))\\n # print('{:10s} {:.12f}'.format('lon_sun', lon_sun.getInfo()))\\n # print('{:10s} {:.12f}'.format('an_sun', an_sun.getInfo()))\\n # print('{:10s} {:.12f}'.format('ecc', ecc.getInfo()))\\n # print('{:10s} {:.12f}'.format('ob_ecl', ob_ecl.getInfo()))\\n # print('{:10s} {:.12f}'.format('ob_corr', ob_corr.getInfo()))\\n # print('{:10s} {:.12f}'.format('var_y', var_y.getInfo()))\\n # print('{:10s} {:.12f}'.format('eq_t', eq_t.getInfo()))\\n # print('{:10s} {:.12f}'.format('sun_eq', sun_eq.getInfo()))\\n # print('{:10s} {:.12f}'.format('sun_true', sun_true.getInfo()))\\n # print('{:10s} {:.12f}'.format('sun_app', sun_app.getInfo()))\\n # print('{:10s} {:.12f}'.format('d', d.getInfo()))\\n\\n return d, eq_t, ha_t\",\n \"def aggregate_full_season_tracking_stats_for_seasons(\\n measure_type: TrackingMeasureType,\\n seasons: List[str],\\n season_types: List[SeasonType],\\n player_or_team: PlayerOrTeam,\\n **kwargs,\\n) -> Tuple[List[Any], Any]:\\n stats_by_season = get_tracking_stats(\\n measure_type, seasons, season_types, player_or_team, **kwargs\\n )\\n\\n stats = sum_tracking_totals(player_or_team, measure_type, stats_by_season)\\n league_totals = sum_tracking_totals(\\\"league\\\", measure_type, stats)\\n return stats, league_totals\",\n \"def get_seasons(seasons):\\n if '-to-' in seasons:\\n from_, to = map(int, seasons.split('-to-'))\\n years = list(range(from_, to+1))\\n seasons = []\\n for i in range(0, len(years)-1):\\n season = \\\"-\\\".join(map(str, [years[i], years[i+1]]))\\n seasons.append(season)\\n return seasons\",\n \"def gnss_satellite_position(dset: \\\"Dataset\\\") -> None:\\n file_path = config.files.path(\\\"output_satellite_position\\\", file_vars={**dset.vars, **dset.analysis})\\n\\n # Add date field to dataset\\n if \\\"date\\\" not in dset.fields:\\n dset.add_text(\\\"date\\\", val=[d.strftime(\\\"%Y/%m/%d %H:%M:%S\\\") for d in dset.time.datetime], write_level=\\\"detail\\\")\\n \\n # Add fields in case of broadcast ephemeris\\n if \\\"broadcast\\\" in config.tech.apriori_orbit.list:\\n if not \\\"trans_time_gpsweek\\\" in dset.fields:\\n dset.add_text(\\n \\\"trans_time_gpsweek\\\",\\n val=[\\n f\\\"{t.gps_ws.week:04.0f}{t.gps_ws.day:1.0f}:{t.gps_ws.seconds:06.0f}\\\" for t in dset.used_transmission_time\\n ],\\n write_level=\\\"detail\\\",\\n )\\n if not \\\"toe_gpsweek\\\" in dset.fields:\\n dset.add_text(\\n \\\"toe_gpsweek\\\",\\n val=[f\\\"{t.gps_ws.week:04.0f}{t.gps_ws.day:1.0f}:{t.gps_ws.seconds:06.0f}\\\" for t in dset.used_toe],\\n write_level=\\\"detail\\\",\\n )\\n if not \\\"diff_trans_toe\\\" in dset.fields:\\n dset.add_float(\\n \\\"diff_trans_toe\\\",\\n val=(dset.used_transmission_time.gps.mjd - dset.used_toe.gps.mjd) * Unit.day2second,\\n unit=\\\"second\\\", \\n write_level=\\\"detail\\\",\\n )\\n if not \\\"age_of_ephemeris\\\" in dset.fields:\\n dset.add_float(\\n \\\"age_of_ephemeris\\\",\\n val=(dset.time.gps.mjd - dset.used_toe.gps.mjd) * Unit.day2second,\\n unit=\\\"second\\\", \\n write_level=\\\"detail\\\",\\n )\\n \\n # Select fields available in Dataset\\n fields = get_existing_fields(dset, FIELDS)\\n\\n # Put together fields in an array as specified by the 'dtype' tuple list\\n output_list = list(zip(*(get_field(dset, f.field, f.attrs, f.unit) for f in fields)))\\n output_array = np.array(output_list, dtype=[(f.name, f.dtype) for f in fields])\\n \\n # Write to disk\\n header = get_header(\\n fields,\\n pgm_version=f\\\"where {where.__version__}\\\",\\n run_by=util.get_user_info()[\\\"inst_abbreviation\\\"] if \\\"inst_abbreviation\\\" in util.get_user_info() else \\\"\\\",\\n summary=\\\"GNSS satellite position results\\\",\\n )\\n np.savetxt(\\n file_path,\\n output_array,\\n fmt=tuple(f.format for f in fields),\\n header=header,\\n delimiter=\\\"\\\",\\n encoding=\\\"utf8\\\",\\n )\",\n \"def sel(self, time=None, lat=None, lon=None, vmax=None, mslp=None,\\n dvmax_dt=None, dmslp_dt=None, stormtype=None, method='exact'):\\n\\n # create copy of storm object\\n new_dict = copy.deepcopy(self.dict)\\n new_dict['subset'] = True\\n NEW_STORM = Storm(new_dict)\\n idx_final = np.arange(len(self.time))\\n\\n # apply time filter\\n if time is None:\\n idx = copy.copy(idx_final)\\n\\n elif isinstance(time, dt):\\n time_diff = np.array([(time - i).total_seconds()\\n for i in NEW_STORM.time])\\n idx = np.abs(time_diff).argmin()\\n if time_diff[idx] != 0:\\n if method == 'exact':\\n msg = f'no exact match for {time}. Use different time or method.'\\n raise ValueError(msg)\\n elif method == 'floor' and time_diff[idx] < 0:\\n idx += -1\\n if idx < 0:\\n msg = f'no points before {time}. Use different time or method.'\\n raise ValueError(msg)\\n elif method == 'ceil' and time_diff[idx] > 0:\\n idx += 1\\n if idx >= len(time_diff):\\n msg = f'no points after {time}. Use different time or method.'\\n raise ValueError(msg)\\n\\n elif isinstance(time, (tuple, list)) and len(time) == 2:\\n time0, time1 = time\\n if time0 is None:\\n time0 = min(NEW_STORM.time)\\n elif not isinstance(time0, dt):\\n msg = 'time bounds must be of type datetime.datetime or None.'\\n raise TypeError(msg)\\n if time1 is None:\\n time1 = max(NEW_STORM.time)\\n elif not isinstance(time1, dt):\\n msg = 'time bounds must be of type datetime.datetime or None.'\\n raise TypeError(msg)\\n tmptimes = np.array(NEW_STORM.time)\\n idx = np.where((tmptimes >= time0) & (tmptimes <= time1))[0]\\n if len(idx) == 0:\\n msg = f'no points between {time}. Use different time bounds.'\\n raise ValueError(msg)\\n\\n else:\\n msg = 'time must be of type datetime.datetime, tuple/list, or None.'\\n raise TypeError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply lat/lon filter\\n if lat is None and lon is None:\\n idx = copy.copy(idx_final)\\n\\n elif is_number(lat) and is_number(lon):\\n dist = np.array([great_circle((lat, lon), (x, y)).kilometers for x, y in zip(\\n NEW_STORM.lon, NEW_STORM.lat)])\\n idx = np.abs(dist).argmin()\\n if dist[idx] != 0:\\n if method == 'exact':\\n msg = f'no exact match for {lat}/{lon}. Use different location or method.'\\n raise ValueError(msg)\\n elif method in ('floor', 'ceil'):\\n warnings.warn(\\n 'floor and ceil do not apply to lat/lon filtering. Using nearest instead.')\\n\\n elif (isinstance(lat, (tuple, list)) and len(lat) == 2) or (isinstance(lon, (tuple, list)) and len(lon) == 2):\\n if not isinstance(lat, (tuple, list)):\\n lat = (None, None)\\n if not isinstance(lon, (tuple, list)):\\n lon = (None, None)\\n lat0, lat1 = lat\\n lon0, lon1 = lon\\n if lat0 is None:\\n lat0 = min(NEW_STORM.lat)\\n elif not is_number(lat0):\\n msg = 'lat/lon bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if lat1 is None:\\n lat1 = max(NEW_STORM.lat)\\n elif not is_number(lat1):\\n msg = 'lat/lon bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if lon0 is None:\\n lon0 = min(NEW_STORM.lon)\\n elif not is_number(lon0):\\n msg = 'lat/lon bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if lon1 is None:\\n lon1 = max(NEW_STORM.lon)\\n elif not is_number(lon1):\\n msg = 'lat/lon bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n\\n tmplat, tmplon = np.array(\\n NEW_STORM.lat), np.array(NEW_STORM.lon) % 360\\n idx = np.where((tmplat >= lat0) & (tmplat <= lat1) &\\n (tmplon >= lon0 % 360) & (tmplon <= lon1 % 360))[0]\\n if len(idx) == 0:\\n msg = f'no points in {lat}/{lon} box. Use different lat/lon bounds.'\\n raise ValueError(msg)\\n\\n else:\\n msg = 'lat and lon must be of the same type: float/int, tuple/list, or None.'\\n raise TypeError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply vmax filter\\n if vmax is None:\\n idx = copy.copy(idx_final)\\n\\n elif isinstance(vmax, (tuple, list)) and len(vmax) == 2:\\n vmax0, vmax1 = vmax\\n if vmax0 is None:\\n vmax0 = np.nanmin(NEW_STORM.vmax)\\n elif not is_number(vmax0):\\n msg = 'vmax bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if vmax1 is None:\\n vmax1 = np.nanmax(NEW_STORM.vmax)\\n elif not is_number(vmax1):\\n msg = 'vmax bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n tmpvmax = np.array(NEW_STORM.vmax)\\n idx = np.where((tmpvmax >= vmax0) & (tmpvmax <= vmax1))[0]\\n if len(idx) == 0:\\n msg = f'no points with vmax between {vmax}. Use different vmax bounds.'\\n raise ValueError(msg)\\n\\n else:\\n msg = 'vmax must be of type tuple/list, or None.'\\n raise TypeError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply mslp filter\\n if mslp is None:\\n idx = copy.copy(idx_final)\\n\\n elif isinstance(mslp, (tuple, list)) and len(mslp) == 2:\\n mslp0, mslp1 = mslp\\n if mslp0 is None:\\n mslp0 = np.nanmin(NEW_STORM.mslp)\\n elif not is_number(mslp0):\\n msg = 'mslp bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if mslp1 is None:\\n mslp1 = np.nanmax(NEW_STORM.mslp)\\n elif not is_number(mslp1):\\n msg = 'mslp bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n tmpmslp = np.array(NEW_STORM.mslp)\\n idx = np.where((tmpmslp >= mslp0) & (tmpmslp <= mslp1))[0]\\n if len(idx) == 0:\\n msg = f'no points with mslp between {mslp}. Use different dmslp_dt bounds.'\\n raise ValueError(msg)\\n\\n else:\\n msg = 'vmax must be of type tuple/list, or None.'\\n raise TypeError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply dvmax_dt filter\\n if dvmax_dt is None:\\n idx = copy.copy(idx_final)\\n\\n elif 'dvmax_dt' not in NEW_STORM.dict.keys():\\n msg = 'dvmax_dt not in storm data. Create new object with interp first.'\\n raise KeyError(msg)\\n\\n elif isinstance(dvmax_dt, (tuple, list)) and len(dvmax_dt) == 2:\\n dvmax_dt0, dvmax_dt1 = dvmax_dt\\n if dvmax_dt0 is None:\\n dvmax_dt0 = np.nanmin(NEW_STORM.dvmax_dt)\\n elif not is_number(dvmax_dt0):\\n msg = 'dmslp_dt bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if dvmax_dt1 is None:\\n dvmax_dt1 = np.nanmax(NEW_STORM.dvmax_dt)\\n elif not is_number(dvmax_dt1):\\n msg = 'dmslp_dt bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n\\n tmpvmax = np.array(NEW_STORM.dvmax_dt)\\n idx = np.where((tmpvmax >= dvmax_dt0) & (tmpvmax <= dvmax_dt1))[0]\\n if len(idx) == 0:\\n msg = f'no points with dvmax_dt between {dvmax_dt}. Use different dvmax_dt bounds.'\\n raise ValueError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply dmslp_dt filter\\n if dmslp_dt is None:\\n idx = copy.copy(idx_final)\\n\\n elif 'dmslp_dt' not in NEW_STORM.dict.keys():\\n msg = 'dmslp_dt not in storm data. Create new object with interp first.'\\n raise KeyError(msg)\\n\\n elif isinstance(dmslp_dt, (tuple, list)) and len(dmslp_dt) == 2:\\n dmslp_dt0, dmslp_dt1 = dmslp_dt\\n if dmslp_dt0 is None:\\n dmslp_dt0 = np.nanmin(NEW_STORM.dmslp_dt)\\n elif not is_number(dmslp_dt0):\\n msg = 'dmslp_dt bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n if dmslp_dt1 is None:\\n dmslp_dt1 = np.nanmax(NEW_STORM.dmslp_dt)\\n elif not is_number(dmslp_dt1):\\n msg = 'dmslp_dt bounds must be of type float/int or None.'\\n raise TypeError(msg)\\n tmpmslp = np.array(NEW_STORM.dmslp_dt)\\n idx = np.where((tmpmslp >= dmslp_dt0) & (tmpmslp <= dmslp_dt1))[0]\\n if len(idx) == 0:\\n msg = f'no points with dmslp_dt between {dmslp_dt}. Use different dmslp_dt bounds.'\\n raise ValueError(msg)\\n\\n # update idx_final\\n idx_final = list(set(idx_final) & set(listify(idx)))\\n\\n # apply stormtype filter\\n if stormtype is None:\\n idx = copy.copy(idx_final)\\n\\n elif isinstance(stormtype, (tuple, list, str)):\\n idx = [i for i, j in enumerate(\\n NEW_STORM.type) if j in listify(stormtype)]\\n if len(idx) == 0:\\n msg = f'no points with type {stormtype}. Use different stormtype.'\\n raise ValueError(msg)\\n\\n else:\\n msg = 'stormtype must be of type tuple/list, str, or None.'\\n raise TypeError(msg)\\n\\n # update idx_final\\n idx_final = sorted(list(set(idx_final) & set(listify(idx))))\\n\\n # Construct new storm dict with subset elements\\n for key in NEW_STORM.dict.keys():\\n if isinstance(NEW_STORM.dict[key], list):\\n NEW_STORM.dict[key] = [NEW_STORM.dict[key][i]\\n for i in idx_final]\\n else:\\n NEW_STORM.dict[key] = NEW_STORM.dict[key]\\n\\n # Add other attributes to new storm object\\n if key == 'realtime':\\n continue\\n if not isinstance(NEW_STORM.dict[key], list) and not isinstance(NEW_STORM.dict[key], dict):\\n NEW_STORM[key] = NEW_STORM.dict[key]\\n NEW_STORM.attrs[key] = NEW_STORM.dict[key]\\n if isinstance(NEW_STORM.dict[key], list) and not isinstance(NEW_STORM.dict[key], dict):\\n NEW_STORM.vars[key] = np.array(NEW_STORM.dict[key])\\n NEW_STORM[key] = np.array(NEW_STORM.dict[key])\\n\\n return NEW_STORM\",\n \"def msatna_blocks_3lag_year(year: int) -> pd.Series:\\n return msatna_blocks_3lag_panel()[year]\",\n \"def get_season(\\n current_date: date, hemisphere: str, season_tracking_type: str\\n) -> str | None:\\n\\n if hemisphere == \\\"equator\\\":\\n return None\\n\\n if season_tracking_type == TYPE_ASTRONOMICAL:\\n spring_start = ephem.next_equinox(str(current_date.year)).datetime()\\n summer_start = ephem.next_solstice(str(current_date.year)).datetime()\\n autumn_start = ephem.next_equinox(spring_start).datetime()\\n winter_start = ephem.next_solstice(summer_start).datetime()\\n else:\\n spring_start = datetime(2017, 3, 1).replace(year=current_date.year)\\n summer_start = spring_start.replace(month=6)\\n autumn_start = spring_start.replace(month=9)\\n winter_start = spring_start.replace(month=12)\\n\\n if spring_start <= current_date < summer_start:\\n season = STATE_SPRING\\n elif summer_start <= current_date < autumn_start:\\n season = STATE_SUMMER\\n elif autumn_start <= current_date < winter_start:\\n season = STATE_AUTUMN\\n elif winter_start <= current_date or spring_start > current_date:\\n season = STATE_WINTER\\n\\n # If user is located in the southern hemisphere swap the season\\n if hemisphere == NORTHERN:\\n return season\\n return HEMISPHERE_SEASON_SWAP.get(season)\",\n \"def _full_to_yearly_ts(self, arr, dt):\\n time_defined = self.def_time and not ('av' in self.dtype_in_time)\\n if time_defined:\\n arr = utils.times.yearly_average(arr, dt)\\n return arr\",\n \"def get_sunspot_data(yy, time1):\\n master = []\\n num_of_ss = np.max(yy.flatten()) # get number of different SS's\\n centroids = []\\n sizes = []\\n numbers = []\\n\\n for i in np.arange(1, num_of_ss + 1): # for each SS:\\n temp_sunspot = SunSpot(1, 1, 1)\\n copy_yy = np.array(yy, copy = True)\\n copy_yy[copy_yy != i] = 0 # get only points == i\\n copy_yy[copy_yy == i] = 1\\n\\n indices_x, indices_y = np.where(yy == i)\\n\\n max_lat = np.max(indices_x)\\n min_lat = np.min(indices_x)\\n mean_lat = max_lat - (max_lat - min_lat)/2\\n \\n max_lon = np.max(indices_y)\\n min_lon = np.min(indices_y)\\n mean_lon = max_lon - (max_lon - min_lon)/2\\n \\n temp_sunspot.mask = copy_yy\\n temp_sunspot.centroid = [mean_lon, mean_lat]\\n temp_sunspot.size = len(indices_x)\\n temp_sunspot.number = i\\n temp_sunspot.x_points = indices_x\\n temp_sunspot.y_points = indices_y\\n temp_sunspot.timestamp = time1\\n temp_sunspot.min_x = min_lon\\n temp_sunspot.max_x = max_lon\\n temp_sunspot.min_y = min_lat\\n temp_sunspot.max_y = max_lat\\n\\n master.append(temp_sunspot)\\n\\n return num_of_ss, master\",\n \"def msl_nn_srtm_interp(self, lon_lat):\\n tiles = self.find_srtm_tiles(lon_lat)\\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\\n lon_lat_msl[:, 0:2] = lon_lat\\n for tile in set(tiles):\\n otile = rasterio.open(tile, 'r')\\n oimg = otile.read(1)\\n idx = np.where(np.array(tiles) == tile)[0]\\n pix = feat.geo_to_pix(\\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\\n pix = np.round(pix).astype(np.int)\\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\\n otile.close()\\n nan_mask = lon_lat_msl[:, 2] == -32768\\n lon_lat_msl[nan_mask, 2] = np.NaN\\n return lon_lat_msl\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def season(self, title=None, season=None):\\n key = f'{self.key}/children?excludeAllLeaves=1'\\n if title is not None and not isinstance(title, int):\\n return self.fetchItem(key, Season, title__iexact=title)\\n elif season is not None or isinstance(title, int):\\n if isinstance(title, int):\\n index = title\\n else:\\n index = season\\n return self.fetchItem(key, Season, index=index)\\n raise BadRequest('Missing argument: title or season is required')\",\n \"def season_limits(self):\\n if self.season == \\\"summer\\\":\\n return\\n neighbors = [(0, 1), (1, 0), (-1, 0), (0, -1)]\\n points_list = []\\n season_pixels = []\\n season_edges = []\\n width = self.grid.width\\n height = self.grid.height\\n x = 0\\n while x < width:\\n y = 0\\n while y < height:\\n points_list.append((x, y))\\n if self.season == \\\"spring\\\" or self.season == \\\"winter\\\":\\n if self.grid.pix_copy[x, y] == (0, 0, 255):\\n season_pixels.append((x, y))\\n else:\\n if self.grid.pix_copy[x, y] == (255, 255, 255):\\n season_pixels.append((x, y))\\n y += 1\\n x += 1\\n for points in points_list:\\n k = 0\\n while k < (len(neighbors)):\\n xp = points[0] + neighbors[k][0]\\n yp = points[1] + neighbors[k][1]\\n condition = self.filter_edges_one(points[0], points[1], xp, yp, season_edges)\\n if condition:\\n season_edges.append((xp, yp))\\n k += 1\\n return season_edges\",\n \"def seasonNumber(self):\\n return self.index\",\n \"def getshowsbyseason(season,year, session = None):\\n url = APIURL.format(season=season, year = year)\\n headers = {\\\"X-CSRF-TOKEN\\\":session.cookies['X-CSRF-TOKEN']}\\n data = alrequests.GET_json(url,session = session, headers=headers)\\n return {cat:[Show(**show) for show in shows] for cat,shows in data.items()}\",\n \"def season_series(game_id, pref_team, other_team, last_season=False):\\n\\n # Init empty dictionaries and lists\\n games_against = list()\\n pref_toi = dict()\\n pref_goals = dict()\\n pref_assists = dict()\\n pref_points = dict()\\n pref_record = {\\\"wins\\\": 0, \\\"losses\\\": 0, \\\"ot\\\": 0}\\n roster_player = True\\n\\n # If this is the first game of the season, we can set the 'last_season' flag to enable the\\n # season series function to check last year's season series between the two teams.\\n if not last_season:\\n season_start = str(game_id)[0:4]\\n season_end = str(int(season_start) + 1)\\n yesterday = datetime.now() - timedelta(days=1)\\n # yesterday = datetime.now() + timedelta(days=50)\\n # schedule_url = (\\n # f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n # f\\\"&expand=schedule.broadcasts,schedule.teams&startDate=\\\"\\n # f\\\"{season_start}-08-01&endDate={yesterday:%Y-%m-%d}\\\"\\n # )\\n schedule_url = (\\n f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n f\\\"&expand=schedule.broadcasts,schedule.teams\\\"\\n f\\\"&season={season_start}{season_end}\\\"\\n )\\n else:\\n season_start = int(str(game_id)[0:4]) - 1\\n season_end = str(int(season_start) + 1)\\n yesterday = datetime.now() - timedelta(days=1)\\n # yesterday = datetime.now() + timedelta(days=50)\\n # schedule_url = (\\n # f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n # f\\\"&expand=schedule.broadcasts,schedule.teams&startDate=\\\"\\n # f\\\"{season_start}-08-01&endDate={season_end}-06-01\\\"\\n # )\\n schedule_url = (\\n f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n f\\\"&expand=schedule.broadcasts,schedule.teams\\\"\\n f\\\"&season={season_start}{season_end}\\\"\\n )\\n\\n schedule = api.nhl_api(schedule_url).json()\\n dates = schedule[\\\"dates\\\"]\\n\\n # Loop through scheduled to get previously played games against\\n for date in dates:\\n game = date[\\\"games\\\"][0]\\n game_type = game[\\\"gameType\\\"]\\n game_id = game[\\\"gamePk\\\"]\\n game_team_home = game[\\\"teams\\\"][\\\"home\\\"][\\\"team\\\"][\\\"name\\\"]\\n game_team_away = game[\\\"teams\\\"][\\\"away\\\"][\\\"team\\\"][\\\"name\\\"]\\n teams = [game_team_away, game_team_home]\\n game_status = game[\\\"status\\\"][\\\"abstractGameState\\\"]\\n if game_type == \\\"R\\\" and game_status == \\\"Final\\\" and other_team.team_name in teams:\\n game_feed = f\\\"/game/{game_id}/feed/live\\\"\\n games_against.append(game_feed)\\n\\n # If the two teams haven't played yet, just exit this function\\n if not games_against:\\n return None, None, None\\n\\n # Loop through newly created games_against list to get each stats\\n for feed in games_against:\\n game = api.nhl_api(feed).json()\\n game_data = game[\\\"gameData\\\"]\\n home_team_name = game_data[\\\"teams\\\"][\\\"home\\\"][\\\"name\\\"]\\n pref_homeaway = \\\"home\\\" if home_team_name == pref_team.team_name else \\\"away\\\"\\n other_homeaway = \\\"away\\\" if home_team_name == pref_team.team_name else \\\"home\\\"\\n\\n # Get season series\\n end_period = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"currentPeriod\\\"]\\n extra_time = True if end_period > 3 else False\\n pref_score = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"teams\\\"][pref_homeaway][\\\"goals\\\"]\\n other_score = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"teams\\\"][other_homeaway][\\\"goals\\\"]\\n if pref_score > other_score:\\n pref_record[\\\"wins\\\"] += 1\\n elif other_score > pref_score and extra_time:\\n pref_record[\\\"ot\\\"] += 1\\n else:\\n pref_record[\\\"losses\\\"] += 1\\n\\n season_series_str = f\\\"Series: {pref_record['wins']}-\\\" f\\\"{pref_record['losses']}-{pref_record['ot']}\\\"\\n\\n # Get stats leaders\\n # pref_teamstats = game[\\\"liveData\\\"][\\\"boxscore\\\"][\\\"teams\\\"][pref_homeaway][\\\"teamStats\\\"]\\n pref_playerstats = game[\\\"liveData\\\"][\\\"boxscore\\\"][\\\"teams\\\"][pref_homeaway][\\\"players\\\"]\\n for id, player in pref_playerstats.items():\\n try:\\n # Calculate TOI\\n player_toi_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"timeOnIce\\\"]\\n player_toi_minutes = int(player_toi_str.split(\\\":\\\")[0])\\n player_toi_seconds = int(player_toi_str.split(\\\":\\\")[1])\\n player_toi = (player_toi_minutes * 60) + player_toi_seconds\\n pref_toi[id] = pref_toi.get(id, 0) + player_toi\\n\\n # Point Totals\\n player_goal_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"goals\\\"]\\n pref_goals[id] = pref_goals.get(id, 0) + int(player_goal_str)\\n player_assist_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"assists\\\"]\\n pref_assists[id] = pref_assists.get(id, 0) + int(player_assist_str)\\n player_points = int(player_goal_str) + int(player_assist_str)\\n pref_points[id] = pref_points.get(id, 0) + int(player_points)\\n\\n except KeyError:\\n pass\\n\\n # Calculate Stats Leaders\\n sorted_toi = sorted(pref_toi.values(), reverse=True)\\n leader_toi = sorted_toi[0]\\n\\n sorted_points = sorted(pref_points.values(), reverse=True)\\n leader_points = sorted_points[0]\\n\\n # Get TOI leader\\n for id in pref_toi.keys():\\n if pref_toi[id] == leader_toi:\\n player_name = roster.player_attr_by_id(pref_team.roster, id, \\\"fullName\\\")\\n if player_name is None:\\n roster_player = False\\n player_id_only = id.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n leader_toi_avg = leader_toi / len(games_against)\\n m, s = divmod(leader_toi_avg, 60)\\n toi_m = int(m)\\n toi_s = int(s)\\n toi_s = \\\"0{}\\\".format(toi_s) if toi_s < 10 else toi_s\\n toi_avg = \\\"{}:{}\\\".format(toi_m, toi_s)\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n toi_leader_str = \\\"TOI Leader: {} with {} / game.\\\".format(player_short_name, toi_avg)\\n\\n # Handle tied points leaders\\n point_leaders = list()\\n for id in pref_points.keys():\\n if pref_points[id] == leader_points:\\n point_leaders.append(id)\\n\\n if leader_points == 0:\\n points_leader_str = \\\"Points Leader: None (all players have 0 points).\\\"\\n\\n elif len(point_leaders) == 1:\\n leader = point_leaders[0]\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n # If the player is no longer on the team, get their information (change string here?)\\n if player_name is None:\\n roster_player = False\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n if not roster_player:\\n points_leader_str = (\\n f\\\"Points Leader: {player_name} with {leader_points} points \\\"\\n f\\\"({player_goals}G {player_assists}A) \\\"\\n )\\n else:\\n points_leader_str = \\\"Points Leader: {} with {} ({}G {}A).\\\".format(\\n player_name, leader_points, player_goals, player_assists\\n )\\n\\n elif len(point_leaders) > 3:\\n point_leaders_with_attrs = list()\\n for leader in point_leaders:\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n if player_name is None:\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n point_leaders_with_attrs.append(player_short_name)\\n\\n point_leaders_joined = \\\", \\\".join(point_leaders_with_attrs[0:3])\\n leftover_leaders = len(point_leaders) - 3\\n points_leader_str = (\\n f\\\"Points Leaders: {point_leaders_joined} & {leftover_leaders} others ({leader_points} each).\\\"\\n )\\n\\n else:\\n point_leaders_with_attrs = list()\\n for leader in point_leaders:\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n if player_name is None:\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n player_str = f\\\"{player_short_name} ({player_goals}G {player_assists}A)\\\"\\n point_leaders_with_attrs.append(player_str)\\n\\n point_leaders_joined = (\\n f\\\", \\\".join(point_leaders_with_attrs[:-1]) + f\\\" & {point_leaders_with_attrs[-1]}\\\"\\n )\\n points_leader_str = \\\"Points Leaders: {} with {} each.\\\".format(point_leaders_joined, leader_points)\\n\\n return season_series_str, points_leader_str, toi_leader_str\",\n \"def current_season():\\n td = datetime.datetime.today()\\n if td.month > 8:\\n return td.year\\n return td.year - 1\",\n \"def seasonal_pattern(season_time):\\n return np.where(season_time < 0.4,\\n np.cos(season_time * 2 * np.pi),\\n 1 / np.exp(3 * season_time))\",\n \"def seasonal_pattern(season_time):\\n return np.where(season_time < 0.4,\\n np.cos(season_time * 2 * np.pi),\\n 1 / np.exp(3 * season_time))\",\n \"def seasonal_pattern(season_time):\\n return np.where(season_time < 0.4,\\n np.cos(season_time * 2 * np.pi),\\n 1 / np.exp(3 * season_time))\",\n \"def seasonal_pattern(season_time):\\r\\n return np.where(season_time < 0.4,\\r\\n np.cos(season_time * 2 * np.pi),\\r\\n 1 / np.exp(3 * season_time))\",\n \"def seasonal_pattern(season_time):\\r\\n return np.where(season_time < 0.4,\\r\\n np.cos(season_time * 2 * np.pi),\\r\\n 1 / np.exp(3 * season_time))\",\n \"def estimateEquinox(year, season):\\r\\n # Valid for years 1000 to 3000\\r\\n y = (year - 2000) / 1000.0;\\r\\n if season == Season.SPRING:\\r\\n return 2451623.80984 + 365242.37404 * y + 0.05169 * (y * y) - 0.00411 * (y * y * y) - 0.00057 * (y * y * y * y)\\r\\n elif season == season.SUMMER:\\r\\n return 2451716.56767 + 365241.62603 * y + 0.00325 * (y * y) + 0.00888 * (y * y * y) - 0.00030 * (y * y * y * y)\\r\\n elif season == Season.AUTUMN:\\r\\n return 2451810.21715 + 365242.01767 * y - 0.11575 * (y * y) + 0.00337 * (y * y * y) + 0.00078 * (y * y * y * y)\\r\\n elif season == Season.WINTER:\\r\\n return 2451900.05952 + 365242.74049 * y - 0.06223 * (y * y) - 0.00823 * (y * y * y) + 0.00032 * (y * y * y * y)\\r\\n else:\\r\\n raise ValueError(\\\"Unknown season\\\")\",\n \"def get_solar(self, name_building):\\n return self._solar.loc[name_building]\",\n \"def season(self, seasonnum, order='aired'):\\n if order=='aired':\\n seasons = self.seasons\\n elif order == 'dvd':\\n seasons = self.dvd_seasons\\n try:\\n return seasons[seasonnum]\\n except KeyError:\\n raise SeasonNotFoundError(\\n 'Season no %s does not exists' % seasonnum\\n ), None, sys.exc_info()[2]\",\n \"def current_season() -> int:\\n now = datetime.now()\\n month, year = now.month, now.year\\n if month < 4:\\n year -= 1\\n return year\",\n \"def ts(self, data):\\n data_masked = self.mask_var(data)\\n sfc_area = data.sfc_area\\n land_mask = _get_land_mask(data, self.do_land_mask)\\n\\n weights = self.mask_var(sfc_area) * land_mask\\n # Mask weights where data values are initially invalid in addition\\n # to applying the region mask.\\n weights = weights.where(np.isfinite(data))\\n sum_weights = _sum_over_lat_lon(weights)\\n return (_sum_over_lat_lon(data_masked*sfc_area*land_mask) /\\n sum_weights)\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def get_current_player_season(self):\\n return self.get_player_season(\\\"current\\\")\",\n \"def wind(\\n da_model: Union[xr.DataArray, xr.Dataset],\\n wind: xr.DataArray = None,\\n wind_u: xr.DataArray = None,\\n wind_v: xr.DataArray = None,\\n altitude: float = 10,\\n altitude_correction: bool = False,\\n freq: pd.Timedelta = None,\\n reproj_method: str = \\\"nearest_index\\\",\\n resample_kwargs: dict = {},\\n logger=logger,\\n):\\n if wind_u is not None and wind_v is not None:\\n wind = np.sqrt(np.power(wind_u, 2) + np.power(wind_v, 2))\\n elif wind is None:\\n raise ValueError(\\\"Either wind or wind_u and wind_v varibales must be supplied.\\\")\\n\\n if wind.raster.dim0 != \\\"time\\\":\\n raise ValueError(f'First wind dim should be \\\"time\\\", not {wind.raster.dim0}')\\n\\n # compute wind at 2 meters altitude\\n if altitude_correction:\\n wind = wind * (4.87 / np.log((67.8 * altitude) - 5.42))\\n # downscale wind (lazy)\\n wind_out = wind.raster.reproject_like(da_model, method=reproj_method)\\n # resample time\\n wind_out.name = \\\"wind\\\"\\n wind_out.attrs.update(unit=\\\"m s-1\\\")\\n if freq is not None:\\n resample_kwargs.update(upsampling=\\\"bfill\\\", downsampling=\\\"mean\\\", logger=logger)\\n wind_out = resample_time(wind_out, freq, conserve_mass=False, **resample_kwargs)\\n return wind_out\",\n \"def reduce_dataset(years, values,flux_floor=0,max_tm_error=0,min_reduction_steps=200):\\n non_zero_ind, min_retained_zero_years = remove_begin_end_zero_flux(years,values,flux_floor,min_reduction_steps)\\n\\n years_mod = years[non_zero_ind]\\n values_mod = values[non_zero_ind]\\n\\n if years_mod.size <3:\\n years_mod = years\\n values_mod = values\\n values_mod = 0\\n else:\\n #makes ure you have not removed more than 1% of the mass when removing 0 or flux floor rates\\n o_mass = TimeSeries(years,values,None,None).integrate().values[-1]\\n r_mass = TimeSeries(years_mod, values_mod, None, None).integrate().values[-1]\\n if abs((o_mass-r_mass)/o_mass)*100 > 1:\\n years_mod = years\\n values_mod = values\\n timeseries = TimeSeries(years_mod, values_mod, None, None)\\n mass = timeseries.integrate()\\n\\n #normalize Values\\n maxval = np.max(values_mod)\\n values_mod = values_mod/maxval\\n o_timeseries = TimeSeries(years,values/maxval,None,None)\\n o_mass = o_timeseries.integrate()\\n timeseries = TimeSeries(years_mod, values_mod, None, None)\\n mass = timeseries.integrate()\\n\\n mx = np.argmax(timeseries.values)\\n points = [0, mx, len(timeseries)]\\n x = timeseries.times\\n\\n ythresh = 100*np.mean(timeseries.values)\\n out_error = 1\\n out_error_last = out_error\\n OUT_ERROR_THRESHOLD = 1e-2\\n\\n UPPER_N = 200\\n LOWER_N = 50\\n last_result = None\\n MAX_ITERATIONS = 80\\n\\n solve_type = SMOOTH\\n simple_peaks = False\\n last_result,ix = reduct_iter(timeseries,flux_floor,ythresh,out_error,out_error_last,OUT_ERROR_THRESHOLD,UPPER_N,LOWER_N,last_result,MAX_ITERATIONS)\\n last_result = retain_min_years(last_result.reduced_flux,o_timeseries,o_mass,min_retained_zero_years)\\n #if there are less points than the min_reduction_steps then use the remaining\\n #points to rebalance the segments with the largest mass errors.\\n play_points = min_reduction_steps - last_result.num_reduced_points\\n bef = last_result.reduced_flux.times.size\\n if play_points > 0:\\n last_result = red_flux.rebalance_extra_points(last_result,play_points)\\n\\n rr = last_result\\n\\n #find peaks for data rebalance and reporting\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=3,rel_height=1)\\n if peaks.size == 0 :\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=2,rel_height=1)\\n if peaks.size == 0:\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=1,rel_height=1)\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=3,rel_height=1)\\n if pneg.size == 0:\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=2,rel_height=1)\\n if pneg.size == 0:\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=1,rel_height=1)\\n\\n peaks = rr.reduced_flux.times[peaks]\\n pneg = rr.reduced_flux.times[pneg]\\n\\n peaks = np.isin(o_timeseries.times,peaks)\\n pneg = np.isin(o_timeseries.times,pneg)\\n peaks = np.where(peaks)\\n pneg = np.where(pneg)\\n\\n peaks = peaks[0]\\n pneg = pneg[0]\\n iter = 0\\n while iter < 100 and (abs(last_result.total_mass_error*maxval) > max_tm_error or abs(last_result.total_mass_error/last_result.mass.values[-1])*100 > .001) :\\n rr = red_flux.rebalance_valleys(rr,peaks,pneg)\\n #keep the lowest total_mass_error\\n if abs(rr.total_mass_error) < abs(last_result.total_mass_error):\\n last_result = rr\\n else:\\n break\\n iter += 1\\n\\n out_times = last_result.reduced_flux.times\\n out_values = last_result.reduced_flux.values\\n #return the reduced data, undo normalize of the values (*maxval)\\n return out_times, out_values*maxval,-(last_result.total_mass_error * maxval),peaks.size,iter\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67101383","0.61974657","0.6165893","0.57036895","0.54976517","0.5443406","0.5429207","0.5275951","0.5232346","0.52280706","0.5203124","0.5159468","0.515358","0.51510376","0.5138082","0.50527817","0.50496626","0.5037915","0.49941966","0.4983268","0.4960697","0.4960681","0.49505866","0.49404982","0.4915507","0.49084416","0.48996848","0.48994577","0.48565385","0.48502243","0.4835316","0.48149383","0.47852203","0.4783123","0.4782393","0.47819227","0.475781","0.47316402","0.46751934","0.46663007","0.46359178","0.4622071","0.46151596","0.46106425","0.4607315","0.45932975","0.45907667","0.45872504","0.45677558","0.4565503","0.45635623","0.456127","0.45180824","0.4513166","0.45096618","0.45052087","0.45003203","0.4499943","0.44956192","0.44949612","0.44929588","0.44784907","0.4470133","0.44687185","0.44681668","0.44603863","0.44559523","0.44547662","0.44499236","0.44454923","0.44445235","0.44413328","0.4436751","0.44357875","0.44354656","0.44241446","0.44230896","0.44210672","0.44198304","0.44127834","0.44057056","0.43943405","0.43906128","0.43755594","0.4371981","0.4371481","0.43562976","0.43562976","0.43562976","0.4354846","0.4354846","0.43529055","0.4342849","0.4342084","0.43336388","0.43304396","0.43279496","0.432592","0.43256846","0.4324524"],"string":"[\n \"0.67101383\",\n \"0.61974657\",\n \"0.6165893\",\n \"0.57036895\",\n \"0.54976517\",\n \"0.5443406\",\n \"0.5429207\",\n \"0.5275951\",\n \"0.5232346\",\n \"0.52280706\",\n \"0.5203124\",\n \"0.5159468\",\n \"0.515358\",\n \"0.51510376\",\n \"0.5138082\",\n \"0.50527817\",\n \"0.50496626\",\n \"0.5037915\",\n \"0.49941966\",\n \"0.4983268\",\n \"0.4960697\",\n \"0.4960681\",\n \"0.49505866\",\n \"0.49404982\",\n \"0.4915507\",\n \"0.49084416\",\n \"0.48996848\",\n \"0.48994577\",\n \"0.48565385\",\n \"0.48502243\",\n \"0.4835316\",\n \"0.48149383\",\n \"0.47852203\",\n \"0.4783123\",\n \"0.4782393\",\n \"0.47819227\",\n \"0.475781\",\n \"0.47316402\",\n \"0.46751934\",\n \"0.46663007\",\n \"0.46359178\",\n \"0.4622071\",\n \"0.46151596\",\n \"0.46106425\",\n \"0.4607315\",\n \"0.45932975\",\n \"0.45907667\",\n \"0.45872504\",\n \"0.45677558\",\n \"0.4565503\",\n \"0.45635623\",\n \"0.456127\",\n \"0.45180824\",\n \"0.4513166\",\n \"0.45096618\",\n \"0.45052087\",\n \"0.45003203\",\n \"0.4499943\",\n \"0.44956192\",\n \"0.44949612\",\n \"0.44929588\",\n \"0.44784907\",\n \"0.4470133\",\n \"0.44687185\",\n \"0.44681668\",\n \"0.44603863\",\n \"0.44559523\",\n \"0.44547662\",\n \"0.44499236\",\n \"0.44454923\",\n \"0.44445235\",\n \"0.44413328\",\n \"0.4436751\",\n \"0.44357875\",\n \"0.44354656\",\n \"0.44241446\",\n \"0.44230896\",\n \"0.44210672\",\n \"0.44198304\",\n \"0.44127834\",\n \"0.44057056\",\n \"0.43943405\",\n \"0.43906128\",\n \"0.43755594\",\n \"0.4371981\",\n \"0.4371481\",\n \"0.43562976\",\n \"0.43562976\",\n \"0.43562976\",\n \"0.4354846\",\n \"0.4354846\",\n \"0.43529055\",\n \"0.4342849\",\n \"0.4342084\",\n \"0.43336388\",\n \"0.43304396\",\n \"0.43279496\",\n \"0.432592\",\n \"0.43256846\",\n \"0.4324524\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6925929"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19871,"cells":{"query":{"kind":"string","value":"as reduce2lat_seasonal, but both lat and lon axes are retained."},"document":{"kind":"string","value":"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv"},"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 reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def correct_lon(ds):\n ds = ds.copy()\n x = ds['x'].data\n ds['x'].data = np.where(x < 0 , 360 + x, x)\n\n lon = ds['lon'].data\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\n \n ds = ds.sortby('x')\n return ds","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def broadcast_lonlat(ds, verbose=True):\n if 'lon' not in ds.variables:\n ds.coords['lon'] = ds['x']\n if 'lat' not in ds.variables:\n ds.coords['lat'] = ds['y']\n \n if len(ds['lon'].dims) < 2:\n ds.coords[\"lon\"] = ds[\"lon\"] * xr.ones_like(ds[\"lat\"])\n if len(ds['lat'].dims) < 2:\n ds.coords[\"lat\"] = xr.ones_like(ds[\"lon\"]) * ds[\"lat\"]\n return ds","def interpolateseasons(self):\n\n remainder = self.season - self.startseason\n f1 = 1.0 - remainder\n self.data = (self.startdata * f1) + (self.stopdata * remainder)","def warren_time_series(lat, lon, dates, variable='snow_depth'):\n\n my_func = {'snow_depth': snow_depth,\n 'swe': swe}\n\n #if not all([isinstance(d, dt.datetime) for d in dates]):\n # print ('Expects datetime objects')\n\n # If lat, lon are vectors, generate 2d grids\n # Need to add code to make sure x and y are DataArrays\n if (count_dims(lat) == 1):\n x, y = np.meshgrid(lon, lat)\n else:\n x, y = lon, lat\n \n if dates.size == 1:\n cube = my_func[variable](x,y,dates.dt.month)\n da = xr.DataArray(cube,\n coords={'lat': x, 'lon': y},\n dims=['lat', 'lon'])\n else:\n cube = [my_func[variable](x, y, m) for m in dates.dt.month.values]\n da = xr.concat(cube, dim='time')\n da['time'] = dates\n\n return da","def switch_lons(ds, lon_name='lon'):\n ds = ds.copy()\n with dask.config.set(**{'array.slicing.split_large_chunks': True}):\n if np.any(ds.coords[lon_name] < 0): # if current coords are -180 to 180\n ds.coords[lon_name] = (ds.coords[lon_name] + 360) % 360\n else:\n ds.coords[lon_name] = (ds.coords[lon_name] + 180) % 360 - 180\n return ds.sortby(ds[lon_name])","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","def _fix_coords(x, y):\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\n return x, y\n lon1 = x[0]\n filter_ = x < lon1\n while filter_.sum():\n filter_ = x < lon1\n x[filter_] += 360\n return x, y","def normalize_longitude(lon: np.ndarray,\n lon_min: Optional[float] = -180.0) -> np.ndarray:\n return ((lon - lon_min) % 360) + lon_min","def msl_nn_srtm_interp(self, lon_lat):\n tiles = self.find_srtm_tiles(lon_lat)\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\n lon_lat_msl[:, 0:2] = lon_lat\n for tile in set(tiles):\n otile = rasterio.open(tile, 'r')\n oimg = otile.read(1)\n idx = np.where(np.array(tiles) == tile)[0]\n pix = feat.geo_to_pix(\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\n pix = np.round(pix).astype(np.int)\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\n otile.close()\n nan_mask = lon_lat_msl[:, 2] == -32768\n lon_lat_msl[nan_mask, 2] = np.NaN\n return lon_lat_msl","def replace_x_y_nominal_lat_lon(ds):\n ds = ds.copy()\n if 'x' in ds.dims and 'y' in ds.dims:\n \n nominal_y = ds.lat.mean('x')\n # extract the equatorial lat and take those lon values as nominal lon\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\n nominal_x = ds.lon.isel(y=eq_ind)\n ds.coords['x'].data = nominal_x.data\n ds.coords['y'].data = nominal_y.data\n\n ds = ds.sortby('x')\n ds = ds.sortby('y')\n \n else:\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\n return ds","def shifts_projection(sc, clean):\n def shifts_projected(clean, axis):\n projected = clean.map(lambda x: x.mean(axis=axis)[:, :, np.newaxis])\n target = getTarget(projected, 30, 1)\n shifts = registerByPlane(sc, projected, target[:, :, np.newaxis], 10, False)\n return shifts[:, :, 0]\n\n # shifts_xy = shifts_projected(clean, 2)\n shifts_xz = shifts_projected(clean, 1)\n shifts_yz = shifts_projected(clean, 0)\n\n # x_shifts = np.mean(np.stack((shifts_xz[:, 0], shifts_xy[:, 0])), axis=0)\n z_shifts = np.mean(np.stack((shifts_xz[:, 1], shifts_yz[:, 1])), axis=0)\n # y_shifts = np.mean(np.stack((shifts_yz[:, 0], shifts_xy[:, 1])), axis=0)\n plt.figure()\n plt.plot(shifts_xz[:, 1])\n plt.plot(shifts_yz[:, 1])\n plt.plot(z_shifts)\n plt.title('Z')\n # plt.figure()\n # plt.plot(shifts_xz[:, 0])\n # plt.plot(shifts_xy[:, 0])\n # plt.plot(x_shifts)\n # plt.title('X')\n # plt.figure()\n # plt.plot(shifts_yz[:, 0])\n # plt.plot(shifts_xy[:, 1])\n # plt.plot(y_shifts)\n # plt.title('Y')\n # shifts_all = np.stack((x_shifts, y_shifts, z_shifts))\n\n def initReg(kv):\n from scipy.ndimage.interpolation import shift\n index, volume = kv\n current_shift = (0, 0, -1 * z_shifts[int(index[0])])\n shifted = shift(volume, current_shift)\n return shifted.astype(np.int16)\n\n reg = clean.map(initReg, with_keys=True, value_shape=clean.shape[1:], dtype=np.int16)\n reg.cache()\n reg.count()\n return reg","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 map_season(x, figsize=(8, 6), **kwargs):\n\n from pycmbs.mapping import map_plot\n\n nvals = len(x.data)\n if nvals == 12:\n year = True\n elif nvals == 4:\n year = False\n else:\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\n\n #/// checks ///\n if x.data.ndim != 3:\n print x.data.ndim\n raise ValueError('only 3D data supported')\n\n if 'vmin' not in kwargs.keys():\n raise ValueError('vmin argument is obligatory for map_seasons()')\n if 'vmax' not in kwargs.keys():\n raise ValueError('vmax argument is obligatory for map_seasons()')\n\n if kwargs['vmin'] is None:\n raise ValueError('vmin MUST NOT be None!')\n if kwargs['vmax'] is None:\n raise ValueError('vmax MUST NOT be None!')\n\n #/// figure and axes\n if 'figure' in kwargs:\n f = kwargs['figure']\n else:\n f = plt.figure(figsize=figsize)\n\n if 'title' in kwargs:\n tit = kwargs.pop('title')\n else:\n tit = x.label\n\n if 'drawparallels' in kwargs:\n drawparallels = kwargs.pop('drawparallels')\n else:\n drawparallels = False\n\n if 'savefile' in kwargs:\n savefile = kwargs.pop('savefile')\n if '.nc' in savefile:\n savefile = savefile[:-3]\n else:\n savefile = None\n\n # plot\n if year:\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\n else:\n labels = ['DJF', 'MAM', 'JJA', 'SON']\n\n # check dates\n if year:\n mo = 1\n for t in x.time:\n if x.num2date(t).month != mo:\n print x.num2date(t), mo\n raise ValueError('Invalid monthly sequence! Can not plot results!')\n mo += 1\n\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\n if 'overlay' in kwargs.keys():\n overlays = kwargs.pop('overlay')\n else:\n overlays = None\n\n for i in range(nvals):\n if year:\n ax = f.add_subplot(4, 3, i + 1)\n #if i % 3 == 2:\n if i > 8:\n show_colorbar = True\n else:\n show_colorbar = False\n else:\n ax = f.add_subplot(2, 2, i + 1)\n if 'show_colorbar' in kwargs:\n show_colorbar = kwargs.pop('show_colorbar')\n else:\n show_colorbar = True\n\n d = x.copy()\n d.data = x.data[i, :, :]\n d.label = labels[i]\n\n if overlays is None:\n overlay = None\n else:\n overlay = overlays[i, :, :]\n\n if savefile is not None:\n tmpoutname = savefile + '_' + labels[i]\n else:\n tmpoutname = None\n\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\n savefile=tmpoutname, colorbar_orientation='horizontal',\n drawparallels=drawparallels, **kwargs)\n del d\n f.suptitle(tit, size=16)\n return f","def wgs84_to_mercator(df, lon, lat):\n k = 6378137\n df[\"x\"] = df[lon] * (k * np.pi/180.0)\n df[\"y\"] = np.log(np.tan((90 + df[lat]) * np.pi/360.0)) * k\n return df","def safeProj(proj, lon, lat):\n x, y = proj(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 undo_mercator_project(x,y):\n lon = y*np.pi\n ex = np.exp(4*np.pi*x)\n lat = np.arcsin((ex - 1)/(ex +1 ))\n lon = lon*360/2/np.pi\n lat = lat*360 /2/np.pi\n return lon, lat","def manipulate_data(ds, var, predef_clim, predef_trnd, trn_yrs, all_yrs, \n apply_latw=True, apply_detrending=True, dropna=True):\n\n \n if((var=='SD')|(var=='sd')|(var=='snowc')): \n ds[var] = ds[var].where(ds[var]>=0, other=0.0)\n ds[var] = ds[var].where(ds[var]==0, other=1.0)\n #ds[var].values = Gauss_filter(ds[var].values, (0,3,3))\n \n \"\"\"\n if((var=='hgt')|(var=='z')|(var=='GPT')):\n months = ds.time.to_index().month; ssn_ends = (months==2)|(months==5)|(months==8)|(months==11)\n ds = ds.sel(time=ssn_ends)\n else: \n ds = ds.resample(time='3M').mean()\n \"\"\"\n \n ds = ds.resample(time='3M').mean()\n\n ds = ds.sel(time=slice(str(all_yrs[0])+'-01-01', str(all_yrs[-1])+'-12-31')) \n \n try: \n clim = predef_clim\n ds = ds.groupby('time.season') - clim\n print('Predefined climatology used')\n except:\n clim = ds.sel(time=slice(str(trn_yrs[0])+'-01-01', str(trn_yrs[-1])+'-12-31')).groupby('time.season').mean('time')\n ds = ds.groupby('time.season') - clim\n print('Climatology calculated from data')\n \n if(apply_latw): ds[var].values = lat_weighting(ds[var].values, \n ds.lat, ds.lon)\n if(dropna):\n ds = ds.stack(gridcell=('lat', 'lon')).dropna(dim='gridcell',how='any')\n else: \n ds = ds.stack(gridcell=('lat', 'lon')).fillna(0)\n \n \n trend_models = { }\n if(apply_detrending): \n ds = ds.load()\n for ssn in ('DJF', 'MAM', 'JJA', 'SON'):\n #ssn_idx = ds['time.season'] == ssn\n \n trn_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], trn_yrs))\n all_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], all_yrs))\n \n trn_x = np.array(ds.time[trn_idx].values.tolist()).reshape(-1,1)\n all_x = np.array(ds.time[all_idx].values.tolist()).reshape(-1,1)\n try:\n trend = predef_trnd[ssn].predict(all_x)\n trend_models[ssn] = predef_trnd[ssn]\n print('Predefined trend model used')\n except:\n #_, trend_model = define_trends(ds[var][trn_idx], trn_x)\n _, trend_model = define_trends(ds[var][all_idx], all_x)\n trend = trend_model.predict(all_x)\n trend_models[ssn] = trend_model\n print('Trends calculated from data')\n \n ds[var][all_idx] = ds[var][all_idx] - trend\n \n\n \n return ds, clim, trend_models","def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \n the_season=np.array(the_season,dtype=np.int32)\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n else:\n if lat_slice.stop is None:\n num_lats=var_nc.shape[2]\n else:\n num_lats=lat_slice.stop - lat_slice.start\n if lon_slice.stop is None:\n num_lons=var_nc.shape[3]\n else:\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n num_years=var_nc.shape[0]//12\n\n for the_year in np.arange(0,num_years):\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n the_season=the_season+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def satReader(directory,month,latmin,latmax,lonmin,lonmax):\n \n ### Enter filename\n filename = 'cs2icesat_regrid_mar_20042015.nc' \n \n ### Month/Years extracted\n dateyr = now.year \n datemo = datetime.date(dateyr,month+1,1).strftime('%B')\n \n ### Retrieve data\n data = Dataset(directory + filename)\n lat = data.variables['lat'][:]\n lon = data.variables['lon'][:]\n thkn = data.variables['thick'][:]\n data.close()\n \n ### Calculate lat/lon region\n xmask = (lat > latmin) & (lat < latmax)\n ymask = (lon > lonmin) & (lon < lonmax)\n \n mask = xmask[:] & ymask[:]\n latvals = np.where(mask == True)[0]\n lonvals = np.where(mask == True)[1]\n latvals = np.unique(latvals)\n lonvals = np.unique(lonvals)\n \n thk = thkn[:,latvals,:]\n thk = thk[:,:,lonvals]\n \n lat = lat[latvals,:]\n lat = lat[:,lonvals]\n lon = lon[latvals,:]\n lon = lon[:,lonvals]\n\n grid = '---> [[%s to %s N, %s to %s E]]' % (latmin,latmax,lonmin,lonmax)\n print 'Completed: Satellite data read (%s)!' % datemo, grid\n \n return lat,lon,thk","def extract_seasonal_component(original_ts, ppy):\n \"\"\"\n # === get in-sample data\n original_ts = original_ts[:-out_of_sample]\n \"\"\"\n if seasonality_test(original_ts, ppy):\n # print(\"seasonal\")\n # ==== get moving averages\n ma_ts = moving_averages(original_ts, ppy)\n\n # ==== get seasonality indices\n le_ts = original_ts * 100 / ma_ts\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\n le_ts = np.reshape(le_ts, (-1, ppy))\n si = np.nanmean(le_ts, 0)\n norm = np.sum(si) / (ppy * 100)\n si = si / norm\n else:\n # print(\"NOT seasonal\")\n si = np.full(ppy, 100)\n return si","def reverse(self, lon, lat):","def timeave_seasonal( mv, seasons=seasonsyr ):\n return seasons.climatology(mv)","def flowline_latlon(coords, fromproj=pyproj.Proj(\"+init=epsg:3413\"), toproj=pyproj.Proj(\"+init=EPSG:4326\")):\n xs = coords[:,0]\n ys = coords[:,1]\n x_lon, y_lat = pyproj.transform(fromproj, toproj, xs, ys)\n latlon_coords = np.asarray(zip(x_lon, y_lat))\n return latlon_coords","def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax is None:\n print \"WARNING- no time axis in\",mv.id\n return None\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n print \"WARNING- cannot compute climatology for\",mv.id,seasons.seasons\n print \"...probably there is no data for times in the requested season.\"\n return None\n avmv = mvseas\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def set_coord_values(ds, wrf_out, footprint_nbins):\n xdim_var = ds.variables[\"dim_x\"]\n ydim_var = ds.variables[\"dim_y\"]\n xdim_bounds_var = ds.variables[\"dim_x_bnds\"]\n ydim_bounds_var = ds.variables[\"dim_y_bnds\"]\n lon_var = ds.variables[\"longitude\"]\n lat_var = ds.variables[\"latitude\"]\n\n time_back_var = ds.variables[\"time_before_observation\"]\n time_back_bounds_var = ds.variables[\"time_before_observation_bnds\"]\n\n height_var = ds.variables[\"height\"]\n height_bounds_var = ds.variables[\"height_bnds\"]\n\n dx = wrf_out[\"dx\"]\n\n xdim_data = wrf_out[\"proj_x_coord\"][0]\n ydim_data = wrf_out[\"proj_y_coord\"][0]\n xdim_var[:] = xdim_data[:]\n ydim_var[:] = ydim_data[:]\n\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\n xdim_bounds_var[-1,0] = xdim_data[-1]\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\n ydim_bounds_var[-1,0] = ydim_data[-1]\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\n\n wrf_lats = wrf_out[\"wrf_lat\"][0][0, :, :]\n wrf_lons = wrf_out[\"wrf_lon\"][0][0, :, :]\n lat_var[:, :] = wrf_lats[:, :]\n lon_var[:, :] = wrf_lons[:, :]\n\n ds.geospatial_lat_min = wrf_lats.min()\n ds.geospatial_lat_max = wrf_lats.max()\n ds.geospatial_lat_units = \"degree_north\"\n ds.geospatial_lon_min = wrf_lons.min()\n ds.geospatial_lon_max = wrf_lons.max()\n ds.geospatial_lon_units = \"degree_east\"\n\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\n time_back_var[:] = time_back_vals\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\n time_back_vals[1:]))\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\n\n height_var[...] = 0\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)","def lat_lons(self):","def convert_coords(date, time_steps, azs, els, obs):\n coord_start_day = datetime(date.year, date.month, date.day)\n \n strategy = []\n for time_step, az, el in zip(time_steps, azs, els):\n if az % np.pi == 0.0: \n az += EPS\n \n ra, dec = sphere.altaz_to_ra_dec(coord_start_day + timedelta(hours=time_step), az, el, obs)\n strategy.append([ra, dec])\n \n return np.array(strategy)","def project_normalize_coordinates(node_feats, transformer=None, crs=None):\n # get home node:\n home_node = node_feats.iloc[\n (node_feats[\"in_degree\"] + node_feats[\"out_degree\"]).argmax()\n ]\n home_center = home_node[\"center\"]\n\n @to_series\n def get_projected_displacement(x, y, home_center):\n if (x_min < x < x_max) and (y_min < y < y_max):\n proj_x, proj_y = transformer.transform(x, y)\n home_x, home_y = transformer.transform(home_center.x, home_center.y)\n return (proj_x - home_x, proj_y - home_y)\n else: # fall back to haversine\n return get_haversine_displacement.__wrapped__(x, y, home_center)\n\n if transformer is not None:\n # get bounds\n x_min, y_min, x_max, y_max = crs.area_of_use.bounds\n normed_coords = node_feats[\"center\"].apply(\n get_projected_displacement, args=[home_center]\n )\n else:\n normed_coords = node_feats[\"center\"].apply(\n get_haversine_displacement, args=[home_center]\n )\n\n # add_distance\n normed_coords[\"distance\"] = normed_coords.apply(\n lambda x: np.sqrt(x[0] ** 2 + x[1] ** 2), axis=1\n )\n # TODO: add as a TEST! compare haversine dist to fake-projected coordinates\n # print(normed_coords[\"distance\"])\n # test_distance = node_feats[\"center\"].apply(\n # lambda point: ti.geogr.point_distances.haversine_dist(\n # point.x, point.y, home_center.x, home_center.y\n # )[0]\n # )\n # print(\n # pd.merge(\n # normed_coords, test_distance, left_index=True, right_index=True\n # )\n # )\n\n return pd.merge(\n node_feats, normed_coords, left_index=True, right_index=True\n )","def _basemap_1d(x, *ys, projection=None):\n xmin, xmax = projection.lonmin, projection.lonmax\n x_orig, ys_orig = x, ys\n ys = []\n for y_orig in ys_orig:\n x, y = _fix_span(*_fix_coords(x_orig, y_orig), xmin, xmax)\n ys.append(y)\n return x, *ys","def test_custom_lon_lat_range():\n import astropy.units as u\n lrange = [-50,-40]\n brange = [-10,10]\n spiral_arm = survey.get_spiral_slice(track = \"Carina_far\", \n lrange = lrange, \n brange = brange)\n spiral_arm2 = survey.get_spiral_slice(track = \"CrF\", \n lrange = lrange*u.deg, \n brange = brange*u.deg)\n\n assert np.allclose(spiral_arm[\"INTEN\"], spiral_arm2[\"INTEN\"], equal_nan = True)","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_latlon(ds, n=50):\n\n nx = ncols(ds)\n ny = nrows(ds)\n src_crs = get_crs(ds)\n dst_crs = CRS(init='epsg:4326')\n idx_x = np.linspace(0, nx - 1, n, dtype=int)\n idx_y = np.linspace(0, ny - 1, n, dtype=int)\n xs = ds.x[idx_x]\n ys = ds.y[idx_y]\n xgrid, ygrid = np.meshgrid(xs, ys)\n lon, lat = rasterio.warp.transform(src_crs, dst_crs, xgrid.flatten(),\n ygrid.flatten())\n lon_sparse = np.empty((ny, nx))\n lat_sparse = np.empty((ny, nx))\n lon_sparse[:] = np.nan\n lat_sparse[:] = np.nan\n # idx_y needs to be a column vector\n lon_sparse[idx_y[:, None], idx_x] = np.array(lon).reshape((n, n))\n lat_sparse[idx_y[:, None], idx_x] = np.array(lat).reshape((n, n))\n ds.coords['lat'] = (('y', 'x'), lat_sparse)\n ds.coords['lon'] = (('y', 'x'), lon_sparse)","def fix_coords_non_symetric_lon(cube):\n # first fix any completely missing coord var names\n utils.fix_dim_coordnames(cube)\n # fix individual coords\n for cube_coord in cube.coords():\n # fix time\n if cube_coord.var_name == 'time':\n logger.info(\"Fixing time...\")\n cube.coord('time').convert_units(\n Unit('days since 1950-1-1 00:00:00', calendar='gregorian'))\n utils.fix_bounds(cube, cube.coord('time'))\n\n # fix longitude\n if cube_coord.var_name == 'lon':\n logger.info(\"Fixing longitude...\")\n if cube_coord.ndim == 1:\n if cube_coord.points[0] < 0. and \\\n cube_coord.points[-1] < 181.:\n lon_coord = cube.coord('longitude').copy()\n lons_below_0 = lon_coord.points[lon_coord.points < 0.] + \\\n 360.\n lons_above_0 = lon_coord.points[lon_coord.points >= 0.]\n lons = np.hstack((lons_above_0, lons_below_0))\n cube_coord.points = lons\n\n utils.fix_bounds(cube, cube_coord)\n cube.attributes['geospatial_lon_min'] = 0.\n cube.attributes['geospatial_lon_max'] = 360.\n utils.roll_cube_data(cube, len(lons_above_0), -1)\n\n # fix latitude\n if cube_coord.var_name == 'lat':\n logger.info(\"Fixing latitude...\")\n utils.fix_bounds(cube, cube.coord('latitude'))\n\n # fix depth\n if cube_coord.var_name == 'lev':\n logger.info(\"Fixing depth...\")\n utils.fix_bounds(cube, cube.coord('depth'))\n\n # fix air_pressure\n if cube_coord.var_name == 'air_pressure':\n logger.info(\"Fixing air pressure...\")\n utils.fix_bounds(cube, cube.coord('air_pressure'))\n\n # remove CS\n cube.coord('latitude').coord_system = None\n cube.coord('longitude').coord_system = None\n\n return cube","def _is_valid_latlong_series(series):\n if ww.accessor_utils._is_dask_series(series):\n series = series = series.get_partition(0).compute()\n if ww.accessor_utils._is_koalas_series(series):\n series = series.to_pandas()\n bracket_type = list\n else:\n bracket_type = tuple\n if series.apply(_is_valid_latlong_value, args=(bracket_type,)).all():\n return True\n return False","def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\n import numpy as np\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\n\n def plotter(pdata, colormax=1, colormin=-999, title=''):\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \n if colormin == -999:\n colormin = -colormax\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\n pdata, lon = addcyclic(pdata, lon)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\n mycmap1 = plt.cm.Blues_r(np.arange(256))\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\n my_cmap[230:282, :] = 1\n if precip == 'yes':\n my_cmap = my_cmap[::-1]\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\"newjet\", my_cmap)\n ctrs = np.linspace(colormin, colormax, 17)\n plot = m.contourf(x, y, pdata, ctrs,\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\n extend='both')\n\n plt.title(title, y=1)\n plt.show()\n return plot\n\n ax1 = fig.add_subplot(3, 3, 1)\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\n ax2 = fig.add_subplot(3, 3, 2)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\n ax3 = fig.add_subplot(3, 3, 3)\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\n ax4 = fig.add_subplot(3, 3, 4)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\n ax5 = fig.add_subplot(3, 3, 5)\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\n ax6 = fig.add_subplot(3, 3, 6)\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\n ax7 = fig.add_subplot(3, 3, 7)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\n ax8 = fig.add_subplot(3, 3, 9)\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\n ax9 = fig.add_subplot(3, 3, 8)\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\n\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\n orientation='horizontal', extend='max')\n \n b.set_label(label='t200 difference ($^\\circ$C)', size=20, fontsize=20, fontname='Arial')\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\n right=.95)","def unproject(self, (x, y)):\n lng = x/EARTH_RADIUS * RAD_TO_DEG\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\n return (lng, lat)","def add_rain_clim_normals(gdf_of_interest,\n grid_of_rain_clim_norm_y = clim_norm_rain_y_np_unique, \n grid_of_rain_clim_norm_x = clim_norm_rain_x_np_unique): \n mean_monthly_rainfall = []\n for index in gdf_of_interest.index:\n closest_y_index = find_nearest_point_1D(grid_of_rain_clim_norm_y, \n gdf_of_interest.geometry.y[index], \n print_nearest_val=False)\n closest_x_index = find_nearest_point_1D(grid_of_rain_clim_norm_x, \n gdf_of_interest.geometry.x[index], \n print_nearest_val=False)\n \n month_of_interest = int(gdf_of_interest[\"Month\"][0])\n month_of_int_format = \"m\" + str(month_of_interest)\n \n mean_monthly_rainfall.append(gdf_clim_norm_rain_mean.loc[\n (gdf_clim_norm_rain_mean[\"east\"] == grid_of_rain_clim_norm_x[closest_x_index]) &\n (gdf_clim_norm_rain_mean[\"north\"] == grid_of_rain_clim_norm_y[closest_y_index]),\n month_of_int_format].values[0])\n \n \n \n gdf_of_interest[\"Mean Monthly Rainfall\"] = mean_monthly_rainfall\n \n return","def map_ll_to_seviri(lon, lat):\n # new method\n # project lat/lon input to meteosat view, mask out of bounds data\n geos = pyproj.Proj(proj='geos', h=35785831.0,lon_0=0,lat_0=0,x_0=0,y_0=0,units='m')\n x,y = geos(lon,lat)\n x = ma.masked_equal(x,1e30)\n y = ma.masked_equal(y,1e30)\n # Convert to index. ~3000.5m per pixel, centre pixel index is [1855,1855]\n x = x/-3000.5+1855\n y = y/3000.5+1855\n return x,y\n # old method\n \"\"\"\n # Define Earth radius and geostationary orbit height in km and calucalte max\n # viewer angle\n r_sat = 42164.\n r_earth = 6378.\n zenith_max = np.arcsin(r_earth/r_sat)\n # convert lat/lon to cartesian coordinates\n x = np.cos(np.radians(lat)) * np.sin(np.radians(lon))\n y = np.sin(np.radians(lat))\n z = np.cos(np.radians(lat)) * np.cos(np.radians(lon))\n # x,y vector magnitude\n d = np.sqrt(x**2 + y**2)\n # Calculate footprint SEVIRI effective zenith angle and mask for > pi/2\n # values\n zenith = np.arctan2(d, z) + np.arctan2(r_earth*d, r_sat-r_earth*z)\n zenith_mask = np.abs(zenith) >= (0.5 * np.pi)\n # Calculate x and y viewer angles\n theta_x = np.arctan2(r_earth*x, r_sat-r_earth*z)\n theta_y = np.arctan2(r_earth*y, r_sat-r_earth*z)\n # Define SEVIRI global index range and offset\n # These should be the same on all files, but may need to check\n x_irange = 3623\n x_ioffset = 44\n y_irange = 3611\n y_ioffset = 51\n # Remap viewer angles to indexes using max viewer angle, index range and\n # offset. Note -ve theta_y as SEVIRI indexes the x-axis right to left(E-W)\n x_out = (1 - theta_x / zenith_max) * 0.5 * x_irange + x_ioffset\n y_out = (1 + theta_y / zenith_max) * 0.5 * y_irange + y_ioffset\n # Return masked arrays using the zenith angle mask\n return ma.array(x_out, mask=zenith_mask), ma.array(y_out, mask=zenith_mask)\n \"\"\"","def reproject(self, lon, lat):\n if self.xform is None:\n # if the CRS hasn't been determined yet, we set it from the first image's lat/lon (take the UTM crs)\n utm_i = str(int(math.floor((self.images[0].lon + 180) / 6 ) % 60) + 1).zfill(2)\n epsg_code = int('326' + utm_i) if (self.images[0].lat >= 0) else int('327' + utm_i)\n self.crs_dest = QgsCoordinateReferenceSystem(epsg_code)\n self.xform = QgsCoordinateTransform(self.crs_src, self.crs_dest, QgsProject.instance())\n return self.xform.transform(QgsPointXY(lon, lat))","def apply_lon_filter(data, lon_bounds):\n \n # Convert to common bounds (0, 360)\n lon_min = adjust_lon_range(lon_bounds[0], radians=False, start=0.0)\n lon_max = adjust_lon_range(lon_bounds[1], radians=False, start=0.0)\n lon_axis = adjust_lon_range(data.getLongitude()[:], radians=False, start=0.0)\n\n # Make required values zero\n ntimes, nlats, nlons = data.shape\n lon_axis_tiled = numpy.tile(lon_axis, (ntimes, nlats, 1))\n \n new_data = numpy.where(lon_axis_tiled < lon_min, 0.0, data)\n \n return numpy.where(lon_axis_tiled > lon_max, 0.0, new_data)","def _reindex_spatial_data_to_regions(ds, df):\n\n # use vectorized indexing in xarray >= 0.10\n if LooseVersion(xr.__version__) > LooseVersion(\"0.9.999\"):\n\n lon_indexer = xr.DataArray(df.lon.values, dims=(\"reshape_index\",))\n lat_indexer = xr.DataArray(df.lat.values, dims=(\"reshape_index\",))\n\n return ds.sel(lon=lon_indexer, lat=lat_indexer)\n\n else:\n res = ds.sel_points(\"reshape_index\", lat=df.lat.values, lon=df.lon.values)\n\n return res","def winter_avg(var_nc,lat_slice=None,lon_slice=None): \n #\n # accumulate in shape [plev,lat,lon]\n #\n # use the whole array if slice objects are missing\n #\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n print \"in winter avg: \",lat_slice,lon_slice\n else:\n num_lats=lat_slice.stop - lat_slice.start\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n #\n # year 0 is special case since it doesn't have a december\n #\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\n accumulate+=the_slice\n num_years=var_nc.shape[0]//12\n #\n # now year 1 has year 0's december\n #\n djf=np.array([11,12,13],dtype=np.int32)\n #\n # iterate one year less because we've alread\n # done year zero as a special case\n #\n for the_year in np.arange(0,num_years-1):\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n djf=djf+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def compute_stage4(lon, lat, year):\n nc = netCDF4.Dataset(\"/mesonet/data/stage4/%s_stage4_hourly.nc\" % (year,))\n lons = nc.variables[\"lon\"][:]\n lats = nc.variables[\"lat\"][:]\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\n (yidx, xidx) = np.unravel_index(dist.argmin(), dist.shape)\n print(\n (\"Computed stage4 nclon:%.2f nclat:%.2f yidx:%s xidx:%s \")\n % (lons[yidx, xidx], lats[yidx, xidx], yidx, xidx)\n )\n p01i = mm2inch(nc.variables[\"p01m\"][:, yidx, xidx])\n nc.close()\n df = pd.DataFrame(\n {\"precip\": 0.0},\n index=pd.date_range(\n \"%s-01-01\" % (year,), \"%s-12-31\" % (year,), tz=\"America/Chicago\"\n ),\n )\n for date in df.index.values:\n date2 = datetime.datetime.utcfromtimestamp(date.tolist() / 1e9)\n ts = datetime.datetime(date2.year, date2.month, date2.day, 6)\n ts = ts.replace(tzinfo=pytz.utc)\n ts = ts.astimezone(pytz.timezone(\"America/Chicago\"))\n ts = ts.replace(hour=0)\n ts = ts.astimezone(pytz.utc)\n tidx = hourly_offset(ts)\n # values are in the rears\n val = np.ma.sum(p01i[tidx + 1 : tidx + 25])\n if val > 0:\n df.at[date, \"precip\"] = val # close enough\n return df","def location_change(lon, lat, dim='time', ilon=None, ilat=None, as_event=True, distance_threshold=10, window=180,\n dates=None, **kwargs):\n import numpy as np\n from xarray import DataArray, full_like\n from ..fun.cal import distance\n\n # count occurence of each coordinate pair\n # use the most common (also the most recent?)\n # to estimate distance from,\n # era-interim has a distance of about 80km so only if larger it would make sense to split?\n if not isinstance(lon, DataArray):\n raise ValueError('requires a DataArray', type(lon))\n if not isinstance(lat, DataArray):\n raise ValueError('requires a DataArray', type(lat))\n\n lon = lon.copy()\n lat = lat.copy()\n lon = lon.bfill(dim)\n lat = lat.bfill(dim)\n\n dist = full_like(lon, 0, dtype=np.float)\n dist.name = 'distance'\n dist.attrs['units'] = 'km'\n fdistance = np.vectorize(distance)\n ishape = lon.values.shape\n lon = lon.values.flatten()\n lat = lat.values.flatten()\n if ilon is None and ilat is None:\n if lon.size > 1:\n # distance between more recent and less recent\n tmp = fdistance(lon[1:], lat[1:], lon[:-1], lat[:-1])\n tmp = np.append(tmp, tmp[-1])\n else:\n tmp = np.array([0])\n dist.values = tmp.reshape(ishape)\n dist.attrs['method'] = 'Backwards'\n else:\n tmp = fdistance(lon, lat, ilon, ilat)\n dist.values = tmp.reshape(ishape)\n dist.attrs['method'] = 'Point(%f E, %f N)' % (ilon, ilat)\n\n # Check for duplicates\n if dist[dim].to_index().duplicated().any():\n dist = dist.isel({dim: ~dist[dim].to_index().duplicated()})\n\n if as_event:\n dist.values = (dist > distance_threshold).astype(float) \\\n .rolling(center=True, min_periods=1, **{dim: window}).mean() \\\n .rolling(center=True, min_periods=1, **{dim: window}).sum()\n dist.attrs['threshold'] = distance_threshold\n dist.attrs['standard_name'] = 'location_change_point'\n if dates is not None:\n dist = dist.reindex(time=dates, method='nearest', fill_value=0) # reindex\n else:\n dist.attrs['standard_name'] = 'distance'\n if dates is not None:\n dist = dist.reindex(time=dates, method='nearest').bfill(dim).ffill(dim)\n\n return dist","def _fixup_coords(self, var):\n for coord_name, data_array in var.coords.items():\n if data_array.attrs.get('standard_name') in ('projection_x_coordinate',\n 'projection_y_coordinate'):\n try:\n var.coords[coord_name].metpy.convert_units('meters')\n except DimensionalityError: # Radians!\n new_data_array = data_array.copy()\n height = var.coords['crs'].item()['perspective_point_height']\n scaled_vals = new_data_array.metpy.unit_array * (height * units.meters)\n new_data_array.metpy.unit_array = scaled_vals.to('meters')\n var.coords[coord_name] = new_data_array","def interpolate(self, lon: np.ndarray, lat: np.ndarray,\n dates: np.ndarray) -> np.ndarray:\n ds = self._select_ds(\n dates.min(), # type: ignore\n dates.max()) # type: ignore\n assert np.all(np.diff(ds.ocean_time.values) == self._dt)\n interpolator = pyinterp.backends.xarray.RegularGridInterpolator(\n ds[self.ssh])\n return interpolator(dict(lat_rho=lat.ravel(),\n lon_rho=lon.ravel(),\n ocean_time=dates.ravel()),\n method=\"bilinear\",\n bounds_error=False).reshape(lon.shape)","def F_interp_geos_mat(sounding_lon,sounding_lat,sounding_datenum,\\\n geos_dir='/mnt/Data2/GEOS/s5p_interp/',\\\n interp_fields=['TROPPT']):\n from scipy.io import loadmat\n from scipy.interpolate import RegularGridInterpolator\n \n start_datenum = np.amin(sounding_datenum)\n end_datenum = np.amax(sounding_datenum)\n start_datetime = datedev_py(start_datenum)\n start_year = start_datetime.year\n start_month = start_datetime.month\n start_day = start_datetime.day\n start_hour = start_datetime.hour\n \n end_datetime = datedev_py(end_datenum)\n end_year = end_datetime.year\n end_month = end_datetime.month\n end_day = end_datetime.day\n end_hour = end_datetime.hour\n end_minute = end_datetime.minute\n end_second = end_datetime.second\n \n step_hour = 3 # geos fp data are 3-hourly\n \n geos_start_hour = start_hour-start_hour%step_hour\n geos_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=geos_start_hour)\n if end_hour > 24-step_hour or (end_hour == 24-step_hour and (end_minute > 0 or end_second > 0)):\n geos_end_hour = 0\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour) +datetime.timedelta(days=1)\n elif end_hour%step_hour == 0 and end_minute == 0 and end_second == 0:\n geos_end_hour = end_hour\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\n else:\n geos_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\n \n nstep = (geos_end_datetime-geos_start_datetime).total_seconds()/3600/step_hour+1\n nstep = int(nstep)\n \n geos_data = {}\n # load narr data\n for istep in range(nstep):\n file_datetime = geos_start_datetime+datetime.timedelta(hours=step_hour*istep)\n file_dir = os.path.join(geos_dir,file_datetime.strftime('Y%Y'),\\\n file_datetime.strftime('M%m'),\\\n file_datetime.strftime('D%d'))\n file_path = os.path.join(file_dir,'subset_'+file_datetime.strftime('%Y%m%d_%H')+'.mat')\n if not geos_data:\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],interp_fields)))\n geos_data['lon'] = mat_data['lon'].flatten()\n geos_data['lat'] = mat_data['lat'].flatten()\n geos_data['datenum'] = np.zeros((nstep),dtype=np.float64)\n for fn in interp_fields:\n geos_data[fn] = np.zeros((len(geos_data['lon']),len(geos_data['lat']),nstep))\n geos_data[fn][...,istep] = mat_data[fn]\n else:\n mat_data = loadmat(file_path,variable_names=interp_fields)\n for fn in interp_fields:\n geos_data[fn][...,istep] = mat_data[fn]\n \n geos_data['datenum'][istep] = (file_datetime.toordinal()\\\n +file_datetime.hour/24.\\\n +file_datetime.minute/1440.\\\n +file_datetime.second/86400.+366.)\n # interpolate\n sounding_interp = {}\n for fn in interp_fields:\n my_interpolating_function = \\\n RegularGridInterpolator((geos_data['lon'],geos_data['lat'],geos_data['datenum']),\\\n geos_data[fn],bounds_error=False,fill_value=np.nan)\n sounding_interp[fn] = my_interpolating_function((sounding_lon,sounding_lat,sounding_datenum))\n return sounding_interp","def msl_to_wgs84(self, lon_lat_msl):\n geoid = rasterio.open(self.geoid)\n lon_lat_hae = np.zeros_like(lon_lat_msl)\n lon_lat_hae[:, 0:2] = lon_lat_msl[:, 0:2]\n gimg = geoid.read(1)\n geo = feat.wgs84_to_geo(\n geoid.crs, lon_lat_msl[:, 0], lon_lat_msl[:, 1])\n pix = feat.geo_to_pix(geoid.affine, geo[:, 0], geo[:, 1])\n pix = np.round(pix).astype(np.int)\n hae = lon_lat_msl[:, 2] + gimg[pix[:, 1], pix[:, 0]]\n lon_lat_hae[:, 2] = hae\n return lon_lat_hae","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def correct_coordinates(ds, verbose=False):\n ds = ds.copy()\n for co in ['x', 'y', 'lon', 'lat', 'lev',\n \"bnds\", \"lev_bounds\", \"lon_bounds\", \"lat_bounds\", \"time_bounds\",\n 'vertices_latitude', 'vertices_longitude',\n ]:\n if co in ds.variables:\n if verbose:\n print('setting %s as coord' %(co))\n ds = ds.set_coords(co)\n return ds","def Reproject(x, y, in_grid = 4326, out_grid = 32737):\n \n inProj = Proj(init='epsg:'+str(in_grid))\n outProj = Proj(init='epsg:'+str(out_grid))\n \n \n x2,y2 = transform(inProj,outProj,x,y)\n \n return x2, y2","def transform(self, resampled_xray, n_burn_in, n_lookahead, skf_is): \n # Set all temps on world map as features\n #valid_range = range(n_burn_in, temperatures_xray['time'].shape[0] - n_lookahead)\n #time_steps, lats, lons = temperatures_xray['tas'].values.shape\n #X = temperatures_xray['tas'].values.reshape((time_steps,lats*lons))\n #X = X[valid_range,:]\n\n tas = select_box(resampled_xray['tas']) \n\n valid_range = range(n_burn_in, resampled_xray['time'].shape[0] - n_lookahead)\n #enso = get_enso_mean(temperatures_xray['tas'])\n # reshape the vector into a table years as rows, months as columns\n #enso_matrix = enso.values.reshape((-1,12))\n\n theShape = tas.shape\n n_time,n_lat,n_long = theShape[0],theShape[1],theShape[2] \n #print n_time,n_lat,n_long \n enso_matrix = tas.values.reshape(-1,12,n_lat,n_long)\n\n count_matrix = np.ones(enso_matrix.shape)\n # compute cumulative means of columns (remember that you can only use\n # the past at each time point) and reshape it into a vector\n enso_monthly_mean = (enso_matrix.cumsum(axis=0) / count_matrix.cumsum(axis=0)).reshape(-1,n_lat,n_long)#.ravel()\n # roll it backwards (6 months) so it corresponds to the month of the target\n\n enso_anomaly = tas - enso_monthly_mean\n\n enso_anomaly_rolled = np.roll(enso_anomaly, n_lookahead - 12,axis = 0)\n # select valid range\n enso_anomaly_rolled_valid = enso_anomaly_rolled[valid_range,:,:]\n # reshape it into a matrix of a single column\n X = enso_anomaly_rolled_valid.reshape(-1,n_lat*n_long)\n\n return X","def atom_to_internal_coordinates(self, verbose: bool = ...) -> None:\n ...","def atom_to_internal_coordinates(self, verbose: bool = ...) -> None:\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[:])","def lateralising_but_not_localising(full_row,\n side_of_symptoms_signs,\n pts_dominant_hemisphere_R_or_L,\n lat_only_Right,\n lat_only_Left):\n lat_only_Right, lat_only_Left = summarise_overall_lat_values(full_row,\n side_of_symptoms_signs,\n pts_dominant_hemisphere_R_or_L,\n lat_only_Right,\n lat_only_Left)\n\n return lat_only_Right, lat_only_Left","def seasonal_series(t, y, edges=None, hard=False):\n t = ensure_tarray(t)\n if len(t) == 1:\n return [t], [y]\n season_ixs = season_indices(t, edges=edges, hard=hard)\n ts = []\n ys = []\n for season in season_ixs:\n ts.append(astropy.time.Time(t.jyear[season], format='jyear', scale=t.scale))\n ys.append(y[season])\n return ts, ys","def lonlat2xy(s_lon, s_lat): # x: easting, y: northing\r\n # convert decimals to seconds...\r\n s_lon = dec2sec(s_lon)\r\n s_lat = dec2sec(s_lat)\r\n\r\n ## Auxiliary values \r\n # i.e. differences of latitude and longitude relative to Bern in the unit [10000'']\r\n s_lng_aux = (s_lon - 26782.5)/10000.\r\n s_lat_aux = (s_lat - 169028.66)/10000.\r\n \r\n # easting\r\n s_x = (600072.37 \r\n + 211455.93*s_lng_aux \r\n - 10938.51*s_lng_aux*s_lat_aux \r\n - 0.36*s_lng_aux*(s_lat_aux**2) \r\n - 44.54*(s_lng_aux**3))\r\n \r\n # northing\r\n s_y = (200147.07 \r\n + 308807.95*s_lat_aux \r\n + 3745.25*(s_lng_aux**2) \r\n + 76.63*(s_lat_aux**2) \r\n - 194.56*(s_lng_aux**2)*s_lat_aux \r\n + 119.79*(s_lat_aux**3))\r\n\r\n return s_x, s_y","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 regrid_longitude_coord(self, cube):\n # make a list with the 'longitude' coord in the form: 0/180/-180/0\n neg_lons = ((cube.coord(\"longitude\").points + 180) % 360) - 180\n # interpolates the cube data to the new 'longitude' dimensions\n cube = cube.interpolate([(\"longitude\", neg_lons)],\n iris.analysis.Linear())\n sorted_cube = self.sorted_dim(cube)\n return sorted_cube","def calculate_latlon_bnds(lats, lons, lat_ax=0):\n if not 1 <= lats.ndim <= 2 or not 1 <= lons.ndim <= 2:\n raise ValueError('Input lats and lons must be 1D or 2D')\n if lats.ndim != lons.ndim:\n raise ValueError(\n 'Input lats and lons must have the same dimensions')\n if lats.ndim > 1 and lats.shape != lons.shape:\n raise ValueError('2D lats and lons must have same array shape.')\n\n if lats.ndim == 2:\n lon_ax = int(np.logical_not(lat_ax))\n bnd_2d = True\n else:\n lat_ax = lon_ax = 0\n bnd_2d = False\n\n dim_order = sorted([lat_ax, lon_ax])\n\n lat_space = np.diff(lats, axis=lat_ax)\n lon_space = np.diff(lons, axis=lon_ax)\n\n nlat = lats.shape[lat_ax]\n nlon = lons.shape[lon_ax]\n\n lat_bnd_shp = [dim_len + 1 for dim_len in lats.shape]\n lon_bnd_shp = [dim_len + 1 for dim_len in lons.shape]\n\n lat_bnds = np.zeros(lat_bnd_shp)\n lon_bnds = np.zeros(lon_bnd_shp)\n\n # Handle cyclic point if necessary\n if bnd_2d:\n if np.any(lon_space > 300):\n i_idx, j_idx = np.where(lon_space > 300)\n lon_space[i_idx, j_idx] = lon_space[i_idx, j_idx + 1]\n\n if np.any(lon_space < -300):\n i_idx, j_idx = np.where(lon_space < -300)\n lon_space[i_idx, j_idx] = lon_space[i_idx, j_idx - 1]\n else:\n if np.any(lon_space > 300):\n i_idx, = np.where(lon_space > 300)\n lon_space[i_idx] = lon_space[i_idx + 1]\n\n if np.any(lon_space < -300):\n i_idx, = np.where(lon_space < -300)\n lon_space[i_idx] = lon_space[i_idx - 1]\n\n # Handle out of bounds latitudes\n lat_space[lat_space > 90] = 90\n lat_space[lat_space < -90] = -90\n\n lon_sl = slice(0, nlon - 1)\n lat_sl = slice(0, nlat - 1)\n all_but_last = slice(0, -1)\n last_two = slice(-2, None)\n all_vals = slice(None)\n\n # TODO: Not an elegant solution for variable dimension order but I think it\n # works...\n if bnd_2d:\n # Create slices to be used for general dimension order\n bnd_slice = (all_but_last, lon_sl)\n coord_slice = (all_vals, all_but_last)\n bnd_end_slice = (all_but_last, last_two)\n coord_end_slice = (all_vals, last_two)\n diff_end_slice = (all_vals, last_two)\n cyclic_bnd_dst = (-1, all_vals)\n cyclic_bnd_src = (-2, all_vals)\n\n # If lon changes over first dimension we want to reverse the slice\n # tuples\n if lon_ax == 0:\n rev = -1\n else:\n rev = 1\n\n lon_bnds[bnd_slice[::rev]] = lons[coord_slice[\n ::rev]] - lon_space / 2\n lon_bnds[bnd_end_slice[::rev]] = (lons[coord_end_slice[::rev]] +\n lon_space[diff_end_slice[\n ::rev]] / 2)\n lon_bnds[cyclic_bnd_dst[::rev]] = lon_bnds[\n cyclic_bnd_src[::rev]]\n\n # Adjust the bnd slice for latitude dimension\n bnd_slice = (all_but_last, lat_sl)\n\n # If lat changes over first dimension we want to reverse the slice\n # tuples\n if lat_ax == 0:\n rev = -1\n else:\n rev = 1\n\n lat_bnds[bnd_slice[::rev]] = lats[coord_slice[\n ::rev]] - lat_space / 2\n lat_bnds[bnd_end_slice[::rev]] = (lats[coord_end_slice[::rev]] +\n lat_space[diff_end_slice[\n ::rev]] / 2)\n lat_bnds[cyclic_bnd_dst[::rev]] = lat_bnds[\n cyclic_bnd_src[::rev]]\n\n else:\n lon_bnds[lon_sl] = lons[all_but_last] - lon_space / 2\n lon_bnds[last_two] = lons[last_two] + lon_space[last_two] / 2\n\n lat_bnds[lat_sl] = lats[all_but_last] - lat_space / 2\n lat_bnds[last_two] = lats[last_two] + lat_space[last_two] / 2\n\n return lat_bnds, lon_bnds","def to_series(func):\n\n @wraps(func)\n def add_series(center, home_center):\n normed_center = func(center.x, center.y, home_center)\n return pd.Series(normed_center, index=[\"x_normed\", \"y_normed\"])\n\n return add_series","def lon360to180(lon):\n\tlon = np.asanyarray(lon)\n\treturn ((lon + 180.) % 360.) - 180.","def seasonal_calc(t, y, func, edges=None):\n ts, ys = seasonal_series(t, y, edges=edges)\n t_means = [t.jyear.mean() for t in ts]\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\n f_y = np.array([func(y) for y in ys])\n return t_means, f_y","def test_smooth_goddard_2013(PM_ds_control_3d_full):\r\n da = PM_ds_control_3d_full\r\n actual = smooth_goddard_2013(\r\n da,\r\n )\r\n # test that x, y not in dims\r\n assert \"x\" not in actual.dims\r\n assert \"y\" not in actual.dims\r\n # tests whether nlat, nlon got reduced\r\n assert actual.time.size < da.time.size\r\n assert actual.lon.size < da.lon.size\r\n assert actual.lat.size < da.lat.size","def seasonality(df):\n df_datetime = pd.DatetimeIndex(df.date_time)\n df[\"month\"] = df_datetime.month\n df = drop_cols(df, [\"date_time\"])\n\n return df","def point_interp_ts(df, time_col, x_col, y_col, data_col, point_shp, point_site_col, from_crs, to_crs=None, interp_fun='cubic', agg_ts_fun=None, period=None, digits=2):\n\n #### Read in points\n if isinstance(point_shp, str) & isinstance(point_site_col, str):\n points = read_file(point_shp)[[point_site_col, 'geometry']]\n to_crs1 = points.crs\n elif isinstance(point_shp, GeoDataFrame) & isinstance(point_site_col, str):\n points = point_shp[[point_site_col, 'geometry']]\n to_crs1 = points.crs\n else:\n raise ValueError('point_shp must be a str path to a shapefile or a GeoDataFrame and point_site_col must be a str.')\n\n #### Create the grids\n df1 = df.copy()\n\n #### Resample the time series data\n if agg_ts_fun is not None:\n df1a = df1.set_index(time_col)\n if agg_ts_fun == 'sum':\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].sum().reset_index()\n elif agg_ts_fun == 'mean':\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].mean().reset_index()\n else:\n raise ValueError(\"agg_ts_fun should be either 'sum' or 'mean'.\")\n time = df2[time_col].unique()\n else:\n df2 = df1\n\n time = df2[time_col].sort_values().unique()\n\n #### Convert input data to crs of points shp and create input xy\n data1 = df2.loc[df2[time_col] == time[0]]\n from_crs1 = convert_crs(from_crs, pass_str=True)\n\n if to_crs is not None:\n to_crs1 = convert_crs(to_crs, pass_str=True)\n points = points.to_crs(to_crs1)\n geometry = [Point(xy) for xy in zip(data1[x_col], data1[y_col])]\n gpd = GeoDataFrame(data1.index, geometry=geometry, crs=from_crs1)\n gpd1 = gpd.to_crs(crs=to_crs1)\n x = gpd1.geometry.apply(lambda p: p.x).round(digits).values\n y = gpd1.geometry.apply(lambda p: p.y).round(digits).values\n\n xy = column_stack((x, y))\n\n #### Prepare the x and y of the points geodataframe output\n x_int = points.geometry.apply(lambda p: p.x).round(digits).values\n y_int = points.geometry.apply(lambda p: p.y).round(digits).values\n sites = points[point_site_col]\n\n xy_int = column_stack((x_int, y_int))\n\n #### Create new df\n sites_ar = tile(sites, len(time))\n time_ar = repeat(time, len(xy_int))\n x_ar = tile(x_int, len(time))\n y_ar = tile(y_int, len(time))\n new_df = DataFrame({'site': sites_ar, 'time': time_ar, 'x': x_ar, 'y': y_ar, data_col: repeat(0, len(time) * len(xy_int))})\n\n new_lst = []\n for t in to_datetime(time):\n set1 = df2.loc[df2[time_col] == t, data_col]\n new_z = griddata(xy, set1.values, xy_int, method=interp_fun).round(digits)\n new_z[new_z < 0] = 0\n new_lst.extend(new_z.tolist())\n# print(t)\n new_df.loc[:, data_col] = new_lst\n\n #### Export results\n return(new_df[new_df[data_col].notnull()])","def grid_interp_ts(df, time_col, x_col, y_col, data_col, grid_res, from_crs=None, to_crs=2193, interp_fun='cubic', agg_ts_fun=None, period=None, digits=2):\n\n #### Create the grids\n df1 = df.copy()\n\n #### Resample the time series data\n if agg_ts_fun is not None:\n df1a = df1.set_index(time_col)\n if agg_ts_fun == 'sum':\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].sum().reset_index()\n elif agg_ts_fun == 'mean':\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].mean().reset_index()\n else:\n raise ValueError(\"agg_ts_fun should be either 'sum' or 'mean'.\")\n time = df2[time_col].unique()\n else:\n df2 = df1\n\n time = df2[time_col].sort_values().unique()\n\n if from_crs is None:\n x = df2.loc[df2[time_col] == time[0], x_col].values\n y = df2.loc[df2[time_col] == time[0], y_col].values\n else:\n data1 = df2.loc[df2[time_col] == time[0]]\n from_crs1 = convert_crs(from_crs, pass_str=True)\n to_crs1 = convert_crs(to_crs, pass_str=True)\n geometry = [Point(xy) for xy in zip(data1[x_col], data1[y_col])]\n gpd = GeoDataFrame(data1.index, geometry=geometry, crs=from_crs1)\n gpd1 = gpd.to_crs(crs=to_crs1)\n x = gpd1.geometry.apply(lambda p: p.x).round(digits).values\n y = gpd1.geometry.apply(lambda p: p.y).round(digits).values\n\n xy = column_stack((x, y))\n\n max_x = x.max()\n min_x = x.min()\n\n max_y = y.max()\n min_y = y.min()\n\n new_x = arange(min_x, max_x, grid_res)\n new_y = arange(min_y, max_y, grid_res)\n x_int, y_int = meshgrid(new_x, new_y)\n\n #### Create new df\n x_int2 = x_int.flatten()\n y_int2 = y_int.flatten()\n xy_int = column_stack((x_int2, y_int2))\n time_df = repeat(time, len(x_int2))\n x_df = tile(x_int2, len(time))\n y_df = tile(y_int2, len(time))\n new_df = DataFrame({'time': time_df, 'x': x_df, 'y': y_df, data_col: repeat(0, len(time) * len(x_int2))})\n\n new_lst = []\n for t in to_datetime(time):\n set1 = df2.loc[df2[time_col] == t, data_col]\n# index = new_df[new_df['time'] == t].index\n new_z = griddata(xy, set1.values, xy_int, method=interp_fun).round(digits)\n new_z[new_z < 0] = 0\n new_lst.extend(new_z.tolist())\n# print(t)\n new_df.loc[:, data_col] = new_lst\n\n #### Export results\n return(new_df[new_df[data_col].notnull()])","def simplify(self, tolerance):\n return _unary_geo(arctern.ST_SimplifyPreserveTopology, self, tolerance)","def create_grid_mapping(ds, wrf_out):\n coord_sys = wrf_out[\"coord_sys\"]\n grid_mapping = coord_sys[\"var_name\"]\n grid_mapping_var = ds.createVariable(grid_mapping, \"i1\", ())\n grid_mapping_var.setncatts({key: val\n for key, val in coord_sys.items()\n if key != \"var_name\"})\n\n ydim_var = ds.variables[\"dim_y\"]\n xdim_var = ds.variables[\"dim_x\"]\n ydim_bounds_var = ds.variables[\"dim_y_bnds\"]\n xdim_bounds_var = ds.variables[\"dim_y_bnds\"]\n\n ydim_var.setncatts(wrf_out[\"proj_y_coord\"][1])\n xdim_var.setncatts(wrf_out[\"proj_x_coord\"][1])\n ydim_var.setncatts(dict(bounds=\"dim_y_bnds\"))\n xdim_var.setncatts(dict(bounds=\"dim_x_bnds\"))\n\n ydim_bounds_var.setncatts(\n {att: val\n for att, val in wrf_out[\"proj_y_coord\"][1].items()\n if att not in (\"standard_name\", \"axis\")})\n xdim_bounds_var.setncatts(\n {att: val\n for att, val in wrf_out[\"proj_x_coord\"][1].items()\n if att not in (\"standard_name\", \"axis\")})\n\n lat_var = ds.createVariable(\"latitude\", \"f4\", (\"dim_y\", \"dim_x\"))\n lon_var = ds.createVariable(\"longitude\", \"f4\", (\"dim_y\", \"dim_x\"))\n\n # lat_coord = lat\n # lon_coord = lon\n lat_var.setncatts(wrf_out[\"wrf_lat\"][1])\n lon_var.setncatts(wrf_out[\"wrf_lon\"][1])\n\n return grid_mapping","def get_time_series(this_lat, this_lon, case, varnames):\n\n cesmdir = '/gpfs/fs1/collections/cdg/data/cesmLE/CESM-CAM5-BGC-LE/atm/proc/tseries/monthly'\n\n if 'LE' in case:\n\n from observational_large_ensemble.params import karen_params_cesm\n\n mode_lag = karen_params_cesm.mode_lag\n cvdp_loc = karen_params_cesm.cvdp_loc\n AMO_cutoff_freq = karen_params_cesm.AMO_cutoff_freq\n\n name_conversion = {'tas': 'TREFHT', 'pr': 'PRECC', 'slp': 'PSL'}\n cesm_names = [name_conversion[v] for v in varnames]\n this_member = int((case).split('-')[-1])\n cvdp_file = '%s/CESM1-CAM5-BGC-LE_#%i.cvdp_data.1920-2018.nc' % (cvdp_loc, this_member)\n\n # Historical filenames for CESM. Will need to append part of RCP8.5 to get full period\n filenames = []\n for var in cesm_names:\n file_str = '%s/%s/b.e11.B20TRC5CNBDRD.f09_g16.%03d.cam.h0.%s.??????-200512.nc' % (cesmdir, var,\n this_member, var)\n this_file = glob(file_str)[0]\n filenames.append(this_file)\n\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames,\n karen_params_cesm.valid_years, mode_lag,\n cvdp_file, AMO_cutoff_freq, name_conversion)\n\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\n\n else:\n\n from observational_large_ensemble.params import karen_params_obs\n\n mode_lag = karen_params_obs.mode_lag\n cvdp_loc = karen_params_obs.cvdp_loc\n AMO_cutoff_freq = karen_params_obs.AMO_cutoff_freq\n\n tas_dir = karen_params_obs.tas_dir\n pr_dir = karen_params_obs.pr_dir\n slp_dir = karen_params_obs.slp_dir\n cvdp_file = '%s/HadISST.cvdp_data.1920-2018.nc' % cvdp_loc\n file_dict = {'tas': '%s/Complete_TAVG_LatLong1.nc' % tas_dir,\n 'pr': '%s/full_data_monthly_v2020.nc' % pr_dir,\n 'slp': '%s/prmsl.mon.mean.nc' % slp_dir}\n\n filenames = []\n for var in varnames:\n filenames.append(file_dict[var])\n\n name_conversion = {'tas': 'temperature', 'pr': 'precip', 'slp': 'prmsl'}\n\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames[0],\n karen_params_obs.valid_years, mode_lag,\n cvdp_file, AMO_cutoff_freq, name_conversion)\n\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\n\n return this_ts, df_shifted","def reset_spatial_dims_attrs(self):\n if self.crs is None:\n raise ValueError(\"CRS is missing. Use set_crs function to resolve.\")\n _da = self._obj\n x_dim, y_dim, x_attrs, y_attrs = gis_utils.axes_attrs(self.crs)\n if x_dim != self.x_dim or y_dim != self.y_dim:\n _da = _da.rename({self.x_dim: x_dim, self.y_dim: y_dim})\n _da[x_dim].attrs.update(x_attrs)\n _da[y_dim].attrs.update(y_attrs)\n _da.raster.set_spatial_dims(x_dim=x_dim, y_dim=y_dim)\n return _da","def local2global(self, local_coord, start, end, strand):\n local2global(local_coord, start, end, strand)","def correct_west(longitudes):\n longitudes[longitudes < 0] += 360.\n return longitudes","def map_to_coords(source_lats, source_lons, target_lats, target_lons):\n source_lats_with_border, source_lons_with_border = add_border(source_lats, 'extrapolate'), add_border(source_lons, 'extrapolate')\n \n if len(target_lats.shape) == 1:\n target_lats = np.tile(target_lats,len(target_lons)).reshape(len(target_lons),-1).T\n target_lons = np.tile(target_lons,len(target_lats)).reshape(len(target_lats),-1)\n \n resample_map_rows = np.zeros(target_lats.shape, dtype=int)\n resample_map_cols = np.zeros(target_lats.shape, dtype=int)\n for i in range(target_lats.shape[0]):\n for j in range(target_lats.shape[1]):\n target_lat, target_lon = target_lats[i,j], target_lons[i,j]\n closest_source_cell = np.argmin(np.square(source_lats_with_border - target_lat) + \n np.square(source_lons_with_border - target_lon))\n resample_map_rows[i,j] = closest_source_cell // source_lats_with_border.shape[1]\n resample_map_cols[i,j] = closest_source_cell % source_lats_with_border.shape[1]\n \n return resample_map_rows, resample_map_cols","def overwrite_season(function):\n @functools.wraps(function)\n def inner(*args, season = None, **kw):\n data = function(*args,**kw)\n if season:\n replace_season(data,season)\n return data\n return inner","def getLocs2d(self, proj='default', extent=1):\n if proj == 'default':\n proj = self.default_transform_2d\n \n index = (proj, extent) \n if index in self._transformed:\n return self._transformed[index]\n \n \n if proj in ['cone', 'lowerCone', 'ideal']:\n \n # fit the 3d sensor locations to a sphere with center (cx, cy, cz)\n # and radius r\n \n # error function\n def err(params):\n r, cx, cy, cz = params\n return (self.locs3d[:, 0] - cx) ** 2 \\\n + (self.locs3d[:, 1] - cy) ** 2 \\\n + (self.locs3d[:, 2] - cz) ** 2 \\\n - r ** 2\n \n # initial guess of sphere parameters (radius and center)\n params = (1, 0, 0, 0)\n # do fit\n (r, cx, cy, cz), stuff = leastsq(err, params)\n \n # center the sensor locations based on the sphere and scale to\n # radius 1\n sphere_center = np.array((cx, cy, cz))\n locs3d = self.locs3d - sphere_center\n locs3d /= r\n \n # implement projection\n locs2d = np.copy(locs3d[:,:2])\n if proj=='cone':\n locs2d[:,0] *= (1 - locs3d[:,2]) \n locs2d[:,1] *= (1 - locs3d[:,2])\n elif proj=='lower cone':\n for i in range(locs2d.shape[0]):\n if locs3d[i,2] < 0:\n locs2d[i,:2] *= (1 - locs3d[i,2]) \n elif proj == 'ideal':\n r_sq = max(locs3d[:,2]) - locs3d[:,2]\n r = np.sqrt(r_sq) # get radius dependent on z\n r_c = np.sqrt(locs3d[:,0]**2 + locs3d[:,1]**2) # current r\n F = r / r_c # stretching factor accounting for current r \n locs2d[:,0] *= F\n locs2d[:,1] *= F\n \n elif proj == None:\n locs2d = np.copy(self.locs3d[:,:2])\n else:\n raise ValueError(\"invalid proj kwarg\")\n \n # correct extent\n if extent:\n locs2d -= np.min(locs2d)\n locs2d /= (np.max(locs2d) / extent)\n \n # save for future access\n self._transformed[index] = locs2d\n return locs2d","def toPointwise_withLinearXYs( self, **kwargs ) :\n\n kwargs['removeOverAdjustedPoints'] = True\n xys = regionsModule.Regions1d.toPointwise_withLinearXYs( self, **kwargs )\n return( XYs1d( data = xys, axes = xys.axes ) )","def geo_transform(self):\n pass","def _getlons(self):\n dlon = 360. / self.nlon\n lons = np.linspace(0. + dlon / 2., 360. - dlon / 2., self.nlon)\n return lons","def latlon_to_scrip(nx, ny, lon0=-180., grid_imask=None, \n file_out=None,):\n \n # compute coordinates of regular grid\n dx = 360. / nx\n dy = 180. / ny\n lat = np.arange(-90. + dy / 2., 90., dy)\n lon = np.arange(lon0 + dx / 2., lon0 + 360., dx)\n \n # make 2D\n y_center = np.broadcast_to(lat[:, None], (ny, nx))\n x_center = np.broadcast_to(lon[None, :], (ny, nx))\n\n # compute corner points: must be counterclockwise\n y_corner = np.stack((y_center - dy / 2., # SW\n y_center - dy / 2., # SE\n y_center + dy / 2., # NE\n y_center + dy / 2.), # NW\n axis=2)\n\n x_corner = np.stack((x_center - dx / 2., # SW\n x_center + dx / 2., # SE\n x_center + dx / 2., # NE\n x_center - dx / 2.), # NW\n axis=2)\n\n # compute area\n y0 = np.sin(y_corner[:, :, 0] * np.pi / 180.) # south\n y1 = np.sin(y_corner[:, :, 3] * np.pi / 180.) # north\n x0 = x_corner[:, :, 0] * np.pi / 180. # west\n x1 = x_corner[:, :, 1] * np.pi / 180. # east\n grid_area = (y1 - y0) * (x1 - x0)\n \n # sum of area should be equal to area of sphere\n np.testing.assert_allclose(grid_area.sum(), 4.*np.pi)\n \n # construct mask\n if grid_imask is None:\n grid_imask = np.ones((ny, nx), dtype=np.int32)\n \n # generate output dataset\n dso = xr.Dataset() \n dso['grid_dims'] = xr.DataArray(np.array([nx, ny], dtype=np.int32), \n dims=('grid_rank',)) \n dso.grid_dims.encoding = {'dtype': np.int32}\n\n dso['grid_center_lat'] = xr.DataArray(y_center.reshape((-1,)), \n dims=('grid_size'),\n attrs={'units': 'degrees'})\n\n dso['grid_center_lon'] = xr.DataArray(x_center.reshape((-1,)), \n dims=('grid_size'),\n attrs={'units': 'degrees'})\n \n dso['grid_corner_lat'] = xr.DataArray(y_corner.reshape((-1, 4)), \n dims=('grid_size', 'grid_corners'), \n attrs={'units': 'degrees'})\n dso['grid_corner_lon'] = xr.DataArray(x_corner.reshape((-1, 4)), \n dims=('grid_size', 'grid_corners'), \n attrs={'units': 'degrees'}) \n\n dso['grid_imask'] = xr.DataArray(grid_imask.reshape((-1,)), \n dims=('grid_size'),\n attrs={'units': 'unitless'})\n dso.grid_imask.encoding = {'dtype': np.int32}\n \n dso['grid_area'] = xr.DataArray(grid_area.reshape((-1,)), \n dims=('grid_size'),\n attrs={'units': 'radians^2',\n 'long_name': 'area weights'})\n \n # force no '_FillValue' if not specified\n for v in dso.variables:\n if '_FillValue' not in dso[v].encoding:\n dso[v].encoding['_FillValue'] = None\n\n dso.attrs = {'title': f'{dy} x {dx} (lat x lon) grid',\n 'created_by': 'latlon_to_scrip',\n 'date_created': f'{datetime.now()}',\n 'conventions': 'SCRIP',\n }\n \n # write output file\n if file_out is not None:\n print(f'writing {file_out}')\n dso.to_netcdf(file_out)\n \n return dso","def get_datetime_seasons(\n self, train: NumpyOrPandas, outp_role: Optional[ColumnRole] = None\n ) -> Optional[LAMLTransformer]:\n _, datetimes = self.get_cols_for_datetime(train)\n for col in copy(datetimes):\n if len(train.roles[col].seasonality) == 0 and train.roles[col].country is None:\n datetimes.remove(col)\n\n if len(datetimes) == 0:\n return\n\n if outp_role is None:\n outp_role = NumericRole(np.float32)\n\n date_as_cat = SequentialTransformer(\n [\n ColumnsSelector(keys=datetimes),\n DateSeasons(outp_role),\n ]\n )\n return date_as_cat","def remove_data(ds, nh_lim, sh_lim, time_max, lat_name='lat', time_name='time'):\n return xr.where((ds[lat_name] < nh_lim) &\n (ds[lat_name] > sh_lim) &\n (ds[time_name] < pd.to_datetime([time_max]).values),\n np.nan,\n ds)","def ll2csflat(lon,lat,ncs):\n j,f,i = ll2jfi(lon,lat,ncs)\n return (j*6+f)*ncs+i","def season_edges(t):\n offset = season_offset(t)\n yr_min = t.datetime.min().year\n left_frac = t.jyear.min() % yr_min\n if left_frac < offset:\n ex_left = 1\n else:\n ex_left = 0\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\n return astropy.time.Time(edges, format='jyear')","def _basemap_2d(x, y, *zs, globe=False, projection=None):\n # Fix coordinates\n x, y = _fix_coords(x, y)\n\n # Fix data\n xmin, xmax = projection.lonmin, projection.lonmax\n x_orig, y_orig, zs_orig = x, y, zs\n zs = []\n for z_orig in zs_orig:\n # Ensure data is within map bounds\n x, z_orig = _fix_span(x_orig, z_orig, xmin, xmax)\n # Bail for 2D coordinates\n if not globe or x_orig.ndim > 1 or y_orig.ndim > 1:\n zs.append(z_orig)\n continue\n # Fix holes over poles by *interpolating* there\n y, z = _add_poles(y_orig, z_orig)\n # Fix seams at map boundary\n if x[0] == xmin and x.size - 1 == z.shape[1]: # scenario 1\n # Edges (e.g. pcolor) fit perfectly against seams. Size is unchanged.\n pass\n elif x.size - 1 == z.shape[1]: # scenario 2\n # Edges (e.g. pcolor) do not fit perfectly. Size augmented by 1.\n x = ma.append(xmin, x)\n x[-1] = xmin + 360\n z = ma.concatenate((z[:, -1:], z), axis=1)\n elif x.size == z.shape[1]: # scenario 3\n # Centers (e.g. contour) must be interpolated to edge. Size augmented by 2.\n xi = np.array([x[-1], x[0] + 360])\n if xi[0] == xi[1]: # impossible to interpolate\n pass\n else:\n zq = ma.concatenate((z[:, -1:], z[:, :1]), axis=1)\n xq = xmin + 360\n zq = (zq[:, :1] * (xi[1] - xq) + zq[:, 1:] * (xq - xi[0])) / (xi[1] - xi[0]) # noqa: E501\n x = ma.concatenate(([xmin], x, [xmin + 360]))\n z = ma.concatenate((zq, z, zq), axis=1)\n else:\n raise ValueError('Unexpected shapes of coordinates or data arrays.')\n zs.append(z)\n\n # Convert coordinates\n if x.ndim == 1 and y.ndim == 1:\n x, y = np.meshgrid(x, y)\n x, y = projection(x, y)\n\n return x, y, *zs","def get_gridcell_history(\n lat,\n lon,\n dataset,\n also_return_snapped_coordinates=False,\n also_return_metadata=False,\n use_imperial_units=True,\n convert_to_local_time=True,\n as_of=None,\n ipfs_timeout=None):\n try:\n metadata = get_metadata(get_heads()[dataset])\n except KeyError:\n raise DatasetError(\"No such dataset in dClimate\")\n\n # set up units\n converter, dweather_unit = get_unit_converter(metadata[\"unit of measurement\"], use_imperial_units)\n\n # get dataset-specific \"no observation\" value\n missing_value = metadata[\"missing value\"]\n try:\n dataset_obj = GRIDDED_DATASETS[dataset](as_of=as_of, ipfs_timeout=ipfs_timeout)\n except KeyError:\n raise DatasetError(\"No such dataset in dClimate\")\n\n try:\n (lat, lon), resp_series = dataset_obj.get_data(lat, lon)\n\n except (ipfshttpclient.exceptions.ErrorResponse, ipfshttpclient.exceptions.TimeoutError, KeyError, FileNotFoundError) as e:\n raise CoordinateNotFoundError(\"Invalid coordinate for dataset\")\n\n # try a timezone-based transformation on the times in case we're using an hourly set.\n if convert_to_local_time:\n try:\n tf = TimezoneFinder()\n local_tz = pytz.timezone(tf.timezone_at(lng=lon, lat=lat))\n resp_series = resp_series.tz_localize(\"UTC\").tz_convert(local_tz)\n except (AttributeError, TypeError): # datetime.date (daily sets) doesn't work with this, only datetime.datetime (hourly sets)\n pass\n\n if type(missing_value) == str:\n resp_series = resp_series.replace(missing_value, np.NaN).astype(float)\n else:\n resp_series.loc[resp_series.astype(float) == missing_value] = np.NaN\n resp_series = resp_series.astype(float)\n \n resp_series = resp_series * dweather_unit\n if converter is not None:\n resp_series = pd.Series(converter(resp_series.values), resp_series.index)\n result = {k: convert_nans_to_none(v) for k, v in resp_series.to_dict().items()}\n \n if also_return_metadata:\n result = tupleify(result) + ({\"metadata\": metadata},)\n if also_return_snapped_coordinates:\n result = tupleify(result) + ({\"snapped to\": (lat, lon)},)\n return result","def prepare(gpi, start_date, end_date, models, satellites, kind=\"clim\", window=35):\n # read data\n ts_input = data_object.read_gpi(gpi, start_date, end_date, models, satellites)\n #ts_input = interp.add_nan(ts_input)\n ts_input = interp.iter_fill(ts_input, max_gap=5)\n\n # either calc climatology, apply moving average filter, or do nothing\n if kind == 'clim':\n ts_smooth = smooth.iter_climats(ts_input)\n plot_title = 'Climatology'\n elif kind == 'movav':\n ts_smooth = smooth.iter_movav(ts_input, window)\n #ts_smooth = ts_gapfill\n plot_title = 'Moving average'\n elif kind == None:\n # return original data\n ts_smooth = ts_input\n else:\n raise NotImplementedError\n pass\n\n # drop rows with missing values\n #ts_smooth = ts_smooth.dropna()\n\n # scale satellite data to model data\n ts_scaled = scaling.scale(ts_smooth, 'mean_std_nan', 0)\n # drop nan rows for slope funcs\n return ts_scaled #.dropna()","def meanRegion(thk_s,thk_p,thk_diff):\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\n \n print '\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\n \n yearmin = 2004\n yearmax = 2015\n years = np.arange(yearmin,yearmax+1,1)\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\n \n fig = plt.figure()\n ax = plt.subplot(111)\n \n ### Call parameters\n plt.rcParams['text.usetex']=True\n plt.rcParams['font.family'] = 'sans-serif'\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\n \n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\n label=r'PIOMAS')\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\n label=r'Satellite')\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\n \n labelsy = map(str,np.arange(0,6,1))\n labelsx = map(str,years)\n plt.xticks(np.arange(len(years)),labelsx)\n plt.yticks(np.arange(0,6,1),labelsy)\n plt.ylabel(r'\\textbf{Thickness (meters)}',fontsize=13)\n \n ### Adjust axes in time series plots \n def adjust_spines(ax, spines):\n for loc, spine in ax.spines.items():\n if loc in spines:\n spine.set_position(('outward', 10))\n else:\n spine.set_color('none') \n if 'left' in spines:\n ax.yaxis.set_ticks_position('left')\n else:\n ax.yaxis.set_ticks([])\n \n if 'bottom' in spines:\n ax.xaxis.set_ticks_position('bottom')\n else:\n ax.xaxis.set_ticks([]) \n \n ### Adjust axes spines\n adjust_spines(ax, ['left', 'bottom'])\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.grid(color='b',zorder=1,alpha=0.3)\n \n plt.legend(shadow=False,fontsize=11,loc='upper right',\n fancybox=True)\n \n plt.text(2,-0.8,r'\\textbf{ICESat}',fontsize=13)\n plt.text(7.3,-0.8,r'\\textbf{PIOMAS}',fontsize=13)\n \n fig.suptitle(r'\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)","def custom_seasonal_adjust(denoise):\n df_adjust = pd.DataFrame()\n df_adjust[0] = denoise.values\n df_adjust[1] = denoise.shift(-52).values\n df_adjust[2] = denoise.shift(-104).values\n seasonality = df_adjust.mean(axis=1)[:52]\n\n start_idx = denoise.index[0]\n df_seasonality = seasonality.append(seasonality, ignore_index=True).append(seasonality[:39], ignore_index=True)\n idx = pd.DatetimeIndex(start=start_idx, freq='W-FRI', periods=len(df_seasonality))\n df_seasonality.index = idx\n \n seasonal_adjust = (denoise - df_seasonality).dropna()\n df_seasonality = df_seasonality.reset_index().\\\n assign(week_num = lambda x: x['index'].dt.week).\\\n drop_duplicates('week_num').\\\n drop(columns='index').rename(columns={0:'Weekly_Sales'})\n \n return df_seasonality, seasonal_adjust","def _fix_span(x, y, xmin, xmax):\n if x.ndim != 1:\n return x, y\n\n # Roll in same direction if some points on right-edge extend\n # more than 360 above min longitude; *they* should be on left side\n lonroll = np.where(x > xmin + 360)[0] # tuple of ids\n if lonroll.size: # non-empty\n roll = x.size - lonroll.min()\n x = np.roll(x, roll)\n y = np.roll(y, roll, axis=-1)\n x[:roll] -= 360 # make monotonic\n\n # Set NaN where data not in range xmin, xmax. Must be done\n # for regional smaller projections or get weird side-effects due\n # to having valid data way outside of the map boundaries\n y = y.copy()\n if x.size - 1 == y.shape[-1]: # test western/eastern grid cell edges\n y[..., (x[1:] < xmin) | (x[:-1] > xmax)] = np.nan\n elif x.size == y.shape[-1]: # test the centers and pad by one for safety\n where = np.where((x < xmin) | (x > xmax))[0]\n y[..., where[1:-1]] = np.nan\n\n return x, y","def project(self, (lng, lat)):\n x = lng * DEG_TO_RAD\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\n y = lat * DEG_TO_RAD\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)"],"string":"[\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def correct_lon(ds):\\n ds = ds.copy()\\n x = ds['x'].data\\n ds['x'].data = np.where(x < 0 , 360 + x, x)\\n\\n lon = ds['lon'].data\\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\\n \\n ds = ds.sortby('x')\\n return ds\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def broadcast_lonlat(ds, verbose=True):\\n if 'lon' not in ds.variables:\\n ds.coords['lon'] = ds['x']\\n if 'lat' not in ds.variables:\\n ds.coords['lat'] = ds['y']\\n \\n if len(ds['lon'].dims) < 2:\\n ds.coords[\\\"lon\\\"] = ds[\\\"lon\\\"] * xr.ones_like(ds[\\\"lat\\\"])\\n if len(ds['lat'].dims) < 2:\\n ds.coords[\\\"lat\\\"] = xr.ones_like(ds[\\\"lon\\\"]) * ds[\\\"lat\\\"]\\n return ds\",\n \"def interpolateseasons(self):\\n\\n remainder = self.season - self.startseason\\n f1 = 1.0 - remainder\\n self.data = (self.startdata * f1) + (self.stopdata * remainder)\",\n \"def warren_time_series(lat, lon, dates, variable='snow_depth'):\\n\\n my_func = {'snow_depth': snow_depth,\\n 'swe': swe}\\n\\n #if not all([isinstance(d, dt.datetime) for d in dates]):\\n # print ('Expects datetime objects')\\n\\n # If lat, lon are vectors, generate 2d grids\\n # Need to add code to make sure x and y are DataArrays\\n if (count_dims(lat) == 1):\\n x, y = np.meshgrid(lon, lat)\\n else:\\n x, y = lon, lat\\n \\n if dates.size == 1:\\n cube = my_func[variable](x,y,dates.dt.month)\\n da = xr.DataArray(cube,\\n coords={'lat': x, 'lon': y},\\n dims=['lat', 'lon'])\\n else:\\n cube = [my_func[variable](x, y, m) for m in dates.dt.month.values]\\n da = xr.concat(cube, dim='time')\\n da['time'] = dates\\n\\n return da\",\n \"def switch_lons(ds, lon_name='lon'):\\n ds = ds.copy()\\n with dask.config.set(**{'array.slicing.split_large_chunks': True}):\\n if np.any(ds.coords[lon_name] < 0): # if current coords are -180 to 180\\n ds.coords[lon_name] = (ds.coords[lon_name] + 360) % 360\\n else:\\n ds.coords[lon_name] = (ds.coords[lon_name] + 180) % 360 - 180\\n return ds.sortby(ds[lon_name])\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def _fix_coords(x, y):\\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\\n return x, y\\n lon1 = x[0]\\n filter_ = x < lon1\\n while filter_.sum():\\n filter_ = x < lon1\\n x[filter_] += 360\\n return x, y\",\n \"def normalize_longitude(lon: np.ndarray,\\n lon_min: Optional[float] = -180.0) -> np.ndarray:\\n return ((lon - lon_min) % 360) + lon_min\",\n \"def msl_nn_srtm_interp(self, lon_lat):\\n tiles = self.find_srtm_tiles(lon_lat)\\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\\n lon_lat_msl[:, 0:2] = lon_lat\\n for tile in set(tiles):\\n otile = rasterio.open(tile, 'r')\\n oimg = otile.read(1)\\n idx = np.where(np.array(tiles) == tile)[0]\\n pix = feat.geo_to_pix(\\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\\n pix = np.round(pix).astype(np.int)\\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\\n otile.close()\\n nan_mask = lon_lat_msl[:, 2] == -32768\\n lon_lat_msl[nan_mask, 2] = np.NaN\\n return lon_lat_msl\",\n \"def replace_x_y_nominal_lat_lon(ds):\\n ds = ds.copy()\\n if 'x' in ds.dims and 'y' in ds.dims:\\n \\n nominal_y = ds.lat.mean('x')\\n # extract the equatorial lat and take those lon values as nominal lon\\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\\n nominal_x = ds.lon.isel(y=eq_ind)\\n ds.coords['x'].data = nominal_x.data\\n ds.coords['y'].data = nominal_y.data\\n\\n ds = ds.sortby('x')\\n ds = ds.sortby('y')\\n \\n else:\\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\\n return ds\",\n \"def shifts_projection(sc, clean):\\n def shifts_projected(clean, axis):\\n projected = clean.map(lambda x: x.mean(axis=axis)[:, :, np.newaxis])\\n target = getTarget(projected, 30, 1)\\n shifts = registerByPlane(sc, projected, target[:, :, np.newaxis], 10, False)\\n return shifts[:, :, 0]\\n\\n # shifts_xy = shifts_projected(clean, 2)\\n shifts_xz = shifts_projected(clean, 1)\\n shifts_yz = shifts_projected(clean, 0)\\n\\n # x_shifts = np.mean(np.stack((shifts_xz[:, 0], shifts_xy[:, 0])), axis=0)\\n z_shifts = np.mean(np.stack((shifts_xz[:, 1], shifts_yz[:, 1])), axis=0)\\n # y_shifts = np.mean(np.stack((shifts_yz[:, 0], shifts_xy[:, 1])), axis=0)\\n plt.figure()\\n plt.plot(shifts_xz[:, 1])\\n plt.plot(shifts_yz[:, 1])\\n plt.plot(z_shifts)\\n plt.title('Z')\\n # plt.figure()\\n # plt.plot(shifts_xz[:, 0])\\n # plt.plot(shifts_xy[:, 0])\\n # plt.plot(x_shifts)\\n # plt.title('X')\\n # plt.figure()\\n # plt.plot(shifts_yz[:, 0])\\n # plt.plot(shifts_xy[:, 1])\\n # plt.plot(y_shifts)\\n # plt.title('Y')\\n # shifts_all = np.stack((x_shifts, y_shifts, z_shifts))\\n\\n def initReg(kv):\\n from scipy.ndimage.interpolation import shift\\n index, volume = kv\\n current_shift = (0, 0, -1 * z_shifts[int(index[0])])\\n shifted = shift(volume, current_shift)\\n return shifted.astype(np.int16)\\n\\n reg = clean.map(initReg, with_keys=True, value_shape=clean.shape[1:], dtype=np.int16)\\n reg.cache()\\n reg.count()\\n return reg\",\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 map_season(x, figsize=(8, 6), **kwargs):\\n\\n from pycmbs.mapping import map_plot\\n\\n nvals = len(x.data)\\n if nvals == 12:\\n year = True\\n elif nvals == 4:\\n year = False\\n else:\\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\\n\\n #/// checks ///\\n if x.data.ndim != 3:\\n print x.data.ndim\\n raise ValueError('only 3D data supported')\\n\\n if 'vmin' not in kwargs.keys():\\n raise ValueError('vmin argument is obligatory for map_seasons()')\\n if 'vmax' not in kwargs.keys():\\n raise ValueError('vmax argument is obligatory for map_seasons()')\\n\\n if kwargs['vmin'] is None:\\n raise ValueError('vmin MUST NOT be None!')\\n if kwargs['vmax'] is None:\\n raise ValueError('vmax MUST NOT be None!')\\n\\n #/// figure and axes\\n if 'figure' in kwargs:\\n f = kwargs['figure']\\n else:\\n f = plt.figure(figsize=figsize)\\n\\n if 'title' in kwargs:\\n tit = kwargs.pop('title')\\n else:\\n tit = x.label\\n\\n if 'drawparallels' in kwargs:\\n drawparallels = kwargs.pop('drawparallels')\\n else:\\n drawparallels = False\\n\\n if 'savefile' in kwargs:\\n savefile = kwargs.pop('savefile')\\n if '.nc' in savefile:\\n savefile = savefile[:-3]\\n else:\\n savefile = None\\n\\n # plot\\n if year:\\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\\n else:\\n labels = ['DJF', 'MAM', 'JJA', 'SON']\\n\\n # check dates\\n if year:\\n mo = 1\\n for t in x.time:\\n if x.num2date(t).month != mo:\\n print x.num2date(t), mo\\n raise ValueError('Invalid monthly sequence! Can not plot results!')\\n mo += 1\\n\\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\\n if 'overlay' in kwargs.keys():\\n overlays = kwargs.pop('overlay')\\n else:\\n overlays = None\\n\\n for i in range(nvals):\\n if year:\\n ax = f.add_subplot(4, 3, i + 1)\\n #if i % 3 == 2:\\n if i > 8:\\n show_colorbar = True\\n else:\\n show_colorbar = False\\n else:\\n ax = f.add_subplot(2, 2, i + 1)\\n if 'show_colorbar' in kwargs:\\n show_colorbar = kwargs.pop('show_colorbar')\\n else:\\n show_colorbar = True\\n\\n d = x.copy()\\n d.data = x.data[i, :, :]\\n d.label = labels[i]\\n\\n if overlays is None:\\n overlay = None\\n else:\\n overlay = overlays[i, :, :]\\n\\n if savefile is not None:\\n tmpoutname = savefile + '_' + labels[i]\\n else:\\n tmpoutname = None\\n\\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\\n savefile=tmpoutname, colorbar_orientation='horizontal',\\n drawparallels=drawparallels, **kwargs)\\n del d\\n f.suptitle(tit, size=16)\\n return f\",\n \"def wgs84_to_mercator(df, lon, lat):\\n k = 6378137\\n df[\\\"x\\\"] = df[lon] * (k * np.pi/180.0)\\n df[\\\"y\\\"] = np.log(np.tan((90 + df[lat]) * np.pi/360.0)) * k\\n return df\",\n \"def safeProj(proj, lon, lat):\\n x, y = proj(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 undo_mercator_project(x,y):\\n lon = y*np.pi\\n ex = np.exp(4*np.pi*x)\\n lat = np.arcsin((ex - 1)/(ex +1 ))\\n lon = lon*360/2/np.pi\\n lat = lat*360 /2/np.pi\\n return lon, lat\",\n \"def manipulate_data(ds, var, predef_clim, predef_trnd, trn_yrs, all_yrs, \\n apply_latw=True, apply_detrending=True, dropna=True):\\n\\n \\n if((var=='SD')|(var=='sd')|(var=='snowc')): \\n ds[var] = ds[var].where(ds[var]>=0, other=0.0)\\n ds[var] = ds[var].where(ds[var]==0, other=1.0)\\n #ds[var].values = Gauss_filter(ds[var].values, (0,3,3))\\n \\n \\\"\\\"\\\"\\n if((var=='hgt')|(var=='z')|(var=='GPT')):\\n months = ds.time.to_index().month; ssn_ends = (months==2)|(months==5)|(months==8)|(months==11)\\n ds = ds.sel(time=ssn_ends)\\n else: \\n ds = ds.resample(time='3M').mean()\\n \\\"\\\"\\\"\\n \\n ds = ds.resample(time='3M').mean()\\n\\n ds = ds.sel(time=slice(str(all_yrs[0])+'-01-01', str(all_yrs[-1])+'-12-31')) \\n \\n try: \\n clim = predef_clim\\n ds = ds.groupby('time.season') - clim\\n print('Predefined climatology used')\\n except:\\n clim = ds.sel(time=slice(str(trn_yrs[0])+'-01-01', str(trn_yrs[-1])+'-12-31')).groupby('time.season').mean('time')\\n ds = ds.groupby('time.season') - clim\\n print('Climatology calculated from data')\\n \\n if(apply_latw): ds[var].values = lat_weighting(ds[var].values, \\n ds.lat, ds.lon)\\n if(dropna):\\n ds = ds.stack(gridcell=('lat', 'lon')).dropna(dim='gridcell',how='any')\\n else: \\n ds = ds.stack(gridcell=('lat', 'lon')).fillna(0)\\n \\n \\n trend_models = { }\\n if(apply_detrending): \\n ds = ds.load()\\n for ssn in ('DJF', 'MAM', 'JJA', 'SON'):\\n #ssn_idx = ds['time.season'] == ssn\\n \\n trn_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], trn_yrs))\\n all_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], all_yrs))\\n \\n trn_x = np.array(ds.time[trn_idx].values.tolist()).reshape(-1,1)\\n all_x = np.array(ds.time[all_idx].values.tolist()).reshape(-1,1)\\n try:\\n trend = predef_trnd[ssn].predict(all_x)\\n trend_models[ssn] = predef_trnd[ssn]\\n print('Predefined trend model used')\\n except:\\n #_, trend_model = define_trends(ds[var][trn_idx], trn_x)\\n _, trend_model = define_trends(ds[var][all_idx], all_x)\\n trend = trend_model.predict(all_x)\\n trend_models[ssn] = trend_model\\n print('Trends calculated from data')\\n \\n ds[var][all_idx] = ds[var][all_idx] - trend\\n \\n\\n \\n return ds, clim, trend_models\",\n \"def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \\n the_season=np.array(the_season,dtype=np.int32)\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n else:\\n if lat_slice.stop is None:\\n num_lats=var_nc.shape[2]\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n if lon_slice.stop is None:\\n num_lons=var_nc.shape[3]\\n else:\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n num_years=var_nc.shape[0]//12\\n\\n for the_year in np.arange(0,num_years):\\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n the_season=the_season+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def satReader(directory,month,latmin,latmax,lonmin,lonmax):\\n \\n ### Enter filename\\n filename = 'cs2icesat_regrid_mar_20042015.nc' \\n \\n ### Month/Years extracted\\n dateyr = now.year \\n datemo = datetime.date(dateyr,month+1,1).strftime('%B')\\n \\n ### Retrieve data\\n data = Dataset(directory + filename)\\n lat = data.variables['lat'][:]\\n lon = data.variables['lon'][:]\\n thkn = data.variables['thick'][:]\\n data.close()\\n \\n ### Calculate lat/lon region\\n xmask = (lat > latmin) & (lat < latmax)\\n ymask = (lon > lonmin) & (lon < lonmax)\\n \\n mask = xmask[:] & ymask[:]\\n latvals = np.where(mask == True)[0]\\n lonvals = np.where(mask == True)[1]\\n latvals = np.unique(latvals)\\n lonvals = np.unique(lonvals)\\n \\n thk = thkn[:,latvals,:]\\n thk = thk[:,:,lonvals]\\n \\n lat = lat[latvals,:]\\n lat = lat[:,lonvals]\\n lon = lon[latvals,:]\\n lon = lon[:,lonvals]\\n\\n grid = '---> [[%s to %s N, %s to %s E]]' % (latmin,latmax,lonmin,lonmax)\\n print 'Completed: Satellite data read (%s)!' % datemo, grid\\n \\n return lat,lon,thk\",\n \"def extract_seasonal_component(original_ts, ppy):\\n \\\"\\\"\\\"\\n # === get in-sample data\\n original_ts = original_ts[:-out_of_sample]\\n \\\"\\\"\\\"\\n if seasonality_test(original_ts, ppy):\\n # print(\\\"seasonal\\\")\\n # ==== get moving averages\\n ma_ts = moving_averages(original_ts, ppy)\\n\\n # ==== get seasonality indices\\n le_ts = original_ts * 100 / ma_ts\\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\\n le_ts = np.reshape(le_ts, (-1, ppy))\\n si = np.nanmean(le_ts, 0)\\n norm = np.sum(si) / (ppy * 100)\\n si = si / norm\\n else:\\n # print(\\\"NOT seasonal\\\")\\n si = np.full(ppy, 100)\\n return si\",\n \"def reverse(self, lon, lat):\",\n \"def timeave_seasonal( mv, seasons=seasonsyr ):\\n return seasons.climatology(mv)\",\n \"def flowline_latlon(coords, fromproj=pyproj.Proj(\\\"+init=epsg:3413\\\"), toproj=pyproj.Proj(\\\"+init=EPSG:4326\\\")):\\n xs = coords[:,0]\\n ys = coords[:,1]\\n x_lon, y_lat = pyproj.transform(fromproj, toproj, xs, ys)\\n latlon_coords = np.asarray(zip(x_lon, y_lat))\\n return latlon_coords\",\n \"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax is None:\\n print \\\"WARNING- no time axis in\\\",mv.id\\n return None\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n print \\\"WARNING- cannot compute climatology for\\\",mv.id,seasons.seasons\\n print \\\"...probably there is no data for times in the requested season.\\\"\\n return None\\n avmv = mvseas\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def set_coord_values(ds, wrf_out, footprint_nbins):\\n xdim_var = ds.variables[\\\"dim_x\\\"]\\n ydim_var = ds.variables[\\\"dim_y\\\"]\\n xdim_bounds_var = ds.variables[\\\"dim_x_bnds\\\"]\\n ydim_bounds_var = ds.variables[\\\"dim_y_bnds\\\"]\\n lon_var = ds.variables[\\\"longitude\\\"]\\n lat_var = ds.variables[\\\"latitude\\\"]\\n\\n time_back_var = ds.variables[\\\"time_before_observation\\\"]\\n time_back_bounds_var = ds.variables[\\\"time_before_observation_bnds\\\"]\\n\\n height_var = ds.variables[\\\"height\\\"]\\n height_bounds_var = ds.variables[\\\"height_bnds\\\"]\\n\\n dx = wrf_out[\\\"dx\\\"]\\n\\n xdim_data = wrf_out[\\\"proj_x_coord\\\"][0]\\n ydim_data = wrf_out[\\\"proj_y_coord\\\"][0]\\n xdim_var[:] = xdim_data[:]\\n ydim_var[:] = ydim_data[:]\\n\\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\\n xdim_bounds_var[-1,0] = xdim_data[-1]\\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\\n ydim_bounds_var[-1,0] = ydim_data[-1]\\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\\n\\n wrf_lats = wrf_out[\\\"wrf_lat\\\"][0][0, :, :]\\n wrf_lons = wrf_out[\\\"wrf_lon\\\"][0][0, :, :]\\n lat_var[:, :] = wrf_lats[:, :]\\n lon_var[:, :] = wrf_lons[:, :]\\n\\n ds.geospatial_lat_min = wrf_lats.min()\\n ds.geospatial_lat_max = wrf_lats.max()\\n ds.geospatial_lat_units = \\\"degree_north\\\"\\n ds.geospatial_lon_min = wrf_lons.min()\\n ds.geospatial_lon_max = wrf_lons.max()\\n ds.geospatial_lon_units = \\\"degree_east\\\"\\n\\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\\n time_back_var[:] = time_back_vals\\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\\n time_back_vals[1:]))\\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\\n\\n height_var[...] = 0\\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)\",\n \"def lat_lons(self):\",\n \"def convert_coords(date, time_steps, azs, els, obs):\\n coord_start_day = datetime(date.year, date.month, date.day)\\n \\n strategy = []\\n for time_step, az, el in zip(time_steps, azs, els):\\n if az % np.pi == 0.0: \\n az += EPS\\n \\n ra, dec = sphere.altaz_to_ra_dec(coord_start_day + timedelta(hours=time_step), az, el, obs)\\n strategy.append([ra, dec])\\n \\n return np.array(strategy)\",\n \"def project_normalize_coordinates(node_feats, transformer=None, crs=None):\\n # get home node:\\n home_node = node_feats.iloc[\\n (node_feats[\\\"in_degree\\\"] + node_feats[\\\"out_degree\\\"]).argmax()\\n ]\\n home_center = home_node[\\\"center\\\"]\\n\\n @to_series\\n def get_projected_displacement(x, y, home_center):\\n if (x_min < x < x_max) and (y_min < y < y_max):\\n proj_x, proj_y = transformer.transform(x, y)\\n home_x, home_y = transformer.transform(home_center.x, home_center.y)\\n return (proj_x - home_x, proj_y - home_y)\\n else: # fall back to haversine\\n return get_haversine_displacement.__wrapped__(x, y, home_center)\\n\\n if transformer is not None:\\n # get bounds\\n x_min, y_min, x_max, y_max = crs.area_of_use.bounds\\n normed_coords = node_feats[\\\"center\\\"].apply(\\n get_projected_displacement, args=[home_center]\\n )\\n else:\\n normed_coords = node_feats[\\\"center\\\"].apply(\\n get_haversine_displacement, args=[home_center]\\n )\\n\\n # add_distance\\n normed_coords[\\\"distance\\\"] = normed_coords.apply(\\n lambda x: np.sqrt(x[0] ** 2 + x[1] ** 2), axis=1\\n )\\n # TODO: add as a TEST! compare haversine dist to fake-projected coordinates\\n # print(normed_coords[\\\"distance\\\"])\\n # test_distance = node_feats[\\\"center\\\"].apply(\\n # lambda point: ti.geogr.point_distances.haversine_dist(\\n # point.x, point.y, home_center.x, home_center.y\\n # )[0]\\n # )\\n # print(\\n # pd.merge(\\n # normed_coords, test_distance, left_index=True, right_index=True\\n # )\\n # )\\n\\n return pd.merge(\\n node_feats, normed_coords, left_index=True, right_index=True\\n )\",\n \"def _basemap_1d(x, *ys, projection=None):\\n xmin, xmax = projection.lonmin, projection.lonmax\\n x_orig, ys_orig = x, ys\\n ys = []\\n for y_orig in ys_orig:\\n x, y = _fix_span(*_fix_coords(x_orig, y_orig), xmin, xmax)\\n ys.append(y)\\n return x, *ys\",\n \"def test_custom_lon_lat_range():\\n import astropy.units as u\\n lrange = [-50,-40]\\n brange = [-10,10]\\n spiral_arm = survey.get_spiral_slice(track = \\\"Carina_far\\\", \\n lrange = lrange, \\n brange = brange)\\n spiral_arm2 = survey.get_spiral_slice(track = \\\"CrF\\\", \\n lrange = lrange*u.deg, \\n brange = brange*u.deg)\\n\\n assert np.allclose(spiral_arm[\\\"INTEN\\\"], spiral_arm2[\\\"INTEN\\\"], equal_nan = True)\",\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_latlon(ds, n=50):\\n\\n nx = ncols(ds)\\n ny = nrows(ds)\\n src_crs = get_crs(ds)\\n dst_crs = CRS(init='epsg:4326')\\n idx_x = np.linspace(0, nx - 1, n, dtype=int)\\n idx_y = np.linspace(0, ny - 1, n, dtype=int)\\n xs = ds.x[idx_x]\\n ys = ds.y[idx_y]\\n xgrid, ygrid = np.meshgrid(xs, ys)\\n lon, lat = rasterio.warp.transform(src_crs, dst_crs, xgrid.flatten(),\\n ygrid.flatten())\\n lon_sparse = np.empty((ny, nx))\\n lat_sparse = np.empty((ny, nx))\\n lon_sparse[:] = np.nan\\n lat_sparse[:] = np.nan\\n # idx_y needs to be a column vector\\n lon_sparse[idx_y[:, None], idx_x] = np.array(lon).reshape((n, n))\\n lat_sparse[idx_y[:, None], idx_x] = np.array(lat).reshape((n, n))\\n ds.coords['lat'] = (('y', 'x'), lat_sparse)\\n ds.coords['lon'] = (('y', 'x'), lon_sparse)\",\n \"def fix_coords_non_symetric_lon(cube):\\n # first fix any completely missing coord var names\\n utils.fix_dim_coordnames(cube)\\n # fix individual coords\\n for cube_coord in cube.coords():\\n # fix time\\n if cube_coord.var_name == 'time':\\n logger.info(\\\"Fixing time...\\\")\\n cube.coord('time').convert_units(\\n Unit('days since 1950-1-1 00:00:00', calendar='gregorian'))\\n utils.fix_bounds(cube, cube.coord('time'))\\n\\n # fix longitude\\n if cube_coord.var_name == 'lon':\\n logger.info(\\\"Fixing longitude...\\\")\\n if cube_coord.ndim == 1:\\n if cube_coord.points[0] < 0. and \\\\\\n cube_coord.points[-1] < 181.:\\n lon_coord = cube.coord('longitude').copy()\\n lons_below_0 = lon_coord.points[lon_coord.points < 0.] + \\\\\\n 360.\\n lons_above_0 = lon_coord.points[lon_coord.points >= 0.]\\n lons = np.hstack((lons_above_0, lons_below_0))\\n cube_coord.points = lons\\n\\n utils.fix_bounds(cube, cube_coord)\\n cube.attributes['geospatial_lon_min'] = 0.\\n cube.attributes['geospatial_lon_max'] = 360.\\n utils.roll_cube_data(cube, len(lons_above_0), -1)\\n\\n # fix latitude\\n if cube_coord.var_name == 'lat':\\n logger.info(\\\"Fixing latitude...\\\")\\n utils.fix_bounds(cube, cube.coord('latitude'))\\n\\n # fix depth\\n if cube_coord.var_name == 'lev':\\n logger.info(\\\"Fixing depth...\\\")\\n utils.fix_bounds(cube, cube.coord('depth'))\\n\\n # fix air_pressure\\n if cube_coord.var_name == 'air_pressure':\\n logger.info(\\\"Fixing air pressure...\\\")\\n utils.fix_bounds(cube, cube.coord('air_pressure'))\\n\\n # remove CS\\n cube.coord('latitude').coord_system = None\\n cube.coord('longitude').coord_system = None\\n\\n return cube\",\n \"def _is_valid_latlong_series(series):\\n if ww.accessor_utils._is_dask_series(series):\\n series = series = series.get_partition(0).compute()\\n if ww.accessor_utils._is_koalas_series(series):\\n series = series.to_pandas()\\n bracket_type = list\\n else:\\n bracket_type = tuple\\n if series.apply(_is_valid_latlong_value, args=(bracket_type,)).all():\\n return True\\n return False\",\n \"def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\\n import numpy as np\\n import matplotlib as mpl\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\\n\\n def plotter(pdata, colormax=1, colormin=-999, title=''):\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \\n if colormin == -999:\\n colormin = -colormax\\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\\n pdata, lon = addcyclic(pdata, lon)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\\n mycmap1 = plt.cm.Blues_r(np.arange(256))\\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\\n my_cmap[230:282, :] = 1\\n if precip == 'yes':\\n my_cmap = my_cmap[::-1]\\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\\\"newjet\\\", my_cmap)\\n ctrs = np.linspace(colormin, colormax, 17)\\n plot = m.contourf(x, y, pdata, ctrs,\\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\\n extend='both')\\n\\n plt.title(title, y=1)\\n plt.show()\\n return plot\\n\\n ax1 = fig.add_subplot(3, 3, 1)\\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\\n ax2 = fig.add_subplot(3, 3, 2)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\\n ax3 = fig.add_subplot(3, 3, 3)\\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\\n ax4 = fig.add_subplot(3, 3, 4)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\\n ax5 = fig.add_subplot(3, 3, 5)\\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\\n ax6 = fig.add_subplot(3, 3, 6)\\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\\n ax7 = fig.add_subplot(3, 3, 7)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\\n ax8 = fig.add_subplot(3, 3, 9)\\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\\n ax9 = fig.add_subplot(3, 3, 8)\\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\\n\\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\\n orientation='horizontal', extend='max')\\n \\n b.set_label(label='t200 difference ($^\\\\circ$C)', size=20, fontsize=20, fontname='Arial')\\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\\n right=.95)\",\n \"def unproject(self, (x, y)):\\n lng = x/EARTH_RADIUS * RAD_TO_DEG\\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\\n return (lng, lat)\",\n \"def add_rain_clim_normals(gdf_of_interest,\\n grid_of_rain_clim_norm_y = clim_norm_rain_y_np_unique, \\n grid_of_rain_clim_norm_x = clim_norm_rain_x_np_unique): \\n mean_monthly_rainfall = []\\n for index in gdf_of_interest.index:\\n closest_y_index = find_nearest_point_1D(grid_of_rain_clim_norm_y, \\n gdf_of_interest.geometry.y[index], \\n print_nearest_val=False)\\n closest_x_index = find_nearest_point_1D(grid_of_rain_clim_norm_x, \\n gdf_of_interest.geometry.x[index], \\n print_nearest_val=False)\\n \\n month_of_interest = int(gdf_of_interest[\\\"Month\\\"][0])\\n month_of_int_format = \\\"m\\\" + str(month_of_interest)\\n \\n mean_monthly_rainfall.append(gdf_clim_norm_rain_mean.loc[\\n (gdf_clim_norm_rain_mean[\\\"east\\\"] == grid_of_rain_clim_norm_x[closest_x_index]) &\\n (gdf_clim_norm_rain_mean[\\\"north\\\"] == grid_of_rain_clim_norm_y[closest_y_index]),\\n month_of_int_format].values[0])\\n \\n \\n \\n gdf_of_interest[\\\"Mean Monthly Rainfall\\\"] = mean_monthly_rainfall\\n \\n return\",\n \"def map_ll_to_seviri(lon, lat):\\n # new method\\n # project lat/lon input to meteosat view, mask out of bounds data\\n geos = pyproj.Proj(proj='geos', h=35785831.0,lon_0=0,lat_0=0,x_0=0,y_0=0,units='m')\\n x,y = geos(lon,lat)\\n x = ma.masked_equal(x,1e30)\\n y = ma.masked_equal(y,1e30)\\n # Convert to index. ~3000.5m per pixel, centre pixel index is [1855,1855]\\n x = x/-3000.5+1855\\n y = y/3000.5+1855\\n return x,y\\n # old method\\n \\\"\\\"\\\"\\n # Define Earth radius and geostationary orbit height in km and calucalte max\\n # viewer angle\\n r_sat = 42164.\\n r_earth = 6378.\\n zenith_max = np.arcsin(r_earth/r_sat)\\n # convert lat/lon to cartesian coordinates\\n x = np.cos(np.radians(lat)) * np.sin(np.radians(lon))\\n y = np.sin(np.radians(lat))\\n z = np.cos(np.radians(lat)) * np.cos(np.radians(lon))\\n # x,y vector magnitude\\n d = np.sqrt(x**2 + y**2)\\n # Calculate footprint SEVIRI effective zenith angle and mask for > pi/2\\n # values\\n zenith = np.arctan2(d, z) + np.arctan2(r_earth*d, r_sat-r_earth*z)\\n zenith_mask = np.abs(zenith) >= (0.5 * np.pi)\\n # Calculate x and y viewer angles\\n theta_x = np.arctan2(r_earth*x, r_sat-r_earth*z)\\n theta_y = np.arctan2(r_earth*y, r_sat-r_earth*z)\\n # Define SEVIRI global index range and offset\\n # These should be the same on all files, but may need to check\\n x_irange = 3623\\n x_ioffset = 44\\n y_irange = 3611\\n y_ioffset = 51\\n # Remap viewer angles to indexes using max viewer angle, index range and\\n # offset. Note -ve theta_y as SEVIRI indexes the x-axis right to left(E-W)\\n x_out = (1 - theta_x / zenith_max) * 0.5 * x_irange + x_ioffset\\n y_out = (1 + theta_y / zenith_max) * 0.5 * y_irange + y_ioffset\\n # Return masked arrays using the zenith angle mask\\n return ma.array(x_out, mask=zenith_mask), ma.array(y_out, mask=zenith_mask)\\n \\\"\\\"\\\"\",\n \"def reproject(self, lon, lat):\\n if self.xform is None:\\n # if the CRS hasn't been determined yet, we set it from the first image's lat/lon (take the UTM crs)\\n utm_i = str(int(math.floor((self.images[0].lon + 180) / 6 ) % 60) + 1).zfill(2)\\n epsg_code = int('326' + utm_i) if (self.images[0].lat >= 0) else int('327' + utm_i)\\n self.crs_dest = QgsCoordinateReferenceSystem(epsg_code)\\n self.xform = QgsCoordinateTransform(self.crs_src, self.crs_dest, QgsProject.instance())\\n return self.xform.transform(QgsPointXY(lon, lat))\",\n \"def apply_lon_filter(data, lon_bounds):\\n \\n # Convert to common bounds (0, 360)\\n lon_min = adjust_lon_range(lon_bounds[0], radians=False, start=0.0)\\n lon_max = adjust_lon_range(lon_bounds[1], radians=False, start=0.0)\\n lon_axis = adjust_lon_range(data.getLongitude()[:], radians=False, start=0.0)\\n\\n # Make required values zero\\n ntimes, nlats, nlons = data.shape\\n lon_axis_tiled = numpy.tile(lon_axis, (ntimes, nlats, 1))\\n \\n new_data = numpy.where(lon_axis_tiled < lon_min, 0.0, data)\\n \\n return numpy.where(lon_axis_tiled > lon_max, 0.0, new_data)\",\n \"def _reindex_spatial_data_to_regions(ds, df):\\n\\n # use vectorized indexing in xarray >= 0.10\\n if LooseVersion(xr.__version__) > LooseVersion(\\\"0.9.999\\\"):\\n\\n lon_indexer = xr.DataArray(df.lon.values, dims=(\\\"reshape_index\\\",))\\n lat_indexer = xr.DataArray(df.lat.values, dims=(\\\"reshape_index\\\",))\\n\\n return ds.sel(lon=lon_indexer, lat=lat_indexer)\\n\\n else:\\n res = ds.sel_points(\\\"reshape_index\\\", lat=df.lat.values, lon=df.lon.values)\\n\\n return res\",\n \"def winter_avg(var_nc,lat_slice=None,lon_slice=None): \\n #\\n # accumulate in shape [plev,lat,lon]\\n #\\n # use the whole array if slice objects are missing\\n #\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n print \\\"in winter avg: \\\",lat_slice,lon_slice\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n #\\n # year 0 is special case since it doesn't have a december\\n #\\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\\n accumulate+=the_slice\\n num_years=var_nc.shape[0]//12\\n #\\n # now year 1 has year 0's december\\n #\\n djf=np.array([11,12,13],dtype=np.int32)\\n #\\n # iterate one year less because we've alread\\n # done year zero as a special case\\n #\\n for the_year in np.arange(0,num_years-1):\\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n djf=djf+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def compute_stage4(lon, lat, year):\\n nc = netCDF4.Dataset(\\\"/mesonet/data/stage4/%s_stage4_hourly.nc\\\" % (year,))\\n lons = nc.variables[\\\"lon\\\"][:]\\n lats = nc.variables[\\\"lat\\\"][:]\\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\\n (yidx, xidx) = np.unravel_index(dist.argmin(), dist.shape)\\n print(\\n (\\\"Computed stage4 nclon:%.2f nclat:%.2f yidx:%s xidx:%s \\\")\\n % (lons[yidx, xidx], lats[yidx, xidx], yidx, xidx)\\n )\\n p01i = mm2inch(nc.variables[\\\"p01m\\\"][:, yidx, xidx])\\n nc.close()\\n df = pd.DataFrame(\\n {\\\"precip\\\": 0.0},\\n index=pd.date_range(\\n \\\"%s-01-01\\\" % (year,), \\\"%s-12-31\\\" % (year,), tz=\\\"America/Chicago\\\"\\n ),\\n )\\n for date in df.index.values:\\n date2 = datetime.datetime.utcfromtimestamp(date.tolist() / 1e9)\\n ts = datetime.datetime(date2.year, date2.month, date2.day, 6)\\n ts = ts.replace(tzinfo=pytz.utc)\\n ts = ts.astimezone(pytz.timezone(\\\"America/Chicago\\\"))\\n ts = ts.replace(hour=0)\\n ts = ts.astimezone(pytz.utc)\\n tidx = hourly_offset(ts)\\n # values are in the rears\\n val = np.ma.sum(p01i[tidx + 1 : tidx + 25])\\n if val > 0:\\n df.at[date, \\\"precip\\\"] = val # close enough\\n return df\",\n \"def location_change(lon, lat, dim='time', ilon=None, ilat=None, as_event=True, distance_threshold=10, window=180,\\n dates=None, **kwargs):\\n import numpy as np\\n from xarray import DataArray, full_like\\n from ..fun.cal import distance\\n\\n # count occurence of each coordinate pair\\n # use the most common (also the most recent?)\\n # to estimate distance from,\\n # era-interim has a distance of about 80km so only if larger it would make sense to split?\\n if not isinstance(lon, DataArray):\\n raise ValueError('requires a DataArray', type(lon))\\n if not isinstance(lat, DataArray):\\n raise ValueError('requires a DataArray', type(lat))\\n\\n lon = lon.copy()\\n lat = lat.copy()\\n lon = lon.bfill(dim)\\n lat = lat.bfill(dim)\\n\\n dist = full_like(lon, 0, dtype=np.float)\\n dist.name = 'distance'\\n dist.attrs['units'] = 'km'\\n fdistance = np.vectorize(distance)\\n ishape = lon.values.shape\\n lon = lon.values.flatten()\\n lat = lat.values.flatten()\\n if ilon is None and ilat is None:\\n if lon.size > 1:\\n # distance between more recent and less recent\\n tmp = fdistance(lon[1:], lat[1:], lon[:-1], lat[:-1])\\n tmp = np.append(tmp, tmp[-1])\\n else:\\n tmp = np.array([0])\\n dist.values = tmp.reshape(ishape)\\n dist.attrs['method'] = 'Backwards'\\n else:\\n tmp = fdistance(lon, lat, ilon, ilat)\\n dist.values = tmp.reshape(ishape)\\n dist.attrs['method'] = 'Point(%f E, %f N)' % (ilon, ilat)\\n\\n # Check for duplicates\\n if dist[dim].to_index().duplicated().any():\\n dist = dist.isel({dim: ~dist[dim].to_index().duplicated()})\\n\\n if as_event:\\n dist.values = (dist > distance_threshold).astype(float) \\\\\\n .rolling(center=True, min_periods=1, **{dim: window}).mean() \\\\\\n .rolling(center=True, min_periods=1, **{dim: window}).sum()\\n dist.attrs['threshold'] = distance_threshold\\n dist.attrs['standard_name'] = 'location_change_point'\\n if dates is not None:\\n dist = dist.reindex(time=dates, method='nearest', fill_value=0) # reindex\\n else:\\n dist.attrs['standard_name'] = 'distance'\\n if dates is not None:\\n dist = dist.reindex(time=dates, method='nearest').bfill(dim).ffill(dim)\\n\\n return dist\",\n \"def _fixup_coords(self, var):\\n for coord_name, data_array in var.coords.items():\\n if data_array.attrs.get('standard_name') in ('projection_x_coordinate',\\n 'projection_y_coordinate'):\\n try:\\n var.coords[coord_name].metpy.convert_units('meters')\\n except DimensionalityError: # Radians!\\n new_data_array = data_array.copy()\\n height = var.coords['crs'].item()['perspective_point_height']\\n scaled_vals = new_data_array.metpy.unit_array * (height * units.meters)\\n new_data_array.metpy.unit_array = scaled_vals.to('meters')\\n var.coords[coord_name] = new_data_array\",\n \"def interpolate(self, lon: np.ndarray, lat: np.ndarray,\\n dates: np.ndarray) -> np.ndarray:\\n ds = self._select_ds(\\n dates.min(), # type: ignore\\n dates.max()) # type: ignore\\n assert np.all(np.diff(ds.ocean_time.values) == self._dt)\\n interpolator = pyinterp.backends.xarray.RegularGridInterpolator(\\n ds[self.ssh])\\n return interpolator(dict(lat_rho=lat.ravel(),\\n lon_rho=lon.ravel(),\\n ocean_time=dates.ravel()),\\n method=\\\"bilinear\\\",\\n bounds_error=False).reshape(lon.shape)\",\n \"def F_interp_geos_mat(sounding_lon,sounding_lat,sounding_datenum,\\\\\\n geos_dir='/mnt/Data2/GEOS/s5p_interp/',\\\\\\n interp_fields=['TROPPT']):\\n from scipy.io import loadmat\\n from scipy.interpolate import RegularGridInterpolator\\n \\n start_datenum = np.amin(sounding_datenum)\\n end_datenum = np.amax(sounding_datenum)\\n start_datetime = datedev_py(start_datenum)\\n start_year = start_datetime.year\\n start_month = start_datetime.month\\n start_day = start_datetime.day\\n start_hour = start_datetime.hour\\n \\n end_datetime = datedev_py(end_datenum)\\n end_year = end_datetime.year\\n end_month = end_datetime.month\\n end_day = end_datetime.day\\n end_hour = end_datetime.hour\\n end_minute = end_datetime.minute\\n end_second = end_datetime.second\\n \\n step_hour = 3 # geos fp data are 3-hourly\\n \\n geos_start_hour = start_hour-start_hour%step_hour\\n geos_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=geos_start_hour)\\n if end_hour > 24-step_hour or (end_hour == 24-step_hour and (end_minute > 0 or end_second > 0)):\\n geos_end_hour = 0\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour) +datetime.timedelta(days=1)\\n elif end_hour%step_hour == 0 and end_minute == 0 and end_second == 0:\\n geos_end_hour = end_hour\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n else:\\n geos_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n \\n nstep = (geos_end_datetime-geos_start_datetime).total_seconds()/3600/step_hour+1\\n nstep = int(nstep)\\n \\n geos_data = {}\\n # load narr data\\n for istep in range(nstep):\\n file_datetime = geos_start_datetime+datetime.timedelta(hours=step_hour*istep)\\n file_dir = os.path.join(geos_dir,file_datetime.strftime('Y%Y'),\\\\\\n file_datetime.strftime('M%m'),\\\\\\n file_datetime.strftime('D%d'))\\n file_path = os.path.join(file_dir,'subset_'+file_datetime.strftime('%Y%m%d_%H')+'.mat')\\n if not geos_data:\\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],interp_fields)))\\n geos_data['lon'] = mat_data['lon'].flatten()\\n geos_data['lat'] = mat_data['lat'].flatten()\\n geos_data['datenum'] = np.zeros((nstep),dtype=np.float64)\\n for fn in interp_fields:\\n geos_data[fn] = np.zeros((len(geos_data['lon']),len(geos_data['lat']),nstep))\\n geos_data[fn][...,istep] = mat_data[fn]\\n else:\\n mat_data = loadmat(file_path,variable_names=interp_fields)\\n for fn in interp_fields:\\n geos_data[fn][...,istep] = mat_data[fn]\\n \\n geos_data['datenum'][istep] = (file_datetime.toordinal()\\\\\\n +file_datetime.hour/24.\\\\\\n +file_datetime.minute/1440.\\\\\\n +file_datetime.second/86400.+366.)\\n # interpolate\\n sounding_interp = {}\\n for fn in interp_fields:\\n my_interpolating_function = \\\\\\n RegularGridInterpolator((geos_data['lon'],geos_data['lat'],geos_data['datenum']),\\\\\\n geos_data[fn],bounds_error=False,fill_value=np.nan)\\n sounding_interp[fn] = my_interpolating_function((sounding_lon,sounding_lat,sounding_datenum))\\n return sounding_interp\",\n \"def msl_to_wgs84(self, lon_lat_msl):\\n geoid = rasterio.open(self.geoid)\\n lon_lat_hae = np.zeros_like(lon_lat_msl)\\n lon_lat_hae[:, 0:2] = lon_lat_msl[:, 0:2]\\n gimg = geoid.read(1)\\n geo = feat.wgs84_to_geo(\\n geoid.crs, lon_lat_msl[:, 0], lon_lat_msl[:, 1])\\n pix = feat.geo_to_pix(geoid.affine, geo[:, 0], geo[:, 1])\\n pix = np.round(pix).astype(np.int)\\n hae = lon_lat_msl[:, 2] + gimg[pix[:, 1], pix[:, 0]]\\n lon_lat_hae[:, 2] = hae\\n return lon_lat_hae\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def correct_coordinates(ds, verbose=False):\\n ds = ds.copy()\\n for co in ['x', 'y', 'lon', 'lat', 'lev',\\n \\\"bnds\\\", \\\"lev_bounds\\\", \\\"lon_bounds\\\", \\\"lat_bounds\\\", \\\"time_bounds\\\",\\n 'vertices_latitude', 'vertices_longitude',\\n ]:\\n if co in ds.variables:\\n if verbose:\\n print('setting %s as coord' %(co))\\n ds = ds.set_coords(co)\\n return ds\",\n \"def Reproject(x, y, in_grid = 4326, out_grid = 32737):\\n \\n inProj = Proj(init='epsg:'+str(in_grid))\\n outProj = Proj(init='epsg:'+str(out_grid))\\n \\n \\n x2,y2 = transform(inProj,outProj,x,y)\\n \\n return x2, y2\",\n \"def transform(self, resampled_xray, n_burn_in, n_lookahead, skf_is): \\n # Set all temps on world map as features\\n #valid_range = range(n_burn_in, temperatures_xray['time'].shape[0] - n_lookahead)\\n #time_steps, lats, lons = temperatures_xray['tas'].values.shape\\n #X = temperatures_xray['tas'].values.reshape((time_steps,lats*lons))\\n #X = X[valid_range,:]\\n\\n tas = select_box(resampled_xray['tas']) \\n\\n valid_range = range(n_burn_in, resampled_xray['time'].shape[0] - n_lookahead)\\n #enso = get_enso_mean(temperatures_xray['tas'])\\n # reshape the vector into a table years as rows, months as columns\\n #enso_matrix = enso.values.reshape((-1,12))\\n\\n theShape = tas.shape\\n n_time,n_lat,n_long = theShape[0],theShape[1],theShape[2] \\n #print n_time,n_lat,n_long \\n enso_matrix = tas.values.reshape(-1,12,n_lat,n_long)\\n\\n count_matrix = np.ones(enso_matrix.shape)\\n # compute cumulative means of columns (remember that you can only use\\n # the past at each time point) and reshape it into a vector\\n enso_monthly_mean = (enso_matrix.cumsum(axis=0) / count_matrix.cumsum(axis=0)).reshape(-1,n_lat,n_long)#.ravel()\\n # roll it backwards (6 months) so it corresponds to the month of the target\\n\\n enso_anomaly = tas - enso_monthly_mean\\n\\n enso_anomaly_rolled = np.roll(enso_anomaly, n_lookahead - 12,axis = 0)\\n # select valid range\\n enso_anomaly_rolled_valid = enso_anomaly_rolled[valid_range,:,:]\\n # reshape it into a matrix of a single column\\n X = enso_anomaly_rolled_valid.reshape(-1,n_lat*n_long)\\n\\n return X\",\n \"def atom_to_internal_coordinates(self, verbose: bool = ...) -> None:\\n ...\",\n \"def atom_to_internal_coordinates(self, verbose: bool = ...) -> None:\\n ...\",\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 lateralising_but_not_localising(full_row,\\n side_of_symptoms_signs,\\n pts_dominant_hemisphere_R_or_L,\\n lat_only_Right,\\n lat_only_Left):\\n lat_only_Right, lat_only_Left = summarise_overall_lat_values(full_row,\\n side_of_symptoms_signs,\\n pts_dominant_hemisphere_R_or_L,\\n lat_only_Right,\\n lat_only_Left)\\n\\n return lat_only_Right, lat_only_Left\",\n \"def seasonal_series(t, y, edges=None, hard=False):\\n t = ensure_tarray(t)\\n if len(t) == 1:\\n return [t], [y]\\n season_ixs = season_indices(t, edges=edges, hard=hard)\\n ts = []\\n ys = []\\n for season in season_ixs:\\n ts.append(astropy.time.Time(t.jyear[season], format='jyear', scale=t.scale))\\n ys.append(y[season])\\n return ts, ys\",\n \"def lonlat2xy(s_lon, s_lat): # x: easting, y: northing\\r\\n # convert decimals to seconds...\\r\\n s_lon = dec2sec(s_lon)\\r\\n s_lat = dec2sec(s_lat)\\r\\n\\r\\n ## Auxiliary values \\r\\n # i.e. differences of latitude and longitude relative to Bern in the unit [10000'']\\r\\n s_lng_aux = (s_lon - 26782.5)/10000.\\r\\n s_lat_aux = (s_lat - 169028.66)/10000.\\r\\n \\r\\n # easting\\r\\n s_x = (600072.37 \\r\\n + 211455.93*s_lng_aux \\r\\n - 10938.51*s_lng_aux*s_lat_aux \\r\\n - 0.36*s_lng_aux*(s_lat_aux**2) \\r\\n - 44.54*(s_lng_aux**3))\\r\\n \\r\\n # northing\\r\\n s_y = (200147.07 \\r\\n + 308807.95*s_lat_aux \\r\\n + 3745.25*(s_lng_aux**2) \\r\\n + 76.63*(s_lat_aux**2) \\r\\n - 194.56*(s_lng_aux**2)*s_lat_aux \\r\\n + 119.79*(s_lat_aux**3))\\r\\n\\r\\n return s_x, s_y\",\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 regrid_longitude_coord(self, cube):\\n # make a list with the 'longitude' coord in the form: 0/180/-180/0\\n neg_lons = ((cube.coord(\\\"longitude\\\").points + 180) % 360) - 180\\n # interpolates the cube data to the new 'longitude' dimensions\\n cube = cube.interpolate([(\\\"longitude\\\", neg_lons)],\\n iris.analysis.Linear())\\n sorted_cube = self.sorted_dim(cube)\\n return sorted_cube\",\n \"def calculate_latlon_bnds(lats, lons, lat_ax=0):\\n if not 1 <= lats.ndim <= 2 or not 1 <= lons.ndim <= 2:\\n raise ValueError('Input lats and lons must be 1D or 2D')\\n if lats.ndim != lons.ndim:\\n raise ValueError(\\n 'Input lats and lons must have the same dimensions')\\n if lats.ndim > 1 and lats.shape != lons.shape:\\n raise ValueError('2D lats and lons must have same array shape.')\\n\\n if lats.ndim == 2:\\n lon_ax = int(np.logical_not(lat_ax))\\n bnd_2d = True\\n else:\\n lat_ax = lon_ax = 0\\n bnd_2d = False\\n\\n dim_order = sorted([lat_ax, lon_ax])\\n\\n lat_space = np.diff(lats, axis=lat_ax)\\n lon_space = np.diff(lons, axis=lon_ax)\\n\\n nlat = lats.shape[lat_ax]\\n nlon = lons.shape[lon_ax]\\n\\n lat_bnd_shp = [dim_len + 1 for dim_len in lats.shape]\\n lon_bnd_shp = [dim_len + 1 for dim_len in lons.shape]\\n\\n lat_bnds = np.zeros(lat_bnd_shp)\\n lon_bnds = np.zeros(lon_bnd_shp)\\n\\n # Handle cyclic point if necessary\\n if bnd_2d:\\n if np.any(lon_space > 300):\\n i_idx, j_idx = np.where(lon_space > 300)\\n lon_space[i_idx, j_idx] = lon_space[i_idx, j_idx + 1]\\n\\n if np.any(lon_space < -300):\\n i_idx, j_idx = np.where(lon_space < -300)\\n lon_space[i_idx, j_idx] = lon_space[i_idx, j_idx - 1]\\n else:\\n if np.any(lon_space > 300):\\n i_idx, = np.where(lon_space > 300)\\n lon_space[i_idx] = lon_space[i_idx + 1]\\n\\n if np.any(lon_space < -300):\\n i_idx, = np.where(lon_space < -300)\\n lon_space[i_idx] = lon_space[i_idx - 1]\\n\\n # Handle out of bounds latitudes\\n lat_space[lat_space > 90] = 90\\n lat_space[lat_space < -90] = -90\\n\\n lon_sl = slice(0, nlon - 1)\\n lat_sl = slice(0, nlat - 1)\\n all_but_last = slice(0, -1)\\n last_two = slice(-2, None)\\n all_vals = slice(None)\\n\\n # TODO: Not an elegant solution for variable dimension order but I think it\\n # works...\\n if bnd_2d:\\n # Create slices to be used for general dimension order\\n bnd_slice = (all_but_last, lon_sl)\\n coord_slice = (all_vals, all_but_last)\\n bnd_end_slice = (all_but_last, last_two)\\n coord_end_slice = (all_vals, last_two)\\n diff_end_slice = (all_vals, last_two)\\n cyclic_bnd_dst = (-1, all_vals)\\n cyclic_bnd_src = (-2, all_vals)\\n\\n # If lon changes over first dimension we want to reverse the slice\\n # tuples\\n if lon_ax == 0:\\n rev = -1\\n else:\\n rev = 1\\n\\n lon_bnds[bnd_slice[::rev]] = lons[coord_slice[\\n ::rev]] - lon_space / 2\\n lon_bnds[bnd_end_slice[::rev]] = (lons[coord_end_slice[::rev]] +\\n lon_space[diff_end_slice[\\n ::rev]] / 2)\\n lon_bnds[cyclic_bnd_dst[::rev]] = lon_bnds[\\n cyclic_bnd_src[::rev]]\\n\\n # Adjust the bnd slice for latitude dimension\\n bnd_slice = (all_but_last, lat_sl)\\n\\n # If lat changes over first dimension we want to reverse the slice\\n # tuples\\n if lat_ax == 0:\\n rev = -1\\n else:\\n rev = 1\\n\\n lat_bnds[bnd_slice[::rev]] = lats[coord_slice[\\n ::rev]] - lat_space / 2\\n lat_bnds[bnd_end_slice[::rev]] = (lats[coord_end_slice[::rev]] +\\n lat_space[diff_end_slice[\\n ::rev]] / 2)\\n lat_bnds[cyclic_bnd_dst[::rev]] = lat_bnds[\\n cyclic_bnd_src[::rev]]\\n\\n else:\\n lon_bnds[lon_sl] = lons[all_but_last] - lon_space / 2\\n lon_bnds[last_two] = lons[last_two] + lon_space[last_two] / 2\\n\\n lat_bnds[lat_sl] = lats[all_but_last] - lat_space / 2\\n lat_bnds[last_two] = lats[last_two] + lat_space[last_two] / 2\\n\\n return lat_bnds, lon_bnds\",\n \"def to_series(func):\\n\\n @wraps(func)\\n def add_series(center, home_center):\\n normed_center = func(center.x, center.y, home_center)\\n return pd.Series(normed_center, index=[\\\"x_normed\\\", \\\"y_normed\\\"])\\n\\n return add_series\",\n \"def lon360to180(lon):\\n\\tlon = np.asanyarray(lon)\\n\\treturn ((lon + 180.) % 360.) - 180.\",\n \"def seasonal_calc(t, y, func, edges=None):\\n ts, ys = seasonal_series(t, y, edges=edges)\\n t_means = [t.jyear.mean() for t in ts]\\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\\n f_y = np.array([func(y) for y in ys])\\n return t_means, f_y\",\n \"def test_smooth_goddard_2013(PM_ds_control_3d_full):\\r\\n da = PM_ds_control_3d_full\\r\\n actual = smooth_goddard_2013(\\r\\n da,\\r\\n )\\r\\n # test that x, y not in dims\\r\\n assert \\\"x\\\" not in actual.dims\\r\\n assert \\\"y\\\" not in actual.dims\\r\\n # tests whether nlat, nlon got reduced\\r\\n assert actual.time.size < da.time.size\\r\\n assert actual.lon.size < da.lon.size\\r\\n assert actual.lat.size < da.lat.size\",\n \"def seasonality(df):\\n df_datetime = pd.DatetimeIndex(df.date_time)\\n df[\\\"month\\\"] = df_datetime.month\\n df = drop_cols(df, [\\\"date_time\\\"])\\n\\n return df\",\n \"def point_interp_ts(df, time_col, x_col, y_col, data_col, point_shp, point_site_col, from_crs, to_crs=None, interp_fun='cubic', agg_ts_fun=None, period=None, digits=2):\\n\\n #### Read in points\\n if isinstance(point_shp, str) & isinstance(point_site_col, str):\\n points = read_file(point_shp)[[point_site_col, 'geometry']]\\n to_crs1 = points.crs\\n elif isinstance(point_shp, GeoDataFrame) & isinstance(point_site_col, str):\\n points = point_shp[[point_site_col, 'geometry']]\\n to_crs1 = points.crs\\n else:\\n raise ValueError('point_shp must be a str path to a shapefile or a GeoDataFrame and point_site_col must be a str.')\\n\\n #### Create the grids\\n df1 = df.copy()\\n\\n #### Resample the time series data\\n if agg_ts_fun is not None:\\n df1a = df1.set_index(time_col)\\n if agg_ts_fun == 'sum':\\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].sum().reset_index()\\n elif agg_ts_fun == 'mean':\\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].mean().reset_index()\\n else:\\n raise ValueError(\\\"agg_ts_fun should be either 'sum' or 'mean'.\\\")\\n time = df2[time_col].unique()\\n else:\\n df2 = df1\\n\\n time = df2[time_col].sort_values().unique()\\n\\n #### Convert input data to crs of points shp and create input xy\\n data1 = df2.loc[df2[time_col] == time[0]]\\n from_crs1 = convert_crs(from_crs, pass_str=True)\\n\\n if to_crs is not None:\\n to_crs1 = convert_crs(to_crs, pass_str=True)\\n points = points.to_crs(to_crs1)\\n geometry = [Point(xy) for xy in zip(data1[x_col], data1[y_col])]\\n gpd = GeoDataFrame(data1.index, geometry=geometry, crs=from_crs1)\\n gpd1 = gpd.to_crs(crs=to_crs1)\\n x = gpd1.geometry.apply(lambda p: p.x).round(digits).values\\n y = gpd1.geometry.apply(lambda p: p.y).round(digits).values\\n\\n xy = column_stack((x, y))\\n\\n #### Prepare the x and y of the points geodataframe output\\n x_int = points.geometry.apply(lambda p: p.x).round(digits).values\\n y_int = points.geometry.apply(lambda p: p.y).round(digits).values\\n sites = points[point_site_col]\\n\\n xy_int = column_stack((x_int, y_int))\\n\\n #### Create new df\\n sites_ar = tile(sites, len(time))\\n time_ar = repeat(time, len(xy_int))\\n x_ar = tile(x_int, len(time))\\n y_ar = tile(y_int, len(time))\\n new_df = DataFrame({'site': sites_ar, 'time': time_ar, 'x': x_ar, 'y': y_ar, data_col: repeat(0, len(time) * len(xy_int))})\\n\\n new_lst = []\\n for t in to_datetime(time):\\n set1 = df2.loc[df2[time_col] == t, data_col]\\n new_z = griddata(xy, set1.values, xy_int, method=interp_fun).round(digits)\\n new_z[new_z < 0] = 0\\n new_lst.extend(new_z.tolist())\\n# print(t)\\n new_df.loc[:, data_col] = new_lst\\n\\n #### Export results\\n return(new_df[new_df[data_col].notnull()])\",\n \"def grid_interp_ts(df, time_col, x_col, y_col, data_col, grid_res, from_crs=None, to_crs=2193, interp_fun='cubic', agg_ts_fun=None, period=None, digits=2):\\n\\n #### Create the grids\\n df1 = df.copy()\\n\\n #### Resample the time series data\\n if agg_ts_fun is not None:\\n df1a = df1.set_index(time_col)\\n if agg_ts_fun == 'sum':\\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].sum().reset_index()\\n elif agg_ts_fun == 'mean':\\n df2 = df1a.groupby([TimeGrouper(period), Grouper(y_col), Grouper(x_col)])[data_col].mean().reset_index()\\n else:\\n raise ValueError(\\\"agg_ts_fun should be either 'sum' or 'mean'.\\\")\\n time = df2[time_col].unique()\\n else:\\n df2 = df1\\n\\n time = df2[time_col].sort_values().unique()\\n\\n if from_crs is None:\\n x = df2.loc[df2[time_col] == time[0], x_col].values\\n y = df2.loc[df2[time_col] == time[0], y_col].values\\n else:\\n data1 = df2.loc[df2[time_col] == time[0]]\\n from_crs1 = convert_crs(from_crs, pass_str=True)\\n to_crs1 = convert_crs(to_crs, pass_str=True)\\n geometry = [Point(xy) for xy in zip(data1[x_col], data1[y_col])]\\n gpd = GeoDataFrame(data1.index, geometry=geometry, crs=from_crs1)\\n gpd1 = gpd.to_crs(crs=to_crs1)\\n x = gpd1.geometry.apply(lambda p: p.x).round(digits).values\\n y = gpd1.geometry.apply(lambda p: p.y).round(digits).values\\n\\n xy = column_stack((x, y))\\n\\n max_x = x.max()\\n min_x = x.min()\\n\\n max_y = y.max()\\n min_y = y.min()\\n\\n new_x = arange(min_x, max_x, grid_res)\\n new_y = arange(min_y, max_y, grid_res)\\n x_int, y_int = meshgrid(new_x, new_y)\\n\\n #### Create new df\\n x_int2 = x_int.flatten()\\n y_int2 = y_int.flatten()\\n xy_int = column_stack((x_int2, y_int2))\\n time_df = repeat(time, len(x_int2))\\n x_df = tile(x_int2, len(time))\\n y_df = tile(y_int2, len(time))\\n new_df = DataFrame({'time': time_df, 'x': x_df, 'y': y_df, data_col: repeat(0, len(time) * len(x_int2))})\\n\\n new_lst = []\\n for t in to_datetime(time):\\n set1 = df2.loc[df2[time_col] == t, data_col]\\n# index = new_df[new_df['time'] == t].index\\n new_z = griddata(xy, set1.values, xy_int, method=interp_fun).round(digits)\\n new_z[new_z < 0] = 0\\n new_lst.extend(new_z.tolist())\\n# print(t)\\n new_df.loc[:, data_col] = new_lst\\n\\n #### Export results\\n return(new_df[new_df[data_col].notnull()])\",\n \"def simplify(self, tolerance):\\n return _unary_geo(arctern.ST_SimplifyPreserveTopology, self, tolerance)\",\n \"def create_grid_mapping(ds, wrf_out):\\n coord_sys = wrf_out[\\\"coord_sys\\\"]\\n grid_mapping = coord_sys[\\\"var_name\\\"]\\n grid_mapping_var = ds.createVariable(grid_mapping, \\\"i1\\\", ())\\n grid_mapping_var.setncatts({key: val\\n for key, val in coord_sys.items()\\n if key != \\\"var_name\\\"})\\n\\n ydim_var = ds.variables[\\\"dim_y\\\"]\\n xdim_var = ds.variables[\\\"dim_x\\\"]\\n ydim_bounds_var = ds.variables[\\\"dim_y_bnds\\\"]\\n xdim_bounds_var = ds.variables[\\\"dim_y_bnds\\\"]\\n\\n ydim_var.setncatts(wrf_out[\\\"proj_y_coord\\\"][1])\\n xdim_var.setncatts(wrf_out[\\\"proj_x_coord\\\"][1])\\n ydim_var.setncatts(dict(bounds=\\\"dim_y_bnds\\\"))\\n xdim_var.setncatts(dict(bounds=\\\"dim_x_bnds\\\"))\\n\\n ydim_bounds_var.setncatts(\\n {att: val\\n for att, val in wrf_out[\\\"proj_y_coord\\\"][1].items()\\n if att not in (\\\"standard_name\\\", \\\"axis\\\")})\\n xdim_bounds_var.setncatts(\\n {att: val\\n for att, val in wrf_out[\\\"proj_x_coord\\\"][1].items()\\n if att not in (\\\"standard_name\\\", \\\"axis\\\")})\\n\\n lat_var = ds.createVariable(\\\"latitude\\\", \\\"f4\\\", (\\\"dim_y\\\", \\\"dim_x\\\"))\\n lon_var = ds.createVariable(\\\"longitude\\\", \\\"f4\\\", (\\\"dim_y\\\", \\\"dim_x\\\"))\\n\\n # lat_coord = lat\\n # lon_coord = lon\\n lat_var.setncatts(wrf_out[\\\"wrf_lat\\\"][1])\\n lon_var.setncatts(wrf_out[\\\"wrf_lon\\\"][1])\\n\\n return grid_mapping\",\n \"def get_time_series(this_lat, this_lon, case, varnames):\\n\\n cesmdir = '/gpfs/fs1/collections/cdg/data/cesmLE/CESM-CAM5-BGC-LE/atm/proc/tseries/monthly'\\n\\n if 'LE' in case:\\n\\n from observational_large_ensemble.params import karen_params_cesm\\n\\n mode_lag = karen_params_cesm.mode_lag\\n cvdp_loc = karen_params_cesm.cvdp_loc\\n AMO_cutoff_freq = karen_params_cesm.AMO_cutoff_freq\\n\\n name_conversion = {'tas': 'TREFHT', 'pr': 'PRECC', 'slp': 'PSL'}\\n cesm_names = [name_conversion[v] for v in varnames]\\n this_member = int((case).split('-')[-1])\\n cvdp_file = '%s/CESM1-CAM5-BGC-LE_#%i.cvdp_data.1920-2018.nc' % (cvdp_loc, this_member)\\n\\n # Historical filenames for CESM. Will need to append part of RCP8.5 to get full period\\n filenames = []\\n for var in cesm_names:\\n file_str = '%s/%s/b.e11.B20TRC5CNBDRD.f09_g16.%03d.cam.h0.%s.??????-200512.nc' % (cesmdir, var,\\n this_member, var)\\n this_file = glob(file_str)[0]\\n filenames.append(this_file)\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames,\\n karen_params_cesm.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n else:\\n\\n from observational_large_ensemble.params import karen_params_obs\\n\\n mode_lag = karen_params_obs.mode_lag\\n cvdp_loc = karen_params_obs.cvdp_loc\\n AMO_cutoff_freq = karen_params_obs.AMO_cutoff_freq\\n\\n tas_dir = karen_params_obs.tas_dir\\n pr_dir = karen_params_obs.pr_dir\\n slp_dir = karen_params_obs.slp_dir\\n cvdp_file = '%s/HadISST.cvdp_data.1920-2018.nc' % cvdp_loc\\n file_dict = {'tas': '%s/Complete_TAVG_LatLong1.nc' % tas_dir,\\n 'pr': '%s/full_data_monthly_v2020.nc' % pr_dir,\\n 'slp': '%s/prmsl.mon.mean.nc' % slp_dir}\\n\\n filenames = []\\n for var in varnames:\\n filenames.append(file_dict[var])\\n\\n name_conversion = {'tas': 'temperature', 'pr': 'precip', 'slp': 'prmsl'}\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames[0],\\n karen_params_obs.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n return this_ts, df_shifted\",\n \"def reset_spatial_dims_attrs(self):\\n if self.crs is None:\\n raise ValueError(\\\"CRS is missing. Use set_crs function to resolve.\\\")\\n _da = self._obj\\n x_dim, y_dim, x_attrs, y_attrs = gis_utils.axes_attrs(self.crs)\\n if x_dim != self.x_dim or y_dim != self.y_dim:\\n _da = _da.rename({self.x_dim: x_dim, self.y_dim: y_dim})\\n _da[x_dim].attrs.update(x_attrs)\\n _da[y_dim].attrs.update(y_attrs)\\n _da.raster.set_spatial_dims(x_dim=x_dim, y_dim=y_dim)\\n return _da\",\n \"def local2global(self, local_coord, start, end, strand):\\n local2global(local_coord, start, end, strand)\",\n \"def correct_west(longitudes):\\n longitudes[longitudes < 0] += 360.\\n return longitudes\",\n \"def map_to_coords(source_lats, source_lons, target_lats, target_lons):\\n source_lats_with_border, source_lons_with_border = add_border(source_lats, 'extrapolate'), add_border(source_lons, 'extrapolate')\\n \\n if len(target_lats.shape) == 1:\\n target_lats = np.tile(target_lats,len(target_lons)).reshape(len(target_lons),-1).T\\n target_lons = np.tile(target_lons,len(target_lats)).reshape(len(target_lats),-1)\\n \\n resample_map_rows = np.zeros(target_lats.shape, dtype=int)\\n resample_map_cols = np.zeros(target_lats.shape, dtype=int)\\n for i in range(target_lats.shape[0]):\\n for j in range(target_lats.shape[1]):\\n target_lat, target_lon = target_lats[i,j], target_lons[i,j]\\n closest_source_cell = np.argmin(np.square(source_lats_with_border - target_lat) + \\n np.square(source_lons_with_border - target_lon))\\n resample_map_rows[i,j] = closest_source_cell // source_lats_with_border.shape[1]\\n resample_map_cols[i,j] = closest_source_cell % source_lats_with_border.shape[1]\\n \\n return resample_map_rows, resample_map_cols\",\n \"def overwrite_season(function):\\n @functools.wraps(function)\\n def inner(*args, season = None, **kw):\\n data = function(*args,**kw)\\n if season:\\n replace_season(data,season)\\n return data\\n return inner\",\n \"def getLocs2d(self, proj='default', extent=1):\\n if proj == 'default':\\n proj = self.default_transform_2d\\n \\n index = (proj, extent) \\n if index in self._transformed:\\n return self._transformed[index]\\n \\n \\n if proj in ['cone', 'lowerCone', 'ideal']:\\n \\n # fit the 3d sensor locations to a sphere with center (cx, cy, cz)\\n # and radius r\\n \\n # error function\\n def err(params):\\n r, cx, cy, cz = params\\n return (self.locs3d[:, 0] - cx) ** 2 \\\\\\n + (self.locs3d[:, 1] - cy) ** 2 \\\\\\n + (self.locs3d[:, 2] - cz) ** 2 \\\\\\n - r ** 2\\n \\n # initial guess of sphere parameters (radius and center)\\n params = (1, 0, 0, 0)\\n # do fit\\n (r, cx, cy, cz), stuff = leastsq(err, params)\\n \\n # center the sensor locations based on the sphere and scale to\\n # radius 1\\n sphere_center = np.array((cx, cy, cz))\\n locs3d = self.locs3d - sphere_center\\n locs3d /= r\\n \\n # implement projection\\n locs2d = np.copy(locs3d[:,:2])\\n if proj=='cone':\\n locs2d[:,0] *= (1 - locs3d[:,2]) \\n locs2d[:,1] *= (1 - locs3d[:,2])\\n elif proj=='lower cone':\\n for i in range(locs2d.shape[0]):\\n if locs3d[i,2] < 0:\\n locs2d[i,:2] *= (1 - locs3d[i,2]) \\n elif proj == 'ideal':\\n r_sq = max(locs3d[:,2]) - locs3d[:,2]\\n r = np.sqrt(r_sq) # get radius dependent on z\\n r_c = np.sqrt(locs3d[:,0]**2 + locs3d[:,1]**2) # current r\\n F = r / r_c # stretching factor accounting for current r \\n locs2d[:,0] *= F\\n locs2d[:,1] *= F\\n \\n elif proj == None:\\n locs2d = np.copy(self.locs3d[:,:2])\\n else:\\n raise ValueError(\\\"invalid proj kwarg\\\")\\n \\n # correct extent\\n if extent:\\n locs2d -= np.min(locs2d)\\n locs2d /= (np.max(locs2d) / extent)\\n \\n # save for future access\\n self._transformed[index] = locs2d\\n return locs2d\",\n \"def toPointwise_withLinearXYs( self, **kwargs ) :\\n\\n kwargs['removeOverAdjustedPoints'] = True\\n xys = regionsModule.Regions1d.toPointwise_withLinearXYs( self, **kwargs )\\n return( XYs1d( data = xys, axes = xys.axes ) )\",\n \"def geo_transform(self):\\n pass\",\n \"def _getlons(self):\\n dlon = 360. / self.nlon\\n lons = np.linspace(0. + dlon / 2., 360. - dlon / 2., self.nlon)\\n return lons\",\n \"def latlon_to_scrip(nx, ny, lon0=-180., grid_imask=None, \\n file_out=None,):\\n \\n # compute coordinates of regular grid\\n dx = 360. / nx\\n dy = 180. / ny\\n lat = np.arange(-90. + dy / 2., 90., dy)\\n lon = np.arange(lon0 + dx / 2., lon0 + 360., dx)\\n \\n # make 2D\\n y_center = np.broadcast_to(lat[:, None], (ny, nx))\\n x_center = np.broadcast_to(lon[None, :], (ny, nx))\\n\\n # compute corner points: must be counterclockwise\\n y_corner = np.stack((y_center - dy / 2., # SW\\n y_center - dy / 2., # SE\\n y_center + dy / 2., # NE\\n y_center + dy / 2.), # NW\\n axis=2)\\n\\n x_corner = np.stack((x_center - dx / 2., # SW\\n x_center + dx / 2., # SE\\n x_center + dx / 2., # NE\\n x_center - dx / 2.), # NW\\n axis=2)\\n\\n # compute area\\n y0 = np.sin(y_corner[:, :, 0] * np.pi / 180.) # south\\n y1 = np.sin(y_corner[:, :, 3] * np.pi / 180.) # north\\n x0 = x_corner[:, :, 0] * np.pi / 180. # west\\n x1 = x_corner[:, :, 1] * np.pi / 180. # east\\n grid_area = (y1 - y0) * (x1 - x0)\\n \\n # sum of area should be equal to area of sphere\\n np.testing.assert_allclose(grid_area.sum(), 4.*np.pi)\\n \\n # construct mask\\n if grid_imask is None:\\n grid_imask = np.ones((ny, nx), dtype=np.int32)\\n \\n # generate output dataset\\n dso = xr.Dataset() \\n dso['grid_dims'] = xr.DataArray(np.array([nx, ny], dtype=np.int32), \\n dims=('grid_rank',)) \\n dso.grid_dims.encoding = {'dtype': np.int32}\\n\\n dso['grid_center_lat'] = xr.DataArray(y_center.reshape((-1,)), \\n dims=('grid_size'),\\n attrs={'units': 'degrees'})\\n\\n dso['grid_center_lon'] = xr.DataArray(x_center.reshape((-1,)), \\n dims=('grid_size'),\\n attrs={'units': 'degrees'})\\n \\n dso['grid_corner_lat'] = xr.DataArray(y_corner.reshape((-1, 4)), \\n dims=('grid_size', 'grid_corners'), \\n attrs={'units': 'degrees'})\\n dso['grid_corner_lon'] = xr.DataArray(x_corner.reshape((-1, 4)), \\n dims=('grid_size', 'grid_corners'), \\n attrs={'units': 'degrees'}) \\n\\n dso['grid_imask'] = xr.DataArray(grid_imask.reshape((-1,)), \\n dims=('grid_size'),\\n attrs={'units': 'unitless'})\\n dso.grid_imask.encoding = {'dtype': np.int32}\\n \\n dso['grid_area'] = xr.DataArray(grid_area.reshape((-1,)), \\n dims=('grid_size'),\\n attrs={'units': 'radians^2',\\n 'long_name': 'area weights'})\\n \\n # force no '_FillValue' if not specified\\n for v in dso.variables:\\n if '_FillValue' not in dso[v].encoding:\\n dso[v].encoding['_FillValue'] = None\\n\\n dso.attrs = {'title': f'{dy} x {dx} (lat x lon) grid',\\n 'created_by': 'latlon_to_scrip',\\n 'date_created': f'{datetime.now()}',\\n 'conventions': 'SCRIP',\\n }\\n \\n # write output file\\n if file_out is not None:\\n print(f'writing {file_out}')\\n dso.to_netcdf(file_out)\\n \\n return dso\",\n \"def get_datetime_seasons(\\n self, train: NumpyOrPandas, outp_role: Optional[ColumnRole] = None\\n ) -> Optional[LAMLTransformer]:\\n _, datetimes = self.get_cols_for_datetime(train)\\n for col in copy(datetimes):\\n if len(train.roles[col].seasonality) == 0 and train.roles[col].country is None:\\n datetimes.remove(col)\\n\\n if len(datetimes) == 0:\\n return\\n\\n if outp_role is None:\\n outp_role = NumericRole(np.float32)\\n\\n date_as_cat = SequentialTransformer(\\n [\\n ColumnsSelector(keys=datetimes),\\n DateSeasons(outp_role),\\n ]\\n )\\n return date_as_cat\",\n \"def remove_data(ds, nh_lim, sh_lim, time_max, lat_name='lat', time_name='time'):\\n return xr.where((ds[lat_name] < nh_lim) &\\n (ds[lat_name] > sh_lim) &\\n (ds[time_name] < pd.to_datetime([time_max]).values),\\n np.nan,\\n ds)\",\n \"def ll2csflat(lon,lat,ncs):\\n j,f,i = ll2jfi(lon,lat,ncs)\\n return (j*6+f)*ncs+i\",\n \"def season_edges(t):\\n offset = season_offset(t)\\n yr_min = t.datetime.min().year\\n left_frac = t.jyear.min() % yr_min\\n if left_frac < offset:\\n ex_left = 1\\n else:\\n ex_left = 0\\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\\n return astropy.time.Time(edges, format='jyear')\",\n \"def _basemap_2d(x, y, *zs, globe=False, projection=None):\\n # Fix coordinates\\n x, y = _fix_coords(x, y)\\n\\n # Fix data\\n xmin, xmax = projection.lonmin, projection.lonmax\\n x_orig, y_orig, zs_orig = x, y, zs\\n zs = []\\n for z_orig in zs_orig:\\n # Ensure data is within map bounds\\n x, z_orig = _fix_span(x_orig, z_orig, xmin, xmax)\\n # Bail for 2D coordinates\\n if not globe or x_orig.ndim > 1 or y_orig.ndim > 1:\\n zs.append(z_orig)\\n continue\\n # Fix holes over poles by *interpolating* there\\n y, z = _add_poles(y_orig, z_orig)\\n # Fix seams at map boundary\\n if x[0] == xmin and x.size - 1 == z.shape[1]: # scenario 1\\n # Edges (e.g. pcolor) fit perfectly against seams. Size is unchanged.\\n pass\\n elif x.size - 1 == z.shape[1]: # scenario 2\\n # Edges (e.g. pcolor) do not fit perfectly. Size augmented by 1.\\n x = ma.append(xmin, x)\\n x[-1] = xmin + 360\\n z = ma.concatenate((z[:, -1:], z), axis=1)\\n elif x.size == z.shape[1]: # scenario 3\\n # Centers (e.g. contour) must be interpolated to edge. Size augmented by 2.\\n xi = np.array([x[-1], x[0] + 360])\\n if xi[0] == xi[1]: # impossible to interpolate\\n pass\\n else:\\n zq = ma.concatenate((z[:, -1:], z[:, :1]), axis=1)\\n xq = xmin + 360\\n zq = (zq[:, :1] * (xi[1] - xq) + zq[:, 1:] * (xq - xi[0])) / (xi[1] - xi[0]) # noqa: E501\\n x = ma.concatenate(([xmin], x, [xmin + 360]))\\n z = ma.concatenate((zq, z, zq), axis=1)\\n else:\\n raise ValueError('Unexpected shapes of coordinates or data arrays.')\\n zs.append(z)\\n\\n # Convert coordinates\\n if x.ndim == 1 and y.ndim == 1:\\n x, y = np.meshgrid(x, y)\\n x, y = projection(x, y)\\n\\n return x, y, *zs\",\n \"def get_gridcell_history(\\n lat,\\n lon,\\n dataset,\\n also_return_snapped_coordinates=False,\\n also_return_metadata=False,\\n use_imperial_units=True,\\n convert_to_local_time=True,\\n as_of=None,\\n ipfs_timeout=None):\\n try:\\n metadata = get_metadata(get_heads()[dataset])\\n except KeyError:\\n raise DatasetError(\\\"No such dataset in dClimate\\\")\\n\\n # set up units\\n converter, dweather_unit = get_unit_converter(metadata[\\\"unit of measurement\\\"], use_imperial_units)\\n\\n # get dataset-specific \\\"no observation\\\" value\\n missing_value = metadata[\\\"missing value\\\"]\\n try:\\n dataset_obj = GRIDDED_DATASETS[dataset](as_of=as_of, ipfs_timeout=ipfs_timeout)\\n except KeyError:\\n raise DatasetError(\\\"No such dataset in dClimate\\\")\\n\\n try:\\n (lat, lon), resp_series = dataset_obj.get_data(lat, lon)\\n\\n except (ipfshttpclient.exceptions.ErrorResponse, ipfshttpclient.exceptions.TimeoutError, KeyError, FileNotFoundError) as e:\\n raise CoordinateNotFoundError(\\\"Invalid coordinate for dataset\\\")\\n\\n # try a timezone-based transformation on the times in case we're using an hourly set.\\n if convert_to_local_time:\\n try:\\n tf = TimezoneFinder()\\n local_tz = pytz.timezone(tf.timezone_at(lng=lon, lat=lat))\\n resp_series = resp_series.tz_localize(\\\"UTC\\\").tz_convert(local_tz)\\n except (AttributeError, TypeError): # datetime.date (daily sets) doesn't work with this, only datetime.datetime (hourly sets)\\n pass\\n\\n if type(missing_value) == str:\\n resp_series = resp_series.replace(missing_value, np.NaN).astype(float)\\n else:\\n resp_series.loc[resp_series.astype(float) == missing_value] = np.NaN\\n resp_series = resp_series.astype(float)\\n \\n resp_series = resp_series * dweather_unit\\n if converter is not None:\\n resp_series = pd.Series(converter(resp_series.values), resp_series.index)\\n result = {k: convert_nans_to_none(v) for k, v in resp_series.to_dict().items()}\\n \\n if also_return_metadata:\\n result = tupleify(result) + ({\\\"metadata\\\": metadata},)\\n if also_return_snapped_coordinates:\\n result = tupleify(result) + ({\\\"snapped to\\\": (lat, lon)},)\\n return result\",\n \"def prepare(gpi, start_date, end_date, models, satellites, kind=\\\"clim\\\", window=35):\\n # read data\\n ts_input = data_object.read_gpi(gpi, start_date, end_date, models, satellites)\\n #ts_input = interp.add_nan(ts_input)\\n ts_input = interp.iter_fill(ts_input, max_gap=5)\\n\\n # either calc climatology, apply moving average filter, or do nothing\\n if kind == 'clim':\\n ts_smooth = smooth.iter_climats(ts_input)\\n plot_title = 'Climatology'\\n elif kind == 'movav':\\n ts_smooth = smooth.iter_movav(ts_input, window)\\n #ts_smooth = ts_gapfill\\n plot_title = 'Moving average'\\n elif kind == None:\\n # return original data\\n ts_smooth = ts_input\\n else:\\n raise NotImplementedError\\n pass\\n\\n # drop rows with missing values\\n #ts_smooth = ts_smooth.dropna()\\n\\n # scale satellite data to model data\\n ts_scaled = scaling.scale(ts_smooth, 'mean_std_nan', 0)\\n # drop nan rows for slope funcs\\n return ts_scaled #.dropna()\",\n \"def meanRegion(thk_s,thk_p,thk_diff):\\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\\n \\n print '\\\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\\n \\n yearmin = 2004\\n yearmax = 2015\\n years = np.arange(yearmin,yearmax+1,1)\\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\\n \\n fig = plt.figure()\\n ax = plt.subplot(111)\\n \\n ### Call parameters\\n plt.rcParams['text.usetex']=True\\n plt.rcParams['font.family'] = 'sans-serif'\\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\\n \\n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\\n label=r'PIOMAS')\\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\\n label=r'Satellite')\\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\\n \\n labelsy = map(str,np.arange(0,6,1))\\n labelsx = map(str,years)\\n plt.xticks(np.arange(len(years)),labelsx)\\n plt.yticks(np.arange(0,6,1),labelsy)\\n plt.ylabel(r'\\\\textbf{Thickness (meters)}',fontsize=13)\\n \\n ### Adjust axes in time series plots \\n def adjust_spines(ax, spines):\\n for loc, spine in ax.spines.items():\\n if loc in spines:\\n spine.set_position(('outward', 10))\\n else:\\n spine.set_color('none') \\n if 'left' in spines:\\n ax.yaxis.set_ticks_position('left')\\n else:\\n ax.yaxis.set_ticks([])\\n \\n if 'bottom' in spines:\\n ax.xaxis.set_ticks_position('bottom')\\n else:\\n ax.xaxis.set_ticks([]) \\n \\n ### Adjust axes spines\\n adjust_spines(ax, ['left', 'bottom'])\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n plt.grid(color='b',zorder=1,alpha=0.3)\\n \\n plt.legend(shadow=False,fontsize=11,loc='upper right',\\n fancybox=True)\\n \\n plt.text(2,-0.8,r'\\\\textbf{ICESat}',fontsize=13)\\n plt.text(7.3,-0.8,r'\\\\textbf{PIOMAS}',fontsize=13)\\n \\n fig.suptitle(r'\\\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)\",\n \"def custom_seasonal_adjust(denoise):\\n df_adjust = pd.DataFrame()\\n df_adjust[0] = denoise.values\\n df_adjust[1] = denoise.shift(-52).values\\n df_adjust[2] = denoise.shift(-104).values\\n seasonality = df_adjust.mean(axis=1)[:52]\\n\\n start_idx = denoise.index[0]\\n df_seasonality = seasonality.append(seasonality, ignore_index=True).append(seasonality[:39], ignore_index=True)\\n idx = pd.DatetimeIndex(start=start_idx, freq='W-FRI', periods=len(df_seasonality))\\n df_seasonality.index = idx\\n \\n seasonal_adjust = (denoise - df_seasonality).dropna()\\n df_seasonality = df_seasonality.reset_index().\\\\\\n assign(week_num = lambda x: x['index'].dt.week).\\\\\\n drop_duplicates('week_num').\\\\\\n drop(columns='index').rename(columns={0:'Weekly_Sales'})\\n \\n return df_seasonality, seasonal_adjust\",\n \"def _fix_span(x, y, xmin, xmax):\\n if x.ndim != 1:\\n return x, y\\n\\n # Roll in same direction if some points on right-edge extend\\n # more than 360 above min longitude; *they* should be on left side\\n lonroll = np.where(x > xmin + 360)[0] # tuple of ids\\n if lonroll.size: # non-empty\\n roll = x.size - lonroll.min()\\n x = np.roll(x, roll)\\n y = np.roll(y, roll, axis=-1)\\n x[:roll] -= 360 # make monotonic\\n\\n # Set NaN where data not in range xmin, xmax. Must be done\\n # for regional smaller projections or get weird side-effects due\\n # to having valid data way outside of the map boundaries\\n y = y.copy()\\n if x.size - 1 == y.shape[-1]: # test western/eastern grid cell edges\\n y[..., (x[1:] < xmin) | (x[:-1] > xmax)] = np.nan\\n elif x.size == y.shape[-1]: # test the centers and pad by one for safety\\n where = np.where((x < xmin) | (x > xmax))[0]\\n y[..., where[1:-1]] = np.nan\\n\\n return x, y\",\n \"def project(self, (lng, lat)):\\n x = lng * DEG_TO_RAD\\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\\n y = lat * DEG_TO_RAD\\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7120988","0.65913016","0.5912345","0.58565855","0.5846651","0.5827005","0.5757517","0.5742788","0.56260955","0.5573889","0.5551024","0.5517785","0.5454073","0.5447219","0.5380435","0.5367206","0.53613245","0.5329884","0.52797866","0.527883","0.5270271","0.52385974","0.52133644","0.52067035","0.51973885","0.5185496","0.5161347","0.5072558","0.5060495","0.50463194","0.50265324","0.5020291","0.5014164","0.5012974","0.49752742","0.4955288","0.49515164","0.49336112","0.4925153","0.49240386","0.49105147","0.4903907","0.4890234","0.48818552","0.488013","0.48553678","0.48503226","0.48412114","0.4820385","0.48123917","0.47799623","0.47758082","0.4767221","0.47542316","0.47121906","0.4675469","0.4673608","0.46706375","0.46701968","0.46593285","0.4651094","0.4651094","0.46497604","0.46432397","0.46430653","0.46413508","0.46366715","0.4629776","0.46220973","0.46133637","0.46072876","0.46063873","0.46008658","0.45994985","0.45953003","0.45940498","0.45929807","0.45878157","0.4575697","0.4575517","0.45690072","0.45625898","0.4555803","0.4549303","0.45370644","0.45334372","0.4527166","0.45256227","0.45220143","0.4515403","0.45151564","0.4506447","0.45047078","0.45028776","0.4502219","0.44990444","0.44982412","0.44979414","0.4493412","0.44883072"],"string":"[\n \"0.7120988\",\n \"0.65913016\",\n \"0.5912345\",\n \"0.58565855\",\n \"0.5846651\",\n \"0.5827005\",\n \"0.5757517\",\n \"0.5742788\",\n \"0.56260955\",\n \"0.5573889\",\n \"0.5551024\",\n \"0.5517785\",\n \"0.5454073\",\n \"0.5447219\",\n \"0.5380435\",\n \"0.5367206\",\n \"0.53613245\",\n \"0.5329884\",\n \"0.52797866\",\n \"0.527883\",\n \"0.5270271\",\n \"0.52385974\",\n \"0.52133644\",\n \"0.52067035\",\n \"0.51973885\",\n \"0.5185496\",\n \"0.5161347\",\n \"0.5072558\",\n \"0.5060495\",\n \"0.50463194\",\n \"0.50265324\",\n \"0.5020291\",\n \"0.5014164\",\n \"0.5012974\",\n \"0.49752742\",\n \"0.4955288\",\n \"0.49515164\",\n \"0.49336112\",\n \"0.4925153\",\n \"0.49240386\",\n \"0.49105147\",\n \"0.4903907\",\n \"0.4890234\",\n \"0.48818552\",\n \"0.488013\",\n \"0.48553678\",\n \"0.48503226\",\n \"0.48412114\",\n \"0.4820385\",\n \"0.48123917\",\n \"0.47799623\",\n \"0.47758082\",\n \"0.4767221\",\n \"0.47542316\",\n \"0.47121906\",\n \"0.4675469\",\n \"0.4673608\",\n \"0.46706375\",\n \"0.46701968\",\n \"0.46593285\",\n \"0.4651094\",\n \"0.4651094\",\n \"0.46497604\",\n \"0.46432397\",\n \"0.46430653\",\n \"0.46413508\",\n \"0.46366715\",\n \"0.4629776\",\n \"0.46220973\",\n \"0.46133637\",\n \"0.46072876\",\n \"0.46063873\",\n \"0.46008658\",\n \"0.45994985\",\n \"0.45953003\",\n \"0.45940498\",\n \"0.45929807\",\n \"0.45878157\",\n \"0.4575697\",\n \"0.4575517\",\n \"0.45690072\",\n \"0.45625898\",\n \"0.4555803\",\n \"0.4549303\",\n \"0.45370644\",\n \"0.45334372\",\n \"0.4527166\",\n \"0.45256227\",\n \"0.45220143\",\n \"0.4515403\",\n \"0.45151564\",\n \"0.4506447\",\n \"0.45047078\",\n \"0.45028776\",\n \"0.4502219\",\n \"0.44990444\",\n \"0.44982412\",\n \"0.44979414\",\n \"0.4493412\",\n \"0.44883072\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7579458"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19872,"cells":{"query":{"kind":"string","value":"as reduce2lat_seasonal, but all nontime axes are retained."},"document":{"kind":"string","value":"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax is None:\n print \"WARNING- no time axis in\",mv.id\n return None\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n print \"WARNING- cannot compute climatology for\",mv.id,seasons.seasons\n print \"...probably there is no data for times in the requested season.\"\n return None\n avmv = mvseas\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv"},"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 reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def interpolateseasons(self):\n\n remainder = self.season - self.startseason\n f1 = 1.0 - remainder\n self.data = (self.startdata * f1) + (self.stopdata * remainder)","def timeave_seasonal( mv, seasons=seasonsyr ):\n return seasons.climatology(mv)","def warren_time_series(lat, lon, dates, variable='snow_depth'):\n\n my_func = {'snow_depth': snow_depth,\n 'swe': swe}\n\n #if not all([isinstance(d, dt.datetime) for d in dates]):\n # print ('Expects datetime objects')\n\n # If lat, lon are vectors, generate 2d grids\n # Need to add code to make sure x and y are DataArrays\n if (count_dims(lat) == 1):\n x, y = np.meshgrid(lon, lat)\n else:\n x, y = lon, lat\n \n if dates.size == 1:\n cube = my_func[variable](x,y,dates.dt.month)\n da = xr.DataArray(cube,\n coords={'lat': x, 'lon': y},\n dims=['lat', 'lon'])\n else:\n cube = [my_func[variable](x, y, m) for m in dates.dt.month.values]\n da = xr.concat(cube, dim='time')\n da['time'] = dates\n\n return da","def map_season(x, figsize=(8, 6), **kwargs):\n\n from pycmbs.mapping import map_plot\n\n nvals = len(x.data)\n if nvals == 12:\n year = True\n elif nvals == 4:\n year = False\n else:\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\n\n #/// checks ///\n if x.data.ndim != 3:\n print x.data.ndim\n raise ValueError('only 3D data supported')\n\n if 'vmin' not in kwargs.keys():\n raise ValueError('vmin argument is obligatory for map_seasons()')\n if 'vmax' not in kwargs.keys():\n raise ValueError('vmax argument is obligatory for map_seasons()')\n\n if kwargs['vmin'] is None:\n raise ValueError('vmin MUST NOT be None!')\n if kwargs['vmax'] is None:\n raise ValueError('vmax MUST NOT be None!')\n\n #/// figure and axes\n if 'figure' in kwargs:\n f = kwargs['figure']\n else:\n f = plt.figure(figsize=figsize)\n\n if 'title' in kwargs:\n tit = kwargs.pop('title')\n else:\n tit = x.label\n\n if 'drawparallels' in kwargs:\n drawparallels = kwargs.pop('drawparallels')\n else:\n drawparallels = False\n\n if 'savefile' in kwargs:\n savefile = kwargs.pop('savefile')\n if '.nc' in savefile:\n savefile = savefile[:-3]\n else:\n savefile = None\n\n # plot\n if year:\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\n else:\n labels = ['DJF', 'MAM', 'JJA', 'SON']\n\n # check dates\n if year:\n mo = 1\n for t in x.time:\n if x.num2date(t).month != mo:\n print x.num2date(t), mo\n raise ValueError('Invalid monthly sequence! Can not plot results!')\n mo += 1\n\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\n if 'overlay' in kwargs.keys():\n overlays = kwargs.pop('overlay')\n else:\n overlays = None\n\n for i in range(nvals):\n if year:\n ax = f.add_subplot(4, 3, i + 1)\n #if i % 3 == 2:\n if i > 8:\n show_colorbar = True\n else:\n show_colorbar = False\n else:\n ax = f.add_subplot(2, 2, i + 1)\n if 'show_colorbar' in kwargs:\n show_colorbar = kwargs.pop('show_colorbar')\n else:\n show_colorbar = True\n\n d = x.copy()\n d.data = x.data[i, :, :]\n d.label = labels[i]\n\n if overlays is None:\n overlay = None\n else:\n overlay = overlays[i, :, :]\n\n if savefile is not None:\n tmpoutname = savefile + '_' + labels[i]\n else:\n tmpoutname = None\n\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\n savefile=tmpoutname, colorbar_orientation='horizontal',\n drawparallels=drawparallels, **kwargs)\n del d\n f.suptitle(tit, size=16)\n return f","def extract_seasonal_component(original_ts, ppy):\n \"\"\"\n # === get in-sample data\n original_ts = original_ts[:-out_of_sample]\n \"\"\"\n if seasonality_test(original_ts, ppy):\n # print(\"seasonal\")\n # ==== get moving averages\n ma_ts = moving_averages(original_ts, ppy)\n\n # ==== get seasonality indices\n le_ts = original_ts * 100 / ma_ts\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\n le_ts = np.reshape(le_ts, (-1, ppy))\n si = np.nanmean(le_ts, 0)\n norm = np.sum(si) / (ppy * 100)\n si = si / norm\n else:\n # print(\"NOT seasonal\")\n si = np.full(ppy, 100)\n return si","def seasonal_series(t, y, edges=None, hard=False):\n t = ensure_tarray(t)\n if len(t) == 1:\n return [t], [y]\n season_ixs = season_indices(t, edges=edges, hard=hard)\n ts = []\n ys = []\n for season in season_ixs:\n ts.append(astropy.time.Time(t.jyear[season], format='jyear', scale=t.scale))\n ys.append(y[season])\n return ts, ys","def manipulate_data(ds, var, predef_clim, predef_trnd, trn_yrs, all_yrs, \n apply_latw=True, apply_detrending=True, dropna=True):\n\n \n if((var=='SD')|(var=='sd')|(var=='snowc')): \n ds[var] = ds[var].where(ds[var]>=0, other=0.0)\n ds[var] = ds[var].where(ds[var]==0, other=1.0)\n #ds[var].values = Gauss_filter(ds[var].values, (0,3,3))\n \n \"\"\"\n if((var=='hgt')|(var=='z')|(var=='GPT')):\n months = ds.time.to_index().month; ssn_ends = (months==2)|(months==5)|(months==8)|(months==11)\n ds = ds.sel(time=ssn_ends)\n else: \n ds = ds.resample(time='3M').mean()\n \"\"\"\n \n ds = ds.resample(time='3M').mean()\n\n ds = ds.sel(time=slice(str(all_yrs[0])+'-01-01', str(all_yrs[-1])+'-12-31')) \n \n try: \n clim = predef_clim\n ds = ds.groupby('time.season') - clim\n print('Predefined climatology used')\n except:\n clim = ds.sel(time=slice(str(trn_yrs[0])+'-01-01', str(trn_yrs[-1])+'-12-31')).groupby('time.season').mean('time')\n ds = ds.groupby('time.season') - clim\n print('Climatology calculated from data')\n \n if(apply_latw): ds[var].values = lat_weighting(ds[var].values, \n ds.lat, ds.lon)\n if(dropna):\n ds = ds.stack(gridcell=('lat', 'lon')).dropna(dim='gridcell',how='any')\n else: \n ds = ds.stack(gridcell=('lat', 'lon')).fillna(0)\n \n \n trend_models = { }\n if(apply_detrending): \n ds = ds.load()\n for ssn in ('DJF', 'MAM', 'JJA', 'SON'):\n #ssn_idx = ds['time.season'] == ssn\n \n trn_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], trn_yrs))\n all_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], all_yrs))\n \n trn_x = np.array(ds.time[trn_idx].values.tolist()).reshape(-1,1)\n all_x = np.array(ds.time[all_idx].values.tolist()).reshape(-1,1)\n try:\n trend = predef_trnd[ssn].predict(all_x)\n trend_models[ssn] = predef_trnd[ssn]\n print('Predefined trend model used')\n except:\n #_, trend_model = define_trends(ds[var][trn_idx], trn_x)\n _, trend_model = define_trends(ds[var][all_idx], all_x)\n trend = trend_model.predict(all_x)\n trend_models[ssn] = trend_model\n print('Trends calculated from data')\n \n ds[var][all_idx] = ds[var][all_idx] - trend\n \n\n \n return ds, clim, trend_models","def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \n the_season=np.array(the_season,dtype=np.int32)\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n else:\n if lat_slice.stop is None:\n num_lats=var_nc.shape[2]\n else:\n num_lats=lat_slice.stop - lat_slice.start\n if lon_slice.stop is None:\n num_lons=var_nc.shape[3]\n else:\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n num_years=var_nc.shape[0]//12\n\n for the_year in np.arange(0,num_years):\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n the_season=the_season+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def seasonality(df):\n df_datetime = pd.DatetimeIndex(df.date_time)\n df[\"month\"] = df_datetime.month\n df = drop_cols(df, [\"date_time\"])\n\n return df","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def season_edges(t):\n offset = season_offset(t)\n yr_min = t.datetime.min().year\n left_frac = t.jyear.min() % yr_min\n if left_frac < offset:\n ex_left = 1\n else:\n ex_left = 0\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\n return astropy.time.Time(edges, format='jyear')","def get_datetime_seasons(\n self, train: NumpyOrPandas, outp_role: Optional[ColumnRole] = None\n ) -> Optional[LAMLTransformer]:\n _, datetimes = self.get_cols_for_datetime(train)\n for col in copy(datetimes):\n if len(train.roles[col].seasonality) == 0 and train.roles[col].country is None:\n datetimes.remove(col)\n\n if len(datetimes) == 0:\n return\n\n if outp_role is None:\n outp_role = NumericRole(np.float32)\n\n date_as_cat = SequentialTransformer(\n [\n ColumnsSelector(keys=datetimes),\n DateSeasons(outp_role),\n ]\n )\n return date_as_cat","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def custom_seasonal_adjust(denoise):\n df_adjust = pd.DataFrame()\n df_adjust[0] = denoise.values\n df_adjust[1] = denoise.shift(-52).values\n df_adjust[2] = denoise.shift(-104).values\n seasonality = df_adjust.mean(axis=1)[:52]\n\n start_idx = denoise.index[0]\n df_seasonality = seasonality.append(seasonality, ignore_index=True).append(seasonality[:39], ignore_index=True)\n idx = pd.DatetimeIndex(start=start_idx, freq='W-FRI', periods=len(df_seasonality))\n df_seasonality.index = idx\n \n seasonal_adjust = (denoise - df_seasonality).dropna()\n df_seasonality = df_seasonality.reset_index().\\\n assign(week_num = lambda x: x['index'].dt.week).\\\n drop_duplicates('week_num').\\\n drop(columns='index').rename(columns={0:'Weekly_Sales'})\n \n return df_seasonality, seasonal_adjust","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def seasonal_calc(t, y, func, edges=None):\n ts, ys = seasonal_series(t, y, edges=edges)\n t_means = [t.jyear.mean() for t in ts]\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\n f_y = np.array([func(y) for y in ys])\n return t_means, f_y","def plot_index_sic_timeseries(anomlous = False, temporal_resolution = 'monthly', detrend = False, imagefolder = 'images/timeseries/SIC_INDICIES', indexname = 'SAM', n = 5, seaice_source = 'nsidc'):\n output_folder = 'processed_data/'\n\n\n if anomlous:\n temp_decomp = 'anomalous'\n else:\n temp_decomp = 'raw'\n\n if detrend:\n dt = 'detrended'\n else:\n dt = 'raw'\n\n filename = f'{indexname}_{temp_decomp}_{temporal_resolution}_{dt}'\n indicies = xr.open_dataset(output_folder + 'INDICIES/' + filename +'.nc')[indexname]\n data = indicies.copy()\n data = data.loc[data.time.dt.year >= 1979]\n seaicename = f'{temp_decomp}_{temporal_resolution}_{n}_{dt}'\n\n seaice = xr.open_dataset(output_folder + 'SIC/' + seaicename +'.nc')\n\n\n times = list(set.intersection(set(seaice.time.values), set(data.time.values)))\n\n seaice = seaice_area_mean(seaice.sel(time=times).sortby('time'), 1)\n data = data.sel(time=times).sortby('time')\n\n\n if seaice_source == 'ecmwf':\n seaice = xr.open_dataset(output_folder + 'ERA5/SIC/' + seaicename +'.nc')\n if seaice_source == 'ecmwf':\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename].mean(dim = ('longitude', 'latitude')))\n if seaice_source == 'nsidc':\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(mean_seaice.time.values.astype(float), mean_seaice)\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n\n title = temp_decomp.capitalize() + ' '\n\n if detrend:\n title += dt + ' '\n\n title += temporal_resolution\n title += f' mean {indexname} and SIC'\n fig, ax = plt.subplots()\n ax2 = plt.twinx(ax)\n ax2.plot([],[])\n\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\n\n ln1 = ax.plot(data.time, data, label = f'{indexname}', color = '#EA1B10')\n ax.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10')\n if seaice_source == 'ecmwf':\n ln2 = ax2.plot(seaice.time, seaice[seaicename].mean(dim = ('longitude', 'latitude')), label = 'SIC', color = '#177E89')\n if seaice_source == 'nsidc':\n ln2 = ax2.plot(mean_seaice.time, mean_seaice, label = 'SIC', color = '#177E89')\n ax2.plot(seaice.time, seaice_m * seaice.time.values.astype(float) + seaice_b, color = '#177E89')\n\n yabs_max = abs(max(ax.get_ylim(), key=abs))\n ax.set_ylim(ymin=-yabs_max, ymax=yabs_max)\n if anomlous or detrend:\n yabs_max = abs(max(ax2.get_ylim(), key=abs))\n ax2.set_ylim(ymin=-yabs_max, ymax=yabs_max)\n\n # ylabels\n ax.set_ylabel(f'{indexname}')\n ax2.set_ylabel(f'Mean SIC')\n\n # legend\n lines = ln1 + ln2\n labels = [line.get_label() for line in lines]\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 2, loc = 'upper right')\n\n plt.title(title)\n plt.savefig(imagefolder + f'/SIC_{indexname}_{filename}_{seaice_source}' + '.pdf')\n plt.show()","def transform(self, resampled_xray, n_burn_in, n_lookahead, skf_is): \n # Set all temps on world map as features\n #valid_range = range(n_burn_in, temperatures_xray['time'].shape[0] - n_lookahead)\n #time_steps, lats, lons = temperatures_xray['tas'].values.shape\n #X = temperatures_xray['tas'].values.reshape((time_steps,lats*lons))\n #X = X[valid_range,:]\n\n tas = select_box(resampled_xray['tas']) \n\n valid_range = range(n_burn_in, resampled_xray['time'].shape[0] - n_lookahead)\n #enso = get_enso_mean(temperatures_xray['tas'])\n # reshape the vector into a table years as rows, months as columns\n #enso_matrix = enso.values.reshape((-1,12))\n\n theShape = tas.shape\n n_time,n_lat,n_long = theShape[0],theShape[1],theShape[2] \n #print n_time,n_lat,n_long \n enso_matrix = tas.values.reshape(-1,12,n_lat,n_long)\n\n count_matrix = np.ones(enso_matrix.shape)\n # compute cumulative means of columns (remember that you can only use\n # the past at each time point) and reshape it into a vector\n enso_monthly_mean = (enso_matrix.cumsum(axis=0) / count_matrix.cumsum(axis=0)).reshape(-1,n_lat,n_long)#.ravel()\n # roll it backwards (6 months) so it corresponds to the month of the target\n\n enso_anomaly = tas - enso_monthly_mean\n\n enso_anomaly_rolled = np.roll(enso_anomaly, n_lookahead - 12,axis = 0)\n # select valid range\n enso_anomaly_rolled_valid = enso_anomaly_rolled[valid_range,:,:]\n # reshape it into a matrix of a single column\n X = enso_anomaly_rolled_valid.reshape(-1,n_lat*n_long)\n\n return X","def shifts_projection(sc, clean):\n def shifts_projected(clean, axis):\n projected = clean.map(lambda x: x.mean(axis=axis)[:, :, np.newaxis])\n target = getTarget(projected, 30, 1)\n shifts = registerByPlane(sc, projected, target[:, :, np.newaxis], 10, False)\n return shifts[:, :, 0]\n\n # shifts_xy = shifts_projected(clean, 2)\n shifts_xz = shifts_projected(clean, 1)\n shifts_yz = shifts_projected(clean, 0)\n\n # x_shifts = np.mean(np.stack((shifts_xz[:, 0], shifts_xy[:, 0])), axis=0)\n z_shifts = np.mean(np.stack((shifts_xz[:, 1], shifts_yz[:, 1])), axis=0)\n # y_shifts = np.mean(np.stack((shifts_yz[:, 0], shifts_xy[:, 1])), axis=0)\n plt.figure()\n plt.plot(shifts_xz[:, 1])\n plt.plot(shifts_yz[:, 1])\n plt.plot(z_shifts)\n plt.title('Z')\n # plt.figure()\n # plt.plot(shifts_xz[:, 0])\n # plt.plot(shifts_xy[:, 0])\n # plt.plot(x_shifts)\n # plt.title('X')\n # plt.figure()\n # plt.plot(shifts_yz[:, 0])\n # plt.plot(shifts_xy[:, 1])\n # plt.plot(y_shifts)\n # plt.title('Y')\n # shifts_all = np.stack((x_shifts, y_shifts, z_shifts))\n\n def initReg(kv):\n from scipy.ndimage.interpolation import shift\n index, volume = kv\n current_shift = (0, 0, -1 * z_shifts[int(index[0])])\n shifted = shift(volume, current_shift)\n return shifted.astype(np.int16)\n\n reg = clean.map(initReg, with_keys=True, value_shape=clean.shape[1:], dtype=np.int16)\n reg.cache()\n reg.count()\n return reg","def resample_sliprate(self, dt, nsamp):\n for ps in self.pointsources:\n ps.resample_sliprate(dt, nsamp)","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 reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def correct_lon(ds):\n ds = ds.copy()\n x = ds['x'].data\n ds['x'].data = np.where(x < 0 , 360 + x, x)\n\n lon = ds['lon'].data\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\n \n ds = ds.sortby('x')\n return ds","def reset_time_dim(ds):\n return ds.assign_coords(Time=pd.to_datetime(ds.XTIME.values))","def test_rise_timeseries_correct_output_shape():\n input_data = np.random.random((10, 1))\n axis_labels = ['t', 'channels']\n labels = [1]\n\n heatmaps = dianna.explain_timeseries(run_model, input_data, \"RISE\", labels, axis_labels=axis_labels,\n n_masks=200, p_keep=.5)\n\n assert heatmaps.shape == (len(labels), *input_data.shape)","def _full_to_yearly_ts(self, arr, dt):\n time_defined = self.def_time and not ('av' in self.dtype_in_time)\n if time_defined:\n arr = utils.times.yearly_average(arr, dt)\n return arr","def test_seasonal_resolution_hindcast(monthly_initialized, monthly_obs):\n seasonal_hindcast = (\n monthly_initialized.rolling(lead=3, center=True).mean().dropna(dim=\"lead\")\n )\n seasonal_hindcast = seasonal_hindcast.isel(lead=slice(0, None, 3))\n seasonal_obs = monthly_obs.rolling(time=3, center=True).mean().dropna(dim=\"time\")\n seasonal_hindcast.lead.attrs[\"units\"] = \"seasons\"\n assert compute_hindcast(seasonal_hindcast, seasonal_obs).all()","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_sic_sic_timeseries(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/SIC/'):\n output_folder = 'processed_data/'\n\n\n if anomlous:\n temp_decomp = 'anomalous'\n else:\n temp_decomp = 'raw'\n\n if detrend:\n dt = 'detrended'\n else:\n dt = 'raw'\n\n filename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\n indicies = xr.open_dataset(output_folder + 'ERA5/SIC/' + filename +'.nc')[filename].mean(dim = ('longitude', 'latitude'))\n data = indicies.copy()\n data = data.loc[data.time.dt.year >= 1979]\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\n seaice = xr.open_dataset(output_folder + 'SIC/' + seaicename +'.nc')[seaicename]\n\n times = list(set.intersection(set(seaice.time.values), set(data.time.values)))\n\n seaice = seaice_area_mean(seaice.sel(time=times).sortby('time'), 1)\n data = data.sel(time=times).sortby('time')\n\n seaice = seaice_area_mean(seaice,1)\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice.time.values.astype(float), seaice)\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n\n title = temp_decomp.capitalize() + ' '\n\n if detrend:\n title += dt + ' '\n\n title += temporal_resolution\n title += f' mean ERA5 and SIC'\n fig, ax = plt.subplots()\n ax2 = plt.twinx(ax)\n ax2.plot([],[])\n\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\n\n ln1 = ax.plot(data.time, data, label = f'ERA5', color = '#EA1B10')\n ax.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10')\n ln2 = ax2.plot(seaice.time, seaice, label = 'SIC', color = '#177E89')\n ax2.plot(seaice.time, seaice_m * seaice.time.values.astype(float) + seaice_b, color = '#177E89')\n\n if anomlous or detrend:\n yabs_max = abs(max(ax2.get_ylim(), key=abs))\n ax2.set_ylim(ymin=-yabs_max, ymax=yabs_max)\n\n yabs_max = abs(max(ax.get_ylim(), key=abs))\n ax.set_ylim(ymin=-yabs_max, ymax=yabs_max)\n\n # ylabels\n ax.set_ylabel(f'ECMWF')\n ax2.set_ylabel(f'Mean SIC')\n\n # legend\n lines = ln1 + ln2\n labels = [line.get_label() for line in lines]\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 2, loc = 'upper right')\n\n plt.title(title)\n plt.savefig(imagefolder + f'/SIC_ERA5_{filename}' + '.pdf')\n plt.show()","def winter_avg(var_nc,lat_slice=None,lon_slice=None): \n #\n # accumulate in shape [plev,lat,lon]\n #\n # use the whole array if slice objects are missing\n #\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n print \"in winter avg: \",lat_slice,lon_slice\n else:\n num_lats=lat_slice.stop - lat_slice.start\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n #\n # year 0 is special case since it doesn't have a december\n #\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\n accumulate+=the_slice\n num_years=var_nc.shape[0]//12\n #\n # now year 1 has year 0's december\n #\n djf=np.array([11,12,13],dtype=np.int32)\n #\n # iterate one year less because we've alread\n # done year zero as a special case\n #\n for the_year in np.arange(0,num_years-1):\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n djf=djf+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def inverse_compress(self, pieces, start):\n \n time_series = [start]\n # stitch linear piece onto last\n for j in range(0, len(pieces)):\n x = np.arange(0,pieces[j,0]+1)/(pieces[j,0])*pieces[j,1]\n #print(x)\n y = time_series[-1] + x\n time_series = time_series + y[1:].tolist()\n\n return time_series","def inverse_compress(self, pieces, start):\n \n time_series = [start]\n # stitch linear piece onto last\n for j in range(0, len(pieces)):\n x = np.arange(0,pieces[j,0]+1)/(pieces[j,0])*pieces[j,1]\n #print(x)\n y = time_series[-1] + x\n time_series = time_series + y[1:].tolist()\n\n return time_series","def add_rain_clim_normals(gdf_of_interest,\n grid_of_rain_clim_norm_y = clim_norm_rain_y_np_unique, \n grid_of_rain_clim_norm_x = clim_norm_rain_x_np_unique): \n mean_monthly_rainfall = []\n for index in gdf_of_interest.index:\n closest_y_index = find_nearest_point_1D(grid_of_rain_clim_norm_y, \n gdf_of_interest.geometry.y[index], \n print_nearest_val=False)\n closest_x_index = find_nearest_point_1D(grid_of_rain_clim_norm_x, \n gdf_of_interest.geometry.x[index], \n print_nearest_val=False)\n \n month_of_interest = int(gdf_of_interest[\"Month\"][0])\n month_of_int_format = \"m\" + str(month_of_interest)\n \n mean_monthly_rainfall.append(gdf_clim_norm_rain_mean.loc[\n (gdf_clim_norm_rain_mean[\"east\"] == grid_of_rain_clim_norm_x[closest_x_index]) &\n (gdf_clim_norm_rain_mean[\"north\"] == grid_of_rain_clim_norm_y[closest_y_index]),\n month_of_int_format].values[0])\n \n \n \n gdf_of_interest[\"Mean Monthly Rainfall\"] = mean_monthly_rainfall\n \n return","def rainfall_series(self):\n\n # assign local temporal variables\n datatype = 'strds'\n increment = str(self.rain_interval)+\" minutes\"\n raster = 'raster'\n rain_excess = 'rain_excess'\n net_difference = 'net_difference'\n #iterations = sum(1 for row in precip)\n\n # create a raster space time dataset\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.elevation_timeseries,\n title=self.elevation_title,\n description=self.elevation_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.depth_timeseries,\n title=self.depth_title,\n description=self.depth_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.erdep_timeseries,\n title=self.erdep_title,\n description=self.erdep_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.flux_timeseries,\n title=self.flux_title,\n description=self.flux_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.difference_timeseries,\n title=self.difference_title,\n description=self.difference_description,\n overwrite=True)\n\n # register the initial digital elevation model\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=self.elevation,\n start=self.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # create evolution object\n evol = Evolution(\n elevation=self.elevation,\n precipitation=self.precipitation,\n start=self.start,\n rain_intensity=self.rain_intensity,\n rain_interval=self.rain_interval,\n walkers=self.walkers,\n runoff=self.runoff,\n mannings=self.mannings,\n detachment=self.detachment,\n transport=self.transport,\n shearstress=self.shearstress,\n density=self.density,\n mass=self.mass,\n grav_diffusion=self.grav_diffusion,\n erdepmin=self.erdepmin,\n erdepmax=self.erdepmax,\n k_factor=self.k_factor,\n c_factor=self.c_factor,\n m=self.m,\n n=self.n,\n threads=self.threads,\n fill_depressions=self.fill_depressions)\n\n # open txt file with precipitation data\n with open(evol.precipitation) as csvfile:\n\n # check for header\n has_header = csv.Sniffer().has_header(csvfile.read(1024))\n\n # rewind\n csvfile.seek(0)\n\n # skip header\n if has_header:\n next(csvfile)\n\n # parse time and precipitation\n precip = csv.reader(csvfile, delimiter=',', skipinitialspace=True)\n\n # initial run\n initial = next(precip)\n evol.start = initial[0]\n evol.rain_intensity = 'rain_intensity'\n # compute rainfall intensity (mm/hr)\n # from rainfall observation (mm)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity}\"\n \"={rain_observation}\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_intensity=evol.rain_intensity,\n rain_observation=float(initial[1]),\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # determine mode and run model\n if self.mode == \"simwe_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.erosion_deposition()\n # remove relative timestamps\n # from r.sim.water and r.sim.sediment\n gscript.run_command(\n 'r.timestamp',\n map=depth,\n date='none')\n gscript.run_command(\n 'r.timestamp',\n map=erosion_deposition,\n date='none')\n\n elif self.mode == \"usped_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.usped()\n\n elif self.mode == \"rusle_mode\":\n (evolved_elevation, time, depth, sediment_flux,\n difference) = evol.rusle()\n\n else:\n raise RuntimeError(\n '{mode} mode does not exist').format(mode=self.mode)\n\n # register the evolved maps\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=evolved_elevation,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.depth_timeseries,\n maps=depth,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.erdep_timeseries,\n maps=erosion_deposition,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n except (NameError, CalledModuleError):\n pass\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.flux_timeseries,\n maps=sediment_flux,\n start=evol.start,\n increment=increment,\n flags='i', overwrite=True)\n except (NameError, CalledModuleError):\n pass\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.difference_timeseries,\n maps=difference,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # run the landscape evolution model for each rainfall record\n for row in precip:\n\n # update the elevation\n evol.elevation=evolved_elevation\n\n # update time\n evol.start=row[0]\n\n # compute rainfall intensity (mm/hr)\n # from rainfall observation (mm)\n rain_intensity = 'rain_intensity'\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity}\"\n \"={rain_observation}\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_intensity=rain_intensity,\n rain_observation=float(row[1]),\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # derive excess water (mm/hr) from rainfall rate (mm/hr)\n # plus the depth (m) per rainfall interval (min)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_excess}\"\n \"={rain_intensity}\"\n \"+{depth}\"\n \"/1000.\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_excess=rain_excess,\n rain_intensity=rain_intensity,\n depth=depth,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # update excess rainfall\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity} = {rain_excess}\".format(\n rain_intensity='rain_intensity',\n rain_excess=rain_excess),\n overwrite=True)\n evol.rain_intensity = rain_intensity\n\n # determine mode and run model\n if self.mode == \"simwe_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.erosion_deposition()\n # remove relative timestamps\n # from r.sim.water and r.sim.sediment\n gscript.run_command(\n 'r.timestamp',\n map=depth,\n date='none')\n gscript.run_command(\n 'r.timestamp',\n map=erosion_deposition,\n date='none')\n\n elif self.mode == \"usped_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.usped()\n\n elif self.mode == \"rusle_mode\":\n (evolved_elevation, time, depth, sediment_flux,\n difference) = evol.rusle()\n\n else:\n raise RuntimeError(\n '{mode} mode does not exist').format(mode=self.mode)\n\n # register the evolved maps\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=evolved_elevation,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.depth_timeseries,\n maps=depth,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.erdep_timeseries,\n maps=erosion_deposition,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n except (NameError, CalledModuleError):\n pass\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.flux_timeseries,\n maps=sediment_flux,\n start=evol.start,\n increment=increment,\n flags='i', overwrite=True)\n except (NameError, CalledModuleError):\n pass\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.difference_timeseries,\n maps=difference,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # remove temporary maps\n gscript.run_command(\n 'g.remove',\n type='raster',\n name=['rain_excess'],\n flags='f')\n\n # compute net elevation change\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{net_difference}\"\n \"= {evolved_elevation}-{elevation}\".format(\n net_difference=net_difference,\n elevation=self.elevation,\n evolved_elevation=evol.elevation),\n overwrite=True)\n gscript.write_command(\n 'r.colors',\n map=net_difference,\n rules='-',\n stdin=difference_colors)","def _initial_conversion(X: Any) -> TimeSeriesInstances:\n if isinstance(X, np.ndarray) and X.ndim == 2:\n X = X.reshape(X.shape[0], 1, X.shape[1])\n return X","def timeave_old( mv ):\n # I haven't thought yet about how missing values would work with this...\n # If time intervals be unequal, this will have to be changed...\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\n n = sh[0]\n # BTW, this is the size of everything else:\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\n mvta = numpy.sum( mv.__array__(), axis=0 )\n mvta /= n\n return mvta","def plot_seaice_timeseries(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/SIC/',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 += ' mean SIC in Antarctica'\n\n\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\n seaice = xr.open_dataset(output_folder + seaicename +'.nc')\n\n if seaice_source == 'nsidc':\n seaice = seaice\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(mean_seaice.time.values.astype(float), mean_seaice)\n if seaice_source =='ecmwf':\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename].sum(dim = ('longitude', 'latitude')))\n ax = plt.gca()\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\n if seaice_source == 'nsidc':\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\n plt.plot(seaice.time, mean_seaice)\n\n if seaice_source == 'ecmwf':\n plt.plot(seaice.time, seaice[seaicename].mean(dim = ('longitude', 'latitude')))\n plt.plot(seaice.time, (seaice_m * seaice.time.values.astype(float) + seaice_b), color = '#177E89')\n plt.title(title)\n plt.savefig(imagefolder + seaicename+f'_{seaice_source}.pdf')\n plt.show()","def satReader(directory,month,latmin,latmax,lonmin,lonmax):\n \n ### Enter filename\n filename = 'cs2icesat_regrid_mar_20042015.nc' \n \n ### Month/Years extracted\n dateyr = now.year \n datemo = datetime.date(dateyr,month+1,1).strftime('%B')\n \n ### Retrieve data\n data = Dataset(directory + filename)\n lat = data.variables['lat'][:]\n lon = data.variables['lon'][:]\n thkn = data.variables['thick'][:]\n data.close()\n \n ### Calculate lat/lon region\n xmask = (lat > latmin) & (lat < latmax)\n ymask = (lon > lonmin) & (lon < lonmax)\n \n mask = xmask[:] & ymask[:]\n latvals = np.where(mask == True)[0]\n lonvals = np.where(mask == True)[1]\n latvals = np.unique(latvals)\n lonvals = np.unique(lonvals)\n \n thk = thkn[:,latvals,:]\n thk = thk[:,:,lonvals]\n \n lat = lat[latvals,:]\n lat = lat[:,lonvals]\n lon = lon[latvals,:]\n lon = lon[:,lonvals]\n\n grid = '---> [[%s to %s N, %s to %s E]]' % (latmin,latmax,lonmin,lonmax)\n print 'Completed: Satellite data read (%s)!' % datemo, grid\n \n return lat,lon,thk","def overwrite_season(function):\n @functools.wraps(function)\n def inner(*args, season = None, **kw):\n data = function(*args,**kw)\n if season:\n replace_season(data,season)\n return data\n return inner","def reduce_dataset(years, values,flux_floor=0,max_tm_error=0,min_reduction_steps=200):\n non_zero_ind, min_retained_zero_years = remove_begin_end_zero_flux(years,values,flux_floor,min_reduction_steps)\n\n years_mod = years[non_zero_ind]\n values_mod = values[non_zero_ind]\n\n if years_mod.size <3:\n years_mod = years\n values_mod = values\n values_mod = 0\n else:\n #makes ure you have not removed more than 1% of the mass when removing 0 or flux floor rates\n o_mass = TimeSeries(years,values,None,None).integrate().values[-1]\n r_mass = TimeSeries(years_mod, values_mod, None, None).integrate().values[-1]\n if abs((o_mass-r_mass)/o_mass)*100 > 1:\n years_mod = years\n values_mod = values\n timeseries = TimeSeries(years_mod, values_mod, None, None)\n mass = timeseries.integrate()\n\n #normalize Values\n maxval = np.max(values_mod)\n values_mod = values_mod/maxval\n o_timeseries = TimeSeries(years,values/maxval,None,None)\n o_mass = o_timeseries.integrate()\n timeseries = TimeSeries(years_mod, values_mod, None, None)\n mass = timeseries.integrate()\n\n mx = np.argmax(timeseries.values)\n points = [0, mx, len(timeseries)]\n x = timeseries.times\n\n ythresh = 100*np.mean(timeseries.values)\n out_error = 1\n out_error_last = out_error\n OUT_ERROR_THRESHOLD = 1e-2\n\n UPPER_N = 200\n LOWER_N = 50\n last_result = None\n MAX_ITERATIONS = 80\n\n solve_type = SMOOTH\n simple_peaks = False\n last_result,ix = reduct_iter(timeseries,flux_floor,ythresh,out_error,out_error_last,OUT_ERROR_THRESHOLD,UPPER_N,LOWER_N,last_result,MAX_ITERATIONS)\n last_result = retain_min_years(last_result.reduced_flux,o_timeseries,o_mass,min_retained_zero_years)\n #if there are less points than the min_reduction_steps then use the remaining\n #points to rebalance the segments with the largest mass errors.\n play_points = min_reduction_steps - last_result.num_reduced_points\n bef = last_result.reduced_flux.times.size\n if play_points > 0:\n last_result = red_flux.rebalance_extra_points(last_result,play_points)\n\n rr = last_result\n\n #find peaks for data rebalance and reporting\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=3,rel_height=1)\n if peaks.size == 0 :\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=2,rel_height=1)\n if peaks.size == 0:\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=1,rel_height=1)\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=3,rel_height=1)\n if pneg.size == 0:\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=2,rel_height=1)\n if pneg.size == 0:\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=1,rel_height=1)\n\n peaks = rr.reduced_flux.times[peaks]\n pneg = rr.reduced_flux.times[pneg]\n\n peaks = np.isin(o_timeseries.times,peaks)\n pneg = np.isin(o_timeseries.times,pneg)\n peaks = np.where(peaks)\n pneg = np.where(pneg)\n\n peaks = peaks[0]\n pneg = pneg[0]\n iter = 0\n while iter < 100 and (abs(last_result.total_mass_error*maxval) > max_tm_error or abs(last_result.total_mass_error/last_result.mass.values[-1])*100 > .001) :\n rr = red_flux.rebalance_valleys(rr,peaks,pneg)\n #keep the lowest total_mass_error\n if abs(rr.total_mass_error) < abs(last_result.total_mass_error):\n last_result = rr\n else:\n break\n iter += 1\n\n out_times = last_result.reduced_flux.times\n out_values = last_result.reduced_flux.values\n #return the reduced data, undo normalize of the values (*maxval)\n return out_times, out_values*maxval,-(last_result.total_mass_error * maxval),peaks.size,iter","def seasonal_means(t, y, edges=None, hard=False):\n ts, ys = seasonal_series(t, y, edges=edges, hard=hard)\n t_means = [t.jyear.mean() for t in ts]\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\n y_means = np.array([y.mean() for y in ys])\n y_std = np.array([y.std() for y in ys])\n y_N = np.array([y.size for y in ys])\n return t_means, y_means, y_std, y_N","def msl_nn_srtm_interp(self, lon_lat):\n tiles = self.find_srtm_tiles(lon_lat)\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\n lon_lat_msl[:, 0:2] = lon_lat\n for tile in set(tiles):\n otile = rasterio.open(tile, 'r')\n oimg = otile.read(1)\n idx = np.where(np.array(tiles) == tile)[0]\n pix = feat.geo_to_pix(\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\n pix = np.round(pix).astype(np.int)\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\n otile.close()\n nan_mask = lon_lat_msl[:, 2] == -32768\n lon_lat_msl[nan_mask, 2] = np.NaN\n return lon_lat_msl","def clean_and_save_timeseries(df):\n drop_columns = ['Lat', \n 'Long', \n 'Province/State']\n\n df.drop(columns=drop_columns, inplace = True)\n \n df_grouped = df.groupby(['Country/Region'], as_index=False).sum()\n df_grouped = df_grouped.set_index('Country/Region').transpose()\n df_grouped.reset_index(level=0, inplace=True)\n df_grouped.rename(columns={'index': 'Date'}, inplace=True)\n df_grouped['Date'] = pd.to_datetime(df_grouped['Date'])\n\n df_grouped.to_csv('../data/worldwide_timeseries.csv', index=False)","def daily_climatology(ds):\n\n dso = xr.Dataset()\n ds = ds.copy()\n doy = day_of_year_noleap(ds.time.values)\n ds['doy'] = xr.DataArray(doy, dims=('time'))\n\n # copy coords\n for v in ds.coords:\n if 'time' not in ds[v].dims:\n dso[v] = ds[v].copy()\n \n first_var = True\n for v in ds.variables:\n if 'time' not in ds[v].dims:\n dso[v] = ds[v].copy()\n continue \n elif v not in ['doy', 'time']:\n shape = list(ds[v].shape)\n dims = ds[v].dims\n shape[0] = 365\n\n dso[v] = xr.DataArray(np.empty(shape), dims=dims)\n count = np.zeros((365,))\n for doy, idx in ds.groupby('doy').groups.items():\n if doy == 0:\n if first_var:\n print('skipping leap days')\n else:\n count[doy-1] += len(idx)\n dso[v].data[doy-1,...] = ds[v].isel(time=idx).mean('time')\n \n first_var = False\n\n dso['time'] = xr.DataArray(np.arange(1, 366, 1), dims=('time'))\n\n return dso","def ann_mean(ds, season=None, time_bnds_varname='time_bnds', time_centered=True, n_req=None):\n \n ds = ds.copy() #deep=True)\n\n if n_req is None:\n if season is not None:\n n_req = 2\n else:\n n_req = 8\n \n if time_bnds_varname is None and not time_centered:\n raise NotImplementedError('time_bnds_varname cannot be \"None\" if time_centered=False')\n \n if not time_centered:\n time_units = ds.time.encoding['units']\n time_calendar = ds.time.encoding['calendar']\n\n # compute time bounds array\n time_bound_data = cftime.date2num(\n ds[time_bnds_varname].data, \n units=time_units, \n calendar=time_calendar) \n\n # center time\n time_centered = cftime.num2date(\n time_bound_data.mean(axis=1),\n units=time_units, \n calendar=time_calendar\n ) \n time_attrs = ds.time.attrs\n time_encoding = ds.time.encoding\n\n ds['time'] = xr.DataArray(\n time_centered,\n dims=('time')\n ) \n \n ones = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n time_mask = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n\n group_by_year = 'time.year'\n rename = {'year': 'time'}\n \n if season is not None:\n season = season.upper()\n if season not in ['DJF', 'MAM', 'JJA', 'SON']:\n raise ValueError(f'unknown season: {season}') \n\n ds['austral_year'] = xr.where(ds['time.month'] > 6, ds['time.year'] + 1, ds['time.year'])\n ds = ds.set_coords('austral_year')\n ones = ones.assign_coords({'austral_year': ds.austral_year})\n time_mask = time_mask.assign_coords({'austral_year': ds.austral_year})\n time_mask = time_mask.where(ds['time.season'] == season).fillna(0)\n \n if season == 'DJF':\n group_by_year = 'austral_year'\n rename = {'austral_year': 'time'}\n \n if time_bnds_varname is not None:\n time_wgt = ds[time_bnds_varname].diff(dim=ds[time_bnds_varname].dims[1])\n if time_wgt.dtype == '<m8[ns]':\n time_wgt = time_wgt / np.timedelta64(1, 'D')\n else: \n time_wgt = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n time_wgt = time_wgt.assign_coords(\n {c: da for c, da in ds.coords.items() if 'time' in da.dims}\n )\n \n time_wgt = time_wgt.where(time_mask==1) #.fillna(0.)\n\n ones = ones.where(time_mask==1)\n time_wgt_grouped = time_wgt.groupby(group_by_year, restore_coord_dims=False)\n time_wgt = time_wgt_grouped / time_wgt_grouped.sum(dim=xr.ALL_DIMS)\n\n nyr = len(time_wgt_grouped.groups)\n \n time_wgt = time_wgt.squeeze()\n\n idx_not_nans = ~np.isnan(time_wgt)\n sum_wgt = time_wgt.groupby(group_by_year).sum(dim=xr.ALL_DIMS)\n idx_not_nans = (sum_wgt > 0)\n\n np.testing.assert_almost_equal(\n sum_wgt[idx_not_nans], \n np.ones(idx_not_nans.sum().values)\n )\n\n nontime_vars = set([v for v in ds.variables if 'time' not in ds[v].dims]) - set(ds.coords)\n dsop = ds.drop_vars(nontime_vars)\n\n if time_bnds_varname is not None:\n dsop = dsop.drop_vars(time_bnds_varname) \n \n def weighted_mean_arr(darr, wgts=None):\n # if NaN are present, we need to use individual weights\n cond = darr.isnull()\n ones = xr.where(cond, 0.0, 1.0)\n if season is None:\n mask = (\n darr.resample({'time': 'A'}, restore_coord_dims=False).mean(dim='time').notnull()\n )\n da_sum = (\n (darr * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n ones_out = (\n (ones * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n count = (\n (ones * wgts.notnull()).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n else:\n mask = (\n darr.groupby(group_by_year, restore_coord_dims=False).mean(dim='time').notnull()\n ).rename(rename)\n \n da_sum = (\n (darr * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n \n ones_out = (\n (ones * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n \n count = (\n (ones * wgts.notnull()).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n\n ones_out = ones_out.where(ones_out > 0.0)\n da_weighted_mean = da_sum / ones_out\n\n return da_weighted_mean.where(mask).where(count >= n_req) \n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n ds_ann = dsop.map(weighted_mean_arr, wgts=time_wgt)\n\n # copy attrs\n for v in ds_ann:\n ds_ann[v].attrs = ds[v].attrs\n\n # restore coords\n ds_ann = xr.merge((ds_ann, ds[list(nontime_vars)]))\n\n # eliminate partials\n ndx = (time_wgt_grouped.count(dim=xr.ALL_DIMS) >= n_req).values\n if not ndx.all():\n ds_ann = ds_ann.isel(time=ndx)\n\n return ds_ann","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def nifti_from_time_series(volume, coords, time_series, nifti_path):\r\n # XXX Implement!\r\n raise NotImplementedError","def convert_coords(date, time_steps, azs, els, obs):\n coord_start_day = datetime(date.year, date.month, date.day)\n \n strategy = []\n for time_step, az, el in zip(time_steps, azs, els):\n if az % np.pi == 0.0: \n az += EPS\n \n ra, dec = sphere.altaz_to_ra_dec(coord_start_day + timedelta(hours=time_step), az, el, obs)\n strategy.append([ra, dec])\n \n return np.array(strategy)","def compute_stage4(lon, lat, year):\n nc = netCDF4.Dataset(\"/mesonet/data/stage4/%s_stage4_hourly.nc\" % (year,))\n lons = nc.variables[\"lon\"][:]\n lats = nc.variables[\"lat\"][:]\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\n (yidx, xidx) = np.unravel_index(dist.argmin(), dist.shape)\n print(\n (\"Computed stage4 nclon:%.2f nclat:%.2f yidx:%s xidx:%s \")\n % (lons[yidx, xidx], lats[yidx, xidx], yidx, xidx)\n )\n p01i = mm2inch(nc.variables[\"p01m\"][:, yidx, xidx])\n nc.close()\n df = pd.DataFrame(\n {\"precip\": 0.0},\n index=pd.date_range(\n \"%s-01-01\" % (year,), \"%s-12-31\" % (year,), tz=\"America/Chicago\"\n ),\n )\n for date in df.index.values:\n date2 = datetime.datetime.utcfromtimestamp(date.tolist() / 1e9)\n ts = datetime.datetime(date2.year, date2.month, date2.day, 6)\n ts = ts.replace(tzinfo=pytz.utc)\n ts = ts.astimezone(pytz.timezone(\"America/Chicago\"))\n ts = ts.replace(hour=0)\n ts = ts.astimezone(pytz.utc)\n tidx = hourly_offset(ts)\n # values are in the rears\n val = np.ma.sum(p01i[tidx + 1 : tidx + 25])\n if val > 0:\n df.at[date, \"precip\"] = val # close enough\n return df","def get_time_series(this_lat, this_lon, case, varnames):\n\n cesmdir = '/gpfs/fs1/collections/cdg/data/cesmLE/CESM-CAM5-BGC-LE/atm/proc/tseries/monthly'\n\n if 'LE' in case:\n\n from observational_large_ensemble.params import karen_params_cesm\n\n mode_lag = karen_params_cesm.mode_lag\n cvdp_loc = karen_params_cesm.cvdp_loc\n AMO_cutoff_freq = karen_params_cesm.AMO_cutoff_freq\n\n name_conversion = {'tas': 'TREFHT', 'pr': 'PRECC', 'slp': 'PSL'}\n cesm_names = [name_conversion[v] for v in varnames]\n this_member = int((case).split('-')[-1])\n cvdp_file = '%s/CESM1-CAM5-BGC-LE_#%i.cvdp_data.1920-2018.nc' % (cvdp_loc, this_member)\n\n # Historical filenames for CESM. Will need to append part of RCP8.5 to get full period\n filenames = []\n for var in cesm_names:\n file_str = '%s/%s/b.e11.B20TRC5CNBDRD.f09_g16.%03d.cam.h0.%s.??????-200512.nc' % (cesmdir, var,\n this_member, var)\n this_file = glob(file_str)[0]\n filenames.append(this_file)\n\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames,\n karen_params_cesm.valid_years, mode_lag,\n cvdp_file, AMO_cutoff_freq, name_conversion)\n\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\n\n else:\n\n from observational_large_ensemble.params import karen_params_obs\n\n mode_lag = karen_params_obs.mode_lag\n cvdp_loc = karen_params_obs.cvdp_loc\n AMO_cutoff_freq = karen_params_obs.AMO_cutoff_freq\n\n tas_dir = karen_params_obs.tas_dir\n pr_dir = karen_params_obs.pr_dir\n slp_dir = karen_params_obs.slp_dir\n cvdp_file = '%s/HadISST.cvdp_data.1920-2018.nc' % cvdp_loc\n file_dict = {'tas': '%s/Complete_TAVG_LatLong1.nc' % tas_dir,\n 'pr': '%s/full_data_monthly_v2020.nc' % pr_dir,\n 'slp': '%s/prmsl.mon.mean.nc' % slp_dir}\n\n filenames = []\n for var in varnames:\n filenames.append(file_dict[var])\n\n name_conversion = {'tas': 'temperature', 'pr': 'precip', 'slp': 'prmsl'}\n\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames[0],\n karen_params_obs.valid_years, mode_lag,\n cvdp_file, AMO_cutoff_freq, name_conversion)\n\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\n\n return this_ts, df_shifted","def switch_lons(ds, lon_name='lon'):\n ds = ds.copy()\n with dask.config.set(**{'array.slicing.split_large_chunks': True}):\n if np.any(ds.coords[lon_name] < 0): # if current coords are -180 to 180\n ds.coords[lon_name] = (ds.coords[lon_name] + 360) % 360\n else:\n ds.coords[lon_name] = (ds.coords[lon_name] + 180) % 360 - 180\n return ds.sortby(ds[lon_name])","def meanRegion(thk_s,thk_p,thk_diff):\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\n \n print '\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\n \n yearmin = 2004\n yearmax = 2015\n years = np.arange(yearmin,yearmax+1,1)\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\n \n fig = plt.figure()\n ax = plt.subplot(111)\n \n ### Call parameters\n plt.rcParams['text.usetex']=True\n plt.rcParams['font.family'] = 'sans-serif'\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\n \n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\n label=r'PIOMAS')\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\n label=r'Satellite')\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\n \n labelsy = map(str,np.arange(0,6,1))\n labelsx = map(str,years)\n plt.xticks(np.arange(len(years)),labelsx)\n plt.yticks(np.arange(0,6,1),labelsy)\n plt.ylabel(r'\\textbf{Thickness (meters)}',fontsize=13)\n \n ### Adjust axes in time series plots \n def adjust_spines(ax, spines):\n for loc, spine in ax.spines.items():\n if loc in spines:\n spine.set_position(('outward', 10))\n else:\n spine.set_color('none') \n if 'left' in spines:\n ax.yaxis.set_ticks_position('left')\n else:\n ax.yaxis.set_ticks([])\n \n if 'bottom' in spines:\n ax.xaxis.set_ticks_position('bottom')\n else:\n ax.xaxis.set_ticks([]) \n \n ### Adjust axes spines\n adjust_spines(ax, ['left', 'bottom'])\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.grid(color='b',zorder=1,alpha=0.3)\n \n plt.legend(shadow=False,fontsize=11,loc='upper right',\n fancybox=True)\n \n plt.text(2,-0.8,r'\\textbf{ICESat}',fontsize=13)\n plt.text(7.3,-0.8,r'\\textbf{PIOMAS}',fontsize=13)\n \n fig.suptitle(r'\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)","def prepare(gpi, start_date, end_date, models, satellites, kind=\"clim\", window=35):\n # read data\n ts_input = data_object.read_gpi(gpi, start_date, end_date, models, satellites)\n #ts_input = interp.add_nan(ts_input)\n ts_input = interp.iter_fill(ts_input, max_gap=5)\n\n # either calc climatology, apply moving average filter, or do nothing\n if kind == 'clim':\n ts_smooth = smooth.iter_climats(ts_input)\n plot_title = 'Climatology'\n elif kind == 'movav':\n ts_smooth = smooth.iter_movav(ts_input, window)\n #ts_smooth = ts_gapfill\n plot_title = 'Moving average'\n elif kind == None:\n # return original data\n ts_smooth = ts_input\n else:\n raise NotImplementedError\n pass\n\n # drop rows with missing values\n #ts_smooth = ts_smooth.dropna()\n\n # scale satellite data to model data\n ts_scaled = scaling.scale(ts_smooth, 'mean_std_nan', 0)\n # drop nan rows for slope funcs\n return ts_scaled #.dropna()","def test_smooth_goddard_2013(PM_ds_control_3d_full):\r\n da = PM_ds_control_3d_full\r\n actual = smooth_goddard_2013(\r\n da,\r\n )\r\n # test that x, y not in dims\r\n assert \"x\" not in actual.dims\r\n assert \"y\" not in actual.dims\r\n # tests whether nlat, nlon got reduced\r\n assert actual.time.size < da.time.size\r\n assert actual.lon.size < da.lon.size\r\n assert actual.lat.size < da.lat.size","def time_series(t, f=0.02):\n T = t.size\n # Seasonal component and time-varying trend component\n ys = np.sin(2 * np.pi * f * t) * 0.6 + np.sin(1 / 5 * 2 * np.pi * f * t) * 0.2\n # Amplitude modulation component\n amp_mod = 0.5 * np.sin(1 / 6 * 2 * np.pi * f * t) + 0.8\n ys *= amp_mod\n ys = np.reshape(ys, (T,1))\n return ys","def replace_season(data,season):\n if not SeasonCharts.matchseason(season):\n raise SeasonCharts.SeasonError\n ## Check data format\n if test_rawdata(data):\n for cat,shows in data.items():\n for show in shows: show['season'] = season\n else:\n for show in data: show['season'] = season","def _map_timestep2timeind(self, timestep):\n if not self.simulation and timestep not in self.timemap:\n # for steady state computation include year 0 or first 12 months\n if self.md.litter_mode=='monthly':\n incl = range(1, 13)\n infall = self.md.monthly_litter\n elif self.md.litter_mode=='yearly':\n incl = [0]\n infall = self.md.yearly_litter\n for ind in range(len(infall)):\n if infall[ind].timestep in incl:\n self.timemap[timestep].append(ind)\n if timestep not in self.timemap and self.md.litter_mode=='yearly':\n # if no year 0 specification, use the one for year 1\n for ind in range(len(infall)):\n if infall[ind].timestep==1:\n self.timemap[timestep].append(ind)\n if self.simulation and timestep not in self.timemap:\n # now for the simulation run\n now, end = self._get_now_and_end(timestep)\n if self.md.duration_unit=='month':\n dur = relativedelta(months=self.timestep_length)\n elif self.md.duration_unit=='year':\n dur = relativedelta(years=self.timestep_length)\n end = now + dur - relativedelta(days=1)\n if self.md.litter_mode=='monthly':\n inputdur = relativedelta(months=1)\n infall = self.md.monthly_litter\n elif self.md.litter_mode=='yearly':\n inputdur = relativedelta(years=1)\n infall = self.md.yearly_litter\n # the first mont/year will have index number 1, hence deduce 1 m/y\n start = STARTDATE - inputdur\n for ind in range(len(infall)):\n incl = self._test4inclusion(ind, infall, now, start, end)\n if incl:\n self.timemap[timestep].append(ind)\n # check for possible area reductions to be mapped\n areachange = self.md.area_change\n for ind in range(len(areachange)):\n incl = self._test4inclusion(ind, areachange, now, start, end)\n if incl:\n self.area_timemap[timestep].append(ind)\n if timestep not in self.timemap:\n self.timemap[timestep] = []\n if timestep not in self.area_timemap:\n self.area_timemap[timestep] = []\n return self.timemap[timestep]","def strain_seasonal(strain, mouse, feature, bin_width, period_length):\n if (not isinstance(strain, int)) or (strain < 0):\n raise ValueError(\n 'Strain must be a non-negative integer')\n if (not all([isinstance(m, int)\n for m in mouse])) or (any([m < 0 for m in mouse])):\n raise ValueError(\n 'Mouse value must be a non-negative integer')\n if feature not in ALL_FEATURES:\n raise ValueError(\n 'Input value must in {\"AS\", \"F\", \"M_AS\", \"M_IS\", \"W\", \"Distance\"}')\n if (not isinstance(bin_width, int)) or bin_width < 0 or bin_width > 1440:\n raise ValueError(\n 'Bin width (minutes) must be a non-negative integer below 1440')\n if period_length < 0:\n raise ValueError(\n 'Peoriod length must be a non-negative integer or float')\n\n # seasonal decomposition\n seasonal_all = np.array([])\n freq = int(period_length * 60 / bin_width)\n\n for m in mouse:\n res = seasonal_decomposition(\n strain, m, feature, bin_width, period_length)\n seasonal_all = np.append(seasonal_all, res.seasonal[0:freq])\n seasonal_all = seasonal_all.reshape([len(mouse), -1])\n\n return seasonal_all","def nms_scale(nz, size, stride):\n # Perform NMS between scales\n for i, e in enumerate(nz):\n if e is None:\n continue\n [s, x, y, sc] = e\n for j, f in enumerate(nz):\n if f is None or j == i:\n continue\n [s_t, x_t, y_t, sc_t] = f\n if overlap_scale([s, x, y], [s_t, x_t, y_t], size, stride):\n if sc >= sc_t:\n nz[j] = None\n else:\n nz[i] = None\n break # Go to i+1\n res = []\n for e in nz:\n if e is None:\n continue\n res.append(e)\n return res","def ssa_full(time_series, embedding_dim=20, reconstruct_components=np.arange(10)):\n\n pc, s, v = ssa_decompose(time_series, embedding_dim)\n time_series_reconstructed = ssa_reconstruct(pc, v, reconstruct_components)\n\n return time_series_reconstructed","def constant_2015():\n\n #Load the CMIP6 historical\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\n #Get low and high level emissions just in the last year (2014)\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\n final_cubes = iris.cube.CubeList()\n for cube in cubes:\n final_cube = cube[-12:]\n final_cubes.append(final_cube)\n \n #Set the year-on-year proportional reductions to be nothing\n yoy_rates = calc_perc_reducts()\n yoy_rates = np.array(yoy_rates)\n yoy_rates = np.ones_like(yoy_rates)\n\n #Create coordinates for new nc file between 2014 and 2100\n lat_coord = cubes[0].coord('latitude')\n lon_coord = cubes[0].coord('longitude')\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\n\n #Create the cube date\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n #Set first year equal to 2014 in CMIP6 historical\n cube_data_surf[:12,...] = final_cubes[0].data\n cube_data_high[:12,...] = final_cubes[1].data\n #Apply equal emissions in all other years too\n for i in range(12,cube_data_surf.shape[0]):\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\n #Make the output cubes\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\n\n fut_cube_high.var_name = 'field569_1'\n fut_cube_high.units='kg/m2/s'\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\n fut_cube_surf.var_name = 'field569'\n fut_cube_surf.units='kg/m2/s'\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\n\n #Load the DMS cube from standard RCP2.6\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\n\n dms_cube.var_name = 'field570'\n dms_cube.attributes.pop('name')\n dms_cube.coord('time').var_name = 'time'\n dms_cube.coord('time').long_name = 'time'\n\n fut_cube_high = fut_cube_high[:-2]\n fut_cube_surf = fut_cube_surf[:-2]\n\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\n\n #Save the final cubes as netcdf (cutting them to be the same length)\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \"SO2DMS_const2014.nc\")\n os.system('ncatted -O -a calendar,time,m,c,\"360_day\" '+data_dir+ \"SO2DMS_const2014.nc\")\n\n return","def distributeSeason(self):\n i = 1\n for day in self.daylist:\n if i >= monthbeg[5] and i < monthbeg[9]: #june through SEpt as per SCE\n day.season = 'summer' #https://www.sce.com/residential/rates/Time-Of-Use-Residential-Rate-Plans\n i = i + 1\n else:\n day.season = 'winter'\n i = i+1","def _fix_austrian_lpis(self, eopatch):\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\n self.mapping,\n on='SNAR_BEZEI')","def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\n import numpy as np\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\n\n def plotter(pdata, colormax=1, colormin=-999, title=''):\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \n if colormin == -999:\n colormin = -colormax\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\n pdata, lon = addcyclic(pdata, lon)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\n mycmap1 = plt.cm.Blues_r(np.arange(256))\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\n my_cmap[230:282, :] = 1\n if precip == 'yes':\n my_cmap = my_cmap[::-1]\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\"newjet\", my_cmap)\n ctrs = np.linspace(colormin, colormax, 17)\n plot = m.contourf(x, y, pdata, ctrs,\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\n extend='both')\n\n plt.title(title, y=1)\n plt.show()\n return plot\n\n ax1 = fig.add_subplot(3, 3, 1)\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\n ax2 = fig.add_subplot(3, 3, 2)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\n ax3 = fig.add_subplot(3, 3, 3)\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\n ax4 = fig.add_subplot(3, 3, 4)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\n ax5 = fig.add_subplot(3, 3, 5)\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\n ax6 = fig.add_subplot(3, 3, 6)\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\n ax7 = fig.add_subplot(3, 3, 7)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\n ax8 = fig.add_subplot(3, 3, 9)\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\n ax9 = fig.add_subplot(3, 3, 8)\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\n\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\n orientation='horizontal', extend='max')\n \n b.set_label(label='t200 difference ($^\\circ$C)', size=20, fontsize=20, fontname='Arial')\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\n right=.95)","def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\n # Lookup parameters per serie\n #seasonality = self.seasonality\n embeds = self.embeds(idxs)\n lev_sms = t.sigmoid(embeds[:, 0])\n\n # Initialize seasonalities\n seas_prod = t.ones(len(Y[:,0]), device=Y.device)\n seasonalities1 = []\n seasonalities2 = []\n seas_sms1 = t.ones(1, device=Y.device)\n seas_sms2 = t.ones(1, device=Y.device)\n\n if len(self.seasonality)>0:\n seas_sms1 = t.sigmoid(embeds[:, 1])\n init_seas1 = t.exp(embeds[:, 2:(2+self.seasonality[0])]).unbind(1)\n assert len(init_seas1) == self.seasonality[0]\n\n for i in range(len(init_seas1)):\n seasonalities1 += [init_seas1[i]]\n seasonalities1 += [init_seas1[0]]\n seas_prod = seas_prod * init_seas1[0]\n\n if len(self.seasonality)==2:\n seas_sms2 = t.sigmoid(embeds[:, 2+self.seasonality[0]])\n init_seas2 = t.exp(embeds[:, 3+self.seasonality[0]:]).unbind(1)\n assert len(init_seas2) == self.seasonality[1]\n\n for i in range(len(init_seas2)):\n seasonalities2 += [init_seas2[i]]\n seasonalities2 += [init_seas2[0]]\n seas_prod = seas_prod * init_seas2[0]\n\n # Initialize levels\n levels = []\n levels += [Y[:,0]/seas_prod]\n\n # Recursive seasonalities and levels\n ys = Y.unbind(1)\n n_time = len(ys)\n for t_idx in range(1, n_time):\n seas_prod_t = t.ones(len(Y[:,t_idx]), device=Y.device)\n if len(self.seasonality)>0:\n seas_prod_t = seas_prod_t * seasonalities1[t_idx]\n if len(self.seasonality)==2:\n seas_prod_t = seas_prod_t * seasonalities2[t_idx]\n\n newlev = lev_sms * (ys[t_idx] / seas_prod_t) + (1-lev_sms) * levels[t_idx-1]\n levels += [newlev]\n\n if len(self.seasonality)==1:\n newseason1 = seas_sms1 * (ys[t_idx] / newlev) + (1-seas_sms1) * seasonalities1[t_idx]\n seasonalities1 += [newseason1]\n\n if len(self.seasonality)==2:\n newseason1 = seas_sms1 * (ys[t_idx] / (newlev * seasonalities2[t_idx])) + \\\n (1-seas_sms1) * seasonalities1[t_idx]\n seasonalities1 += [newseason1]\n newseason2 = seas_sms2 * (ys[t_idx] / (newlev * seasonalities1[t_idx])) + \\\n (1-seas_sms2) * seasonalities2[t_idx]\n seasonalities2 += [newseason2]\n\n levels = t.stack(levels).transpose(1,0)\n\n seasonalities = []\n\n if len(self.seasonality)>0:\n seasonalities += [t.stack(seasonalities1).transpose(1,0)]\n\n if len(self.seasonality)==2:\n seasonalities += [t.stack(seasonalities2).transpose(1,0)]\n\n return levels, seasonalities","def plot_subplot_trend(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/subplots/',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 trends'\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 if seaice_source == 'nsidc':\n seaice = seaice/250\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = xr.apply_ufunc(scipy.stats.linregress, seaice[seaicename].time.values.astype(float), seaice[seaicename], input_core_dims=[['time'],['time']], vectorize=True, dask='parallelized', output_dtypes=[float]*5, output_core_dims=[[]]*5)\n if seaice_source =='ecmwf':\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename])\n seaice_m = seaice_m * 1e9 * 60 * 60 * 24 * 365\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\n seaice_m = seaice_m*area\n seaice_m = seaice_m.where(seaice_m != 0)\n seaice_m = seaice_m.where(seaice_p_value <= 0.05)\n\n\n# Index xontributions\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 newdata = {} \n for indexname in indicies[:-1]:\n a = scipy.stats.linregress(index_data[indexname].time.values.astype(float), index_data[indexname])\n newdata[indexname] = a[0] * dataset[indexname] * 24*60*60*365e9\n title = temp_decomp.capitalize() + ' '\n if detrend == 'detrended':\n title += detrend + ' '\n title += temporal_resolution\n title += f' SIC trend contributions'\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\n # Plotting\n for i in range(len(indicies)-1):\n indexname = indicies[i]\n newdata[indexname] = newdata[indexname] * area / 250\n newdata[indexname] = newdata[indexname].where(newdata[indexname] !=0)\n\n\n\n fig = plt.figure(figsize = (15,5))\n\n # seaice_m = log_data(seaice_m)\n max_ = min(seaice_m.max(),-seaice_m.min())\n # max_ = 1\n divnorm = TwoSlopeNorm(vmin=-max_, vcenter=0, vmax=max_)\n ax = fig.add_subplot(131, projection = ccrs.SouthPolarStereo())\n # Plotting\n contor = ax.contourf(seaice_m.x, seaice_m.y, seaice_m, cmap = 'RdBu', levels = 100, norm = divnorm, transform=ccrs.SouthPolarStereo())\n ax.coastlines()\n ax.set_axis_off()\n # cbar = plt.colorbar(contor)\n # cbar.set_label('Trend in SIE (km$^2$ yr$^{-1}$)')\n # plt.title(title)\n ax = [fig.add_subplot(2,6,3, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,4, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,9, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,10, projection = ccrs.SouthPolarStereo())]\n for i in range(len(indicies)-1):\n indexname = indicies[i]\n # newdata[indexname] = log_data(newdata[indexname])\n newdata[indexname] = newdata[indexname].where(newdata[indexname] !=0)\n contor = ax[i].contourf(dataset.x, dataset.y, newdata[indexname], cmap = 'RdBu', norm = divnorm, transform=ccrs.SouthPolarStereo(), levels = 100)\n ax[i].coastlines()\n ax[i].set_axis_off()\n ax[i].set_title(indicies[i])\n\n ax = fig.add_subplot(1,3,3, projection = ccrs.SouthPolarStereo())\n data = seaice_m\n for i in range(len(indicies)-1):\n indexname = indicies[i]\n data = data - newdata[indexname]\n ax.contourf(dataset.x, dataset.y, data, cmap = 'RdBu', norm = divnorm, levels = 100, transform=ccrs.SouthPolarStereo())\n ax.coastlines()\n fig.subplots_adjust(right=0.9)\n cbar_ax = fig.add_axes([0.95, 0.15, 0.05, 0.7])\n cbar = fig.colorbar(cm.ScalarMappable(norm=divnorm, cmap='RdBu'), cax=cbar_ax, shrink=0.88)\n\n plt.savefig(imagefolder + seaicename + '.pdf')\n plt.show()","def broadcast_lonlat(ds, verbose=True):\n if 'lon' not in ds.variables:\n ds.coords['lon'] = ds['x']\n if 'lat' not in ds.variables:\n ds.coords['lat'] = ds['y']\n \n if len(ds['lon'].dims) < 2:\n ds.coords[\"lon\"] = ds[\"lon\"] * xr.ones_like(ds[\"lat\"])\n if len(ds['lat'].dims) < 2:\n ds.coords[\"lat\"] = xr.ones_like(ds[\"lon\"]) * ds[\"lat\"]\n return ds","def one_period_plot():\n file = \"Data/matfiles/20131221.mat\"\n object = MatReader(file)\n\n NeA = object.NeA\n latA = object.latA\n times = object.secondsA\n mlt = object.mltA\n ind1 = 2606 #lat inds\n ind2 = 13940 #lat inds\n \n ind1 = 3197 #mlat inds\n ind2 = 14390 #mlat inds\n \n T = ind2 - ind1\n ind1 += int(T/2)\n ind2 += int(T/2)\n\n latA = latA[ind1:ind2]\n NeA = NeA[ind1:ind2]\n # NeA = object.meanie(NeA, 5)\n times = times[ind1:ind2]\n mlt = mlt[ind1:ind2]\n mlt = hour_round(mlt)\n\n lats = np.zeros_like(latA)\n lats[0] = latA[0]\n for i in range(len(latA)-1):\n dlat = latA[i+1] - latA[i]\n if dlat < 0:\n lats[i+1] = lats[i] - dlat\n else:\n lats[i+1] = lats[i] + dlat\n\n lats += 90\n\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\n # plt.plot(lats, NeA, \".\", markersize = 1)\n # plt.plot([0, 0], [0, np.max(NeA)], \"k\")\n # plt.plot([30, 30], [0, np.max(NeA)], \"k\")\n # plt.plot([60, 60], [0, np.max(NeA)], \"k\")\n # plt.plot([120, 120],[0, np.max(NeA)], \"k\")\n # plt.plot([150, 150], [0, np.max(NeA)], \"k\")\n # plt.plot([167, 167], [0, np.max(NeA)], \"k\")\n # plt.plot([193, 193], [0, np.max(NeA)], \"k\")\n # plt.plot([210, 210], [0, np.max(NeA)], \"k\")\n # plt.plot([240, 244], [0, np.max(NeA)], \"k\")\n # plt.plot([300, 300], [0, np.max(NeA)], \"k\")\n # plt.plot([330, 330], [0, np.max(NeA)], \"k\")\n # plt.plot([360, 360], [0, np.max(NeA)], \"k\")\n # plt.xticks(xticks)\n # plt.xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n # plt.ylabel(\"Electron density [cm$^{-1}$]\")\n # plt.title(\"One SWARM satellite period\")\n # plt.grid(\"on\", axis = \"x\", xdata = gridticks)\n #adding letters\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\n y = np.zeros_like(x) - np.max(NeA)/40\n s = [\"S\", \"B\", \"A\", \"B\", \"C\", \"D\", \"C\", \"B\", \"A\", \"B\", \"S\"]\n # for i in range(len(x)):\n # plt.text(x[i], y[i], s[i], fontsize = 10)\n # plt.savefig(\"Figures/swarm_period.pdf\")\n # plt.show()\n\n # plt.plot(times, latA)\n # plt.plot(times, mlt)\n # plt.show()\n print(lats[0])\n print(lats[-1])\n \n fig, ax = plt.subplots()\n ax.plot(lats, NeA, \".\", markersize = 1)\n ax.set_xticks(xticks, minor=False)\n ax.set_xticks([167, 193], minor=True)\n ax.xaxis.grid(True, which = \"major\")\n ax.xaxis.grid(True, which = \"minor\")\n for i in range(len(x)):\n ax.text(x[i], y[i], s[i], fontsize = 10)\n ax.set_xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n ax.set_ylabel(\"Electron density [cm$^{-1}$]\")\n ax.set_title(\"One Swarm satellite period\")\n # plt.savefig(\"Figures/swarm_period.pdf\")\n plt.show()\n plt.plot(mlt, NeA)\n plt.show()\n plt.plot(mlt, lats)\n plt.show()","def msatna_blocks_3lag_year(year: int) -> pd.Series:\n return msatna_blocks_3lag_panel()[year]","def equalise_ts(station_list):\n s_y={}\n s_y_size = 5000 #large number for first pass\n for s in station_list:\n s_data = np.loadtxt('station_fuelType/'+s+\"_P98\",delimiter=',')\n s_y[s] = s_data[:,1]\n while float(s_y[s][0]) == 0.0:\n s_y[s]=s_y[s][1:len(s_y[s])]\n if len(s_y[s])<s_y_size:\n s_y_size = len(s_y[s])\n \n for s in s_y:\n if len(s_y[s])>s_y_size:\n s_y[s]=s_y[s][len(s_y[s])-s_y_size:len(s_y[s])]\n \n ts_y = np.ndarray(shape=[0, s_y_size], dtype = 'float')\n for key, v in s_y.items():\n ts_y = np.vstack([ts_y, np.array(v)])\n\n return ts_y","def set_coord_values(ds, wrf_out, footprint_nbins):\n xdim_var = ds.variables[\"dim_x\"]\n ydim_var = ds.variables[\"dim_y\"]\n xdim_bounds_var = ds.variables[\"dim_x_bnds\"]\n ydim_bounds_var = ds.variables[\"dim_y_bnds\"]\n lon_var = ds.variables[\"longitude\"]\n lat_var = ds.variables[\"latitude\"]\n\n time_back_var = ds.variables[\"time_before_observation\"]\n time_back_bounds_var = ds.variables[\"time_before_observation_bnds\"]\n\n height_var = ds.variables[\"height\"]\n height_bounds_var = ds.variables[\"height_bnds\"]\n\n dx = wrf_out[\"dx\"]\n\n xdim_data = wrf_out[\"proj_x_coord\"][0]\n ydim_data = wrf_out[\"proj_y_coord\"][0]\n xdim_var[:] = xdim_data[:]\n ydim_var[:] = ydim_data[:]\n\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\n xdim_bounds_var[-1,0] = xdim_data[-1]\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\n ydim_bounds_var[-1,0] = ydim_data[-1]\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\n\n wrf_lats = wrf_out[\"wrf_lat\"][0][0, :, :]\n wrf_lons = wrf_out[\"wrf_lon\"][0][0, :, :]\n lat_var[:, :] = wrf_lats[:, :]\n lon_var[:, :] = wrf_lons[:, :]\n\n ds.geospatial_lat_min = wrf_lats.min()\n ds.geospatial_lat_max = wrf_lats.max()\n ds.geospatial_lat_units = \"degree_north\"\n ds.geospatial_lon_min = wrf_lons.min()\n ds.geospatial_lon_max = wrf_lons.max()\n ds.geospatial_lon_units = \"degree_east\"\n\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\n time_back_var[:] = time_back_vals\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\n time_back_vals[1:]))\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\n\n height_var[...] = 0\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)","def rescale(self):\n # forecast on real data, don't need this anymore\n pass","def transform(self, y=None):\n forecast_dates = self.X[[\"dt_time\", \"month_day\"]]\n weather_avg = pd.read_csv(\"../data/weather_averages.csv\")\n weather_fcst = weather_avg[\n [\"DATE\", \"DLY-TMAX-NORMAL\", \"DLY-PRCP-50PCTL\", \"DLY-SNOW-50PCTL\"]\n ]\n weather_fcst[\"DATE\"] = pd.to_datetime(\n weather_fcst[\"DATE\"].astype(\"str\"), format=\"%Y%m%d\", errors=\"ignore\"\n )\n weather_fcst[\"month_day\"] = weather_fcst[\"DATE\"].dt.strftime(\"%m/%d\")\n weather_fcst = weather_fcst[\n [\"month_day\", \"DLY-PRCP-50PCTL\", \"DLY-TMAX-NORMAL\", \"DLY-SNOW-50PCTL\"]\n ].rename(\n columns={\n \"DLY-PRCP-50PCTL\": \"precip\",\n \"DLY-TMAX-NORMAL\": \"temp_max\",\n \"DLY-SNOW-50PCTL\": \"snow\",\n }\n )\n weather_fcst[\"snow\"] = 0.0\n weather_fcst = forecast_dates.join(\n weather_fcst.set_index(\"month_day\"), on=\"month_day\"\n )\n near_term_weather = seattle_weather_fcst()\n\n for i in range(len(near_term_weather)):\n weather_fcst[\"temp_max\"][\n weather_fcst[\"dt_time\"] == near_term_weather[\"date\"][i]\n ] = near_term_weather[\"temp_max\"][i]\n if near_term_weather[\"precip_bool\"][i] == 0:\n weather_fcst[\"precip\"][\n weather_fcst[\"dt_time\"] == near_term_weather[\"date\"][0]\n ] = 0\n\n self.X[[\"precip\", \"temp_max\", \"snow\"]] = weather_fcst[\n [\"precip\", \"temp_max\", \"snow\"]\n ]\n return self.X.drop(\n columns=[\n \"dt_time\",\n \"year\",\n \"month\",\n \"day\",\n \"day_of_week\",\n \"month_day\",\n \"month_weekday\",\n \"spec_day\",\n ]\n )","def _fix_coords(x, y):\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\n return x, y\n lon1 = x[0]\n filter_ = x < lon1\n while filter_.sum():\n filter_ = x < lon1\n x[filter_] += 360\n return x, y","def timeseries(self, x, convert=None, rmnans=False, timeslice=None, **kw):\n x = x.replace('.','/')\n try: v = self[x]['value'][:].squeeze()\n except KeyError:\n raise KeyError('could not read value for {0}'.format(x))\n# if x.split('/')[-1] == 'platform_orientation':\n# v[v < 0] += 2*np.pi\n if convert: \n v = convert(v)\n t = self[x]['time'][:].squeeze() - 366\n if timeslice:\n if type(timeslice[0]) is datetime.datetime: \n timeslice[0] = matplotlib.dates.date2num(timeslice[0])\n if type(timeslice[1]) is datetime.datetime: \n timeslice[1] = matplotlib.dates.date2num(timeslice[1])\n v = v[np.logical_and(t > timeslice[0], t < timeslice[1])]\n t = t[np.logical_and(t > timeslice[0], t < timeslice[1])]\n if rmnans:\n v, t = oalib.rmnans(v, t)\n return v, t","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def ts_fit(series: TimeSeries) -> TimeSeries:\n pass","def ll2csflat(lon,lat,ncs):\n j,f,i = ll2jfi(lon,lat,ncs)\n return (j*6+f)*ncs+i","def _interpolate_meteorological_data(dset, data, rundate):\n rundate = datetime(rundate.year, rundate.month, rundate.day)\n for field, station in [(f, f[4:]) for f in data.keys() if f.startswith(\"met_\")]:\n log.debug(f\"Meteorological data available for station {station}\")\n\n met_time = data[field].pop(\"met_time\")\n flat_list = [item for sublist in met_time for item in sublist]\n met_time_float = np.array([(flat_list[i] - rundate).total_seconds() for i in range(0, len(flat_list))])\n met_time_unique, met_index = np.unique(met_time_float, return_index=True)\n\n diff = len(met_time_float) - len(met_time_unique)\n if diff > 0:\n log.dev(f\"Removed duplicate met data for station {station}\")\n log.dev(\"Do this for the actual obs data also!\")\n if len(met_time_unique) == 1:\n for met_type in data[field].keys():\n data[field][met_type] = np.repeat(data[field][met_type][0], dset.num_obs)\n continue\n\n # Extrapolation one month before/after\n # (this is overkill, most of these values will be removed later when taking the diagonal)\n min_time = min(met_time_unique) - 31 * 86400\n max_time = max(met_time_unique) + 31 * 86400\n met_time_unique = np.hstack((np.array(min_time), met_time_unique, np.array(max_time)))\n\n for met_type in data[field].keys():\n met_data_array = data[field][met_type]\n flat_list = [item for sublist in met_data_array for item in sublist]\n met_data_array = np.array([flat_list[i] for i in met_index])\n met_data_array = np.hstack((met_data_array[0], met_data_array, met_data_array[-1]))\n data[field][met_type] = interpolation.interpolate(\n met_time_unique, met_data_array, dset.obs_time, kind=\"cubic\"\n )\n\n return data","def F_interp_narr_mat(sounding_lon,sounding_lat,sounding_datenum,\\\n narr_dir='/mnt/Data2/NARR/acmap_narr/',\\\n file_collection_names=['flx'],\\\n file_collection_fields=[['GPH_tropopause','P_tropopause']]):\n from scipy.io import loadmat\n from scipy.interpolate import griddata\n \n start_datenum = np.amin(sounding_datenum)\n end_datenum = np.amax(sounding_datenum)\n start_datetime = datedev_py(start_datenum)\n start_year = start_datetime.year\n start_month = start_datetime.month\n start_day = start_datetime.day\n start_hour = start_datetime.hour\n end_datetime = datedev_py(end_datenum)\n end_year = end_datetime.year\n end_month = end_datetime.month\n end_day = end_datetime.day\n end_hour = end_datetime.hour\n step_hour = 3 # narr data are 3-hourly\n narr_start_hour = start_hour-start_hour%step_hour\n narr_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=narr_start_hour)\n if end_hour >= 24-step_hour:\n narr_end_hour = 0\n narr_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=narr_end_hour)\\\n +datetime.timedelta(days=1)\n else:\n narr_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\n narr_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=narr_end_hour)\n nstep = (narr_end_datetime-narr_start_datetime).total_seconds()/3600/step_hour+1\n nstep = int(nstep)\n \n narr_data = {}\n # load narr data\n for i in range(len(file_collection_names)):\n file_collection_name = file_collection_names[i]\n file_collection_field = file_collection_fields[i]\n for istep in range(nstep):\n file_datetime = narr_start_datetime+datetime.timedelta(hours=step_hour*istep)\n file_name = 'subset_'+file_collection_name+file_datetime.strftime('_%d_%H.mat')\n file_path = os.path.join(narr_dir,file_datetime.strftime('%Y'),\\\n file_datetime.strftime('%m'),file_name)\n if not narr_data:\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],file_collection_field)))\n narr_data['lon'] = mat_data['lon']\n narr_data['lat'] = mat_data['lat']\n for fn in file_collection_field:\n narr_data[fn] = np.zeros((narr_data['lon'].shape[0],narr_data['lon'].shape[1],nstep))\n narr_data[fn][...,istep] = mat_data[fn]\n else:\n mat_data = loadmat(file_path,variable_names=file_collection_field)\n for fn in file_collection_field:\n narr_data[fn][...,istep] = mat_data[fn]\n # construct time axis\n narr_data['datenum'] = np.zeros((nstep),dtype=np.float64)\n for istep in range(nstep):\n file_datetime = narr_start_datetime+datetime.timedelta(hours=step_hour*istep)\n narr_data['datenum'][istep] = (file_datetime.toordinal()\\\n +file_datetime.hour/24.\\\n +file_datetime.minute/1440.\\\n +file_datetime.second/86400.+366.)\n # interpolate\n lon_pts = np.repeat(narr_data['lon'][...,np.newaxis],nstep,axis=narr_data['lon'].ndim)\n lat_pts = np.repeat(narr_data['lat'][...,np.newaxis],nstep,axis=narr_data['lat'].ndim)\n datenum_pts = np.ones(lon_pts.shape)\n for istep in range(nstep):\n datenum_pts[...,istep] = datenum_pts[...,istep]*narr_data['datenum'][istep]\n \n sounding_interp = {}\n # griddata is slow. may need to project sounding_lon/lat to narr x/y space and use interpn\n for i in range(len(file_collection_names)):\n file_collection_field = file_collection_fields[i]\n for fn in file_collection_field:\n sounding_interp[fn] = griddata((lon_pts.flatten(),lat_pts.flatten(),datenum_pts.flatten()),\\\n narr_data[fn].flatten(),(sounding_lon,sounding_lat,sounding_datenum))\n return sounding_interp","def reconfig_to_datetime(all_files, datetime_axis, time_freq, nrows=1):\n\n new_ydata = {}\n max_primary = max_secondary = float(\"-inf\")\n min_primary = min_secondary = float(\"inf\")\n for key, value in all_files.iteritems():\n \n\tassert isinstance(value, nio.InputData)\n\t\n\t# Convert original xaxis to datetime objects #\n\t\n\torig_dtaxis = value.datetimes\n\t\n\t# Check the start point of original xaxis against the new datetime_axis #\n\t\n\tmissval = value.data.missing_value\n\tydata = value.data[:]\n\t\n if orig_dtaxis[0] in datetime_axis[:]:\n\t nfill = rrule(eval(time_freq), dtstart=datetime_axis[0], until=orig_dtaxis[0]).count() - 1\n\t for i in xrange(nfill):\n\t ydata = numpy.insert(ydata, 0, missval)\n\telse:\n\t ystart = orig_dtaxis[:].index(datetime_axis[0])\n\t ydata = ydata[ystart:]\n\t orig_dtaxis = orig_dtaxis[ystart:]\n\t\t \n # Check the end point of original xaxis against the new datetime_axis #\n\t\n if orig_dtaxis[-1] in datetime_axis[:]:\n nfill = rrule(eval(time_freq), dtstart=orig_dtaxis[-1], until=datetime_axis[-1]).count() - 1\n\t for i in xrange(nfill):\n\t ydata = numpy.append(ydata, missval)\n else:\n\t yend = orig_dtaxis[:].index(datetime_axis[-1]) + 1\n ydata = ydata[:yend]\n\n # Update the minimum and maximum value #\n\n ydata = numpy.ma.masked_values(ydata, missval)\n\n if value.set == 'primary':\n max_primary, min_primary = nio.hi_lo(ydata, max_primary, min_primary)\n elif value.set == 'secondary':\n max_secondary, min_secondary = nio.hi_lo(ydata, max_secondary, min_secondary)\n\n new_ydata[key] = YaxisElement(split_nrows(ydata, nrows), \n all_files[key].tag, \n all_files[key].set)\n \n primary_bounds = (min_primary, max_primary)\n secondary_bounds = None if max_secondary == float(\"inf\") else (min_secondary, max_secondary)\n\n\n return new_ydata, primary_bounds, secondary_bounds","def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\n y_transformed, _ = Y.median(1)\n y_transformed = y_transformed.reshape(-1, 1)\n levels = y_transformed.repeat(1, Y.shape[1])\n seasonalities = None\n\n return levels, None","def test_time_series_from_file():\r\n\r\n TR = 1.35\r\n ts_ff = io.time_series_from_file\r\n\r\n #File names:\r\n fmri_file1 = os.path.join(data_path,'fmri1.nii.gz')\r\n fmri_file2 = os.path.join(data_path,'fmri2.nii.gz')\r\n\r\n #Spatial coordinates into the volumes:\r\n coords1 = np.array([[5,5,5,5],[5,5,5,5],[1,2,3,4]])\r\n coords2 = np.array([[6,6,6,6],[6,6,6,6],[3,4,5,6]])\r\n\r\n #No averaging, no normalization:\r\n t1 = ts_ff([fmri_file1,fmri_file2],[coords1,coords2],TR)\r\n\r\n npt.assert_equal(t1[0].shape,(4,80)) # 4 coordinates, 80 time-points\r\n\r\n t2 = ts_ff([fmri_file1,fmri_file2],[coords1,coords2],TR,average=True)\r\n\r\n npt.assert_equal(t2[0].shape,(80,)) # collapse coordinates,80 time-points\r\n\r\n t3 = ts_ff(fmri_file1,coords1,TR,normalize='zscore')\r\n\r\n #The mean of each channel should be almost equal to 0:\r\n npt.assert_almost_equal(t3.data[0].mean(),0)\r\n #And the standard deviation should be almost equal to 1:\r\n npt.assert_almost_equal(t3.data[0].std(),1)\r\n\r\n t4 = ts_ff(fmri_file1,coords1,TR,normalize='percent')\r\n\r\n #In this case, the average is almost equal to 0, but no constraint on the\r\n #std:\r\n npt.assert_almost_equal(t4.data[0].mean(),0)\r\n\r\n #Make sure that we didn't mess up the sampling interval:\r\n npt.assert_equal(t4.sampling_interval,nitime.TimeArray(1.35))\r\n\r\n # Test the default behavior:\r\n data = io.load(fmri_file1).get_data()\r\n t5 = ts_ff(fmri_file1)\r\n npt.assert_equal(t5.shape, data.shape)\r\n npt.assert_equal(t5.sampling_interval, ts.TimeArray(1, time_unit='s'))\r\n\r\n # Test initializing TR with a TimeArray:\r\n t6= ts_ff(fmri_file1, TR=ts.TimeArray(1350, time_unit='ms'))\r\n npt.assert_equal(t4.sampling_interval, t6.sampling_interval)\r\n\r\n # Check the concatenation dimensions:\r\n t7 = ts_ff([fmri_file1, fmri_file2])\r\n npt.assert_equal([t7.shape[:3], t7.shape[-1]], [data.shape[:3], data.shape[-1]*2])\r\n\r\n t8 = ts_ff([fmri_file1, fmri_file2], average=True)\r\n npt.assert_equal(t8.shape[0], data.shape[-1]*2)\r\n\r\n t9 = ts_ff([fmri_file1, fmri_file2], average=True, normalize='zscore')\r\n npt.assert_almost_equal(t9.data.mean(), 0)","def normalize(self) -> Self:\n new_values = normalize_i8_timestamps(self.asi8, self.tz, reso=self._creso)\n dt64_values = new_values.view(self._ndarray.dtype)\n\n dta = type(self)._simple_new(dt64_values, dtype=dt64_values.dtype)\n dta = dta._with_freq(\"infer\")\n if self.tz is not None:\n dta = dta.tz_localize(self.tz)\n return dta","def get_cycling_timeseries_2017(station: str):\n\n # Load data\n cycling_df = pd.read_csv(\"src/Helsingin_pyorailijamaarat.csv\", sep=\";\")\n\n # Drop rows and columns with only null values\n cycling_df = cycling_df \\\n .dropna(axis=0, how=\"all\") \\\n .dropna(axis=1, how=\"all\")\n\n # Create Date column and reindex dataset\n cycling_df[\"Date\"] = create_date_column(cycling_df[\"Päivämäärä\"])\n cycling_df = cycling_df.set_index(\"Date\")\n\n # Drop redundan\n cycling_df.drop([\"Päivämäärä\"], axis=\"columns\", inplace=True)\n\n cycling_df = cycling_df.loc['2017', station]\n\n cycling_df = cycling_df \\\n .groupby(cycling_df.index.date) \\\n .sum()\n\n return cycling_df","def reformat(dataset):\n x = dataset[:, 1] \n x = np.stack(x) # reshape to (n, mel bands, timesteps)\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \n y = dataset[:, 2] \n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\n return x, y","def F_interp_geos_mat(sounding_lon,sounding_lat,sounding_datenum,\\\n geos_dir='/mnt/Data2/GEOS/s5p_interp/',\\\n interp_fields=['TROPPT']):\n from scipy.io import loadmat\n from scipy.interpolate import RegularGridInterpolator\n \n start_datenum = np.amin(sounding_datenum)\n end_datenum = np.amax(sounding_datenum)\n start_datetime = datedev_py(start_datenum)\n start_year = start_datetime.year\n start_month = start_datetime.month\n start_day = start_datetime.day\n start_hour = start_datetime.hour\n \n end_datetime = datedev_py(end_datenum)\n end_year = end_datetime.year\n end_month = end_datetime.month\n end_day = end_datetime.day\n end_hour = end_datetime.hour\n end_minute = end_datetime.minute\n end_second = end_datetime.second\n \n step_hour = 3 # geos fp data are 3-hourly\n \n geos_start_hour = start_hour-start_hour%step_hour\n geos_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=geos_start_hour)\n if end_hour > 24-step_hour or (end_hour == 24-step_hour and (end_minute > 0 or end_second > 0)):\n geos_end_hour = 0\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour) +datetime.timedelta(days=1)\n elif end_hour%step_hour == 0 and end_minute == 0 and end_second == 0:\n geos_end_hour = end_hour\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\n else:\n geos_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\n \n nstep = (geos_end_datetime-geos_start_datetime).total_seconds()/3600/step_hour+1\n nstep = int(nstep)\n \n geos_data = {}\n # load narr data\n for istep in range(nstep):\n file_datetime = geos_start_datetime+datetime.timedelta(hours=step_hour*istep)\n file_dir = os.path.join(geos_dir,file_datetime.strftime('Y%Y'),\\\n file_datetime.strftime('M%m'),\\\n file_datetime.strftime('D%d'))\n file_path = os.path.join(file_dir,'subset_'+file_datetime.strftime('%Y%m%d_%H')+'.mat')\n if not geos_data:\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],interp_fields)))\n geos_data['lon'] = mat_data['lon'].flatten()\n geos_data['lat'] = mat_data['lat'].flatten()\n geos_data['datenum'] = np.zeros((nstep),dtype=np.float64)\n for fn in interp_fields:\n geos_data[fn] = np.zeros((len(geos_data['lon']),len(geos_data['lat']),nstep))\n geos_data[fn][...,istep] = mat_data[fn]\n else:\n mat_data = loadmat(file_path,variable_names=interp_fields)\n for fn in interp_fields:\n geos_data[fn][...,istep] = mat_data[fn]\n \n geos_data['datenum'][istep] = (file_datetime.toordinal()\\\n +file_datetime.hour/24.\\\n +file_datetime.minute/1440.\\\n +file_datetime.second/86400.+366.)\n # interpolate\n sounding_interp = {}\n for fn in interp_fields:\n my_interpolating_function = \\\n RegularGridInterpolator((geos_data['lon'],geos_data['lat'],geos_data['datenum']),\\\n geos_data[fn],bounds_error=False,fill_value=np.nan)\n sounding_interp[fn] = my_interpolating_function((sounding_lon,sounding_lat,sounding_datenum))\n return sounding_interp","def _sort_by_satellite(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n time = []\n satellite = []\n system = []\n for sat in sorted(self.dset.unique(\"satellite\"), reverse=True):\n idx = self.dset.filter(satellite=sat)\n time.extend(self.dset.time.gps.datetime[idx])\n satellite.extend(self.dset.satellite[idx])\n system.extend(self.dset.system[idx])\n \n return np.array([time]), np.array([satellite]), np.array([system])","def reshape_at_dist(self):\n self.all_dist_per_mol = np.zeros((self.nmol, self.at_per_mol, self.at_per_mol))\n for imol in range(self.nmol):\n start, end = self.at_per_mol*imol, (imol+1)*self.at_per_mol\n self.all_dist_per_mol[imol] = self.all_dist[start:end,\n start:end]","def replace_x_y_nominal_lat_lon(ds):\n ds = ds.copy()\n if 'x' in ds.dims and 'y' in ds.dims:\n \n nominal_y = ds.lat.mean('x')\n # extract the equatorial lat and take those lon values as nominal lon\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\n nominal_x = ds.lon.isel(y=eq_ind)\n ds.coords['x'].data = nominal_x.data\n ds.coords['y'].data = nominal_y.data\n\n ds = ds.sortby('x')\n ds = ds.sortby('y')\n \n else:\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\n return ds","def run(ts):\n nc = netCDF4.Dataset(('/mesonet/data/iemre/%s_mw_mrms_daily.nc'\n '') % (ts.year,), 'a')\n offset = iemre.daily_offset(ts)\n ncprecip = nc.variables['p01d']\n\n # We want this mrms variable to replicate the netcdf file, so the\n # origin is the southwestern corner\n ts += datetime.timedelta(hours=24)\n gmtts = ts.astimezone(pytz.timezone(\"UTC\"))\n\n gribfn = gmtts.strftime((\"/mnt/a4/data/%Y/%m/%d/mrms/ncep/\"\n \"RadarOnly_QPE_24H/\"\n \"RadarOnly_QPE_24H_00.00_%Y%m%d-%H%M00.grib2.gz\"))\n if not os.path.isfile(gribfn):\n print(\"merge_mrms_q3.py MISSING %s\" % (gribfn,))\n return\n\n fp = gzip.GzipFile(gribfn, 'rb')\n (_, tmpfn) = tempfile.mkstemp()\n tmpfp = open(tmpfn, 'wb')\n tmpfp.write(fp.read())\n tmpfp.close()\n grbs = pygrib.open(tmpfn)\n grb = grbs[1]\n lats, _ = grb.latlons()\n os.unlink(tmpfn)\n\n val = grb['values']\n # Anything less than zero, we set to zero\n val = np.where(val < 0, 0, val)\n\n # CAREFUL HERE! The MRMS grid is North to South\n # set top (smallest y)\n y0 = int((lats[0, 0] - iemre.NORTH) * 100.0)\n y1 = int((lats[0, 0] - iemre.SOUTH) * 100.0)\n x0 = int((iemre.WEST - mrms.WEST) * 100.0)\n x1 = int((iemre.EAST - mrms.WEST) * 100.0)\n # print 'y0:%s y1:%s x0:%s x1:%s' % (y0, y1, x0, x1)\n ncprecip[offset, :, :] = np.flipud(val[y0:y1, x0:x1])\n # m = MapPlot(sector='midwest')\n # x, y = np.meshgrid(nc.variables['lon'][:], nc.variables['lat'][:])\n # m.pcolormesh(x, y, ncprecip[offset,:,:], range(10), latlon=True)\n # m.postprocess(filename='test.png')\n # (fig, ax) = plt.subplots()\n # ax.imshow(mrms)\n # fig.savefig('test.png')\n # (fig, ax) = plt.subplots()\n # ax.imshow(mrms[y0:y1,x0:x1])\n # fig.savefig('test2.png')\n nc.close()","def run_denoising(time_series, hpf_before_regression, inds_to_include, interpolation_method,\n noise_comps, clean_comps, high_pass, low_pass, n_skip_vols, TR, filter_order = 6):\n\n\n initial_dvars = dvars(time_series, np.linspace(0,n_skip_vols - 1,n_skip_vols,dtype=int))\n\n #Load the arrays with the data for both the clean and noise components to be used in regression\n clean_comps_pre_filter = clean_comps\n noise_comps_pre_filter = noise_comps\n\n #Apply an initial HPF to everything if necessary - this does not remove scrubbed timepoints,\n #but does skips the first n_skip_vols (which will be set to 0 and not used in subsequent steps)\n if hpf_before_regression != False:\n\n b, a = imaging_utils.construct_filter('highpass', [hpf_before_regression], TR, filter_order)\n\n #start with the clean comps matrix\n if type(clean_comps_pre_filter) != type(False):\n\n clean_comps_post_filter = np.zeros(clean_comps_pre_filter.shape)\n for clean_dim in range(clean_comps_pre_filter.shape[0]):\n\n clean_comps_post_filter[clean_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, clean_comps_pre_filter[clean_dim, n_skip_vols:])\n\n #this option for both clean/noise indicates there is no input matrix to filter\n else:\n\n clean_comps_post_filter = False\n\n #Move to the noise comps matrix\n if type(noise_comps_pre_filter) != type(False):\n\n noise_comps_post_filter = np.zeros(noise_comps_pre_filter.shape)\n for noise_dim in range(noise_comps_pre_filter.shape[0]):\n\n noise_comps_post_filter[noise_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, noise_comps_pre_filter[noise_dim, n_skip_vols:])\n\n else:\n\n noise_comps_post_filter = False\n\n #then filter the original time signal\n filtered_time_series = np.zeros(time_series.shape)\n for original_ts_dim in range(time_series.shape[0]):\n\n filtered_time_series[original_ts_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, time_series[original_ts_dim, n_skip_vols:])\n\n #If you don't want to apply the initial HPF, then\n #just make a copy of the matrices of interest\n else:\n\n clean_comps_post_filter = clean_comps_pre_filter\n noise_comps_post_filter = noise_comps_pre_filter\n filtered_time_series = time_series\n\n\n\n\n #Now create the nuisance regression model. Only do this step if\n #the noise_comps_post_filter isn't false.\n good_timepoint_inds = np.where(inds_to_include == True)[0]\n bad_timepoint_inds = np.where(inds_to_include == False)[0]\n\n if type(noise_comps_post_filter) == type(False):\n\n regressed_time_signal = filtered_time_series\n original_std = None\n\n else:\n\n\n #Calculate the standard deviation of the signal before nuisance regression\n original_std = np.std(filtered_time_series[:,good_timepoint_inds], axis=1)\n\n #Weird thing where I need to swap dimensions here...(implemented correctly)\n\n #First add constant/linear trend to the denoising model\n constant = np.ones((1,filtered_time_series.shape[1]))\n linear_trend = np.linspace(0,filtered_time_series.shape[1],num=filtered_time_series.shape[1])\n linear_trend = np.reshape(linear_trend, (1,filtered_time_series.shape[1]))[0]\n noise_comps_post_filter = np.vstack((constant, linear_trend, noise_comps_post_filter))\n\n regressed_time_signal = np.zeros(filtered_time_series.shape).transpose()\n filtered_time_series_T = filtered_time_series.transpose()\n\n #If there aren't any clean components,\n #do a \"hard\" or \"agressive\" denosing\n if type(clean_comps_post_filter) == type(False):\n\n noise_comps_post_filter_T_to_be_used = noise_comps_post_filter[:,good_timepoint_inds].transpose()\n XT_X_Neg1_XT = np.linalg.pinv(noise_comps_post_filter_T_to_be_used)\n\n for temp_time_signal_dim in range(filtered_time_series.shape[0]):\n regressed_time_signal[good_timepoint_inds,temp_time_signal_dim] = imaging_utils.partial_clean_fast(filtered_time_series_T[good_timepoint_inds,temp_time_signal_dim], XT_X_Neg1_XT, noise_comps_post_filter_T_to_be_used)\n\n\n\n #If there are clean components, then\n #do a \"soft\" denoising\n else:\n\n full_matrix_to_be_used = np.vstack((noise_comps_post_filter, clean_comps_post_filter))[:,good_timepoint_inds].transpose()\n noise_comps_post_filter_T_to_be_used = noise_comps_post_filter[:,good_timepoint_inds].transpose()\n XT_X_Neg1_XT = np.linalg.pinv(full_matrix_to_be_used)\n\n for temp_time_signal_dim in range(filtered_time_series.shape[0]):\n regressed_time_signal[good_timepoint_inds,temp_time_signal_dim] = imaging_utils.partial_clean_fast(filtered_time_series_T[good_timepoint_inds,temp_time_signal_dim], XT_X_Neg1_XT, noise_comps_post_filter_T_to_be_used)\n\n\n #Put back into original dimensions\n regressed_time_signal = regressed_time_signal.transpose()\n\n #Calculate the standard deviation of the signal after the nuisance regression\n post_regression_std = np.std(regressed_time_signal[:,good_timepoint_inds], axis=1)\n\n\n #Now apply interpolation\n interpolated_time_signal = np.zeros(regressed_time_signal.shape)\n\n if interpolation_method == 'spectral':\n\n interpolated_time_signal = spectral_interpolation_fast(inds_to_include, regressed_time_signal, TR)\n\n else:\n for dim in range(regressed_time_signal.shape[0]):\n interpolated_time_signal[dim,:] = interpolate(inds_to_include, regressed_time_signal[dim,:], interpolation_method, TR)\n\n #Now if necessary, apply additional filterign:\n if high_pass == False and low_pass == False:\n\n filtered_time_signal = interpolated_time_signal\n\n else:\n\n if high_pass != False and low_pass == False:\n\n b, a = imaging_utils.construct_filter('highpass', [high_pass], TR, filter_order)\n\n elif high_pass == False and low_pass != False:\n\n b, a = imaging_utils.construct_filter('lowpass', [low_pass], TR, filter_order)\n\n elif high_pass != False and low_pass != False:\n\n b, a = imaging_utils.construct_filter('bandpass', [high_pass, low_pass], TR, filter_order)\n\n filtered_time_signal = np.zeros(regressed_time_signal.shape)\n for dim in range(regressed_time_signal.shape[0]):\n\n filtered_time_signal[dim,:] = imaging_utils.apply_filter(b,a,regressed_time_signal[dim,:])\n\n final_dvars = dvars(filtered_time_signal, bad_timepoint_inds)\n\n #Now set all the undefined timepoints to Nan\n cleaned_time_signal = filtered_time_signal\n cleaned_time_signal[:,bad_timepoint_inds] = np.nan\n\n output_dict = {}\n denoising_stats = {}\n\n output_dict['cleaned_timeseries'] = cleaned_time_signal\n\n denoising_stats['dvars_pre_cleaning'] = initial_dvars\n denoising_stats['dvars_post_cleaning'] = final_dvars\n\n dvars_stats = {}\n dvars_stats['mean_dvars_pre_cleaning'] = np.mean(initial_dvars[(initial_dvars > 0)])\n dvars_stats['mean_dvars_post_cleaning'] = np.mean(final_dvars[(final_dvars > 0)])\n dvars_stats['max_dvars_pre_cleaning'] = np.max(initial_dvars)\n dvars_stats['max_dvars_post_cleaning'] = np.max(final_dvars)\n dvars_stats['dvars_remaining_ratio'] = np.mean(final_dvars[(final_dvars > 0)])/np.mean(initial_dvars[(initial_dvars > 0)])\n dvars_stats['def'] = 'DVARS calculated before any denoising steps (or filtering), and also after.\\nBad timepoints not included in any stats.'\n denoising_stats['dvars_stats.json'] = dvars_stats\n\n\n if type(original_std) != type(None):\n\n output_dict['std_before_regression'] = original_std\n output_dict['std_after_regression'] = post_regression_std\n\n output_dict['denoising_stats'] = denoising_stats\n\n\n\n return output_dict","def seasonal_decomposition(strain, mouse, feature, bin_width, period_length):\n\n if (not isinstance(strain, int)) or (strain < 0):\n raise ValueError(\n 'Strain must be a non-negative integer')\n if (not isinstance(mouse, int)) or (mouse < 0):\n raise ValueError(\n 'Mouse value must be a non-negative integer')\n if feature not in ALL_FEATURES:\n raise ValueError(\n 'Input value must in {\"AS\", \"F\", \"M_AS\", \"M_IS\", \"W\", \"Distance\"}')\n if (not isinstance(bin_width, int)) or bin_width < 0 or bin_width > 1440:\n raise ValueError(\n 'Bin width (minutes) must be a non-negative integer below 1440')\n if period_length < 0:\n raise ValueError(\n 'Peoriod length must be a non-negative integer or float')\n\n freq = int(period_length * 60 / bin_width)\n if feature == \"Distance\":\n ts = aggregate_movement(strain=strain, mouse=mouse,\n bin_width=bin_width)\n else:\n ts = aggregate_interval(strain=strain, mouse=mouse,\n feature=feature, bin_width=bin_width)\n res = sm.tsa.seasonal_decompose(ts.values, freq=freq, model=\"additive\")\n\n return res","def fixdims(var):\n\t\n\tfor ii in var.dims:\n\t\tkk=ii[:3].lower()\n\t\t\n\t\tif kk == 'lat':\n\t\t\tvar=var.rename({ii:'lat'})\n\t\t\t\n\t\tif kk == 'lon':\n\t\t\tvar=var.rename({ii:'lon'})\n\t\t\t\n\t\tif kk == 'lev' or kk == 'ple' or kk == 'pre':\n\t\t\tvar=var.rename({ii:'level'})\n\n\t\tif kk == 'tim':\n\t\t\tvar=var.rename({ii:'time'})\n\n\treturn var","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","def plot_seaice_trend(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/trends/SIC/',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 trends'\n\n\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\n if seaice_source == 'nsidc':\n seaice = seaice * area /250\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = xr.apply_ufunc(scipy.stats.linregress, seaice[seaicename].time.values.astype(float), seaice[seaicename], input_core_dims=[['time'],['time']], vectorize=True, dask='parallelized', output_dtypes=[float]*5, output_core_dims=[[]]*5)\n if seaice_source =='ecmwf':\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename])\n \n seaice_m = seaice_m * 1e9 * 60 * 60 * 24 * 365\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\n # seaice_m = seaice_m*area\n seaice_m = seaice_m.where(seaice_m != 0)\n # seaice_m = seaice_m.where(seaice_p_value <= 0.05)\n max_ = seaice_m.max()\n min_ = seaice_m.min() \n # max_ = 1\n divnorm = TwoSlopeNorm(vmin=min_, vcenter=0, vmax=max_)\n fig = plt.figure(figsize = (5,5))\n ax = fig.add_subplot(111, projection = ccrs.SouthPolarStereo())\n # Plotting\n contor = ax.contourf(seaice_m.x, seaice_m.y, seaice_m, cmap = 'RdBu', levels = 11, norm = divnorm, transform=ccrs.SouthPolarStereo())\n ax.coastlines()\n ax.set_axis_off()\n cbar = plt.colorbar(contor)\n cbar.set_label('Trend in SIE (km$^2$ yr$^{-1}$)')\n plt.title(title)\n plt.savefig(imagefolder + seaicename + '.pdf')\n plt.show()","def series_to_supervised(data, n_in=1, n_out=1, dropnan=True, stride=None, dates=False, leaks=True):\n df = pd.DataFrame(data)\n \n time = None\n if 'date' in df.columns:\n time = 'date'\n elif 'time' in df.columns:\n time = 'time'\n if time != None:\n df = df.drop([time], axis=1)\n \n if 'leak' in df.columns:\n df = df.drop(['leak'], axis=1) \n n_vars = df.shape[1]\n times_column = list()\n if dates and time != None:\n times_column = data[time]\n del data\n \n cols, names, pivots = list(), list(), list()\n \n # input sequence (t-n, ... t-1)\n for i in range(n_in, 0, -1):\n cols.append(df.shift(i))\n names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n\t# forecast sequence (t, t+1, ... t+n)\n for i in range(0, n_out):\n cols.append(df.shift(-i))\n if i == 0:\n names += [('var%d(t)' % (j+1)) for j in range(n_vars)]\n else:\n names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n\t# put it all together\n agg = pd.concat(cols, axis=1)\n \n agg.columns = names\n\n #stride - delete windows\n if stride != None:\n indexes_to_drop = list()\n for i in range(stride, agg.shape[0], stride):\n print(\"index\", i)\n pivots += [i]\n \n onset = 0\n offset = pivots[0]\n for i in range(0, len(pivots)):\n print(\"onset\", onset)\n print(\"offset\", offset)\n to_drop = [ x for x in range(onset,offset)]\n indexes_to_drop += to_drop\n try:\n onset = pivots[i] + 1\n offset = pivots[i+1]\n \n except IndexError:\n onset = pivots[i] + 1\n offset = agg.shape[0]\n to_drop = [ x for x in range(onset,offset)]\n indexes_to_drop += to_drop\n \n \n \n print(\"indexes_to_drop\", indexes_to_drop)\n \n agg.drop(df.index[indexes_to_drop], inplace=True)\n \"\"\"\n if dates and time!=None:\n agg[time] = times_column\n \"\"\" \n # drop rows with NaN values \n if dropnan:\n agg.dropna(inplace=True)\n \n\n return agg"],"string":"[\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def interpolateseasons(self):\\n\\n remainder = self.season - self.startseason\\n f1 = 1.0 - remainder\\n self.data = (self.startdata * f1) + (self.stopdata * remainder)\",\n \"def timeave_seasonal( mv, seasons=seasonsyr ):\\n return seasons.climatology(mv)\",\n \"def warren_time_series(lat, lon, dates, variable='snow_depth'):\\n\\n my_func = {'snow_depth': snow_depth,\\n 'swe': swe}\\n\\n #if not all([isinstance(d, dt.datetime) for d in dates]):\\n # print ('Expects datetime objects')\\n\\n # If lat, lon are vectors, generate 2d grids\\n # Need to add code to make sure x and y are DataArrays\\n if (count_dims(lat) == 1):\\n x, y = np.meshgrid(lon, lat)\\n else:\\n x, y = lon, lat\\n \\n if dates.size == 1:\\n cube = my_func[variable](x,y,dates.dt.month)\\n da = xr.DataArray(cube,\\n coords={'lat': x, 'lon': y},\\n dims=['lat', 'lon'])\\n else:\\n cube = [my_func[variable](x, y, m) for m in dates.dt.month.values]\\n da = xr.concat(cube, dim='time')\\n da['time'] = dates\\n\\n return da\",\n \"def map_season(x, figsize=(8, 6), **kwargs):\\n\\n from pycmbs.mapping import map_plot\\n\\n nvals = len(x.data)\\n if nvals == 12:\\n year = True\\n elif nvals == 4:\\n year = False\\n else:\\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\\n\\n #/// checks ///\\n if x.data.ndim != 3:\\n print x.data.ndim\\n raise ValueError('only 3D data supported')\\n\\n if 'vmin' not in kwargs.keys():\\n raise ValueError('vmin argument is obligatory for map_seasons()')\\n if 'vmax' not in kwargs.keys():\\n raise ValueError('vmax argument is obligatory for map_seasons()')\\n\\n if kwargs['vmin'] is None:\\n raise ValueError('vmin MUST NOT be None!')\\n if kwargs['vmax'] is None:\\n raise ValueError('vmax MUST NOT be None!')\\n\\n #/// figure and axes\\n if 'figure' in kwargs:\\n f = kwargs['figure']\\n else:\\n f = plt.figure(figsize=figsize)\\n\\n if 'title' in kwargs:\\n tit = kwargs.pop('title')\\n else:\\n tit = x.label\\n\\n if 'drawparallels' in kwargs:\\n drawparallels = kwargs.pop('drawparallels')\\n else:\\n drawparallels = False\\n\\n if 'savefile' in kwargs:\\n savefile = kwargs.pop('savefile')\\n if '.nc' in savefile:\\n savefile = savefile[:-3]\\n else:\\n savefile = None\\n\\n # plot\\n if year:\\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\\n else:\\n labels = ['DJF', 'MAM', 'JJA', 'SON']\\n\\n # check dates\\n if year:\\n mo = 1\\n for t in x.time:\\n if x.num2date(t).month != mo:\\n print x.num2date(t), mo\\n raise ValueError('Invalid monthly sequence! Can not plot results!')\\n mo += 1\\n\\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\\n if 'overlay' in kwargs.keys():\\n overlays = kwargs.pop('overlay')\\n else:\\n overlays = None\\n\\n for i in range(nvals):\\n if year:\\n ax = f.add_subplot(4, 3, i + 1)\\n #if i % 3 == 2:\\n if i > 8:\\n show_colorbar = True\\n else:\\n show_colorbar = False\\n else:\\n ax = f.add_subplot(2, 2, i + 1)\\n if 'show_colorbar' in kwargs:\\n show_colorbar = kwargs.pop('show_colorbar')\\n else:\\n show_colorbar = True\\n\\n d = x.copy()\\n d.data = x.data[i, :, :]\\n d.label = labels[i]\\n\\n if overlays is None:\\n overlay = None\\n else:\\n overlay = overlays[i, :, :]\\n\\n if savefile is not None:\\n tmpoutname = savefile + '_' + labels[i]\\n else:\\n tmpoutname = None\\n\\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\\n savefile=tmpoutname, colorbar_orientation='horizontal',\\n drawparallels=drawparallels, **kwargs)\\n del d\\n f.suptitle(tit, size=16)\\n return f\",\n \"def extract_seasonal_component(original_ts, ppy):\\n \\\"\\\"\\\"\\n # === get in-sample data\\n original_ts = original_ts[:-out_of_sample]\\n \\\"\\\"\\\"\\n if seasonality_test(original_ts, ppy):\\n # print(\\\"seasonal\\\")\\n # ==== get moving averages\\n ma_ts = moving_averages(original_ts, ppy)\\n\\n # ==== get seasonality indices\\n le_ts = original_ts * 100 / ma_ts\\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\\n le_ts = np.reshape(le_ts, (-1, ppy))\\n si = np.nanmean(le_ts, 0)\\n norm = np.sum(si) / (ppy * 100)\\n si = si / norm\\n else:\\n # print(\\\"NOT seasonal\\\")\\n si = np.full(ppy, 100)\\n return si\",\n \"def seasonal_series(t, y, edges=None, hard=False):\\n t = ensure_tarray(t)\\n if len(t) == 1:\\n return [t], [y]\\n season_ixs = season_indices(t, edges=edges, hard=hard)\\n ts = []\\n ys = []\\n for season in season_ixs:\\n ts.append(astropy.time.Time(t.jyear[season], format='jyear', scale=t.scale))\\n ys.append(y[season])\\n return ts, ys\",\n \"def manipulate_data(ds, var, predef_clim, predef_trnd, trn_yrs, all_yrs, \\n apply_latw=True, apply_detrending=True, dropna=True):\\n\\n \\n if((var=='SD')|(var=='sd')|(var=='snowc')): \\n ds[var] = ds[var].where(ds[var]>=0, other=0.0)\\n ds[var] = ds[var].where(ds[var]==0, other=1.0)\\n #ds[var].values = Gauss_filter(ds[var].values, (0,3,3))\\n \\n \\\"\\\"\\\"\\n if((var=='hgt')|(var=='z')|(var=='GPT')):\\n months = ds.time.to_index().month; ssn_ends = (months==2)|(months==5)|(months==8)|(months==11)\\n ds = ds.sel(time=ssn_ends)\\n else: \\n ds = ds.resample(time='3M').mean()\\n \\\"\\\"\\\"\\n \\n ds = ds.resample(time='3M').mean()\\n\\n ds = ds.sel(time=slice(str(all_yrs[0])+'-01-01', str(all_yrs[-1])+'-12-31')) \\n \\n try: \\n clim = predef_clim\\n ds = ds.groupby('time.season') - clim\\n print('Predefined climatology used')\\n except:\\n clim = ds.sel(time=slice(str(trn_yrs[0])+'-01-01', str(trn_yrs[-1])+'-12-31')).groupby('time.season').mean('time')\\n ds = ds.groupby('time.season') - clim\\n print('Climatology calculated from data')\\n \\n if(apply_latw): ds[var].values = lat_weighting(ds[var].values, \\n ds.lat, ds.lon)\\n if(dropna):\\n ds = ds.stack(gridcell=('lat', 'lon')).dropna(dim='gridcell',how='any')\\n else: \\n ds = ds.stack(gridcell=('lat', 'lon')).fillna(0)\\n \\n \\n trend_models = { }\\n if(apply_detrending): \\n ds = ds.load()\\n for ssn in ('DJF', 'MAM', 'JJA', 'SON'):\\n #ssn_idx = ds['time.season'] == ssn\\n \\n trn_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], trn_yrs))\\n all_idx = bool_index_to_int_index(np.isin(ds['time.season'], ssn) & np.isin(ds['time.year'], all_yrs))\\n \\n trn_x = np.array(ds.time[trn_idx].values.tolist()).reshape(-1,1)\\n all_x = np.array(ds.time[all_idx].values.tolist()).reshape(-1,1)\\n try:\\n trend = predef_trnd[ssn].predict(all_x)\\n trend_models[ssn] = predef_trnd[ssn]\\n print('Predefined trend model used')\\n except:\\n #_, trend_model = define_trends(ds[var][trn_idx], trn_x)\\n _, trend_model = define_trends(ds[var][all_idx], all_x)\\n trend = trend_model.predict(all_x)\\n trend_models[ssn] = trend_model\\n print('Trends calculated from data')\\n \\n ds[var][all_idx] = ds[var][all_idx] - trend\\n \\n\\n \\n return ds, clim, trend_models\",\n \"def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \\n the_season=np.array(the_season,dtype=np.int32)\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n else:\\n if lat_slice.stop is None:\\n num_lats=var_nc.shape[2]\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n if lon_slice.stop is None:\\n num_lons=var_nc.shape[3]\\n else:\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n num_years=var_nc.shape[0]//12\\n\\n for the_year in np.arange(0,num_years):\\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n the_season=the_season+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def seasonality(df):\\n df_datetime = pd.DatetimeIndex(df.date_time)\\n df[\\\"month\\\"] = df_datetime.month\\n df = drop_cols(df, [\\\"date_time\\\"])\\n\\n return df\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def season_edges(t):\\n offset = season_offset(t)\\n yr_min = t.datetime.min().year\\n left_frac = t.jyear.min() % yr_min\\n if left_frac < offset:\\n ex_left = 1\\n else:\\n ex_left = 0\\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\\n return astropy.time.Time(edges, format='jyear')\",\n \"def get_datetime_seasons(\\n self, train: NumpyOrPandas, outp_role: Optional[ColumnRole] = None\\n ) -> Optional[LAMLTransformer]:\\n _, datetimes = self.get_cols_for_datetime(train)\\n for col in copy(datetimes):\\n if len(train.roles[col].seasonality) == 0 and train.roles[col].country is None:\\n datetimes.remove(col)\\n\\n if len(datetimes) == 0:\\n return\\n\\n if outp_role is None:\\n outp_role = NumericRole(np.float32)\\n\\n date_as_cat = SequentialTransformer(\\n [\\n ColumnsSelector(keys=datetimes),\\n DateSeasons(outp_role),\\n ]\\n )\\n return date_as_cat\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def custom_seasonal_adjust(denoise):\\n df_adjust = pd.DataFrame()\\n df_adjust[0] = denoise.values\\n df_adjust[1] = denoise.shift(-52).values\\n df_adjust[2] = denoise.shift(-104).values\\n seasonality = df_adjust.mean(axis=1)[:52]\\n\\n start_idx = denoise.index[0]\\n df_seasonality = seasonality.append(seasonality, ignore_index=True).append(seasonality[:39], ignore_index=True)\\n idx = pd.DatetimeIndex(start=start_idx, freq='W-FRI', periods=len(df_seasonality))\\n df_seasonality.index = idx\\n \\n seasonal_adjust = (denoise - df_seasonality).dropna()\\n df_seasonality = df_seasonality.reset_index().\\\\\\n assign(week_num = lambda x: x['index'].dt.week).\\\\\\n drop_duplicates('week_num').\\\\\\n drop(columns='index').rename(columns={0:'Weekly_Sales'})\\n \\n return df_seasonality, seasonal_adjust\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def seasonal_calc(t, y, func, edges=None):\\n ts, ys = seasonal_series(t, y, edges=edges)\\n t_means = [t.jyear.mean() for t in ts]\\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\\n f_y = np.array([func(y) for y in ys])\\n return t_means, f_y\",\n \"def plot_index_sic_timeseries(anomlous = False, temporal_resolution = 'monthly', detrend = False, imagefolder = 'images/timeseries/SIC_INDICIES', indexname = 'SAM', n = 5, seaice_source = 'nsidc'):\\n output_folder = 'processed_data/'\\n\\n\\n if anomlous:\\n temp_decomp = 'anomalous'\\n else:\\n temp_decomp = 'raw'\\n\\n if detrend:\\n dt = 'detrended'\\n else:\\n dt = 'raw'\\n\\n filename = f'{indexname}_{temp_decomp}_{temporal_resolution}_{dt}'\\n indicies = xr.open_dataset(output_folder + 'INDICIES/' + filename +'.nc')[indexname]\\n data = indicies.copy()\\n data = data.loc[data.time.dt.year >= 1979]\\n seaicename = f'{temp_decomp}_{temporal_resolution}_{n}_{dt}'\\n\\n seaice = xr.open_dataset(output_folder + 'SIC/' + seaicename +'.nc')\\n\\n\\n times = list(set.intersection(set(seaice.time.values), set(data.time.values)))\\n\\n seaice = seaice_area_mean(seaice.sel(time=times).sortby('time'), 1)\\n data = data.sel(time=times).sortby('time')\\n\\n\\n if seaice_source == 'ecmwf':\\n seaice = xr.open_dataset(output_folder + 'ERA5/SIC/' + seaicename +'.nc')\\n if seaice_source == 'ecmwf':\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename].mean(dim = ('longitude', 'latitude')))\\n if seaice_source == 'nsidc':\\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(mean_seaice.time.values.astype(float), mean_seaice)\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n\\n title = temp_decomp.capitalize() + ' '\\n\\n if detrend:\\n title += dt + ' '\\n\\n title += temporal_resolution\\n title += f' mean {indexname} and SIC'\\n fig, ax = plt.subplots()\\n ax2 = plt.twinx(ax)\\n ax2.plot([],[])\\n\\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\\n\\n ln1 = ax.plot(data.time, data, label = f'{indexname}', color = '#EA1B10')\\n ax.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10')\\n if seaice_source == 'ecmwf':\\n ln2 = ax2.plot(seaice.time, seaice[seaicename].mean(dim = ('longitude', 'latitude')), label = 'SIC', color = '#177E89')\\n if seaice_source == 'nsidc':\\n ln2 = ax2.plot(mean_seaice.time, mean_seaice, label = 'SIC', color = '#177E89')\\n ax2.plot(seaice.time, seaice_m * seaice.time.values.astype(float) + seaice_b, color = '#177E89')\\n\\n yabs_max = abs(max(ax.get_ylim(), key=abs))\\n ax.set_ylim(ymin=-yabs_max, ymax=yabs_max)\\n if anomlous or detrend:\\n yabs_max = abs(max(ax2.get_ylim(), key=abs))\\n ax2.set_ylim(ymin=-yabs_max, ymax=yabs_max)\\n\\n # ylabels\\n ax.set_ylabel(f'{indexname}')\\n ax2.set_ylabel(f'Mean SIC')\\n\\n # legend\\n lines = ln1 + ln2\\n labels = [line.get_label() for line in lines]\\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 2, loc = 'upper right')\\n\\n plt.title(title)\\n plt.savefig(imagefolder + f'/SIC_{indexname}_{filename}_{seaice_source}' + '.pdf')\\n plt.show()\",\n \"def transform(self, resampled_xray, n_burn_in, n_lookahead, skf_is): \\n # Set all temps on world map as features\\n #valid_range = range(n_burn_in, temperatures_xray['time'].shape[0] - n_lookahead)\\n #time_steps, lats, lons = temperatures_xray['tas'].values.shape\\n #X = temperatures_xray['tas'].values.reshape((time_steps,lats*lons))\\n #X = X[valid_range,:]\\n\\n tas = select_box(resampled_xray['tas']) \\n\\n valid_range = range(n_burn_in, resampled_xray['time'].shape[0] - n_lookahead)\\n #enso = get_enso_mean(temperatures_xray['tas'])\\n # reshape the vector into a table years as rows, months as columns\\n #enso_matrix = enso.values.reshape((-1,12))\\n\\n theShape = tas.shape\\n n_time,n_lat,n_long = theShape[0],theShape[1],theShape[2] \\n #print n_time,n_lat,n_long \\n enso_matrix = tas.values.reshape(-1,12,n_lat,n_long)\\n\\n count_matrix = np.ones(enso_matrix.shape)\\n # compute cumulative means of columns (remember that you can only use\\n # the past at each time point) and reshape it into a vector\\n enso_monthly_mean = (enso_matrix.cumsum(axis=0) / count_matrix.cumsum(axis=0)).reshape(-1,n_lat,n_long)#.ravel()\\n # roll it backwards (6 months) so it corresponds to the month of the target\\n\\n enso_anomaly = tas - enso_monthly_mean\\n\\n enso_anomaly_rolled = np.roll(enso_anomaly, n_lookahead - 12,axis = 0)\\n # select valid range\\n enso_anomaly_rolled_valid = enso_anomaly_rolled[valid_range,:,:]\\n # reshape it into a matrix of a single column\\n X = enso_anomaly_rolled_valid.reshape(-1,n_lat*n_long)\\n\\n return X\",\n \"def shifts_projection(sc, clean):\\n def shifts_projected(clean, axis):\\n projected = clean.map(lambda x: x.mean(axis=axis)[:, :, np.newaxis])\\n target = getTarget(projected, 30, 1)\\n shifts = registerByPlane(sc, projected, target[:, :, np.newaxis], 10, False)\\n return shifts[:, :, 0]\\n\\n # shifts_xy = shifts_projected(clean, 2)\\n shifts_xz = shifts_projected(clean, 1)\\n shifts_yz = shifts_projected(clean, 0)\\n\\n # x_shifts = np.mean(np.stack((shifts_xz[:, 0], shifts_xy[:, 0])), axis=0)\\n z_shifts = np.mean(np.stack((shifts_xz[:, 1], shifts_yz[:, 1])), axis=0)\\n # y_shifts = np.mean(np.stack((shifts_yz[:, 0], shifts_xy[:, 1])), axis=0)\\n plt.figure()\\n plt.plot(shifts_xz[:, 1])\\n plt.plot(shifts_yz[:, 1])\\n plt.plot(z_shifts)\\n plt.title('Z')\\n # plt.figure()\\n # plt.plot(shifts_xz[:, 0])\\n # plt.plot(shifts_xy[:, 0])\\n # plt.plot(x_shifts)\\n # plt.title('X')\\n # plt.figure()\\n # plt.plot(shifts_yz[:, 0])\\n # plt.plot(shifts_xy[:, 1])\\n # plt.plot(y_shifts)\\n # plt.title('Y')\\n # shifts_all = np.stack((x_shifts, y_shifts, z_shifts))\\n\\n def initReg(kv):\\n from scipy.ndimage.interpolation import shift\\n index, volume = kv\\n current_shift = (0, 0, -1 * z_shifts[int(index[0])])\\n shifted = shift(volume, current_shift)\\n return shifted.astype(np.int16)\\n\\n reg = clean.map(initReg, with_keys=True, value_shape=clean.shape[1:], dtype=np.int16)\\n reg.cache()\\n reg.count()\\n return reg\",\n \"def resample_sliprate(self, dt, nsamp):\\n for ps in self.pointsources:\\n ps.resample_sliprate(dt, nsamp)\",\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 reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def correct_lon(ds):\\n ds = ds.copy()\\n x = ds['x'].data\\n ds['x'].data = np.where(x < 0 , 360 + x, x)\\n\\n lon = ds['lon'].data\\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\\n \\n ds = ds.sortby('x')\\n return ds\",\n \"def reset_time_dim(ds):\\n return ds.assign_coords(Time=pd.to_datetime(ds.XTIME.values))\",\n \"def test_rise_timeseries_correct_output_shape():\\n input_data = np.random.random((10, 1))\\n axis_labels = ['t', 'channels']\\n labels = [1]\\n\\n heatmaps = dianna.explain_timeseries(run_model, input_data, \\\"RISE\\\", labels, axis_labels=axis_labels,\\n n_masks=200, p_keep=.5)\\n\\n assert heatmaps.shape == (len(labels), *input_data.shape)\",\n \"def _full_to_yearly_ts(self, arr, dt):\\n time_defined = self.def_time and not ('av' in self.dtype_in_time)\\n if time_defined:\\n arr = utils.times.yearly_average(arr, dt)\\n return arr\",\n \"def test_seasonal_resolution_hindcast(monthly_initialized, monthly_obs):\\n seasonal_hindcast = (\\n monthly_initialized.rolling(lead=3, center=True).mean().dropna(dim=\\\"lead\\\")\\n )\\n seasonal_hindcast = seasonal_hindcast.isel(lead=slice(0, None, 3))\\n seasonal_obs = monthly_obs.rolling(time=3, center=True).mean().dropna(dim=\\\"time\\\")\\n seasonal_hindcast.lead.attrs[\\\"units\\\"] = \\\"seasons\\\"\\n assert compute_hindcast(seasonal_hindcast, seasonal_obs).all()\",\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_sic_sic_timeseries(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/SIC/'):\\n output_folder = 'processed_data/'\\n\\n\\n if anomlous:\\n temp_decomp = 'anomalous'\\n else:\\n temp_decomp = 'raw'\\n\\n if detrend:\\n dt = 'detrended'\\n else:\\n dt = 'raw'\\n\\n filename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\\n indicies = xr.open_dataset(output_folder + 'ERA5/SIC/' + filename +'.nc')[filename].mean(dim = ('longitude', 'latitude'))\\n data = indicies.copy()\\n data = data.loc[data.time.dt.year >= 1979]\\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\\n seaice = xr.open_dataset(output_folder + 'SIC/' + seaicename +'.nc')[seaicename]\\n\\n times = list(set.intersection(set(seaice.time.values), set(data.time.values)))\\n\\n seaice = seaice_area_mean(seaice.sel(time=times).sortby('time'), 1)\\n data = data.sel(time=times).sortby('time')\\n\\n seaice = seaice_area_mean(seaice,1)\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice.time.values.astype(float), seaice)\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n\\n title = temp_decomp.capitalize() + ' '\\n\\n if detrend:\\n title += dt + ' '\\n\\n title += temporal_resolution\\n title += f' mean ERA5 and SIC'\\n fig, ax = plt.subplots()\\n ax2 = plt.twinx(ax)\\n ax2.plot([],[])\\n\\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\\n\\n ln1 = ax.plot(data.time, data, label = f'ERA5', color = '#EA1B10')\\n ax.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10')\\n ln2 = ax2.plot(seaice.time, seaice, label = 'SIC', color = '#177E89')\\n ax2.plot(seaice.time, seaice_m * seaice.time.values.astype(float) + seaice_b, color = '#177E89')\\n\\n if anomlous or detrend:\\n yabs_max = abs(max(ax2.get_ylim(), key=abs))\\n ax2.set_ylim(ymin=-yabs_max, ymax=yabs_max)\\n\\n yabs_max = abs(max(ax.get_ylim(), key=abs))\\n ax.set_ylim(ymin=-yabs_max, ymax=yabs_max)\\n\\n # ylabels\\n ax.set_ylabel(f'ECMWF')\\n ax2.set_ylabel(f'Mean SIC')\\n\\n # legend\\n lines = ln1 + ln2\\n labels = [line.get_label() for line in lines]\\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 2, loc = 'upper right')\\n\\n plt.title(title)\\n plt.savefig(imagefolder + f'/SIC_ERA5_{filename}' + '.pdf')\\n plt.show()\",\n \"def winter_avg(var_nc,lat_slice=None,lon_slice=None): \\n #\\n # accumulate in shape [plev,lat,lon]\\n #\\n # use the whole array if slice objects are missing\\n #\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n print \\\"in winter avg: \\\",lat_slice,lon_slice\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n #\\n # year 0 is special case since it doesn't have a december\\n #\\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\\n accumulate+=the_slice\\n num_years=var_nc.shape[0]//12\\n #\\n # now year 1 has year 0's december\\n #\\n djf=np.array([11,12,13],dtype=np.int32)\\n #\\n # iterate one year less because we've alread\\n # done year zero as a special case\\n #\\n for the_year in np.arange(0,num_years-1):\\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n djf=djf+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def inverse_compress(self, pieces, start):\\n \\n time_series = [start]\\n # stitch linear piece onto last\\n for j in range(0, len(pieces)):\\n x = np.arange(0,pieces[j,0]+1)/(pieces[j,0])*pieces[j,1]\\n #print(x)\\n y = time_series[-1] + x\\n time_series = time_series + y[1:].tolist()\\n\\n return time_series\",\n \"def inverse_compress(self, pieces, start):\\n \\n time_series = [start]\\n # stitch linear piece onto last\\n for j in range(0, len(pieces)):\\n x = np.arange(0,pieces[j,0]+1)/(pieces[j,0])*pieces[j,1]\\n #print(x)\\n y = time_series[-1] + x\\n time_series = time_series + y[1:].tolist()\\n\\n return time_series\",\n \"def add_rain_clim_normals(gdf_of_interest,\\n grid_of_rain_clim_norm_y = clim_norm_rain_y_np_unique, \\n grid_of_rain_clim_norm_x = clim_norm_rain_x_np_unique): \\n mean_monthly_rainfall = []\\n for index in gdf_of_interest.index:\\n closest_y_index = find_nearest_point_1D(grid_of_rain_clim_norm_y, \\n gdf_of_interest.geometry.y[index], \\n print_nearest_val=False)\\n closest_x_index = find_nearest_point_1D(grid_of_rain_clim_norm_x, \\n gdf_of_interest.geometry.x[index], \\n print_nearest_val=False)\\n \\n month_of_interest = int(gdf_of_interest[\\\"Month\\\"][0])\\n month_of_int_format = \\\"m\\\" + str(month_of_interest)\\n \\n mean_monthly_rainfall.append(gdf_clim_norm_rain_mean.loc[\\n (gdf_clim_norm_rain_mean[\\\"east\\\"] == grid_of_rain_clim_norm_x[closest_x_index]) &\\n (gdf_clim_norm_rain_mean[\\\"north\\\"] == grid_of_rain_clim_norm_y[closest_y_index]),\\n month_of_int_format].values[0])\\n \\n \\n \\n gdf_of_interest[\\\"Mean Monthly Rainfall\\\"] = mean_monthly_rainfall\\n \\n return\",\n \"def rainfall_series(self):\\n\\n # assign local temporal variables\\n datatype = 'strds'\\n increment = str(self.rain_interval)+\\\" minutes\\\"\\n raster = 'raster'\\n rain_excess = 'rain_excess'\\n net_difference = 'net_difference'\\n #iterations = sum(1 for row in precip)\\n\\n # create a raster space time dataset\\n gscript.run_command(\\n 't.create',\\n type=datatype,\\n temporaltype=self.temporaltype,\\n output=self.elevation_timeseries,\\n title=self.elevation_title,\\n description=self.elevation_description,\\n overwrite=True)\\n gscript.run_command(\\n 't.create',\\n type=datatype,\\n temporaltype=self.temporaltype,\\n output=self.depth_timeseries,\\n title=self.depth_title,\\n description=self.depth_description,\\n overwrite=True)\\n gscript.run_command(\\n 't.create',\\n type=datatype,\\n temporaltype=self.temporaltype,\\n output=self.erdep_timeseries,\\n title=self.erdep_title,\\n description=self.erdep_description,\\n overwrite=True)\\n gscript.run_command(\\n 't.create',\\n type=datatype,\\n temporaltype=self.temporaltype,\\n output=self.flux_timeseries,\\n title=self.flux_title,\\n description=self.flux_description,\\n overwrite=True)\\n gscript.run_command(\\n 't.create',\\n type=datatype,\\n temporaltype=self.temporaltype,\\n output=self.difference_timeseries,\\n title=self.difference_title,\\n description=self.difference_description,\\n overwrite=True)\\n\\n # register the initial digital elevation model\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.elevation_timeseries,\\n maps=self.elevation,\\n start=self.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n\\n # create evolution object\\n evol = Evolution(\\n elevation=self.elevation,\\n precipitation=self.precipitation,\\n start=self.start,\\n rain_intensity=self.rain_intensity,\\n rain_interval=self.rain_interval,\\n walkers=self.walkers,\\n runoff=self.runoff,\\n mannings=self.mannings,\\n detachment=self.detachment,\\n transport=self.transport,\\n shearstress=self.shearstress,\\n density=self.density,\\n mass=self.mass,\\n grav_diffusion=self.grav_diffusion,\\n erdepmin=self.erdepmin,\\n erdepmax=self.erdepmax,\\n k_factor=self.k_factor,\\n c_factor=self.c_factor,\\n m=self.m,\\n n=self.n,\\n threads=self.threads,\\n fill_depressions=self.fill_depressions)\\n\\n # open txt file with precipitation data\\n with open(evol.precipitation) as csvfile:\\n\\n # check for header\\n has_header = csv.Sniffer().has_header(csvfile.read(1024))\\n\\n # rewind\\n csvfile.seek(0)\\n\\n # skip header\\n if has_header:\\n next(csvfile)\\n\\n # parse time and precipitation\\n precip = csv.reader(csvfile, delimiter=',', skipinitialspace=True)\\n\\n # initial run\\n initial = next(precip)\\n evol.start = initial[0]\\n evol.rain_intensity = 'rain_intensity'\\n # compute rainfall intensity (mm/hr)\\n # from rainfall observation (mm)\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_intensity}\\\"\\n \\\"={rain_observation}\\\"\\n \\\"/{rain_interval}\\\"\\n \\\"*60.\\\".format(\\n rain_intensity=evol.rain_intensity,\\n rain_observation=float(initial[1]),\\n rain_interval=self.rain_interval),\\n overwrite=True)\\n\\n # determine mode and run model\\n if self.mode == \\\"simwe_mode\\\":\\n (evolved_elevation, time, depth, erosion_deposition,\\n difference) = evol.erosion_deposition()\\n # remove relative timestamps\\n # from r.sim.water and r.sim.sediment\\n gscript.run_command(\\n 'r.timestamp',\\n map=depth,\\n date='none')\\n gscript.run_command(\\n 'r.timestamp',\\n map=erosion_deposition,\\n date='none')\\n\\n elif self.mode == \\\"usped_mode\\\":\\n (evolved_elevation, time, depth, erosion_deposition,\\n difference) = evol.usped()\\n\\n elif self.mode == \\\"rusle_mode\\\":\\n (evolved_elevation, time, depth, sediment_flux,\\n difference) = evol.rusle()\\n\\n else:\\n raise RuntimeError(\\n '{mode} mode does not exist').format(mode=self.mode)\\n\\n # register the evolved maps\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.elevation_timeseries,\\n maps=evolved_elevation,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.depth_timeseries,\\n maps=depth,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n try:\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.erdep_timeseries,\\n maps=erosion_deposition,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n except (NameError, CalledModuleError):\\n pass\\n try:\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.flux_timeseries,\\n maps=sediment_flux,\\n start=evol.start,\\n increment=increment,\\n flags='i', overwrite=True)\\n except (NameError, CalledModuleError):\\n pass\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.difference_timeseries,\\n maps=difference,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n\\n # run the landscape evolution model for each rainfall record\\n for row in precip:\\n\\n # update the elevation\\n evol.elevation=evolved_elevation\\n\\n # update time\\n evol.start=row[0]\\n\\n # compute rainfall intensity (mm/hr)\\n # from rainfall observation (mm)\\n rain_intensity = 'rain_intensity'\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_intensity}\\\"\\n \\\"={rain_observation}\\\"\\n \\\"/{rain_interval}\\\"\\n \\\"*60.\\\".format(\\n rain_intensity=rain_intensity,\\n rain_observation=float(row[1]),\\n rain_interval=self.rain_interval),\\n overwrite=True)\\n\\n # derive excess water (mm/hr) from rainfall rate (mm/hr)\\n # plus the depth (m) per rainfall interval (min)\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_excess}\\\"\\n \\\"={rain_intensity}\\\"\\n \\\"+{depth}\\\"\\n \\\"/1000.\\\"\\n \\\"/{rain_interval}\\\"\\n \\\"*60.\\\".format(\\n rain_excess=rain_excess,\\n rain_intensity=rain_intensity,\\n depth=depth,\\n rain_interval=self.rain_interval),\\n overwrite=True)\\n\\n # update excess rainfall\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_intensity} = {rain_excess}\\\".format(\\n rain_intensity='rain_intensity',\\n rain_excess=rain_excess),\\n overwrite=True)\\n evol.rain_intensity = rain_intensity\\n\\n # determine mode and run model\\n if self.mode == \\\"simwe_mode\\\":\\n (evolved_elevation, time, depth, erosion_deposition,\\n difference) = evol.erosion_deposition()\\n # remove relative timestamps\\n # from r.sim.water and r.sim.sediment\\n gscript.run_command(\\n 'r.timestamp',\\n map=depth,\\n date='none')\\n gscript.run_command(\\n 'r.timestamp',\\n map=erosion_deposition,\\n date='none')\\n\\n elif self.mode == \\\"usped_mode\\\":\\n (evolved_elevation, time, depth, erosion_deposition,\\n difference) = evol.usped()\\n\\n elif self.mode == \\\"rusle_mode\\\":\\n (evolved_elevation, time, depth, sediment_flux,\\n difference) = evol.rusle()\\n\\n else:\\n raise RuntimeError(\\n '{mode} mode does not exist').format(mode=self.mode)\\n\\n # register the evolved maps\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.elevation_timeseries,\\n maps=evolved_elevation,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.depth_timeseries,\\n maps=depth,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n try:\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.erdep_timeseries,\\n maps=erosion_deposition,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n except (NameError, CalledModuleError):\\n pass\\n try:\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.flux_timeseries,\\n maps=sediment_flux,\\n start=evol.start,\\n increment=increment,\\n flags='i', overwrite=True)\\n except (NameError, CalledModuleError):\\n pass\\n gscript.run_command(\\n 't.register',\\n type=raster,\\n input=self.difference_timeseries,\\n maps=difference,\\n start=evol.start,\\n increment=increment,\\n flags='i',\\n overwrite=True)\\n\\n # remove temporary maps\\n gscript.run_command(\\n 'g.remove',\\n type='raster',\\n name=['rain_excess'],\\n flags='f')\\n\\n # compute net elevation change\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{net_difference}\\\"\\n \\\"= {evolved_elevation}-{elevation}\\\".format(\\n net_difference=net_difference,\\n elevation=self.elevation,\\n evolved_elevation=evol.elevation),\\n overwrite=True)\\n gscript.write_command(\\n 'r.colors',\\n map=net_difference,\\n rules='-',\\n stdin=difference_colors)\",\n \"def _initial_conversion(X: Any) -> TimeSeriesInstances:\\n if isinstance(X, np.ndarray) and X.ndim == 2:\\n X = X.reshape(X.shape[0], 1, X.shape[1])\\n return X\",\n \"def timeave_old( mv ):\\n # I haven't thought yet about how missing values would work with this...\\n # If time intervals be unequal, this will have to be changed...\\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\\n n = sh[0]\\n # BTW, this is the size of everything else:\\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\\n mvta = numpy.sum( mv.__array__(), axis=0 )\\n mvta /= n\\n return mvta\",\n \"def plot_seaice_timeseries(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/SIC/',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 += ' mean SIC in Antarctica'\\n\\n\\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\\n seaice = xr.open_dataset(output_folder + seaicename +'.nc')\\n\\n if seaice_source == 'nsidc':\\n seaice = seaice\\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(mean_seaice.time.values.astype(float), mean_seaice)\\n if seaice_source =='ecmwf':\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename].sum(dim = ('longitude', 'latitude')))\\n ax = plt.gca()\\n if anomlous or detrend: ax.axhline(0, alpha = 0.5)\\n if seaice_source == 'nsidc':\\n mean_seaice = seaice_area_mean(seaice[seaicename],1)\\n plt.plot(seaice.time, mean_seaice)\\n\\n if seaice_source == 'ecmwf':\\n plt.plot(seaice.time, seaice[seaicename].mean(dim = ('longitude', 'latitude')))\\n plt.plot(seaice.time, (seaice_m * seaice.time.values.astype(float) + seaice_b), color = '#177E89')\\n plt.title(title)\\n plt.savefig(imagefolder + seaicename+f'_{seaice_source}.pdf')\\n plt.show()\",\n \"def satReader(directory,month,latmin,latmax,lonmin,lonmax):\\n \\n ### Enter filename\\n filename = 'cs2icesat_regrid_mar_20042015.nc' \\n \\n ### Month/Years extracted\\n dateyr = now.year \\n datemo = datetime.date(dateyr,month+1,1).strftime('%B')\\n \\n ### Retrieve data\\n data = Dataset(directory + filename)\\n lat = data.variables['lat'][:]\\n lon = data.variables['lon'][:]\\n thkn = data.variables['thick'][:]\\n data.close()\\n \\n ### Calculate lat/lon region\\n xmask = (lat > latmin) & (lat < latmax)\\n ymask = (lon > lonmin) & (lon < lonmax)\\n \\n mask = xmask[:] & ymask[:]\\n latvals = np.where(mask == True)[0]\\n lonvals = np.where(mask == True)[1]\\n latvals = np.unique(latvals)\\n lonvals = np.unique(lonvals)\\n \\n thk = thkn[:,latvals,:]\\n thk = thk[:,:,lonvals]\\n \\n lat = lat[latvals,:]\\n lat = lat[:,lonvals]\\n lon = lon[latvals,:]\\n lon = lon[:,lonvals]\\n\\n grid = '---> [[%s to %s N, %s to %s E]]' % (latmin,latmax,lonmin,lonmax)\\n print 'Completed: Satellite data read (%s)!' % datemo, grid\\n \\n return lat,lon,thk\",\n \"def overwrite_season(function):\\n @functools.wraps(function)\\n def inner(*args, season = None, **kw):\\n data = function(*args,**kw)\\n if season:\\n replace_season(data,season)\\n return data\\n return inner\",\n \"def reduce_dataset(years, values,flux_floor=0,max_tm_error=0,min_reduction_steps=200):\\n non_zero_ind, min_retained_zero_years = remove_begin_end_zero_flux(years,values,flux_floor,min_reduction_steps)\\n\\n years_mod = years[non_zero_ind]\\n values_mod = values[non_zero_ind]\\n\\n if years_mod.size <3:\\n years_mod = years\\n values_mod = values\\n values_mod = 0\\n else:\\n #makes ure you have not removed more than 1% of the mass when removing 0 or flux floor rates\\n o_mass = TimeSeries(years,values,None,None).integrate().values[-1]\\n r_mass = TimeSeries(years_mod, values_mod, None, None).integrate().values[-1]\\n if abs((o_mass-r_mass)/o_mass)*100 > 1:\\n years_mod = years\\n values_mod = values\\n timeseries = TimeSeries(years_mod, values_mod, None, None)\\n mass = timeseries.integrate()\\n\\n #normalize Values\\n maxval = np.max(values_mod)\\n values_mod = values_mod/maxval\\n o_timeseries = TimeSeries(years,values/maxval,None,None)\\n o_mass = o_timeseries.integrate()\\n timeseries = TimeSeries(years_mod, values_mod, None, None)\\n mass = timeseries.integrate()\\n\\n mx = np.argmax(timeseries.values)\\n points = [0, mx, len(timeseries)]\\n x = timeseries.times\\n\\n ythresh = 100*np.mean(timeseries.values)\\n out_error = 1\\n out_error_last = out_error\\n OUT_ERROR_THRESHOLD = 1e-2\\n\\n UPPER_N = 200\\n LOWER_N = 50\\n last_result = None\\n MAX_ITERATIONS = 80\\n\\n solve_type = SMOOTH\\n simple_peaks = False\\n last_result,ix = reduct_iter(timeseries,flux_floor,ythresh,out_error,out_error_last,OUT_ERROR_THRESHOLD,UPPER_N,LOWER_N,last_result,MAX_ITERATIONS)\\n last_result = retain_min_years(last_result.reduced_flux,o_timeseries,o_mass,min_retained_zero_years)\\n #if there are less points than the min_reduction_steps then use the remaining\\n #points to rebalance the segments with the largest mass errors.\\n play_points = min_reduction_steps - last_result.num_reduced_points\\n bef = last_result.reduced_flux.times.size\\n if play_points > 0:\\n last_result = red_flux.rebalance_extra_points(last_result,play_points)\\n\\n rr = last_result\\n\\n #find peaks for data rebalance and reporting\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=3,rel_height=1)\\n if peaks.size == 0 :\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=2,rel_height=1)\\n if peaks.size == 0:\\n peaks, _ = sig.find_peaks(rr.reduced_flux.values,width=1,rel_height=1)\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=3,rel_height=1)\\n if pneg.size == 0:\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=2,rel_height=1)\\n if pneg.size == 0:\\n pneg, _ = sig.find_peaks(-rr.reduced_flux.values,width=1,rel_height=1)\\n\\n peaks = rr.reduced_flux.times[peaks]\\n pneg = rr.reduced_flux.times[pneg]\\n\\n peaks = np.isin(o_timeseries.times,peaks)\\n pneg = np.isin(o_timeseries.times,pneg)\\n peaks = np.where(peaks)\\n pneg = np.where(pneg)\\n\\n peaks = peaks[0]\\n pneg = pneg[0]\\n iter = 0\\n while iter < 100 and (abs(last_result.total_mass_error*maxval) > max_tm_error or abs(last_result.total_mass_error/last_result.mass.values[-1])*100 > .001) :\\n rr = red_flux.rebalance_valleys(rr,peaks,pneg)\\n #keep the lowest total_mass_error\\n if abs(rr.total_mass_error) < abs(last_result.total_mass_error):\\n last_result = rr\\n else:\\n break\\n iter += 1\\n\\n out_times = last_result.reduced_flux.times\\n out_values = last_result.reduced_flux.values\\n #return the reduced data, undo normalize of the values (*maxval)\\n return out_times, out_values*maxval,-(last_result.total_mass_error * maxval),peaks.size,iter\",\n \"def seasonal_means(t, y, edges=None, hard=False):\\n ts, ys = seasonal_series(t, y, edges=edges, hard=hard)\\n t_means = [t.jyear.mean() for t in ts]\\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\\n y_means = np.array([y.mean() for y in ys])\\n y_std = np.array([y.std() for y in ys])\\n y_N = np.array([y.size for y in ys])\\n return t_means, y_means, y_std, y_N\",\n \"def msl_nn_srtm_interp(self, lon_lat):\\n tiles = self.find_srtm_tiles(lon_lat)\\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\\n lon_lat_msl[:, 0:2] = lon_lat\\n for tile in set(tiles):\\n otile = rasterio.open(tile, 'r')\\n oimg = otile.read(1)\\n idx = np.where(np.array(tiles) == tile)[0]\\n pix = feat.geo_to_pix(\\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\\n pix = np.round(pix).astype(np.int)\\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\\n otile.close()\\n nan_mask = lon_lat_msl[:, 2] == -32768\\n lon_lat_msl[nan_mask, 2] = np.NaN\\n return lon_lat_msl\",\n \"def clean_and_save_timeseries(df):\\n drop_columns = ['Lat', \\n 'Long', \\n 'Province/State']\\n\\n df.drop(columns=drop_columns, inplace = True)\\n \\n df_grouped = df.groupby(['Country/Region'], as_index=False).sum()\\n df_grouped = df_grouped.set_index('Country/Region').transpose()\\n df_grouped.reset_index(level=0, inplace=True)\\n df_grouped.rename(columns={'index': 'Date'}, inplace=True)\\n df_grouped['Date'] = pd.to_datetime(df_grouped['Date'])\\n\\n df_grouped.to_csv('../data/worldwide_timeseries.csv', index=False)\",\n \"def daily_climatology(ds):\\n\\n dso = xr.Dataset()\\n ds = ds.copy()\\n doy = day_of_year_noleap(ds.time.values)\\n ds['doy'] = xr.DataArray(doy, dims=('time'))\\n\\n # copy coords\\n for v in ds.coords:\\n if 'time' not in ds[v].dims:\\n dso[v] = ds[v].copy()\\n \\n first_var = True\\n for v in ds.variables:\\n if 'time' not in ds[v].dims:\\n dso[v] = ds[v].copy()\\n continue \\n elif v not in ['doy', 'time']:\\n shape = list(ds[v].shape)\\n dims = ds[v].dims\\n shape[0] = 365\\n\\n dso[v] = xr.DataArray(np.empty(shape), dims=dims)\\n count = np.zeros((365,))\\n for doy, idx in ds.groupby('doy').groups.items():\\n if doy == 0:\\n if first_var:\\n print('skipping leap days')\\n else:\\n count[doy-1] += len(idx)\\n dso[v].data[doy-1,...] = ds[v].isel(time=idx).mean('time')\\n \\n first_var = False\\n\\n dso['time'] = xr.DataArray(np.arange(1, 366, 1), dims=('time'))\\n\\n return dso\",\n \"def ann_mean(ds, season=None, time_bnds_varname='time_bnds', time_centered=True, n_req=None):\\n \\n ds = ds.copy() #deep=True)\\n\\n if n_req is None:\\n if season is not None:\\n n_req = 2\\n else:\\n n_req = 8\\n \\n if time_bnds_varname is None and not time_centered:\\n raise NotImplementedError('time_bnds_varname cannot be \\\"None\\\" if time_centered=False')\\n \\n if not time_centered:\\n time_units = ds.time.encoding['units']\\n time_calendar = ds.time.encoding['calendar']\\n\\n # compute time bounds array\\n time_bound_data = cftime.date2num(\\n ds[time_bnds_varname].data, \\n units=time_units, \\n calendar=time_calendar) \\n\\n # center time\\n time_centered = cftime.num2date(\\n time_bound_data.mean(axis=1),\\n units=time_units, \\n calendar=time_calendar\\n ) \\n time_attrs = ds.time.attrs\\n time_encoding = ds.time.encoding\\n\\n ds['time'] = xr.DataArray(\\n time_centered,\\n dims=('time')\\n ) \\n \\n ones = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n time_mask = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n\\n group_by_year = 'time.year'\\n rename = {'year': 'time'}\\n \\n if season is not None:\\n season = season.upper()\\n if season not in ['DJF', 'MAM', 'JJA', 'SON']:\\n raise ValueError(f'unknown season: {season}') \\n\\n ds['austral_year'] = xr.where(ds['time.month'] > 6, ds['time.year'] + 1, ds['time.year'])\\n ds = ds.set_coords('austral_year')\\n ones = ones.assign_coords({'austral_year': ds.austral_year})\\n time_mask = time_mask.assign_coords({'austral_year': ds.austral_year})\\n time_mask = time_mask.where(ds['time.season'] == season).fillna(0)\\n \\n if season == 'DJF':\\n group_by_year = 'austral_year'\\n rename = {'austral_year': 'time'}\\n \\n if time_bnds_varname is not None:\\n time_wgt = ds[time_bnds_varname].diff(dim=ds[time_bnds_varname].dims[1])\\n if time_wgt.dtype == '<m8[ns]':\\n time_wgt = time_wgt / np.timedelta64(1, 'D')\\n else: \\n time_wgt = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n time_wgt = time_wgt.assign_coords(\\n {c: da for c, da in ds.coords.items() if 'time' in da.dims}\\n )\\n \\n time_wgt = time_wgt.where(time_mask==1) #.fillna(0.)\\n\\n ones = ones.where(time_mask==1)\\n time_wgt_grouped = time_wgt.groupby(group_by_year, restore_coord_dims=False)\\n time_wgt = time_wgt_grouped / time_wgt_grouped.sum(dim=xr.ALL_DIMS)\\n\\n nyr = len(time_wgt_grouped.groups)\\n \\n time_wgt = time_wgt.squeeze()\\n\\n idx_not_nans = ~np.isnan(time_wgt)\\n sum_wgt = time_wgt.groupby(group_by_year).sum(dim=xr.ALL_DIMS)\\n idx_not_nans = (sum_wgt > 0)\\n\\n np.testing.assert_almost_equal(\\n sum_wgt[idx_not_nans], \\n np.ones(idx_not_nans.sum().values)\\n )\\n\\n nontime_vars = set([v for v in ds.variables if 'time' not in ds[v].dims]) - set(ds.coords)\\n dsop = ds.drop_vars(nontime_vars)\\n\\n if time_bnds_varname is not None:\\n dsop = dsop.drop_vars(time_bnds_varname) \\n \\n def weighted_mean_arr(darr, wgts=None):\\n # if NaN are present, we need to use individual weights\\n cond = darr.isnull()\\n ones = xr.where(cond, 0.0, 1.0)\\n if season is None:\\n mask = (\\n darr.resample({'time': 'A'}, restore_coord_dims=False).mean(dim='time').notnull()\\n )\\n da_sum = (\\n (darr * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n ones_out = (\\n (ones * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n count = (\\n (ones * wgts.notnull()).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n else:\\n mask = (\\n darr.groupby(group_by_year, restore_coord_dims=False).mean(dim='time').notnull()\\n ).rename(rename)\\n \\n da_sum = (\\n (darr * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n ones_out = (\\n (ones * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n count = (\\n (ones * wgts.notnull()).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n\\n ones_out = ones_out.where(ones_out > 0.0)\\n da_weighted_mean = da_sum / ones_out\\n\\n return da_weighted_mean.where(mask).where(count >= n_req) \\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n ds_ann = dsop.map(weighted_mean_arr, wgts=time_wgt)\\n\\n # copy attrs\\n for v in ds_ann:\\n ds_ann[v].attrs = ds[v].attrs\\n\\n # restore coords\\n ds_ann = xr.merge((ds_ann, ds[list(nontime_vars)]))\\n\\n # eliminate partials\\n ndx = (time_wgt_grouped.count(dim=xr.ALL_DIMS) >= n_req).values\\n if not ndx.all():\\n ds_ann = ds_ann.isel(time=ndx)\\n\\n return ds_ann\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def nifti_from_time_series(volume, coords, time_series, nifti_path):\\r\\n # XXX Implement!\\r\\n raise NotImplementedError\",\n \"def convert_coords(date, time_steps, azs, els, obs):\\n coord_start_day = datetime(date.year, date.month, date.day)\\n \\n strategy = []\\n for time_step, az, el in zip(time_steps, azs, els):\\n if az % np.pi == 0.0: \\n az += EPS\\n \\n ra, dec = sphere.altaz_to_ra_dec(coord_start_day + timedelta(hours=time_step), az, el, obs)\\n strategy.append([ra, dec])\\n \\n return np.array(strategy)\",\n \"def compute_stage4(lon, lat, year):\\n nc = netCDF4.Dataset(\\\"/mesonet/data/stage4/%s_stage4_hourly.nc\\\" % (year,))\\n lons = nc.variables[\\\"lon\\\"][:]\\n lats = nc.variables[\\\"lat\\\"][:]\\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\\n (yidx, xidx) = np.unravel_index(dist.argmin(), dist.shape)\\n print(\\n (\\\"Computed stage4 nclon:%.2f nclat:%.2f yidx:%s xidx:%s \\\")\\n % (lons[yidx, xidx], lats[yidx, xidx], yidx, xidx)\\n )\\n p01i = mm2inch(nc.variables[\\\"p01m\\\"][:, yidx, xidx])\\n nc.close()\\n df = pd.DataFrame(\\n {\\\"precip\\\": 0.0},\\n index=pd.date_range(\\n \\\"%s-01-01\\\" % (year,), \\\"%s-12-31\\\" % (year,), tz=\\\"America/Chicago\\\"\\n ),\\n )\\n for date in df.index.values:\\n date2 = datetime.datetime.utcfromtimestamp(date.tolist() / 1e9)\\n ts = datetime.datetime(date2.year, date2.month, date2.day, 6)\\n ts = ts.replace(tzinfo=pytz.utc)\\n ts = ts.astimezone(pytz.timezone(\\\"America/Chicago\\\"))\\n ts = ts.replace(hour=0)\\n ts = ts.astimezone(pytz.utc)\\n tidx = hourly_offset(ts)\\n # values are in the rears\\n val = np.ma.sum(p01i[tidx + 1 : tidx + 25])\\n if val > 0:\\n df.at[date, \\\"precip\\\"] = val # close enough\\n return df\",\n \"def get_time_series(this_lat, this_lon, case, varnames):\\n\\n cesmdir = '/gpfs/fs1/collections/cdg/data/cesmLE/CESM-CAM5-BGC-LE/atm/proc/tseries/monthly'\\n\\n if 'LE' in case:\\n\\n from observational_large_ensemble.params import karen_params_cesm\\n\\n mode_lag = karen_params_cesm.mode_lag\\n cvdp_loc = karen_params_cesm.cvdp_loc\\n AMO_cutoff_freq = karen_params_cesm.AMO_cutoff_freq\\n\\n name_conversion = {'tas': 'TREFHT', 'pr': 'PRECC', 'slp': 'PSL'}\\n cesm_names = [name_conversion[v] for v in varnames]\\n this_member = int((case).split('-')[-1])\\n cvdp_file = '%s/CESM1-CAM5-BGC-LE_#%i.cvdp_data.1920-2018.nc' % (cvdp_loc, this_member)\\n\\n # Historical filenames for CESM. Will need to append part of RCP8.5 to get full period\\n filenames = []\\n for var in cesm_names:\\n file_str = '%s/%s/b.e11.B20TRC5CNBDRD.f09_g16.%03d.cam.h0.%s.??????-200512.nc' % (cesmdir, var,\\n this_member, var)\\n this_file = glob(file_str)[0]\\n filenames.append(this_file)\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames,\\n karen_params_cesm.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n else:\\n\\n from observational_large_ensemble.params import karen_params_obs\\n\\n mode_lag = karen_params_obs.mode_lag\\n cvdp_loc = karen_params_obs.cvdp_loc\\n AMO_cutoff_freq = karen_params_obs.AMO_cutoff_freq\\n\\n tas_dir = karen_params_obs.tas_dir\\n pr_dir = karen_params_obs.pr_dir\\n slp_dir = karen_params_obs.slp_dir\\n cvdp_file = '%s/HadISST.cvdp_data.1920-2018.nc' % cvdp_loc\\n file_dict = {'tas': '%s/Complete_TAVG_LatLong1.nc' % tas_dir,\\n 'pr': '%s/full_data_monthly_v2020.nc' % pr_dir,\\n 'slp': '%s/prmsl.mon.mean.nc' % slp_dir}\\n\\n filenames = []\\n for var in varnames:\\n filenames.append(file_dict[var])\\n\\n name_conversion = {'tas': 'temperature', 'pr': 'precip', 'slp': 'prmsl'}\\n\\n daX, df_shifted, _ = get_obs(case, varnames[0], filenames[0],\\n karen_params_obs.valid_years, mode_lag,\\n cvdp_file, AMO_cutoff_freq, name_conversion)\\n\\n this_ts = daX.sel({'lat': this_lat, 'lon': this_lon}, method='nearest')\\n\\n return this_ts, df_shifted\",\n \"def switch_lons(ds, lon_name='lon'):\\n ds = ds.copy()\\n with dask.config.set(**{'array.slicing.split_large_chunks': True}):\\n if np.any(ds.coords[lon_name] < 0): # if current coords are -180 to 180\\n ds.coords[lon_name] = (ds.coords[lon_name] + 360) % 360\\n else:\\n ds.coords[lon_name] = (ds.coords[lon_name] + 180) % 360 - 180\\n return ds.sortby(ds[lon_name])\",\n \"def meanRegion(thk_s,thk_p,thk_diff):\\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\\n \\n print '\\\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\\n \\n yearmin = 2004\\n yearmax = 2015\\n years = np.arange(yearmin,yearmax+1,1)\\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\\n \\n fig = plt.figure()\\n ax = plt.subplot(111)\\n \\n ### Call parameters\\n plt.rcParams['text.usetex']=True\\n plt.rcParams['font.family'] = 'sans-serif'\\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\\n \\n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\\n label=r'PIOMAS')\\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\\n label=r'Satellite')\\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\\n \\n labelsy = map(str,np.arange(0,6,1))\\n labelsx = map(str,years)\\n plt.xticks(np.arange(len(years)),labelsx)\\n plt.yticks(np.arange(0,6,1),labelsy)\\n plt.ylabel(r'\\\\textbf{Thickness (meters)}',fontsize=13)\\n \\n ### Adjust axes in time series plots \\n def adjust_spines(ax, spines):\\n for loc, spine in ax.spines.items():\\n if loc in spines:\\n spine.set_position(('outward', 10))\\n else:\\n spine.set_color('none') \\n if 'left' in spines:\\n ax.yaxis.set_ticks_position('left')\\n else:\\n ax.yaxis.set_ticks([])\\n \\n if 'bottom' in spines:\\n ax.xaxis.set_ticks_position('bottom')\\n else:\\n ax.xaxis.set_ticks([]) \\n \\n ### Adjust axes spines\\n adjust_spines(ax, ['left', 'bottom'])\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n plt.grid(color='b',zorder=1,alpha=0.3)\\n \\n plt.legend(shadow=False,fontsize=11,loc='upper right',\\n fancybox=True)\\n \\n plt.text(2,-0.8,r'\\\\textbf{ICESat}',fontsize=13)\\n plt.text(7.3,-0.8,r'\\\\textbf{PIOMAS}',fontsize=13)\\n \\n fig.suptitle(r'\\\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)\",\n \"def prepare(gpi, start_date, end_date, models, satellites, kind=\\\"clim\\\", window=35):\\n # read data\\n ts_input = data_object.read_gpi(gpi, start_date, end_date, models, satellites)\\n #ts_input = interp.add_nan(ts_input)\\n ts_input = interp.iter_fill(ts_input, max_gap=5)\\n\\n # either calc climatology, apply moving average filter, or do nothing\\n if kind == 'clim':\\n ts_smooth = smooth.iter_climats(ts_input)\\n plot_title = 'Climatology'\\n elif kind == 'movav':\\n ts_smooth = smooth.iter_movav(ts_input, window)\\n #ts_smooth = ts_gapfill\\n plot_title = 'Moving average'\\n elif kind == None:\\n # return original data\\n ts_smooth = ts_input\\n else:\\n raise NotImplementedError\\n pass\\n\\n # drop rows with missing values\\n #ts_smooth = ts_smooth.dropna()\\n\\n # scale satellite data to model data\\n ts_scaled = scaling.scale(ts_smooth, 'mean_std_nan', 0)\\n # drop nan rows for slope funcs\\n return ts_scaled #.dropna()\",\n \"def test_smooth_goddard_2013(PM_ds_control_3d_full):\\r\\n da = PM_ds_control_3d_full\\r\\n actual = smooth_goddard_2013(\\r\\n da,\\r\\n )\\r\\n # test that x, y not in dims\\r\\n assert \\\"x\\\" not in actual.dims\\r\\n assert \\\"y\\\" not in actual.dims\\r\\n # tests whether nlat, nlon got reduced\\r\\n assert actual.time.size < da.time.size\\r\\n assert actual.lon.size < da.lon.size\\r\\n assert actual.lat.size < da.lat.size\",\n \"def time_series(t, f=0.02):\\n T = t.size\\n # Seasonal component and time-varying trend component\\n ys = np.sin(2 * np.pi * f * t) * 0.6 + np.sin(1 / 5 * 2 * np.pi * f * t) * 0.2\\n # Amplitude modulation component\\n amp_mod = 0.5 * np.sin(1 / 6 * 2 * np.pi * f * t) + 0.8\\n ys *= amp_mod\\n ys = np.reshape(ys, (T,1))\\n return ys\",\n \"def replace_season(data,season):\\n if not SeasonCharts.matchseason(season):\\n raise SeasonCharts.SeasonError\\n ## Check data format\\n if test_rawdata(data):\\n for cat,shows in data.items():\\n for show in shows: show['season'] = season\\n else:\\n for show in data: show['season'] = season\",\n \"def _map_timestep2timeind(self, timestep):\\n if not self.simulation and timestep not in self.timemap:\\n # for steady state computation include year 0 or first 12 months\\n if self.md.litter_mode=='monthly':\\n incl = range(1, 13)\\n infall = self.md.monthly_litter\\n elif self.md.litter_mode=='yearly':\\n incl = [0]\\n infall = self.md.yearly_litter\\n for ind in range(len(infall)):\\n if infall[ind].timestep in incl:\\n self.timemap[timestep].append(ind)\\n if timestep not in self.timemap and self.md.litter_mode=='yearly':\\n # if no year 0 specification, use the one for year 1\\n for ind in range(len(infall)):\\n if infall[ind].timestep==1:\\n self.timemap[timestep].append(ind)\\n if self.simulation and timestep not in self.timemap:\\n # now for the simulation run\\n now, end = self._get_now_and_end(timestep)\\n if self.md.duration_unit=='month':\\n dur = relativedelta(months=self.timestep_length)\\n elif self.md.duration_unit=='year':\\n dur = relativedelta(years=self.timestep_length)\\n end = now + dur - relativedelta(days=1)\\n if self.md.litter_mode=='monthly':\\n inputdur = relativedelta(months=1)\\n infall = self.md.monthly_litter\\n elif self.md.litter_mode=='yearly':\\n inputdur = relativedelta(years=1)\\n infall = self.md.yearly_litter\\n # the first mont/year will have index number 1, hence deduce 1 m/y\\n start = STARTDATE - inputdur\\n for ind in range(len(infall)):\\n incl = self._test4inclusion(ind, infall, now, start, end)\\n if incl:\\n self.timemap[timestep].append(ind)\\n # check for possible area reductions to be mapped\\n areachange = self.md.area_change\\n for ind in range(len(areachange)):\\n incl = self._test4inclusion(ind, areachange, now, start, end)\\n if incl:\\n self.area_timemap[timestep].append(ind)\\n if timestep not in self.timemap:\\n self.timemap[timestep] = []\\n if timestep not in self.area_timemap:\\n self.area_timemap[timestep] = []\\n return self.timemap[timestep]\",\n \"def strain_seasonal(strain, mouse, feature, bin_width, period_length):\\n if (not isinstance(strain, int)) or (strain < 0):\\n raise ValueError(\\n 'Strain must be a non-negative integer')\\n if (not all([isinstance(m, int)\\n for m in mouse])) or (any([m < 0 for m in mouse])):\\n raise ValueError(\\n 'Mouse value must be a non-negative integer')\\n if feature not in ALL_FEATURES:\\n raise ValueError(\\n 'Input value must in {\\\"AS\\\", \\\"F\\\", \\\"M_AS\\\", \\\"M_IS\\\", \\\"W\\\", \\\"Distance\\\"}')\\n if (not isinstance(bin_width, int)) or bin_width < 0 or bin_width > 1440:\\n raise ValueError(\\n 'Bin width (minutes) must be a non-negative integer below 1440')\\n if period_length < 0:\\n raise ValueError(\\n 'Peoriod length must be a non-negative integer or float')\\n\\n # seasonal decomposition\\n seasonal_all = np.array([])\\n freq = int(period_length * 60 / bin_width)\\n\\n for m in mouse:\\n res = seasonal_decomposition(\\n strain, m, feature, bin_width, period_length)\\n seasonal_all = np.append(seasonal_all, res.seasonal[0:freq])\\n seasonal_all = seasonal_all.reshape([len(mouse), -1])\\n\\n return seasonal_all\",\n \"def nms_scale(nz, size, stride):\\n # Perform NMS between scales\\n for i, e in enumerate(nz):\\n if e is None:\\n continue\\n [s, x, y, sc] = e\\n for j, f in enumerate(nz):\\n if f is None or j == i:\\n continue\\n [s_t, x_t, y_t, sc_t] = f\\n if overlap_scale([s, x, y], [s_t, x_t, y_t], size, stride):\\n if sc >= sc_t:\\n nz[j] = None\\n else:\\n nz[i] = None\\n break # Go to i+1\\n res = []\\n for e in nz:\\n if e is None:\\n continue\\n res.append(e)\\n return res\",\n \"def ssa_full(time_series, embedding_dim=20, reconstruct_components=np.arange(10)):\\n\\n pc, s, v = ssa_decompose(time_series, embedding_dim)\\n time_series_reconstructed = ssa_reconstruct(pc, v, reconstruct_components)\\n\\n return time_series_reconstructed\",\n \"def constant_2015():\\n\\n #Load the CMIP6 historical\\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\\n #Get low and high level emissions just in the last year (2014)\\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\\n final_cubes = iris.cube.CubeList()\\n for cube in cubes:\\n final_cube = cube[-12:]\\n final_cubes.append(final_cube)\\n \\n #Set the year-on-year proportional reductions to be nothing\\n yoy_rates = calc_perc_reducts()\\n yoy_rates = np.array(yoy_rates)\\n yoy_rates = np.ones_like(yoy_rates)\\n\\n #Create coordinates for new nc file between 2014 and 2100\\n lat_coord = cubes[0].coord('latitude')\\n lon_coord = cubes[0].coord('longitude')\\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\\n\\n #Create the cube date\\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n #Set first year equal to 2014 in CMIP6 historical\\n cube_data_surf[:12,...] = final_cubes[0].data\\n cube_data_high[:12,...] = final_cubes[1].data\\n #Apply equal emissions in all other years too\\n for i in range(12,cube_data_surf.shape[0]):\\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\\n #Make the output cubes\\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\\n\\n fut_cube_high.var_name = 'field569_1'\\n fut_cube_high.units='kg/m2/s'\\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\\n fut_cube_surf.var_name = 'field569'\\n fut_cube_surf.units='kg/m2/s'\\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\\n\\n #Load the DMS cube from standard RCP2.6\\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\\n\\n dms_cube.var_name = 'field570'\\n dms_cube.attributes.pop('name')\\n dms_cube.coord('time').var_name = 'time'\\n dms_cube.coord('time').long_name = 'time'\\n\\n fut_cube_high = fut_cube_high[:-2]\\n fut_cube_surf = fut_cube_surf[:-2]\\n\\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\\n\\n #Save the final cubes as netcdf (cutting them to be the same length)\\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n os.system('ncatted -O -a calendar,time,m,c,\\\"360_day\\\" '+data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n\\n return\",\n \"def distributeSeason(self):\\n i = 1\\n for day in self.daylist:\\n if i >= monthbeg[5] and i < monthbeg[9]: #june through SEpt as per SCE\\n day.season = 'summer' #https://www.sce.com/residential/rates/Time-Of-Use-Residential-Rate-Plans\\n i = i + 1\\n else:\\n day.season = 'winter'\\n i = i+1\",\n \"def _fix_austrian_lpis(self, eopatch):\\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\\n self.mapping,\\n on='SNAR_BEZEI')\",\n \"def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\\n import numpy as np\\n import matplotlib as mpl\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\\n\\n def plotter(pdata, colormax=1, colormin=-999, title=''):\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \\n if colormin == -999:\\n colormin = -colormax\\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\\n pdata, lon = addcyclic(pdata, lon)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\\n mycmap1 = plt.cm.Blues_r(np.arange(256))\\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\\n my_cmap[230:282, :] = 1\\n if precip == 'yes':\\n my_cmap = my_cmap[::-1]\\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\\\"newjet\\\", my_cmap)\\n ctrs = np.linspace(colormin, colormax, 17)\\n plot = m.contourf(x, y, pdata, ctrs,\\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\\n extend='both')\\n\\n plt.title(title, y=1)\\n plt.show()\\n return plot\\n\\n ax1 = fig.add_subplot(3, 3, 1)\\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\\n ax2 = fig.add_subplot(3, 3, 2)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\\n ax3 = fig.add_subplot(3, 3, 3)\\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\\n ax4 = fig.add_subplot(3, 3, 4)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\\n ax5 = fig.add_subplot(3, 3, 5)\\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\\n ax6 = fig.add_subplot(3, 3, 6)\\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\\n ax7 = fig.add_subplot(3, 3, 7)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\\n ax8 = fig.add_subplot(3, 3, 9)\\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\\n ax9 = fig.add_subplot(3, 3, 8)\\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\\n\\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\\n orientation='horizontal', extend='max')\\n \\n b.set_label(label='t200 difference ($^\\\\circ$C)', size=20, fontsize=20, fontname='Arial')\\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\\n right=.95)\",\n \"def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\\n # Lookup parameters per serie\\n #seasonality = self.seasonality\\n embeds = self.embeds(idxs)\\n lev_sms = t.sigmoid(embeds[:, 0])\\n\\n # Initialize seasonalities\\n seas_prod = t.ones(len(Y[:,0]), device=Y.device)\\n seasonalities1 = []\\n seasonalities2 = []\\n seas_sms1 = t.ones(1, device=Y.device)\\n seas_sms2 = t.ones(1, device=Y.device)\\n\\n if len(self.seasonality)>0:\\n seas_sms1 = t.sigmoid(embeds[:, 1])\\n init_seas1 = t.exp(embeds[:, 2:(2+self.seasonality[0])]).unbind(1)\\n assert len(init_seas1) == self.seasonality[0]\\n\\n for i in range(len(init_seas1)):\\n seasonalities1 += [init_seas1[i]]\\n seasonalities1 += [init_seas1[0]]\\n seas_prod = seas_prod * init_seas1[0]\\n\\n if len(self.seasonality)==2:\\n seas_sms2 = t.sigmoid(embeds[:, 2+self.seasonality[0]])\\n init_seas2 = t.exp(embeds[:, 3+self.seasonality[0]:]).unbind(1)\\n assert len(init_seas2) == self.seasonality[1]\\n\\n for i in range(len(init_seas2)):\\n seasonalities2 += [init_seas2[i]]\\n seasonalities2 += [init_seas2[0]]\\n seas_prod = seas_prod * init_seas2[0]\\n\\n # Initialize levels\\n levels = []\\n levels += [Y[:,0]/seas_prod]\\n\\n # Recursive seasonalities and levels\\n ys = Y.unbind(1)\\n n_time = len(ys)\\n for t_idx in range(1, n_time):\\n seas_prod_t = t.ones(len(Y[:,t_idx]), device=Y.device)\\n if len(self.seasonality)>0:\\n seas_prod_t = seas_prod_t * seasonalities1[t_idx]\\n if len(self.seasonality)==2:\\n seas_prod_t = seas_prod_t * seasonalities2[t_idx]\\n\\n newlev = lev_sms * (ys[t_idx] / seas_prod_t) + (1-lev_sms) * levels[t_idx-1]\\n levels += [newlev]\\n\\n if len(self.seasonality)==1:\\n newseason1 = seas_sms1 * (ys[t_idx] / newlev) + (1-seas_sms1) * seasonalities1[t_idx]\\n seasonalities1 += [newseason1]\\n\\n if len(self.seasonality)==2:\\n newseason1 = seas_sms1 * (ys[t_idx] / (newlev * seasonalities2[t_idx])) + \\\\\\n (1-seas_sms1) * seasonalities1[t_idx]\\n seasonalities1 += [newseason1]\\n newseason2 = seas_sms2 * (ys[t_idx] / (newlev * seasonalities1[t_idx])) + \\\\\\n (1-seas_sms2) * seasonalities2[t_idx]\\n seasonalities2 += [newseason2]\\n\\n levels = t.stack(levels).transpose(1,0)\\n\\n seasonalities = []\\n\\n if len(self.seasonality)>0:\\n seasonalities += [t.stack(seasonalities1).transpose(1,0)]\\n\\n if len(self.seasonality)==2:\\n seasonalities += [t.stack(seasonalities2).transpose(1,0)]\\n\\n return levels, seasonalities\",\n \"def plot_subplot_trend(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/subplots/',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 trends'\\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 if seaice_source == 'nsidc':\\n seaice = seaice/250\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = xr.apply_ufunc(scipy.stats.linregress, seaice[seaicename].time.values.astype(float), seaice[seaicename], input_core_dims=[['time'],['time']], vectorize=True, dask='parallelized', output_dtypes=[float]*5, output_core_dims=[[]]*5)\\n if seaice_source =='ecmwf':\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename])\\n seaice_m = seaice_m * 1e9 * 60 * 60 * 24 * 365\\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\\n seaice_m = seaice_m*area\\n seaice_m = seaice_m.where(seaice_m != 0)\\n seaice_m = seaice_m.where(seaice_p_value <= 0.05)\\n\\n\\n# Index xontributions\\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 newdata = {} \\n for indexname in indicies[:-1]:\\n a = scipy.stats.linregress(index_data[indexname].time.values.astype(float), index_data[indexname])\\n newdata[indexname] = a[0] * dataset[indexname] * 24*60*60*365e9\\n title = temp_decomp.capitalize() + ' '\\n if detrend == 'detrended':\\n title += detrend + ' '\\n title += temporal_resolution\\n title += f' SIC trend contributions'\\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\\n # Plotting\\n for i in range(len(indicies)-1):\\n indexname = indicies[i]\\n newdata[indexname] = newdata[indexname] * area / 250\\n newdata[indexname] = newdata[indexname].where(newdata[indexname] !=0)\\n\\n\\n\\n fig = plt.figure(figsize = (15,5))\\n\\n # seaice_m = log_data(seaice_m)\\n max_ = min(seaice_m.max(),-seaice_m.min())\\n # max_ = 1\\n divnorm = TwoSlopeNorm(vmin=-max_, vcenter=0, vmax=max_)\\n ax = fig.add_subplot(131, projection = ccrs.SouthPolarStereo())\\n # Plotting\\n contor = ax.contourf(seaice_m.x, seaice_m.y, seaice_m, cmap = 'RdBu', levels = 100, norm = divnorm, transform=ccrs.SouthPolarStereo())\\n ax.coastlines()\\n ax.set_axis_off()\\n # cbar = plt.colorbar(contor)\\n # cbar.set_label('Trend in SIE (km$^2$ yr$^{-1}$)')\\n # plt.title(title)\\n ax = [fig.add_subplot(2,6,3, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,4, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,9, projection = ccrs.SouthPolarStereo()),fig.add_subplot(2,6,10, projection = ccrs.SouthPolarStereo())]\\n for i in range(len(indicies)-1):\\n indexname = indicies[i]\\n # newdata[indexname] = log_data(newdata[indexname])\\n newdata[indexname] = newdata[indexname].where(newdata[indexname] !=0)\\n contor = ax[i].contourf(dataset.x, dataset.y, newdata[indexname], cmap = 'RdBu', norm = divnorm, transform=ccrs.SouthPolarStereo(), levels = 100)\\n ax[i].coastlines()\\n ax[i].set_axis_off()\\n ax[i].set_title(indicies[i])\\n\\n ax = fig.add_subplot(1,3,3, projection = ccrs.SouthPolarStereo())\\n data = seaice_m\\n for i in range(len(indicies)-1):\\n indexname = indicies[i]\\n data = data - newdata[indexname]\\n ax.contourf(dataset.x, dataset.y, data, cmap = 'RdBu', norm = divnorm, levels = 100, transform=ccrs.SouthPolarStereo())\\n ax.coastlines()\\n fig.subplots_adjust(right=0.9)\\n cbar_ax = fig.add_axes([0.95, 0.15, 0.05, 0.7])\\n cbar = fig.colorbar(cm.ScalarMappable(norm=divnorm, cmap='RdBu'), cax=cbar_ax, shrink=0.88)\\n\\n plt.savefig(imagefolder + seaicename + '.pdf')\\n plt.show()\",\n \"def broadcast_lonlat(ds, verbose=True):\\n if 'lon' not in ds.variables:\\n ds.coords['lon'] = ds['x']\\n if 'lat' not in ds.variables:\\n ds.coords['lat'] = ds['y']\\n \\n if len(ds['lon'].dims) < 2:\\n ds.coords[\\\"lon\\\"] = ds[\\\"lon\\\"] * xr.ones_like(ds[\\\"lat\\\"])\\n if len(ds['lat'].dims) < 2:\\n ds.coords[\\\"lat\\\"] = xr.ones_like(ds[\\\"lon\\\"]) * ds[\\\"lat\\\"]\\n return ds\",\n \"def one_period_plot():\\n file = \\\"Data/matfiles/20131221.mat\\\"\\n object = MatReader(file)\\n\\n NeA = object.NeA\\n latA = object.latA\\n times = object.secondsA\\n mlt = object.mltA\\n ind1 = 2606 #lat inds\\n ind2 = 13940 #lat inds\\n \\n ind1 = 3197 #mlat inds\\n ind2 = 14390 #mlat inds\\n \\n T = ind2 - ind1\\n ind1 += int(T/2)\\n ind2 += int(T/2)\\n\\n latA = latA[ind1:ind2]\\n NeA = NeA[ind1:ind2]\\n # NeA = object.meanie(NeA, 5)\\n times = times[ind1:ind2]\\n mlt = mlt[ind1:ind2]\\n mlt = hour_round(mlt)\\n\\n lats = np.zeros_like(latA)\\n lats[0] = latA[0]\\n for i in range(len(latA)-1):\\n dlat = latA[i+1] - latA[i]\\n if dlat < 0:\\n lats[i+1] = lats[i] - dlat\\n else:\\n lats[i+1] = lats[i] + dlat\\n\\n lats += 90\\n\\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\\n # plt.plot(lats, NeA, \\\".\\\", markersize = 1)\\n # plt.plot([0, 0], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([30, 30], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([60, 60], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([120, 120],[0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([150, 150], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([167, 167], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([193, 193], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([210, 210], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([240, 244], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([300, 300], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([330, 330], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([360, 360], [0, np.max(NeA)], \\\"k\\\")\\n # plt.xticks(xticks)\\n # plt.xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n # plt.ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n # plt.title(\\\"One SWARM satellite period\\\")\\n # plt.grid(\\\"on\\\", axis = \\\"x\\\", xdata = gridticks)\\n #adding letters\\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\\n y = np.zeros_like(x) - np.max(NeA)/40\\n s = [\\\"S\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"C\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"S\\\"]\\n # for i in range(len(x)):\\n # plt.text(x[i], y[i], s[i], fontsize = 10)\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n # plt.show()\\n\\n # plt.plot(times, latA)\\n # plt.plot(times, mlt)\\n # plt.show()\\n print(lats[0])\\n print(lats[-1])\\n \\n fig, ax = plt.subplots()\\n ax.plot(lats, NeA, \\\".\\\", markersize = 1)\\n ax.set_xticks(xticks, minor=False)\\n ax.set_xticks([167, 193], minor=True)\\n ax.xaxis.grid(True, which = \\\"major\\\")\\n ax.xaxis.grid(True, which = \\\"minor\\\")\\n for i in range(len(x)):\\n ax.text(x[i], y[i], s[i], fontsize = 10)\\n ax.set_xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n ax.set_ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n ax.set_title(\\\"One Swarm satellite period\\\")\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n plt.show()\\n plt.plot(mlt, NeA)\\n plt.show()\\n plt.plot(mlt, lats)\\n plt.show()\",\n \"def msatna_blocks_3lag_year(year: int) -> pd.Series:\\n return msatna_blocks_3lag_panel()[year]\",\n \"def equalise_ts(station_list):\\n s_y={}\\n s_y_size = 5000 #large number for first pass\\n for s in station_list:\\n s_data = np.loadtxt('station_fuelType/'+s+\\\"_P98\\\",delimiter=',')\\n s_y[s] = s_data[:,1]\\n while float(s_y[s][0]) == 0.0:\\n s_y[s]=s_y[s][1:len(s_y[s])]\\n if len(s_y[s])<s_y_size:\\n s_y_size = len(s_y[s])\\n \\n for s in s_y:\\n if len(s_y[s])>s_y_size:\\n s_y[s]=s_y[s][len(s_y[s])-s_y_size:len(s_y[s])]\\n \\n ts_y = np.ndarray(shape=[0, s_y_size], dtype = 'float')\\n for key, v in s_y.items():\\n ts_y = np.vstack([ts_y, np.array(v)])\\n\\n return ts_y\",\n \"def set_coord_values(ds, wrf_out, footprint_nbins):\\n xdim_var = ds.variables[\\\"dim_x\\\"]\\n ydim_var = ds.variables[\\\"dim_y\\\"]\\n xdim_bounds_var = ds.variables[\\\"dim_x_bnds\\\"]\\n ydim_bounds_var = ds.variables[\\\"dim_y_bnds\\\"]\\n lon_var = ds.variables[\\\"longitude\\\"]\\n lat_var = ds.variables[\\\"latitude\\\"]\\n\\n time_back_var = ds.variables[\\\"time_before_observation\\\"]\\n time_back_bounds_var = ds.variables[\\\"time_before_observation_bnds\\\"]\\n\\n height_var = ds.variables[\\\"height\\\"]\\n height_bounds_var = ds.variables[\\\"height_bnds\\\"]\\n\\n dx = wrf_out[\\\"dx\\\"]\\n\\n xdim_data = wrf_out[\\\"proj_x_coord\\\"][0]\\n ydim_data = wrf_out[\\\"proj_y_coord\\\"][0]\\n xdim_var[:] = xdim_data[:]\\n ydim_var[:] = ydim_data[:]\\n\\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\\n xdim_bounds_var[-1,0] = xdim_data[-1]\\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\\n ydim_bounds_var[-1,0] = ydim_data[-1]\\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\\n\\n wrf_lats = wrf_out[\\\"wrf_lat\\\"][0][0, :, :]\\n wrf_lons = wrf_out[\\\"wrf_lon\\\"][0][0, :, :]\\n lat_var[:, :] = wrf_lats[:, :]\\n lon_var[:, :] = wrf_lons[:, :]\\n\\n ds.geospatial_lat_min = wrf_lats.min()\\n ds.geospatial_lat_max = wrf_lats.max()\\n ds.geospatial_lat_units = \\\"degree_north\\\"\\n ds.geospatial_lon_min = wrf_lons.min()\\n ds.geospatial_lon_max = wrf_lons.max()\\n ds.geospatial_lon_units = \\\"degree_east\\\"\\n\\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\\n time_back_var[:] = time_back_vals\\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\\n time_back_vals[1:]))\\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\\n\\n height_var[...] = 0\\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)\",\n \"def rescale(self):\\n # forecast on real data, don't need this anymore\\n pass\",\n \"def transform(self, y=None):\\n forecast_dates = self.X[[\\\"dt_time\\\", \\\"month_day\\\"]]\\n weather_avg = pd.read_csv(\\\"../data/weather_averages.csv\\\")\\n weather_fcst = weather_avg[\\n [\\\"DATE\\\", \\\"DLY-TMAX-NORMAL\\\", \\\"DLY-PRCP-50PCTL\\\", \\\"DLY-SNOW-50PCTL\\\"]\\n ]\\n weather_fcst[\\\"DATE\\\"] = pd.to_datetime(\\n weather_fcst[\\\"DATE\\\"].astype(\\\"str\\\"), format=\\\"%Y%m%d\\\", errors=\\\"ignore\\\"\\n )\\n weather_fcst[\\\"month_day\\\"] = weather_fcst[\\\"DATE\\\"].dt.strftime(\\\"%m/%d\\\")\\n weather_fcst = weather_fcst[\\n [\\\"month_day\\\", \\\"DLY-PRCP-50PCTL\\\", \\\"DLY-TMAX-NORMAL\\\", \\\"DLY-SNOW-50PCTL\\\"]\\n ].rename(\\n columns={\\n \\\"DLY-PRCP-50PCTL\\\": \\\"precip\\\",\\n \\\"DLY-TMAX-NORMAL\\\": \\\"temp_max\\\",\\n \\\"DLY-SNOW-50PCTL\\\": \\\"snow\\\",\\n }\\n )\\n weather_fcst[\\\"snow\\\"] = 0.0\\n weather_fcst = forecast_dates.join(\\n weather_fcst.set_index(\\\"month_day\\\"), on=\\\"month_day\\\"\\n )\\n near_term_weather = seattle_weather_fcst()\\n\\n for i in range(len(near_term_weather)):\\n weather_fcst[\\\"temp_max\\\"][\\n weather_fcst[\\\"dt_time\\\"] == near_term_weather[\\\"date\\\"][i]\\n ] = near_term_weather[\\\"temp_max\\\"][i]\\n if near_term_weather[\\\"precip_bool\\\"][i] == 0:\\n weather_fcst[\\\"precip\\\"][\\n weather_fcst[\\\"dt_time\\\"] == near_term_weather[\\\"date\\\"][0]\\n ] = 0\\n\\n self.X[[\\\"precip\\\", \\\"temp_max\\\", \\\"snow\\\"]] = weather_fcst[\\n [\\\"precip\\\", \\\"temp_max\\\", \\\"snow\\\"]\\n ]\\n return self.X.drop(\\n columns=[\\n \\\"dt_time\\\",\\n \\\"year\\\",\\n \\\"month\\\",\\n \\\"day\\\",\\n \\\"day_of_week\\\",\\n \\\"month_day\\\",\\n \\\"month_weekday\\\",\\n \\\"spec_day\\\",\\n ]\\n )\",\n \"def _fix_coords(x, y):\\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\\n return x, y\\n lon1 = x[0]\\n filter_ = x < lon1\\n while filter_.sum():\\n filter_ = x < lon1\\n x[filter_] += 360\\n return x, y\",\n \"def timeseries(self, x, convert=None, rmnans=False, timeslice=None, **kw):\\n x = x.replace('.','/')\\n try: v = self[x]['value'][:].squeeze()\\n except KeyError:\\n raise KeyError('could not read value for {0}'.format(x))\\n# if x.split('/')[-1] == 'platform_orientation':\\n# v[v < 0] += 2*np.pi\\n if convert: \\n v = convert(v)\\n t = self[x]['time'][:].squeeze() - 366\\n if timeslice:\\n if type(timeslice[0]) is datetime.datetime: \\n timeslice[0] = matplotlib.dates.date2num(timeslice[0])\\n if type(timeslice[1]) is datetime.datetime: \\n timeslice[1] = matplotlib.dates.date2num(timeslice[1])\\n v = v[np.logical_and(t > timeslice[0], t < timeslice[1])]\\n t = t[np.logical_and(t > timeslice[0], t < timeslice[1])]\\n if rmnans:\\n v, t = oalib.rmnans(v, t)\\n return v, t\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def ts_fit(series: TimeSeries) -> TimeSeries:\\n pass\",\n \"def ll2csflat(lon,lat,ncs):\\n j,f,i = ll2jfi(lon,lat,ncs)\\n return (j*6+f)*ncs+i\",\n \"def _interpolate_meteorological_data(dset, data, rundate):\\n rundate = datetime(rundate.year, rundate.month, rundate.day)\\n for field, station in [(f, f[4:]) for f in data.keys() if f.startswith(\\\"met_\\\")]:\\n log.debug(f\\\"Meteorological data available for station {station}\\\")\\n\\n met_time = data[field].pop(\\\"met_time\\\")\\n flat_list = [item for sublist in met_time for item in sublist]\\n met_time_float = np.array([(flat_list[i] - rundate).total_seconds() for i in range(0, len(flat_list))])\\n met_time_unique, met_index = np.unique(met_time_float, return_index=True)\\n\\n diff = len(met_time_float) - len(met_time_unique)\\n if diff > 0:\\n log.dev(f\\\"Removed duplicate met data for station {station}\\\")\\n log.dev(\\\"Do this for the actual obs data also!\\\")\\n if len(met_time_unique) == 1:\\n for met_type in data[field].keys():\\n data[field][met_type] = np.repeat(data[field][met_type][0], dset.num_obs)\\n continue\\n\\n # Extrapolation one month before/after\\n # (this is overkill, most of these values will be removed later when taking the diagonal)\\n min_time = min(met_time_unique) - 31 * 86400\\n max_time = max(met_time_unique) + 31 * 86400\\n met_time_unique = np.hstack((np.array(min_time), met_time_unique, np.array(max_time)))\\n\\n for met_type in data[field].keys():\\n met_data_array = data[field][met_type]\\n flat_list = [item for sublist in met_data_array for item in sublist]\\n met_data_array = np.array([flat_list[i] for i in met_index])\\n met_data_array = np.hstack((met_data_array[0], met_data_array, met_data_array[-1]))\\n data[field][met_type] = interpolation.interpolate(\\n met_time_unique, met_data_array, dset.obs_time, kind=\\\"cubic\\\"\\n )\\n\\n return data\",\n \"def F_interp_narr_mat(sounding_lon,sounding_lat,sounding_datenum,\\\\\\n narr_dir='/mnt/Data2/NARR/acmap_narr/',\\\\\\n file_collection_names=['flx'],\\\\\\n file_collection_fields=[['GPH_tropopause','P_tropopause']]):\\n from scipy.io import loadmat\\n from scipy.interpolate import griddata\\n \\n start_datenum = np.amin(sounding_datenum)\\n end_datenum = np.amax(sounding_datenum)\\n start_datetime = datedev_py(start_datenum)\\n start_year = start_datetime.year\\n start_month = start_datetime.month\\n start_day = start_datetime.day\\n start_hour = start_datetime.hour\\n end_datetime = datedev_py(end_datenum)\\n end_year = end_datetime.year\\n end_month = end_datetime.month\\n end_day = end_datetime.day\\n end_hour = end_datetime.hour\\n step_hour = 3 # narr data are 3-hourly\\n narr_start_hour = start_hour-start_hour%step_hour\\n narr_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=narr_start_hour)\\n if end_hour >= 24-step_hour:\\n narr_end_hour = 0\\n narr_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=narr_end_hour)\\\\\\n +datetime.timedelta(days=1)\\n else:\\n narr_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\\n narr_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=narr_end_hour)\\n nstep = (narr_end_datetime-narr_start_datetime).total_seconds()/3600/step_hour+1\\n nstep = int(nstep)\\n \\n narr_data = {}\\n # load narr data\\n for i in range(len(file_collection_names)):\\n file_collection_name = file_collection_names[i]\\n file_collection_field = file_collection_fields[i]\\n for istep in range(nstep):\\n file_datetime = narr_start_datetime+datetime.timedelta(hours=step_hour*istep)\\n file_name = 'subset_'+file_collection_name+file_datetime.strftime('_%d_%H.mat')\\n file_path = os.path.join(narr_dir,file_datetime.strftime('%Y'),\\\\\\n file_datetime.strftime('%m'),file_name)\\n if not narr_data:\\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],file_collection_field)))\\n narr_data['lon'] = mat_data['lon']\\n narr_data['lat'] = mat_data['lat']\\n for fn in file_collection_field:\\n narr_data[fn] = np.zeros((narr_data['lon'].shape[0],narr_data['lon'].shape[1],nstep))\\n narr_data[fn][...,istep] = mat_data[fn]\\n else:\\n mat_data = loadmat(file_path,variable_names=file_collection_field)\\n for fn in file_collection_field:\\n narr_data[fn][...,istep] = mat_data[fn]\\n # construct time axis\\n narr_data['datenum'] = np.zeros((nstep),dtype=np.float64)\\n for istep in range(nstep):\\n file_datetime = narr_start_datetime+datetime.timedelta(hours=step_hour*istep)\\n narr_data['datenum'][istep] = (file_datetime.toordinal()\\\\\\n +file_datetime.hour/24.\\\\\\n +file_datetime.minute/1440.\\\\\\n +file_datetime.second/86400.+366.)\\n # interpolate\\n lon_pts = np.repeat(narr_data['lon'][...,np.newaxis],nstep,axis=narr_data['lon'].ndim)\\n lat_pts = np.repeat(narr_data['lat'][...,np.newaxis],nstep,axis=narr_data['lat'].ndim)\\n datenum_pts = np.ones(lon_pts.shape)\\n for istep in range(nstep):\\n datenum_pts[...,istep] = datenum_pts[...,istep]*narr_data['datenum'][istep]\\n \\n sounding_interp = {}\\n # griddata is slow. may need to project sounding_lon/lat to narr x/y space and use interpn\\n for i in range(len(file_collection_names)):\\n file_collection_field = file_collection_fields[i]\\n for fn in file_collection_field:\\n sounding_interp[fn] = griddata((lon_pts.flatten(),lat_pts.flatten(),datenum_pts.flatten()),\\\\\\n narr_data[fn].flatten(),(sounding_lon,sounding_lat,sounding_datenum))\\n return sounding_interp\",\n \"def reconfig_to_datetime(all_files, datetime_axis, time_freq, nrows=1):\\n\\n new_ydata = {}\\n max_primary = max_secondary = float(\\\"-inf\\\")\\n min_primary = min_secondary = float(\\\"inf\\\")\\n for key, value in all_files.iteritems():\\n \\n\\tassert isinstance(value, nio.InputData)\\n\\t\\n\\t# Convert original xaxis to datetime objects #\\n\\t\\n\\torig_dtaxis = value.datetimes\\n\\t\\n\\t# Check the start point of original xaxis against the new datetime_axis #\\n\\t\\n\\tmissval = value.data.missing_value\\n\\tydata = value.data[:]\\n\\t\\n if orig_dtaxis[0] in datetime_axis[:]:\\n\\t nfill = rrule(eval(time_freq), dtstart=datetime_axis[0], until=orig_dtaxis[0]).count() - 1\\n\\t for i in xrange(nfill):\\n\\t ydata = numpy.insert(ydata, 0, missval)\\n\\telse:\\n\\t ystart = orig_dtaxis[:].index(datetime_axis[0])\\n\\t ydata = ydata[ystart:]\\n\\t orig_dtaxis = orig_dtaxis[ystart:]\\n\\t\\t \\n # Check the end point of original xaxis against the new datetime_axis #\\n\\t\\n if orig_dtaxis[-1] in datetime_axis[:]:\\n nfill = rrule(eval(time_freq), dtstart=orig_dtaxis[-1], until=datetime_axis[-1]).count() - 1\\n\\t for i in xrange(nfill):\\n\\t ydata = numpy.append(ydata, missval)\\n else:\\n\\t yend = orig_dtaxis[:].index(datetime_axis[-1]) + 1\\n ydata = ydata[:yend]\\n\\n # Update the minimum and maximum value #\\n\\n ydata = numpy.ma.masked_values(ydata, missval)\\n\\n if value.set == 'primary':\\n max_primary, min_primary = nio.hi_lo(ydata, max_primary, min_primary)\\n elif value.set == 'secondary':\\n max_secondary, min_secondary = nio.hi_lo(ydata, max_secondary, min_secondary)\\n\\n new_ydata[key] = YaxisElement(split_nrows(ydata, nrows), \\n all_files[key].tag, \\n all_files[key].set)\\n \\n primary_bounds = (min_primary, max_primary)\\n secondary_bounds = None if max_secondary == float(\\\"inf\\\") else (min_secondary, max_secondary)\\n\\n\\n return new_ydata, primary_bounds, secondary_bounds\",\n \"def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\\n y_transformed, _ = Y.median(1)\\n y_transformed = y_transformed.reshape(-1, 1)\\n levels = y_transformed.repeat(1, Y.shape[1])\\n seasonalities = None\\n\\n return levels, None\",\n \"def test_time_series_from_file():\\r\\n\\r\\n TR = 1.35\\r\\n ts_ff = io.time_series_from_file\\r\\n\\r\\n #File names:\\r\\n fmri_file1 = os.path.join(data_path,'fmri1.nii.gz')\\r\\n fmri_file2 = os.path.join(data_path,'fmri2.nii.gz')\\r\\n\\r\\n #Spatial coordinates into the volumes:\\r\\n coords1 = np.array([[5,5,5,5],[5,5,5,5],[1,2,3,4]])\\r\\n coords2 = np.array([[6,6,6,6],[6,6,6,6],[3,4,5,6]])\\r\\n\\r\\n #No averaging, no normalization:\\r\\n t1 = ts_ff([fmri_file1,fmri_file2],[coords1,coords2],TR)\\r\\n\\r\\n npt.assert_equal(t1[0].shape,(4,80)) # 4 coordinates, 80 time-points\\r\\n\\r\\n t2 = ts_ff([fmri_file1,fmri_file2],[coords1,coords2],TR,average=True)\\r\\n\\r\\n npt.assert_equal(t2[0].shape,(80,)) # collapse coordinates,80 time-points\\r\\n\\r\\n t3 = ts_ff(fmri_file1,coords1,TR,normalize='zscore')\\r\\n\\r\\n #The mean of each channel should be almost equal to 0:\\r\\n npt.assert_almost_equal(t3.data[0].mean(),0)\\r\\n #And the standard deviation should be almost equal to 1:\\r\\n npt.assert_almost_equal(t3.data[0].std(),1)\\r\\n\\r\\n t4 = ts_ff(fmri_file1,coords1,TR,normalize='percent')\\r\\n\\r\\n #In this case, the average is almost equal to 0, but no constraint on the\\r\\n #std:\\r\\n npt.assert_almost_equal(t4.data[0].mean(),0)\\r\\n\\r\\n #Make sure that we didn't mess up the sampling interval:\\r\\n npt.assert_equal(t4.sampling_interval,nitime.TimeArray(1.35))\\r\\n\\r\\n # Test the default behavior:\\r\\n data = io.load(fmri_file1).get_data()\\r\\n t5 = ts_ff(fmri_file1)\\r\\n npt.assert_equal(t5.shape, data.shape)\\r\\n npt.assert_equal(t5.sampling_interval, ts.TimeArray(1, time_unit='s'))\\r\\n\\r\\n # Test initializing TR with a TimeArray:\\r\\n t6= ts_ff(fmri_file1, TR=ts.TimeArray(1350, time_unit='ms'))\\r\\n npt.assert_equal(t4.sampling_interval, t6.sampling_interval)\\r\\n\\r\\n # Check the concatenation dimensions:\\r\\n t7 = ts_ff([fmri_file1, fmri_file2])\\r\\n npt.assert_equal([t7.shape[:3], t7.shape[-1]], [data.shape[:3], data.shape[-1]*2])\\r\\n\\r\\n t8 = ts_ff([fmri_file1, fmri_file2], average=True)\\r\\n npt.assert_equal(t8.shape[0], data.shape[-1]*2)\\r\\n\\r\\n t9 = ts_ff([fmri_file1, fmri_file2], average=True, normalize='zscore')\\r\\n npt.assert_almost_equal(t9.data.mean(), 0)\",\n \"def normalize(self) -> Self:\\n new_values = normalize_i8_timestamps(self.asi8, self.tz, reso=self._creso)\\n dt64_values = new_values.view(self._ndarray.dtype)\\n\\n dta = type(self)._simple_new(dt64_values, dtype=dt64_values.dtype)\\n dta = dta._with_freq(\\\"infer\\\")\\n if self.tz is not None:\\n dta = dta.tz_localize(self.tz)\\n return dta\",\n \"def get_cycling_timeseries_2017(station: str):\\n\\n # Load data\\n cycling_df = pd.read_csv(\\\"src/Helsingin_pyorailijamaarat.csv\\\", sep=\\\";\\\")\\n\\n # Drop rows and columns with only null values\\n cycling_df = cycling_df \\\\\\n .dropna(axis=0, how=\\\"all\\\") \\\\\\n .dropna(axis=1, how=\\\"all\\\")\\n\\n # Create Date column and reindex dataset\\n cycling_df[\\\"Date\\\"] = create_date_column(cycling_df[\\\"Päivämäärä\\\"])\\n cycling_df = cycling_df.set_index(\\\"Date\\\")\\n\\n # Drop redundan\\n cycling_df.drop([\\\"Päivämäärä\\\"], axis=\\\"columns\\\", inplace=True)\\n\\n cycling_df = cycling_df.loc['2017', station]\\n\\n cycling_df = cycling_df \\\\\\n .groupby(cycling_df.index.date) \\\\\\n .sum()\\n\\n return cycling_df\",\n \"def reformat(dataset):\\n x = dataset[:, 1] \\n x = np.stack(x) # reshape to (n, mel bands, timesteps)\\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \\n y = dataset[:, 2] \\n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\\n return x, y\",\n \"def F_interp_geos_mat(sounding_lon,sounding_lat,sounding_datenum,\\\\\\n geos_dir='/mnt/Data2/GEOS/s5p_interp/',\\\\\\n interp_fields=['TROPPT']):\\n from scipy.io import loadmat\\n from scipy.interpolate import RegularGridInterpolator\\n \\n start_datenum = np.amin(sounding_datenum)\\n end_datenum = np.amax(sounding_datenum)\\n start_datetime = datedev_py(start_datenum)\\n start_year = start_datetime.year\\n start_month = start_datetime.month\\n start_day = start_datetime.day\\n start_hour = start_datetime.hour\\n \\n end_datetime = datedev_py(end_datenum)\\n end_year = end_datetime.year\\n end_month = end_datetime.month\\n end_day = end_datetime.day\\n end_hour = end_datetime.hour\\n end_minute = end_datetime.minute\\n end_second = end_datetime.second\\n \\n step_hour = 3 # geos fp data are 3-hourly\\n \\n geos_start_hour = start_hour-start_hour%step_hour\\n geos_start_datetime = datetime.datetime(year=start_year,month=start_month,day=start_day,hour=geos_start_hour)\\n if end_hour > 24-step_hour or (end_hour == 24-step_hour and (end_minute > 0 or end_second > 0)):\\n geos_end_hour = 0\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour) +datetime.timedelta(days=1)\\n elif end_hour%step_hour == 0 and end_minute == 0 and end_second == 0:\\n geos_end_hour = end_hour\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n else:\\n geos_end_hour = (step_hour-(end_hour+1)%step_hour)%step_hour+end_hour+1\\n geos_end_datetime = datetime.datetime(year=end_year,month=end_month,day=end_day,hour=geos_end_hour)\\n \\n nstep = (geos_end_datetime-geos_start_datetime).total_seconds()/3600/step_hour+1\\n nstep = int(nstep)\\n \\n geos_data = {}\\n # load narr data\\n for istep in range(nstep):\\n file_datetime = geos_start_datetime+datetime.timedelta(hours=step_hour*istep)\\n file_dir = os.path.join(geos_dir,file_datetime.strftime('Y%Y'),\\\\\\n file_datetime.strftime('M%m'),\\\\\\n file_datetime.strftime('D%d'))\\n file_path = os.path.join(file_dir,'subset_'+file_datetime.strftime('%Y%m%d_%H')+'.mat')\\n if not geos_data:\\n mat_data = loadmat(file_path,variable_names=np.concatenate((['lat','lon'],interp_fields)))\\n geos_data['lon'] = mat_data['lon'].flatten()\\n geos_data['lat'] = mat_data['lat'].flatten()\\n geos_data['datenum'] = np.zeros((nstep),dtype=np.float64)\\n for fn in interp_fields:\\n geos_data[fn] = np.zeros((len(geos_data['lon']),len(geos_data['lat']),nstep))\\n geos_data[fn][...,istep] = mat_data[fn]\\n else:\\n mat_data = loadmat(file_path,variable_names=interp_fields)\\n for fn in interp_fields:\\n geos_data[fn][...,istep] = mat_data[fn]\\n \\n geos_data['datenum'][istep] = (file_datetime.toordinal()\\\\\\n +file_datetime.hour/24.\\\\\\n +file_datetime.minute/1440.\\\\\\n +file_datetime.second/86400.+366.)\\n # interpolate\\n sounding_interp = {}\\n for fn in interp_fields:\\n my_interpolating_function = \\\\\\n RegularGridInterpolator((geos_data['lon'],geos_data['lat'],geos_data['datenum']),\\\\\\n geos_data[fn],bounds_error=False,fill_value=np.nan)\\n sounding_interp[fn] = my_interpolating_function((sounding_lon,sounding_lat,sounding_datenum))\\n return sounding_interp\",\n \"def _sort_by_satellite(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\\n time = []\\n satellite = []\\n system = []\\n for sat in sorted(self.dset.unique(\\\"satellite\\\"), reverse=True):\\n idx = self.dset.filter(satellite=sat)\\n time.extend(self.dset.time.gps.datetime[idx])\\n satellite.extend(self.dset.satellite[idx])\\n system.extend(self.dset.system[idx])\\n \\n return np.array([time]), np.array([satellite]), np.array([system])\",\n \"def reshape_at_dist(self):\\n self.all_dist_per_mol = np.zeros((self.nmol, self.at_per_mol, self.at_per_mol))\\n for imol in range(self.nmol):\\n start, end = self.at_per_mol*imol, (imol+1)*self.at_per_mol\\n self.all_dist_per_mol[imol] = self.all_dist[start:end,\\n start:end]\",\n \"def replace_x_y_nominal_lat_lon(ds):\\n ds = ds.copy()\\n if 'x' in ds.dims and 'y' in ds.dims:\\n \\n nominal_y = ds.lat.mean('x')\\n # extract the equatorial lat and take those lon values as nominal lon\\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\\n nominal_x = ds.lon.isel(y=eq_ind)\\n ds.coords['x'].data = nominal_x.data\\n ds.coords['y'].data = nominal_y.data\\n\\n ds = ds.sortby('x')\\n ds = ds.sortby('y')\\n \\n else:\\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\\n return ds\",\n \"def run(ts):\\n nc = netCDF4.Dataset(('/mesonet/data/iemre/%s_mw_mrms_daily.nc'\\n '') % (ts.year,), 'a')\\n offset = iemre.daily_offset(ts)\\n ncprecip = nc.variables['p01d']\\n\\n # We want this mrms variable to replicate the netcdf file, so the\\n # origin is the southwestern corner\\n ts += datetime.timedelta(hours=24)\\n gmtts = ts.astimezone(pytz.timezone(\\\"UTC\\\"))\\n\\n gribfn = gmtts.strftime((\\\"/mnt/a4/data/%Y/%m/%d/mrms/ncep/\\\"\\n \\\"RadarOnly_QPE_24H/\\\"\\n \\\"RadarOnly_QPE_24H_00.00_%Y%m%d-%H%M00.grib2.gz\\\"))\\n if not os.path.isfile(gribfn):\\n print(\\\"merge_mrms_q3.py MISSING %s\\\" % (gribfn,))\\n return\\n\\n fp = gzip.GzipFile(gribfn, 'rb')\\n (_, tmpfn) = tempfile.mkstemp()\\n tmpfp = open(tmpfn, 'wb')\\n tmpfp.write(fp.read())\\n tmpfp.close()\\n grbs = pygrib.open(tmpfn)\\n grb = grbs[1]\\n lats, _ = grb.latlons()\\n os.unlink(tmpfn)\\n\\n val = grb['values']\\n # Anything less than zero, we set to zero\\n val = np.where(val < 0, 0, val)\\n\\n # CAREFUL HERE! The MRMS grid is North to South\\n # set top (smallest y)\\n y0 = int((lats[0, 0] - iemre.NORTH) * 100.0)\\n y1 = int((lats[0, 0] - iemre.SOUTH) * 100.0)\\n x0 = int((iemre.WEST - mrms.WEST) * 100.0)\\n x1 = int((iemre.EAST - mrms.WEST) * 100.0)\\n # print 'y0:%s y1:%s x0:%s x1:%s' % (y0, y1, x0, x1)\\n ncprecip[offset, :, :] = np.flipud(val[y0:y1, x0:x1])\\n # m = MapPlot(sector='midwest')\\n # x, y = np.meshgrid(nc.variables['lon'][:], nc.variables['lat'][:])\\n # m.pcolormesh(x, y, ncprecip[offset,:,:], range(10), latlon=True)\\n # m.postprocess(filename='test.png')\\n # (fig, ax) = plt.subplots()\\n # ax.imshow(mrms)\\n # fig.savefig('test.png')\\n # (fig, ax) = plt.subplots()\\n # ax.imshow(mrms[y0:y1,x0:x1])\\n # fig.savefig('test2.png')\\n nc.close()\",\n \"def run_denoising(time_series, hpf_before_regression, inds_to_include, interpolation_method,\\n noise_comps, clean_comps, high_pass, low_pass, n_skip_vols, TR, filter_order = 6):\\n\\n\\n initial_dvars = dvars(time_series, np.linspace(0,n_skip_vols - 1,n_skip_vols,dtype=int))\\n\\n #Load the arrays with the data for both the clean and noise components to be used in regression\\n clean_comps_pre_filter = clean_comps\\n noise_comps_pre_filter = noise_comps\\n\\n #Apply an initial HPF to everything if necessary - this does not remove scrubbed timepoints,\\n #but does skips the first n_skip_vols (which will be set to 0 and not used in subsequent steps)\\n if hpf_before_regression != False:\\n\\n b, a = imaging_utils.construct_filter('highpass', [hpf_before_regression], TR, filter_order)\\n\\n #start with the clean comps matrix\\n if type(clean_comps_pre_filter) != type(False):\\n\\n clean_comps_post_filter = np.zeros(clean_comps_pre_filter.shape)\\n for clean_dim in range(clean_comps_pre_filter.shape[0]):\\n\\n clean_comps_post_filter[clean_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, clean_comps_pre_filter[clean_dim, n_skip_vols:])\\n\\n #this option for both clean/noise indicates there is no input matrix to filter\\n else:\\n\\n clean_comps_post_filter = False\\n\\n #Move to the noise comps matrix\\n if type(noise_comps_pre_filter) != type(False):\\n\\n noise_comps_post_filter = np.zeros(noise_comps_pre_filter.shape)\\n for noise_dim in range(noise_comps_pre_filter.shape[0]):\\n\\n noise_comps_post_filter[noise_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, noise_comps_pre_filter[noise_dim, n_skip_vols:])\\n\\n else:\\n\\n noise_comps_post_filter = False\\n\\n #then filter the original time signal\\n filtered_time_series = np.zeros(time_series.shape)\\n for original_ts_dim in range(time_series.shape[0]):\\n\\n filtered_time_series[original_ts_dim, n_skip_vols:] = imaging_utils.apply_filter(b, a, time_series[original_ts_dim, n_skip_vols:])\\n\\n #If you don't want to apply the initial HPF, then\\n #just make a copy of the matrices of interest\\n else:\\n\\n clean_comps_post_filter = clean_comps_pre_filter\\n noise_comps_post_filter = noise_comps_pre_filter\\n filtered_time_series = time_series\\n\\n\\n\\n\\n #Now create the nuisance regression model. Only do this step if\\n #the noise_comps_post_filter isn't false.\\n good_timepoint_inds = np.where(inds_to_include == True)[0]\\n bad_timepoint_inds = np.where(inds_to_include == False)[0]\\n\\n if type(noise_comps_post_filter) == type(False):\\n\\n regressed_time_signal = filtered_time_series\\n original_std = None\\n\\n else:\\n\\n\\n #Calculate the standard deviation of the signal before nuisance regression\\n original_std = np.std(filtered_time_series[:,good_timepoint_inds], axis=1)\\n\\n #Weird thing where I need to swap dimensions here...(implemented correctly)\\n\\n #First add constant/linear trend to the denoising model\\n constant = np.ones((1,filtered_time_series.shape[1]))\\n linear_trend = np.linspace(0,filtered_time_series.shape[1],num=filtered_time_series.shape[1])\\n linear_trend = np.reshape(linear_trend, (1,filtered_time_series.shape[1]))[0]\\n noise_comps_post_filter = np.vstack((constant, linear_trend, noise_comps_post_filter))\\n\\n regressed_time_signal = np.zeros(filtered_time_series.shape).transpose()\\n filtered_time_series_T = filtered_time_series.transpose()\\n\\n #If there aren't any clean components,\\n #do a \\\"hard\\\" or \\\"agressive\\\" denosing\\n if type(clean_comps_post_filter) == type(False):\\n\\n noise_comps_post_filter_T_to_be_used = noise_comps_post_filter[:,good_timepoint_inds].transpose()\\n XT_X_Neg1_XT = np.linalg.pinv(noise_comps_post_filter_T_to_be_used)\\n\\n for temp_time_signal_dim in range(filtered_time_series.shape[0]):\\n regressed_time_signal[good_timepoint_inds,temp_time_signal_dim] = imaging_utils.partial_clean_fast(filtered_time_series_T[good_timepoint_inds,temp_time_signal_dim], XT_X_Neg1_XT, noise_comps_post_filter_T_to_be_used)\\n\\n\\n\\n #If there are clean components, then\\n #do a \\\"soft\\\" denoising\\n else:\\n\\n full_matrix_to_be_used = np.vstack((noise_comps_post_filter, clean_comps_post_filter))[:,good_timepoint_inds].transpose()\\n noise_comps_post_filter_T_to_be_used = noise_comps_post_filter[:,good_timepoint_inds].transpose()\\n XT_X_Neg1_XT = np.linalg.pinv(full_matrix_to_be_used)\\n\\n for temp_time_signal_dim in range(filtered_time_series.shape[0]):\\n regressed_time_signal[good_timepoint_inds,temp_time_signal_dim] = imaging_utils.partial_clean_fast(filtered_time_series_T[good_timepoint_inds,temp_time_signal_dim], XT_X_Neg1_XT, noise_comps_post_filter_T_to_be_used)\\n\\n\\n #Put back into original dimensions\\n regressed_time_signal = regressed_time_signal.transpose()\\n\\n #Calculate the standard deviation of the signal after the nuisance regression\\n post_regression_std = np.std(regressed_time_signal[:,good_timepoint_inds], axis=1)\\n\\n\\n #Now apply interpolation\\n interpolated_time_signal = np.zeros(regressed_time_signal.shape)\\n\\n if interpolation_method == 'spectral':\\n\\n interpolated_time_signal = spectral_interpolation_fast(inds_to_include, regressed_time_signal, TR)\\n\\n else:\\n for dim in range(regressed_time_signal.shape[0]):\\n interpolated_time_signal[dim,:] = interpolate(inds_to_include, regressed_time_signal[dim,:], interpolation_method, TR)\\n\\n #Now if necessary, apply additional filterign:\\n if high_pass == False and low_pass == False:\\n\\n filtered_time_signal = interpolated_time_signal\\n\\n else:\\n\\n if high_pass != False and low_pass == False:\\n\\n b, a = imaging_utils.construct_filter('highpass', [high_pass], TR, filter_order)\\n\\n elif high_pass == False and low_pass != False:\\n\\n b, a = imaging_utils.construct_filter('lowpass', [low_pass], TR, filter_order)\\n\\n elif high_pass != False and low_pass != False:\\n\\n b, a = imaging_utils.construct_filter('bandpass', [high_pass, low_pass], TR, filter_order)\\n\\n filtered_time_signal = np.zeros(regressed_time_signal.shape)\\n for dim in range(regressed_time_signal.shape[0]):\\n\\n filtered_time_signal[dim,:] = imaging_utils.apply_filter(b,a,regressed_time_signal[dim,:])\\n\\n final_dvars = dvars(filtered_time_signal, bad_timepoint_inds)\\n\\n #Now set all the undefined timepoints to Nan\\n cleaned_time_signal = filtered_time_signal\\n cleaned_time_signal[:,bad_timepoint_inds] = np.nan\\n\\n output_dict = {}\\n denoising_stats = {}\\n\\n output_dict['cleaned_timeseries'] = cleaned_time_signal\\n\\n denoising_stats['dvars_pre_cleaning'] = initial_dvars\\n denoising_stats['dvars_post_cleaning'] = final_dvars\\n\\n dvars_stats = {}\\n dvars_stats['mean_dvars_pre_cleaning'] = np.mean(initial_dvars[(initial_dvars > 0)])\\n dvars_stats['mean_dvars_post_cleaning'] = np.mean(final_dvars[(final_dvars > 0)])\\n dvars_stats['max_dvars_pre_cleaning'] = np.max(initial_dvars)\\n dvars_stats['max_dvars_post_cleaning'] = np.max(final_dvars)\\n dvars_stats['dvars_remaining_ratio'] = np.mean(final_dvars[(final_dvars > 0)])/np.mean(initial_dvars[(initial_dvars > 0)])\\n dvars_stats['def'] = 'DVARS calculated before any denoising steps (or filtering), and also after.\\\\nBad timepoints not included in any stats.'\\n denoising_stats['dvars_stats.json'] = dvars_stats\\n\\n\\n if type(original_std) != type(None):\\n\\n output_dict['std_before_regression'] = original_std\\n output_dict['std_after_regression'] = post_regression_std\\n\\n output_dict['denoising_stats'] = denoising_stats\\n\\n\\n\\n return output_dict\",\n \"def seasonal_decomposition(strain, mouse, feature, bin_width, period_length):\\n\\n if (not isinstance(strain, int)) or (strain < 0):\\n raise ValueError(\\n 'Strain must be a non-negative integer')\\n if (not isinstance(mouse, int)) or (mouse < 0):\\n raise ValueError(\\n 'Mouse value must be a non-negative integer')\\n if feature not in ALL_FEATURES:\\n raise ValueError(\\n 'Input value must in {\\\"AS\\\", \\\"F\\\", \\\"M_AS\\\", \\\"M_IS\\\", \\\"W\\\", \\\"Distance\\\"}')\\n if (not isinstance(bin_width, int)) or bin_width < 0 or bin_width > 1440:\\n raise ValueError(\\n 'Bin width (minutes) must be a non-negative integer below 1440')\\n if period_length < 0:\\n raise ValueError(\\n 'Peoriod length must be a non-negative integer or float')\\n\\n freq = int(period_length * 60 / bin_width)\\n if feature == \\\"Distance\\\":\\n ts = aggregate_movement(strain=strain, mouse=mouse,\\n bin_width=bin_width)\\n else:\\n ts = aggregate_interval(strain=strain, mouse=mouse,\\n feature=feature, bin_width=bin_width)\\n res = sm.tsa.seasonal_decompose(ts.values, freq=freq, model=\\\"additive\\\")\\n\\n return res\",\n \"def fixdims(var):\\n\\t\\n\\tfor ii in var.dims:\\n\\t\\tkk=ii[:3].lower()\\n\\t\\t\\n\\t\\tif kk == 'lat':\\n\\t\\t\\tvar=var.rename({ii:'lat'})\\n\\t\\t\\t\\n\\t\\tif kk == 'lon':\\n\\t\\t\\tvar=var.rename({ii:'lon'})\\n\\t\\t\\t\\n\\t\\tif kk == 'lev' or kk == 'ple' or kk == 'pre':\\n\\t\\t\\tvar=var.rename({ii:'level'})\\n\\n\\t\\tif kk == 'tim':\\n\\t\\t\\tvar=var.rename({ii:'time'})\\n\\n\\treturn var\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def plot_seaice_trend(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/trends/SIC/',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 trends'\\n\\n\\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\\n if seaice_source == 'nsidc':\\n seaice = seaice * area /250\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = xr.apply_ufunc(scipy.stats.linregress, seaice[seaicename].time.values.astype(float), seaice[seaicename], input_core_dims=[['time'],['time']], vectorize=True, dask='parallelized', output_dtypes=[float]*5, output_core_dims=[[]]*5)\\n if seaice_source =='ecmwf':\\n seaice_m, seaice_b, seaice_r_value, seaice_p_value, seaice_std_err = scipy.stats.linregress(seaice[seaicename].time.values.astype(float), seaice[seaicename])\\n \\n seaice_m = seaice_m * 1e9 * 60 * 60 * 24 * 365\\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\\n # seaice_m = seaice_m*area\\n seaice_m = seaice_m.where(seaice_m != 0)\\n # seaice_m = seaice_m.where(seaice_p_value <= 0.05)\\n max_ = seaice_m.max()\\n min_ = seaice_m.min() \\n # max_ = 1\\n divnorm = TwoSlopeNorm(vmin=min_, vcenter=0, vmax=max_)\\n fig = plt.figure(figsize = (5,5))\\n ax = fig.add_subplot(111, projection = ccrs.SouthPolarStereo())\\n # Plotting\\n contor = ax.contourf(seaice_m.x, seaice_m.y, seaice_m, cmap = 'RdBu', levels = 11, norm = divnorm, transform=ccrs.SouthPolarStereo())\\n ax.coastlines()\\n ax.set_axis_off()\\n cbar = plt.colorbar(contor)\\n cbar.set_label('Trend in SIE (km$^2$ yr$^{-1}$)')\\n plt.title(title)\\n plt.savefig(imagefolder + seaicename + '.pdf')\\n plt.show()\",\n \"def series_to_supervised(data, n_in=1, n_out=1, dropnan=True, stride=None, dates=False, leaks=True):\\n df = pd.DataFrame(data)\\n \\n time = None\\n if 'date' in df.columns:\\n time = 'date'\\n elif 'time' in df.columns:\\n time = 'time'\\n if time != None:\\n df = df.drop([time], axis=1)\\n \\n if 'leak' in df.columns:\\n df = df.drop(['leak'], axis=1) \\n n_vars = df.shape[1]\\n times_column = list()\\n if dates and time != None:\\n times_column = data[time]\\n del data\\n \\n cols, names, pivots = list(), list(), list()\\n \\n # input sequence (t-n, ... t-1)\\n for i in range(n_in, 0, -1):\\n cols.append(df.shift(i))\\n names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\\n\\t# forecast sequence (t, t+1, ... t+n)\\n for i in range(0, n_out):\\n cols.append(df.shift(-i))\\n if i == 0:\\n names += [('var%d(t)' % (j+1)) for j in range(n_vars)]\\n else:\\n names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\\n\\t# put it all together\\n agg = pd.concat(cols, axis=1)\\n \\n agg.columns = names\\n\\n #stride - delete windows\\n if stride != None:\\n indexes_to_drop = list()\\n for i in range(stride, agg.shape[0], stride):\\n print(\\\"index\\\", i)\\n pivots += [i]\\n \\n onset = 0\\n offset = pivots[0]\\n for i in range(0, len(pivots)):\\n print(\\\"onset\\\", onset)\\n print(\\\"offset\\\", offset)\\n to_drop = [ x for x in range(onset,offset)]\\n indexes_to_drop += to_drop\\n try:\\n onset = pivots[i] + 1\\n offset = pivots[i+1]\\n \\n except IndexError:\\n onset = pivots[i] + 1\\n offset = agg.shape[0]\\n to_drop = [ x for x in range(onset,offset)]\\n indexes_to_drop += to_drop\\n \\n \\n \\n print(\\\"indexes_to_drop\\\", indexes_to_drop)\\n \\n agg.drop(df.index[indexes_to_drop], inplace=True)\\n \\\"\\\"\\\"\\n if dates and time!=None:\\n agg[time] = times_column\\n \\\"\\\"\\\" \\n # drop rows with NaN values \\n if dropnan:\\n agg.dropna(inplace=True)\\n \\n\\n return agg\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74530834","0.70475537","0.6324904","0.59645534","0.5937632","0.58018863","0.57699883","0.57024586","0.5577448","0.5530543","0.54834914","0.54797405","0.5413724","0.5400654","0.5268981","0.51579803","0.5137244","0.5122184","0.5121492","0.5113712","0.5081684","0.50614643","0.50353134","0.50346076","0.50281006","0.50122374","0.49842882","0.495423","0.49348593","0.49339175","0.4924001","0.49199128","0.49192458","0.49063665","0.49063665","0.4901688","0.48939288","0.48840037","0.48647884","0.4864266","0.48576108","0.4837941","0.48373562","0.4836774","0.48223403","0.48106667","0.48026472","0.4779808","0.47781143","0.47778067","0.47673413","0.47585538","0.47564587","0.47516078","0.47459483","0.47271854","0.47184357","0.46973425","0.4695794","0.4672637","0.46648479","0.46591318","0.4655102","0.4653882","0.46342698","0.4624153","0.46166974","0.46089825","0.45822838","0.45787424","0.4575104","0.4574311","0.4567557","0.4560179","0.45434222","0.45327342","0.45265415","0.45243895","0.45238733","0.45118982","0.4502001","0.45017534","0.44996032","0.4497857","0.44735342","0.4459282","0.44563812","0.4455388","0.445496","0.44546953","0.44537374","0.44496435","0.44474107","0.444447","0.44438338","0.44431633","0.4438566","0.44364658","0.44295996","0.4428116"],"string":"[\n \"0.74530834\",\n \"0.70475537\",\n \"0.6324904\",\n \"0.59645534\",\n \"0.5937632\",\n \"0.58018863\",\n \"0.57699883\",\n \"0.57024586\",\n \"0.5577448\",\n \"0.5530543\",\n \"0.54834914\",\n \"0.54797405\",\n \"0.5413724\",\n \"0.5400654\",\n \"0.5268981\",\n \"0.51579803\",\n \"0.5137244\",\n \"0.5122184\",\n \"0.5121492\",\n \"0.5113712\",\n \"0.5081684\",\n \"0.50614643\",\n \"0.50353134\",\n \"0.50346076\",\n \"0.50281006\",\n \"0.50122374\",\n \"0.49842882\",\n \"0.495423\",\n \"0.49348593\",\n \"0.49339175\",\n \"0.4924001\",\n \"0.49199128\",\n \"0.49192458\",\n \"0.49063665\",\n \"0.49063665\",\n \"0.4901688\",\n \"0.48939288\",\n \"0.48840037\",\n \"0.48647884\",\n \"0.4864266\",\n \"0.48576108\",\n \"0.4837941\",\n \"0.48373562\",\n \"0.4836774\",\n \"0.48223403\",\n \"0.48106667\",\n \"0.48026472\",\n \"0.4779808\",\n \"0.47781143\",\n \"0.47778067\",\n \"0.47673413\",\n \"0.47585538\",\n \"0.47564587\",\n \"0.47516078\",\n \"0.47459483\",\n \"0.47271854\",\n \"0.47184357\",\n \"0.46973425\",\n \"0.4695794\",\n \"0.4672637\",\n \"0.46648479\",\n \"0.46591318\",\n \"0.4655102\",\n \"0.4653882\",\n \"0.46342698\",\n \"0.4624153\",\n \"0.46166974\",\n \"0.46089825\",\n \"0.45822838\",\n \"0.45787424\",\n \"0.4575104\",\n \"0.4574311\",\n \"0.4567557\",\n \"0.4560179\",\n \"0.45434222\",\n \"0.45327342\",\n \"0.45265415\",\n \"0.45243895\",\n \"0.45238733\",\n \"0.45118982\",\n \"0.4502001\",\n \"0.45017534\",\n \"0.44996032\",\n \"0.4497857\",\n \"0.44735342\",\n \"0.4459282\",\n \"0.44563812\",\n \"0.4455388\",\n \"0.445496\",\n \"0.44546953\",\n \"0.44537374\",\n \"0.44496435\",\n \"0.44474107\",\n \"0.444447\",\n \"0.44438338\",\n \"0.44431633\",\n \"0.4438566\",\n \"0.44364658\",\n \"0.44295996\",\n \"0.4428116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5721398"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":19873,"cells":{"query":{"kind":"string","value":"Input is a leveldependent variable mv and a level slev to select. slev is an instance of udunits thus it has a value and a units attribute. This function will create and return a new variable mvs without a level axis. The values of mvs correspond to the values of mv with level set to slev. Interpolation isn't done yet, but is planned !"},"document":{"kind":"string","value":"def select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\n else:\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\n if ids is None or len(ids)==0:\n ig = len(levax)-1\n else:\n ig = ids[0][0]\n # Crude fist cut: don't interpolate, just return a value\n if levax == mv.getAxisList()[0]:\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\n elif levax == mv.getAxisList()[1]:\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\n else:\n print \"ERROR, select_lev() does not support level axis except as first or second dimentions\"\n return None\n return mvs"},"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 levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def uvsChangeLevel(mot, oldlev, newlev):\n\n ####################\n # TODO - part 3\n diff = abs(oldlev - newlev)\n if oldlev > newlev:\n factor = diff * 2\n elif oldlev < newlev:\n factor = 1 / (diff * 2)\n else:\n factor = 1\n\n nmot = mot * factor\n ####################\n return nmot","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def scale_u_and_v(u, v, level, pyr):\n # TODO: Your code here\n image = pyr[level-1]\n expanded_u = ps4.expand_image(u)\n expanded_v = ps4.expand_image(v)\n scaled_u = expanded_u * 2\n scaled_v = expanded_v * 2\n if image.shape[0] == scaled_u.shape[0] - 1:\n scaled_u = scaled_u[:-1, :]\n if image.shape[1] == scaled_u.shape[1] - 1:\n scaled_u = scaled_u[:, :-1]\n if image.shape[0] == scaled_v.shape[0] - 1:\n scaled_v = scaled_v[:-1, :]\n if image.shape[1] == scaled_v.shape[1] - 1:\n scaled_v = scaled_v[:, :-1]\n return scaled_u, scaled_v","def heightvar( mv ):\n if mv is None: return None\n lev_axis = levAxis(mv)\n heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km\n heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,\n attributes={'units':\"km\"} )\n return heightmv","def _msqrd_v_l_l(s, t, model: SingleRhNeutrinoModel, ml: float):\n mx = model.mx\n u = 0.5 * np.tan(2 * model.theta)\n return (\n -2\n * u**2\n * GF**2\n * (\n 2 * ml**4 * (1 + 4 * SW**2 + 8 * SW**4)\n + 2 * ml**2 * (mx**2 - s - 2 * (1 + 4 * SW**2 + 8 * SW**4) * t)\n + (1 + 4 * SW**2 + 8 * SW**4)\n * (s**2 + 2 * s * t + 2 * t**2 - mx**2 * (s + 2 * t))\n )\n )","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def test_set_uv(self):\n s = State(substance=\"water\")\n s.uv = Q_(1013250.0, \"J/kg\"), Q_(0.4772010021515822, \"m**3/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.uv[0], Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.uv[1], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\n return float(-np.sqrt(self.periods_in_a_year) *\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))","def vol_from_var_func(self, level: float = 0.95, months_from_last: int = None,\n from_date: dt.date = None, to_date: dt.date = None, interpolation: str = 'lower',\n drift_adjust: bool = False, periods_in_a_year_fixed: int = None) -> float:\n earlier, later = self.calc_range(months_from_last, from_date, to_date)\n if periods_in_a_year_fixed:\n time_factor = periods_in_a_year_fixed\n else:\n fraction = (later - earlier).days / 365.25\n how_many = self.tsdf.loc[earlier:later].count(numeric_only=True)\n time_factor = how_many / fraction\n if drift_adjust:\n return float((-np.sqrt(time_factor) / ss.norm.ppf(level)) *\n (self.var_down_func(level, months_from_last, from_date, to_date, interpolation) -\n self.tsdf.loc[earlier:later].pct_change().sum() /\n len(self.tsdf.loc[earlier:later].pct_change())))\n else:\n return float(-np.sqrt(time_factor) *\n self.var_down_func(level, months_from_last, from_date, to_date,\n interpolation) / ss.norm.ppf(level))","def test_set_vu(self):\n s = State(substance=\"water\")\n s.vu = Q_(0.4772010021515822, \"m**3/kg\"), Q_(1013250.0, \"J/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vu[0], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vu[1], Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def test_set_vs(self):\n s = State(substance=\"water\")\n s.vs = Q_(0.4772010021515822, \"m**3/kg\"), Q_(3028.9867985920914, \"J/(kg*K)\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vs[0], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vs[1], Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","async def uv_level(self, uvi):\n\n if uvi is None:\n return \"no-data\"\n\n if uvi >= 10.5:\n return self._translations[\"uv\"][\"extreme\"]\n if uvi >= 7.5:\n return self._translations[\"uv\"][\"very-high\"]\n if uvi >= 5.5:\n return self._translations[\"uv\"][\"high\"]\n if uvi >= 2.5:\n return self._translations[\"uv\"][\"moderate\"]\n if uvi > 0:\n return self._translations[\"uv\"][\"low\"]\n \n return self._translations[\"uv\"][\"none\"]","def _newMV(self, newValue=None, *, dtype: np.dtype = None) -> 'MultiVector':\n if newValue is None and dtype is None:\n raise TypeError(\"Must specify either a type or value\")\n\n return self.__class__(self.layout, newValue, dtype=dtype)","def volume(mid, vols):\n bt = mid.ticks_per_beat\n trk = MidiTrack()\n trk.name = \"Volume variation\"\n trk.append(Message(\"control_change\",\n control=7,\n time=0,\n value=vols[0]))\n\n for i, vol in enumerate(vols):\n trk.append(Message(\"control_change\",\n control=7,\n time=bt,\n value=vol))\n\n mid.tracks.append(trk)\n return mid","def update_units(self):\n unit_var_value = self.view.vars['unit'].get()\n if unit_var_value == 'm3ph':\n self.minran_u_label.config(text='m³/h')\n self.maxran_u_label.config(text='m³/h')\n self.points_tview.heading('vflow', text='Przepływ [m³/h]', anchor=tk.CENTER)\n elif unit_var_value == 'lps':\n self.minran_u_label.config(text='l/s')\n self.maxran_u_label.config(text='l/s')\n self.points_tview.heading('vflow', text='Przepływ [l/s]', anchor=tk.CENTER)\n self.view.vars['pump_eff_min'].convert_unit(unit_var_value)\n self.view.vars['pump_eff_max'].convert_unit(unit_var_value)\n self.view.vars['pump_characteristic'].convert_unit(unit_var_value)","def rkm_MS_pathvar(models, s_span, X):\n W_dst_var=np.ndarray(models.shape[0],np.float64)\n for i in range(models.shape[0]):\n W = models[i,:,:]\n res = W[1:,:]-W[0:-1,:]\n W_dst=np.linalg.norm(res, axis=1)\n W_dst_var[i] = np.var(W_dst)\n\n return W_dst_var","def interp_vel(z, u, v, sva, zi, pPsva, return_diagnostics=False):\n\n svac, ir, ic, w1, w2 = interp_quantity(z, sva, zi, pPsva, True)\n\n um = u[ir, ic]\n vm = v[ir, ic]\n svam = sva[ir, ic]\n\n theta = np.arctan2(vm[:, 0] - vm[:, 1], um[:, 0] - um[:, 1])\n\n ur = np.empty_like(um)\n ur[:, 0] = um[:, 0]*np.cos(theta) + vm[:, 0]*np.sin(theta)\n ur[:, 1] = um[:, 1]*np.cos(theta) + vm[:, 1]*np.sin(theta)\n vr = -um[:, 0]*np.sin(theta) + vm[:, 0]*np.cos(theta)\n\n sc = (ur[:, 0]*(svac - svam[:, 1]) + ur[:, 1]*(svam[:, 0] - svac))\n sc /= (svam[:, 0] - svam[:, 1])\n\n uc = sc*np.cos(theta) - vr*np.sin(theta)\n vc = sc*np.sin(theta) + vr*np.cos(theta)\n\n if return_diagnostics:\n return uc, vc, ir, ic, w1, w2\n else:\n return uc, vc","def _msqrd_l_u_d(s, t, model: SingleRhNeutrinoModel, mu, md, ml, ckm):\n mx = model.mx\n u = 0.5 * np.tan(2 * model.theta)\n return (\n 16.0\n * GF**2\n * (ml**2 + mx**2 - s - t)\n * (s + t - mu**2 - md**2)\n * u**2\n * abs(ckm) ** 2\n )","def _v_to_lbs(slope,offset,V):\n return V # without slope and offset data, keep this a stub","def duv(self, u, v):\n return np.column_stack(\n [_.ev(u, v, dx=1, dy=1) for _ in (self.splz, self.sply, self.splx)])","def test_set_sv(self):\n s = State(substance=\"water\")\n s.sv = Q_(3028.9867985920914, \"J/(kg*K)\"), Q_(0.4772010021515822, \"m**3/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.sv[0], Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.sv[1], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def randomMV(\n layout, min=-2.0, max=2.0, grades=None, mvClass=MultiVector,\n uniform=None, n=1, normed=False):\n\n if n > 1:\n # return many multivectors\n return [randomMV(layout=layout, min=min, max=max, grades=grades,\n mvClass=mvClass, uniform=uniform, n=1,\n normed=normed) for k in range(n)]\n\n if uniform is None:\n uniform = np.random.uniform\n\n if grades is None:\n mv = mvClass(layout, uniform(min, max, (layout.gaDims,)))\n else:\n if isinstance(grades, int):\n grades = [grades]\n newValue = np.zeros((layout.gaDims,))\n for i in range(layout.gaDims):\n if layout.gradeList[i] in grades:\n newValue[i] = uniform(min, max)\n mv = mvClass(layout, newValue)\n\n if normed:\n mv = mv.normal()\n\n return mv","def voltmeter_settings(self, scalefactor, offset):\n if scalefactor is not None and offset is not None:\n if self._request('SM', str(scalefactor), str(offset))[0]:\n return scalefactor, offset\n else:\n done, data = self._request('GM')\n if done:\n return int(data[0]), int(data[1])\n\n raise EvseError","def modality(v):\n \n s = st.skew(vel, bias=False)\n k = st.kurtosis(vel, bias=False)\n m = (1+s**2)/(3+k**2)\n return s, k, m","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def import_velocity(self,fname,units='m'):\n velmod=pd.read_csv(fname,sep=' ',names=['depth','vp','vs','rho'])\n \n if units =='m':\n \n velmod.depth=velmod.depth/1000\n velmod.vp=velmod.vp/1000\n velmod.vs=velmod.vs/1000\n velmod.rho=velmod.rho/1000 \n \n self.velocity_model['depth']=velmod.depth.values\n self.velocity_model['vp']=velmod.vp.values\n self.velocity_model['vs']=velmod.vs.values\n self.velocity_model['rho']=velmod.rho.values","def svd(matrix):\n u = None\n s = None\n v = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return u, s, v","def gmv(cov):\n n = cov.shape[0]\n return msr(0, np.repeat(1, n), cov)","def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\n self.v=initial_v\n self.v_select=v_select\n self.max_dev_semitones=max_dev_semitones","def mlv(self,vStart,diff):\n vCurr=vStart\n while diff>0.0001 :\n \"\"\"CHANGE THE ABOVE TO BE AN ARGUMENT\"\"\"\n likeCurr=self.margprobseq(v=vCurr)\n vUp=vCurr+diff\n vDown=vCurr-diff\n if (vDown < 0):\n vDown = 0\n likeUp=self.margprobseq(v=vUp)\n likeDown=self.margprobseq(v=vDown)\n if likeDown>likeCurr :\n vCurr=vDown\n vUp=vCurr+diff\n vDown=vCurr-diff\n elif likeUp>likeCurr :\n vCurr=vUp\n vUp=vCurr+diff\n vDown=vCurr-diff\n else :\n diff=(diff/2.0) \n return vCurr","def duu(self, u, v):\n return np.column_stack(\n [_.ev(u, v, dx=2) for _ in (self.splz, self.sply, self.splx)])","def test_set_vp(self):\n s = State(substance=\"water\")\n s.vp = Q_(0.4772010021515822, \"m**3/kg\"), Q_(101325.0, \"Pa\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vp[0], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vp[1], Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore\n s.vp = Q_(3.189303132125469, \"m**3/kg\"), Q_(101325.0, \"Pa\")\n assert np.isclose(s.T, Q_(700.9882316847855, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vp[0], Q_(3.189303132125469, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vp[1], Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.u, Q_(3013250, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(8623.283568815832, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(3.189303132125469, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(3336406.139862406, \"J/kg\")) # type: ignore\n assert s.x is None","def set_channel_v_unit(self , channel_v_unit:float): \n self.__channel_v_unit = channel_v_unit","def gradeInvol(self) -> 'MultiVector':\n\n signs = np.power(-1, self.layout.gradeList)\n\n newValue = signs * self.value\n\n return self._newMV(newValue)","def mults(self, s):\n prod = Vector.fromSequence(self.mV)\n prod.scale(s)\n return prod","def dv(self, u, v):\n return np.column_stack(\n [_.ev(u, v, dy=1) for _ in (self.splz, self.sply, self.splx)])","def reduce2scalar( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def sm_set_Vsource(self,level,compliance):\n self.sm.set_Vsource()\n self.sm.set_source_level(level)\n self.sm.set_compliance_level(compliance)\n self.sm_output_on()","def du(self, u, v):\n return np.column_stack(\n [_.ev(u, v, dx=1) for _ in (self.splz, self.sply, self.splx)])","def my_mvn(mu_x, mu_y, r):\n return multivariate_normal([mu_x, mu_y], [[r, 0], [0, r]])","def scw_loss(phi, v, m):\n return max(0, phi * np.sqrt(v) - m)","def __idiv__(self,value):\n if isinstance(value,LiveStat):\n raise Exception (\"Ratio of Statistics is not supported\")\n else:\n if self.vmin is not None:\n # mu(s x) = 1/N sum s x = s/N sum x\n self.vmean /= value\n if value < 0:\n m = self.vmin\n M = self.vmax\n self.vmin = M/value\n self.vmax = m/value\n else:\n self.vmin /= value\n self.vmax /= value\n self.vsum /= value\n # vm2(s x) = sum (s x - mu(s x))^2 = sum (s x - s mu(x))^2 = sum s^2 (x - mu(x))^2 = s^2 sum (x - mu(x))^2 = s^2 vm^2\n self.vm2 /= value*value\n print (\"div Missing: M3 and M4\")\n self.dirty = True\n return self","def Distribution_Local_galaxy_DM(self, dmv, vpar):\n val = vpar[0] * np.exp(-np.power((dmv - vpar[1]) / vpar[2], 2.)) \\\n + vpar[3] * np.exp(-np.power((dmv - vpar[4]) / vpar[5], 2.))\n return val","def reparametrize(self, mu, logvar):\n std = logvar.div(2).exp()\n eps = torch.Tensor(std.data.new(std.size()).normal_())\n return mu + std * eps","def __init__(self, level_model: LevelModel, level_low_limit: int, level_high_limit: int):\n self.level_model = level_model\n self.level_min = min(level_model.level_bounds[0], level_model.level_bounds[1])\n self.level_max = max(level_model.level_bounds[0], level_model.level_bounds[1])\n self.level_low_limit = level_low_limit\n self.level_high_limit = level_high_limit\n self.x_axis = ''\n self.y_axis = ''\n self.period = ''\n self.current_level = 'NONE'\n self.bs_class = 'alert-success'","def vol_handler(bot, update, args):\n if len(args) == 1:\n if args[0].isdigit():\n return update.message.reply_text(vol_set(args[0]))\n elif args[0] == 'mute':\n return update.message.reply_text(vol_mute())\n\n return update.message.reply_text('Syntax: /v [mute|<level(0-100)>]')","def width_v_v_v(model: SingleRhNeutrinoModel, genv: Generation):\n mx = model.mx\n u = 0.5 * np.tan(2 * model.theta)\n w = parameters.GF**2 * mx**5 / (768 * np.pi**3) * u**2\n pre = 2 if genv == model.gen else 1.0\n return pre * w","def dvv(self, u, v):\n return np.column_stack(\n [_.ev(u, v, dy=2) for _ in (self.splz, self.sply, self.splx)])","def velocity(self,level='cell'):\r\n\r\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\r\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \r\n vels = []\r\n vols = self.last_sim_step_volume()\r\n \r\n if level=='cell':\r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n return vels\r\n \r\n elif level=='section': \r\n # 先计算每一个元胞的再按照volume计算加权平均\r\n \r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2)) \r\n\r\n \r\n # 将速度按照volume加权平均\r\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\r\n sum_vol = sum(vols)\r\n if sum_vol == 0:\r\n avg_vel = 0\r\n else:\r\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\r\n \r\n return avg_vel\r\n\r\n\r\n else :\r\n raise ValueError('no such level for collecting data')","def a_sv(self, phi, tl, psi_l, z, m):\n\t\tif self.MMAX*((self.TH - tl)/(self.TH - self.TW)*(1. - self.ALPHA_2) + self.ALPHA_2) > m and (1. - self.K*(tl - self.TOPT)**2.) >0:\n\t\t\treturn (self.AMMAX*(1. - self.K*(tl - self.TOPT)**2.) - self.r_dv(phi, tl))*self.f_m(z, m, tl)*self.a_psilc02(psi_l)\n\t\telse:\n\t\t\treturn 0.","def a_sv(self, phi, tl, psi_l, z, m):\n\t\tif self.mmax*((self.TH - tl)/(self.TH - self.TW)*(1. - self.ALPHA_2) + self.ALPHA_2) > m and (1. - self.K*(tl - self.TOPT)**2.) >0:\n\t\t\treturn (self.AMMAX*(1. - self.K*(tl - self.TOPT)**2.) - self.r_dv(phi, tl))*self.f_m(z, m, tl)*self.a_psilc02(psi_l)\n\t\telse:\n\t\t\treturn 0.","def addVariable(\n self, desmptr_name, name=None, value=None, lower=None, upper=None, scale=1.0, rows=None, cols=None, dh=0.001\n ):\n # if name is none, use the desptmr name instead\n if name is not None:\n dvName = name\n else:\n dvName = desmptr_name\n\n if dvName in self.DVs.keys():\n raise Error(\"Design variable name \" + dvName + \" already in use.\")\n\n # find the design parm index in ESP\n if desmptr_name not in self.csmDesPmtrs.keys():\n raise Error(\n 'User specified design parameter name \"' + desmptr_name + '\" which was not found in the CSM file'\n )\n\n csmDesPmtr = self.csmDesPmtrs[desmptr_name]\n numRow = csmDesPmtr.numRow\n numCol = csmDesPmtr.numCol\n self._validateRowCol(rows, cols, numRow, numCol, dvName)\n\n if rows is None:\n rows = range(1, numRow + 1)\n if cols is None:\n cols = range(1, numCol + 1)\n # if value is None, get the current value from ESP\n if value is None:\n value = self._csmToFlat(csmDesPmtr.baseValue, rows, cols, numRow, numCol)\n else:\n # validate that it is of correct length\n if len(value) != len(rows) * len(cols):\n raise Error(\n \"User-specified DV value does not match the dimensionality\"\n + \"of the ESP despmtr. Value is of length \"\n + str(len(value))\n + \" but should be \"\n + str(len(rows) * len(cols))\n )\n\n # check that upper and lower are correct length\n\n if upper is not None:\n if isinstance(upper, (float, int)):\n upper = np.ones((len(rows) * len(cols),)) * upper\n if len(upper) != len(rows) * len(cols):\n raise Error(\n \"User-specified DV upper bound does not match the dimensionality\"\n + \"of the ESP despmtr. Upper is of length \"\n + str(len(upper))\n + \" but should be \"\n + str(len(rows) * len(cols))\n )\n\n if lower is not None:\n if isinstance(lower, (float, int)):\n lower = np.ones((len(rows) * len(cols),)) * lower\n if len(lower) != len(rows) * len(cols):\n raise Error(\n \"User-specified DV lower bound does not match the dimensionality\"\n + \"of the ESP despmtr. lower is of length \"\n + str(len(lower))\n + \" but should be \"\n + str(len(rows) * len(cols))\n )\n nVal = len(rows) * len(cols)\n\n # add an entry in the global DV list to make finite differencing load balancing easy\n globalStartInd = len(self.globalDVList)\n for localInd in range(nVal):\n self.globalDVList.append((dvName, localInd))\n\n self.DVs[dvName] = espDV(csmDesPmtr, dvName, value, lower, upper, scale, rows, cols, dh, globalStartInd)","def spddir_to_uv(wspd, wdir):\n if isinstance(wspd, list) or isinstance(wdir, list):\n wspd = np.array(wspd, dtype=float)\n wdir = np.array(wdir, dtype=float)\n\n rad = 4.0 * np.arctan(1) / 180.0\n u = -wspd * np.sin(rad * wdir)\n v = -wspd * np.cos(rad * wdir)\n\n # If the speed is zero, then u and v should be set to zero (not NaN)\n if hasattr(u, \"__len__\"):\n u[np.where(wspd == 0)] = 0\n v[np.where(wspd == 0)] = 0\n elif wspd == 0:\n u = float(0)\n v = float(0)\n\n return np.round(u, 3), np.round(v, 3)","def get_level_mag(slide, level):\n return level_mags(slide)[level]","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","async def _design_lvl_shift_inv_pun(self, pseg: int, nseg: int, inv_nseg: int, out_inv_m: int,\n fanout: float,\n pinfo: Any, tbm_specs: Dict[str, Any], has_rst, dual_output,\n vin, vout) -> Tuple[int, int]:\n inv_beta = get_tech_global_info('bag3_digital')['inv_beta']\n tb_params = self._get_full_tb_params()\n # Use a binary iterator to find the PMOS size\n load_seg = nseg + (pseg if has_rst else 0)\n inv_pseg_nom = int(np.round(inv_beta * load_seg / ((1 + inv_beta) * fanout)))\n inv_pseg_nom = 1 if inv_pseg_nom == 0 else inv_pseg_nom\n iterator = BinaryIterator(-inv_pseg_nom + 1, 0)\n err_best = float('inf')\n inv_in_nseg, inv_in_pseg = self._size_input_inv_for_fanout(inv_pseg_nom, inv_nseg, pseg,\n nseg, fanout, has_rst)\n all_corners = get_tech_global_info('bag3_digital')['signoff_envs']['all_corners']\n\n while iterator.has_next():\n pseg_off = iterator.get_next()\n inv_pseg = inv_pseg_nom + pseg_off\n dut_params = self._get_lvl_shift_params_dict(pinfo, pseg, nseg, inv_pseg, inv_nseg,\n inv_in_nseg, inv_in_pseg, out_inv_m,\n has_rst, dual_output)\n dut = await self.async_new_dut('lvshift', STDCellWrapper, dut_params)\n\n err_worst = -1 * float('Inf')\n for env in all_corners['envs']:\n tbm_specs['sim_envs'] = [env]\n tbm_specs['sim_params']['vdd_in'] = all_corners[vin][env]\n tbm_specs['sim_params']['vdd'] = all_corners[vout][env]\n tbm = cast(CombLogicTimingTB, self.make_tbm(CombLogicTimingTB, tbm_specs))\n sim_results = await self.async_simulate_tbm_obj(f'sim_inv_pseg_{inv_pseg}_{env}',\n dut, tbm, tb_params)\n tdr_cur, tdf_cur = CombLogicTimingTB.get_output_delay(sim_results.data, tbm.specs,\n 'in',\n 'out', False, in_pwr='vdd_in',\n out_pwr='vdd')\n\n '''\n plt.figure()\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['in'].flatten(), 'b')\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['inb_buf'].flatten(), 'g')\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['in_buf'].flatten(), 'r')\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['midn'].flatten(), 'k')\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['midp'].flatten(), 'c')\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['out'].flatten(), 'm')\n plt.legend(['in', 'inb_buf', 'in_buf', 'midn', 'midp', 'out'])\n plt.title(f'pseg_off: {pseg_off}, pseg: {inv_pseg}, nseg: {inv_nseg-pseg_off}, fanout: {fanout}')\n plt.show(block=False)\n '''\n\n # Error checking\n if math.isinf(np.max(tdr_cur)) or math.isinf(np.max(tdf_cur)):\n raise ValueError(\"Got infinite delay!\")\n if np.min(tdr_cur) < 0 or np.min(tdf_cur) < 0:\n raise ValueError(\"Got negative delay.\")\n\n err_cur = np.abs(tdr_cur[0] - tdf_cur[0])\n if err_cur > err_worst:\n err_worst = err_cur\n worst_env = env\n tdr = tdr_cur[0]\n tdf = tdf_cur[0]\n\n '''\n print(f'iter: {inv_pseg}')\n print(f'env: {worst_env}, tdr: {tdr}, tdf: {tdf}')\n breakpoint()\n '''\n\n if tdr < tdf:\n iterator.down(tdr - tdf, False)\n else:\n iterator.up(tdr - tdf, False)\n\n err_abs = np.abs(tdr - tdf)\n if err_abs < err_best:\n err_best = err_abs\n iterator.save_info(pseg_off)\n\n pseg_off = iterator.get_last_save_info()\n pseg_off = 0 if pseg_off is None else pseg_off # Should only hit this case if inv_pseg_nom = 1\n inv_pseg = inv_pseg_nom + pseg_off\n\n return inv_pseg, inv_nseg - 0 * pseg_off","def create_follicle_uv(source_object, u_pos, v_pos):\n result = _create_follicle(source_object, uv_position = [u_pos, v_pos])\n return result","def getdviolvar(self,whichsol_,sub,viol): # 3\n if not isinstance(whichsol_,soltype): raise TypeError(\"Argument whichsol has wrong type\")\n num_ = None\n if num_ is None:\n num_ = len(sub)\n elif num_ != len(sub):\n raise IndexError(\"Inconsistent length of array sub\")\n if num_ is None: num_ = 0\n if sub is None: raise TypeError(\"Invalid type for argument sub\")\n if sub is None:\n sub_ = None\n else:\n try:\n sub_ = memoryview(sub)\n except TypeError:\n try:\n _tmparr_sub = array.array(\"i\",sub)\n except TypeError:\n raise TypeError(\"Argument sub has wrong type\")\n else:\n sub_ = memoryview(_tmparr_sub)\n \n else:\n if sub_.format != \"i\":\n sub_ = memoryview(array.array(\"i\",sub))\n \n if viol is None: raise TypeError(\"Invalid type for argument viol\")\n _copyback_viol = False\n if viol is None:\n viol_ = None\n else:\n try:\n viol_ = memoryview(viol)\n except TypeError:\n try:\n _tmparr_viol = array.array(\"d\",viol)\n except TypeError:\n raise TypeError(\"Argument viol has wrong type\")\n else:\n viol_ = memoryview(_tmparr_viol)\n _copyback_viol = True\n else:\n if viol_.format != \"d\":\n viol_ = memoryview(array.array(\"d\",viol))\n _copyback_viol = True\n if viol_ is not None and len(viol_) != (num_):\n raise ValueError(\"Array argument viol has wrong length\")\n res = self.__obj.getdviolvar(whichsol_,num_,sub_,viol_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _copyback_viol:\n viol[:] = _tmparr_viol","def __init__(self, m,r,v):\n self.m = m\n self.r = r\n self.v = v\n self.rv = np.array([r,0,0,v])","def wind_uv_to_spd(U, V):\n WSPD = np.sqrt(np.square(U) + np.square(V))\n return WSPD","def vi2ev(v,mu):\n return 0.5*mu*mp*v**2/eV2J","def sigma2w_lenschow(velo_sel):\n\n sigma2_w = np.nanvar(velo_sel[:]) # - np.nanvar(velo_error_sel[:]) --> negative values, TBD\n my_acf_norm = acf_fast_normalized(velo_sel[:])\n\n # Robustly fit linear model with RANSAC algorithm\n ransac = linear_model.RANSACRegressor()\n x = np.empty([6, 2])\n x[:, 0] = 1\n x[:, 1] = np.arange(1, 7, 1)\n ransac.fit(x, np.multiply(my_acf_norm[1:7], sigma2_w))\n line_x = np.empty([7, 2])\n line_x[:, 0] = 1\n line_x[:, 1] = np.arange(0, 7, 1)\n line_y_ransac = ransac.predict(line_x)\n # if unbiased variance less than 'biased' variance, no significant amount of noise --> used 'biased' variance\n if line_y_ransac[0] < sigma2_w:\n velo_var = line_y_ransac[0]\n else:\n velo_var = sigma2_w\n\n return velo_var","def getpviolvar(self,whichsol_,sub,viol): # 3\n if not isinstance(whichsol_,soltype): raise TypeError(\"Argument whichsol has wrong type\")\n num_ = None\n if num_ is None:\n num_ = len(sub)\n elif num_ != len(sub):\n raise IndexError(\"Inconsistent length of array sub\")\n if num_ is None: num_ = 0\n if sub is None: raise TypeError(\"Invalid type for argument sub\")\n if sub is None:\n sub_ = None\n else:\n try:\n sub_ = memoryview(sub)\n except TypeError:\n try:\n _tmparr_sub = array.array(\"i\",sub)\n except TypeError:\n raise TypeError(\"Argument sub has wrong type\")\n else:\n sub_ = memoryview(_tmparr_sub)\n \n else:\n if sub_.format != \"i\":\n sub_ = memoryview(array.array(\"i\",sub))\n \n if viol is None: raise TypeError(\"Invalid type for argument viol\")\n _copyback_viol = False\n if viol is None:\n viol_ = None\n else:\n try:\n viol_ = memoryview(viol)\n except TypeError:\n try:\n _tmparr_viol = array.array(\"d\",viol)\n except TypeError:\n raise TypeError(\"Argument viol has wrong type\")\n else:\n viol_ = memoryview(_tmparr_viol)\n _copyback_viol = True\n else:\n if viol_.format != \"d\":\n viol_ = memoryview(array.array(\"d\",viol))\n _copyback_viol = True\n if viol_ is not None and len(viol_) != (num_):\n raise ValueError(\"Array argument viol has wrong length\")\n res = self.__obj.getpviolvar(whichsol_,num_,sub_,viol_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _copyback_viol:\n viol[:] = _tmparr_viol","def test_set_vT(self):\n s = State(substance=\"water\")\n s.vT = Q_(1.801983936953226, \"m**3/kg\"), Q_(400.0, \"K\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vT[1], Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.vT[0], Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(2547715.3635084038, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(7496.2021523754065, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cp, Q_(2009.2902478486988, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cv, Q_(1509.1482452129906, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(2730301.3859201893, \"J/kg\")) # type: ignore\n assert s.x is None","def test_set_vh(self):\n s = State(substance=\"water\")\n s.vh = Q_(0.4772010021515822, \"m**3/kg\"), Q_(1061602.391543017, \"J/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vh[0], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vh[1], Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def reparametrize(self, mu, log_var):\n eps = to_var(torch.randn(mu.size(0), mu.size(1)))\n z = mu + eps * torch.exp(0.5 * log_var) # 0.5 to convert var to std\n return z","def get_velocity_sink(strength, xs, ys, X, Y):\r\n u = strength / (2 * math.pi) * (X - xs) / ((X - xs)**2 + (Y - ys)**2)\r\n v = strength / (2 * math.pi) * (Y - ys) / ((X - xs)**2 + (Y - ys)**2)\r\n \r\n return u, v","def doParametersOfInterest(self):\n ''' ref : physicsmodel -> rvf\n self.modelBuilder.out.var(\"MH\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\n self.modelBuilder.out.var(\"MH\").setConstant(False)\n '''\n\n self.modelBuilder.doVar(\"mu[0,0,1000]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doVar(\"Fvbf[0,0,1]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu,Fvbf\")\n self.modelBuilder.doVar(\"\")\n self.modelBuilder.factory_('expr::ggH_s_func(\"(@0-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_b_func(\"(1-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\"sqrt(@0)*(1.-@1)\", mu,Fvbf)')\n\n self.modelBuilder.factory_('expr::vbfH_s_func(\"(@0-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\"(1-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\"sqrt(@0)*(@1)\", mu,Fvbf)')","def normalize_zoomlvl(lvl):\n if lvl < gMinZoomLevel:\n return gMinZoomLevel\n elif lvl > gMaxZoomLevel:\n return gMaxZoomLevel\n else:\n return lvl - gMinZoomLevel","def test_velocity(self):\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\n # r must contain 2 elements, otherwise the density and pressure are nan\n r = np.array([0.7, 0.8])\n t = 6.25e-6\n solrt = sol(r, t)\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def set_variables(self,dv,scale=False):\n\n if type(dv) == np.ndarray:\n dv = dv.tolist()\n\n var_list = self.get_variables()\n\n for ivar, var in enumerate(var_list):\n if type(dv[0]) == Variable:\n var.value = dv[ivar].value * var.scaling if scale else dv[ivar].value\n else:\n value = dv.pop(0)\n var.value = value * var.scaling if scale else value\n\n # Make sure the coupled variables get set too\n self._enforce_coupling()","def subvs2(vis=None, outputvis=None, timerange='', spw='',\n mode='linear', subtime1='', subtime2='',\n smoothaxis='time', smoothtype='flat', smoothwidth='5',\n splitsel=True, reverse=False, overwrite=False):\n # check the visbility ms\n casalog.post('input parameters:')\n casalog.post('vis: ' + vis)\n casalog.post('outputvis: ' + outputvis)\n if mode not in ['linear']:\n casalog.post('smoothaxis: ' + smoothaxis)\n casalog.post('smoothtype: ' + smoothtype)\n casalog.post('smoothwidth: ' + str(smoothwidth))\n if not outputvis or outputvis.isspace():\n raise ValueError('Please specify outputvis')\n\n if os.path.exists(outputvis):\n if overwrite:\n print(\"The already existing output measurement set will be updated.\")\n else:\n raise ValueError(\"Output MS {} already exists - will not overwrite.\".format(outputvis))\n else:\n if not splitsel:\n shutil.copytree(vis, outputvis)\n else:\n ms_in.open(vis, nomodify=True)\n ms_in.split(outputvis, spw=spw, time=timerange, whichcol='DATA')\n ms_in.close()\n\n if timerange and (type(timerange) == str):\n [btimeo, etimeo] = timerange.split('~')\n btimeosec = qa.getvalue(qa.convert(qa.totime(btimeo), 's'))\n etimeosec = qa.getvalue(qa.convert(qa.totime(etimeo), 's'))\n timebinosec = etimeosec - btimeosec\n if timebinosec < 0:\n raise Exception('Negative timebin! Please check the \"timerange\" parameter.')\n casalog.post('Selected timerange: ' + timerange + ' as the time for UV subtraction.')\n else:\n casalog.post('Output timerange not specified, using the entire timerange')\n\n if spw and (type(spw) == str):\n spwlist = spw.split(';')\n else:\n casalog.post('spw not specified, use all frequency channels')\n\n # read the output data\n\n datams.open(outputvis, nomodify=False)\n\n datamsmd.open(outputvis)\n spwinfod = datams.getspectralwindowinfo()\n spwinfok = spwinfod.keys()\n spwinfok = sorted(spwinfok, key=int)\n spwinfol = [spwinfod[k] for k in spwinfok]\n for s, spi in enumerate(spwinfol):\n print('processing spectral window {}'.format(spi['SpectralWindowId']))\n datams.selectinit(reset=True)\n staql = {'time': '', 'spw': ''}\n if not splitsel:\n # outputvis is identical to input visibility, do the selection\n if timerange and (type(timerange == str)):\n staql['time'] = timerange\n if spw and (type(spw) == str):\n staql['spw'] = spwlist[s]\n if not spw and not timerange:\n # data selection is not made\n print('selecting all spws and times')\n staql['spw'] = str(spi['SpectralWindowId'])\n else:\n # outputvis is splitted, selections have already applied, select all the data\n print('split the selected spws and times')\n staql['spw'] = str(spi['SpectralWindowId'])\n datams.msselect(staql)\n orec = datams.getdata(['data', 'time', 'axis_info'], ifraxis=True)\n npol, nchan, nbl, ntim = orec['data'].shape\n print('dimension of output data', orec['data'].shape)\n casalog.post('Number of baselines: ' + str(nbl))\n casalog.post('Number of spectral channels: ' + str(nchan))\n casalog.post('Number of time pixels: ' + str(ntim))\n\n try:\n if mode == 'linear':\n # define and check the background time ranges\n if subtime1 and (type(subtime1) == str):\n [bsubtime1, esubtime1] = subtime1.split('~')\n bsubtime1sec = qa.getvalue(qa.convert(qa.totime(bsubtime1), 's'))\n esubtime1sec = qa.getvalue(qa.convert(qa.totime(esubtime1), 's'))\n timebin1sec = esubtime1sec - bsubtime1sec\n if timebin1sec < 0:\n raise Exception('Negative timebin! Please check the \"subtime1\" parameter.')\n casalog.post('Selected timerange 1: ' + subtime1 + ' as background for uv subtraction.')\n else:\n raise Exception('Please enter at least one timerange as the background')\n if subtime2 and (type(subtime2) == str):\n [bsubtime2, esubtime2] = subtime2.split('~')\n bsubtime2sec = qa.getvalue(qa.convert(qa.totime(bsubtime2), 's'))\n esubtime2sec = qa.getvalue(qa.convert(qa.totime(esubtime2), 's'))\n timebin2sec = esubtime2sec - bsubtime2sec\n if timebin2sec < 0:\n raise Exception('Negative timebin! Please check the \"subtime2\" parameter.')\n timebin2 = str(timebin2sec) + 's'\n casalog.post('Selected timerange 2: ' + subtime2 + ' as background for uv subtraction.')\n # plus 1s is to ensure averaging over the entire timerange\n else:\n casalog.post('Timerange 2 not selected, using only timerange 1 as background')\n\n # Select the background indicated by subtime1\n ms_in.open(vis, nomodify=True)\n # Select the spw id\n # ms_in.msselect({'time': subtime1})\n staql0 = {'time': subtime1, 'spw': ''}\n if spw and (type(spw) == str):\n staql0['spw'] = spwlist[s]\n else:\n staql0['spw'] = staql['spw']\n ms_in.msselect(staql0)\n rec1 = ms_in.getdata(['data', 'time', 'axis_info'], ifraxis=True)\n # print('shape of the frequency matrix ',rec1['axis_info']['freq_axis']['chan_freq'].shape)\n sz1 = rec1['data'].shape\n print('dimension of selected background 1', rec1['data'].shape)\n # the data shape is (n_pol,n_channel,n_baseline,n_time), no need to reshape\n # rec1['data']=rec1['data'].reshape(sz1[0],sz1[1],sz1[2],nspw,sz1[3]/nspw,order='F')\n # print('reshaped rec1 ', rec1['data'].shape)\n rec1avg = np.average(rec1['data'], axis=3)\n casalog.post('Averaging the visibilities in subtime1: ' + subtime1)\n ms_in.close()\n if subtime2 and (type(subtime2) == str):\n ms_in.open(vis, nomodify=True)\n # Select the spw id\n staql0 = {'time': subtime2, 'spw': ''}\n if spw and (type(spw) == str):\n staql0['spw'] = spwlist[s]\n else:\n staql0['spw'] = staql['spw']\n ms_in.msselect(staql0)\n rec2 = ms_in.getdata(['data', 'time', 'axis_info'], ifraxis=True)\n sz2 = rec2['data'].shape\n print('dimension of selected background 2', rec2['data'].shape)\n # rec2['data']=rec2['data'].reshape(sz2[0],sz2[1],sz2[2],nspw,sz2[3]/nspw,order='F')\n # print('reshaped rec1 ', rec2['data'].shape)\n rec2avg = np.average(rec2['data'], axis=3)\n ms_in.close()\n casalog.post('Averaged the visibilities in subtime2: ' + subtime2)\n if subtime1 and (not subtime2):\n casalog.post('Only \"subtime1\" is defined, subtracting background defined in subtime1: ' + subtime1)\n t1 = (np.amax(rec1['time']) + np.amin(rec1['time'])) / 2.\n print('t1: ', qa.time(qa.quantity(t1, 's'), form='ymd', prec=10))\n for i in range(ntim):\n orec['data'][:, :, :, i] -= rec1avg\n if reverse:\n orec['data'][:, :, :, i] = -orec['data'][:, :, :, i]\n if subtime1 and subtime2 and (type(subtime2) == str):\n casalog.post(\n 'Both subtime1 and subtime2 are specified, doing linear interpolation between \"subtime1\" and \"subtime2\"')\n t1 = (np.amax(rec1['time']) + np.amin(rec1['time'])) / 2.\n t2 = (np.amax(rec2['time']) + np.amin(rec2['time'])) / 2.\n touts = orec['time']\n print('t1: ', qa.time(qa.quantity(t1, 's'), form='ymd', prec=10))\n print('t2: ', qa.time(qa.quantity(t2, 's'), form='ymd', prec=10))\n for i in range(ntim):\n tout = touts[i]\n if tout > np.amax([t1, t2]):\n tout = np.amax([t1, t2])\n elif tout < np.amin([t1, t2]):\n tout = np.amin([t1, t2])\n orec['data'][:, :, :, i] -= (rec2avg - rec1avg) * (tout - t1) / (t2 - t1) + rec1avg\n if reverse:\n orec['data'][:, :, :, i] = -orec['data'][:, :, :, i]\n elif mode == 'highpass':\n if smoothtype != 'flat' and smoothtype != 'hanning' and smoothtype != 'hamming' and smoothtype != 'bartlett' and smoothtype != 'blackman':\n raise Exception('Unknown smoothtype ' + str(smoothtype))\n if smoothaxis == 'time':\n if smoothwidth <= 0 or smoothwidth >= ntim:\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\n else:\n for i in range(orec['data'].shape[0]):\n for j in range(nchan):\n for k in range(nbl):\n orec['data'][i, j, k, :] -= su.smooth(orec['data'][i, j, k, :],\n smoothwidth,\n smoothtype)\n if smoothaxis == 'freq':\n if smoothwidth <= 0 or smoothwidth >= nchan:\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\n else:\n for i in range(orec['data'].shape[0]):\n for j in range(nbl):\n for k in range(ntim):\n orec['data'][i, :, j, k] -= su.smooth(orec['data'][i, :, j, k],\n smoothwidth,\n smoothtype)\n elif mode == 'lowpass':\n if smoothtype != 'flat' and smoothtype != 'hanning' and smoothtype != 'hamming' and smoothtype != 'bartlett' and smoothtype != 'blackman':\n raise Exception('Unknown smoothtype ' + str(smoothtype))\n if smoothaxis == 'time':\n if smoothwidth <= 0 or smoothwidth >= ntim:\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\n else:\n for i in range(orec['data'].shape[0]):\n for j in range(nchan):\n for k in range(nbl):\n orec['data'][i, j, k, :] = su.smooth(orec['data'][i, j, k, :],\n smoothwidth,\n smoothtype)\n if smoothaxis == 'freq':\n if smoothwidth <= 0 or smoothwidth >= nchan:\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\n else:\n for i in range(orec['data'].shape[0]):\n for j in range(nbl):\n for k in range(ntim):\n orec['data'][i, :, j, k] = su.smooth(orec['data'][i, :, j, k],\n smoothwidth,\n smoothtype)\n else:\n raise Exception('Unknown mode' + str(mode))\n except Exception as instance:\n print('*** Error ***', instance)\n\n # orec['data']=orec['data'].reshape(szo[0],szo[1],szo[2],szo[3],order='F')\n # put the modified data back into the output visibility set\n del orec['time']\n del orec['axis_info']\n # ms_in.open(outputvis,nomodify=False)\n # if not splitsel:\n # outputvis is identical to input visibility, do the selection\n # if timerange and (type(timerange==str)):\n # datams.msselect({'time':timerange})\n # if spw and (type(spw)==str):\n # datams.selectinit(datadescid=int(spwid))\n # nchan=int(echan)-int(bchan)+1\n # datams.selectchannel(nchan,int(bchan),1,1)\n # if not spw and not timerange:\n # data selection is not made\n # datams.selectinit(datadescid=0)\n # else:\n # outputvis is splitted, selections have already applied, select all the data\n # datams.selectinit(datadescid=0)\n datams.putdata(orec)\n datams.close()\n datamsmd.done()","def vec2scal(self, property='curl'):\n # replace few common names\n property='vorticity' if property == 'curl' else property\n property = 'tke' if property == 'ken' else property\n property='vorticity' if property == 'vort' else property\n \n method_name = str(property)\n method = getattr(self, method_name, lambda: \"nothing\")\n \n if len(self._obj.attrs['variables']) <= 4: # only x,y,u,v\n self._obj.attrs['variables'].append(property)\n else:\n self._obj.attrs['variables'][-1] = property\n \n return method()","def _make_msqrd_and_masses_v_l_l(\n model: SingleRhNeutrinoModel, genv: Generation, genl1: Generation, genl2: Generation\n):\n\n genn = model.gen\n ml1 = _lepton_masses[genl1]\n ml2 = _lepton_masses[genl2]\n\n if genn == genv == genl1 == genl2:\n masses = (0.0, ml1, ml1)\n\n def msqrd(s, t):\n return _msqrd_v_l_l(s, t, model, ml1)\n\n elif (genn == genv) and (genl1 == genl2):\n masses = (0.0, ml1, ml1)\n\n def msqrd(s, t):\n return _msqrd_v_f_f(s, t, model, ml1)\n\n elif (genn == genl1) and (genv == genl2):\n mu, md, ml = 0.0, ml2, ml1\n masses = (mu, md, ml)\n\n def msqrd(s, t):\n return _msqrd_l_u_d(s, t, model, mu, md, ml, 1.0)\n\n elif (genn == genl2) and (genv == genl1):\n mu, md, ml = 0.0, ml1, ml2\n masses = (mu, md, ml)\n\n def msqrd(s, t):\n return _msqrd_l_u_d(s, t, model, mu, md, ml, 1.0)\n\n else:\n masses = (0.0, ml1, ml2)\n\n def msqrd(s, t):\n return np.zeros_like(s)\n\n return msqrd, masses","def uvsInv(mot):\n ####################\n # TODO - part 1a\n # x' to x and y' to y is just reverse direction\n u1 = -mot[0]\n v1 = -mot[1]\n \n # w' to w is solved via getting (w-w')/w' in terms of the original s\n sNew = -mot[2]/(mot[2]+1)\n \n # new motion has moved center aka projection of x0, y0 by motion\n x0 = mot[3] + mot[0]\n y0 = mot[4] + mot[1]\n motinv = np.array([u1, v1, sNew, x0, y0])\n ####################\n\n return motinv","def multiscale(m, r):\n from neuropype_ephy.mse import get_mse_multiple_sensors\n from nipype.interfaces.utility import Function\n mse = pe.Node(interface=Function(input_names=['ts_file', 'm', 'r'],\n output_names=['mse_file'],\n function=get_mse_multiple_sensors),\n name='mse')\n\n mse.inputs.m = m\n mse.inputs.r = r\n return mse","def vxvyvz(ra, dec, l, b, mura, mudec, vrad, dist, parallax=False, vlsr=220, vsun=(-11.1, 12.24, 7.25), zsun=0, rsun=8,\n\t\t emura=None, emudec=None, evrad=None, edist=None, MCerror=False):\n\n\tif parallax:\n\t\tdist_new = ut.parallax_to_distance(dist)\n\t\tif edist is not None: edist_new = edist * dist * dist\n\telse:\n\t\tdist_new = dist\n\t\tedist_new = edist\n\n\tmul, mub = co.pmrapmdec_to_pmllpmbb(mura, mudec, ra, dec, degree=True).T\n\n\txs, ys, zs, vxs, vys, vzs = co.sphergal_to_rectgal(l, b, dist_new, vrad, mul, mub, degree=True).T\n\n\tRs = np.sqrt(xs * xs + ys * ys)\n\n\tvsun = np.array([0., vlsr, 0., ]) + np.array(vsun)\n\t# vsun=(0,0,0)\n\n\tR, phi, Z = co.XYZ_to_galcencyl(xs, ys, zs, Zsun=zsun, Xsun=rsun).T\n\n\tif edist is not None:\n\t\teR = np.abs(edist_new * np.cos(b * np.pi / 180))\n\t\teZ = np.abs(edist_new * np.sin(b * np.pi / 180))\n\telse:\n\t\teR = np.nan\n\t\teZ = np.nan\n\n\tvR, vT, vZ = co.vxvyvz_to_galcencyl(vxs, vys, vzs, R, phi, Z, vsun=vsun, Xsun=rsun, Zsun=zsun,\n\t\t\t\t\t\t\t\t\t\tgalcen=True).T\n\n\tif emura is not None and emudec is not None and evrad is not None and edist is not None:\n\t\tcovpmrapmdec = np.zeros((len(emura), 2, 2))\n\t\tcovpmrapmdec[:, 0, 0] = emura\n\t\tcovpmrapmdec[:, 1, 1] = emudec\n\t\tcovpmlpmb = co.cov_pmrapmdec_to_pmllpmbb(covpmrapmdec, ra, dec, degree=True)\n\t\tcovV = co.cov_dvrpmllbb_to_vxyz(dist, edist, evrad, mul, mub, covpmlpmb, l, b, plx=parallax, degree=True)\n\n\t\teVx, eVy, eVz = covV[:, 0, 0], covV[:, 1, 1], covV[:, 2, 2]\n\t\txg = xs - rsun\n\t\ttheta = np.arctan2(ys, xg)\n\t\tct = np.cos(theta)\n\t\tst = np.sin(theta)\n\t\teVR = np.sqrt(eVx * eVx * ct * ct + eVy * eVy * st * st)\n\t\teVT = np.sqrt(eVx * eVx * st * st + eVy * eVy * ct * ct)\n\n\t\treturn Rs, R, Z, vZ, vR, vT, eR, eZ, eVR, eVT, eVz\n\n\treturn Rs, R, Z, vZ, vR, vT","def Vminpu(*args):\n # Getter\n if len(args) == 0:\n return CheckForError(lib.Generators_Get_Vminpu())\n\n # Setter\n Value, = args\n CheckForError(lib.Generators_Set_Vminpu(Value))","def mi_pressure_vessel(self, u):\n assert len(u) == 4, 'MI Pressure vessel design needs to specify 4 parameters.'\n R = u[0]\n L = u[1]\n ts = u[2]\n th = u[3]\n fitness = 0.6224 * R * ts * L + 1.7781 * R ** 2 * th + 3.1611 * ts ** 2 * L + 19.8621 * R * ts ** 2\n return fitness","def _msqrd_v_f_f(s, t, model: SingleRhNeutrinoModel, mf: float):\n mx = model.mx\n u = 0.5 * np.tan(2 * model.theta)\n\n return (\n -2\n * u**2\n * GF**2\n * (\n 2 * mf**4 * (1 - 4 * SW**2 + 8 * SW**4)\n + 2 * mf**2 * (mx**2 - s - 2 * (1 - 4 * SW**2 + 8 * SW**4) * t)\n + (1 - 4 * SW**2 + 8 * SW**4)\n * (s**2 + 2 * s * t + 2 * t**2 - mx**2 * (s + 2 * t))\n )\n )","def target_velocity(self, s):\n # YOUR CODE HERE\n if s > self.total_length:\n s = self.total_length\n angular = np.array([0, 0 ,0])\n else:\n angular = np.array([0,0,self.targ_angular])\n\n theta = s/self.total_length*self.angle\n v_x = np.cos(theta)*self.targ_speed\n if self.left_turn:\n v_y = np.sin(theta)*self.targ_speed\n else:\n v_y = -np.sin(theta)*self.targ_speed\n \n linear = np.array([v_x, v_y, 0])\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\n \n toRet = [linear, angular]\n \n return toRet","def create_flux_vector_pms_gr(self):\n soma_prod = 0\n soma_inj = 0\n lim4 = 1e-4\n store_velocity = {}\n store_flux = {}\n for primal in self.primals:\n #1\n primal_id = self.mb.tag_get_data(self.primal_id_tag, primal, flat=True)[0]\n primal_id = self.ident_primal[primal_id]\n fine_elems_in_primal = self.mb.get_entities_by_handle(primal)\n for volume in fine_elems_in_primal:\n #2\n flux = {}\n velocity = {}\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\n centroid_volume = self.mesh_topo_util.get_average_position([volume])\n z_vol = self.tz - centroid_volume[2]\n adjs_vol = self.mesh_topo_util.get_bridge_adjacencies(volume, 2, 3)\n gid_vol = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\n for adj in adjs_vol:\n #3\n gid_adj = self.mb.tag_get_data(self.global_id_tag, adj, flat=True)[0]\n if adj not in fine_elems_in_primal:\n #4\n pvol = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\n padj = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\n #3\n else:\n #4\n pvol = self.mb.tag_get_data(self.pcorr_tag, volume, flat=True)[0]\n padj = self.mb.tag_get_data(self.pcorr_tag, adj, flat=True)[0]\n #3\n kadj = self.mb.tag_get_data(self.perm_tag, adj).reshape([3, 3])\n centroid_adj = self.mesh_topo_util.get_average_position([adj])\n z_adj = self.tz - centroid_adj[2]\n direction = centroid_adj - centroid_volume\n unit = direction/np.linalg.norm(direction)\n #unit = vetor unitario na direcao de direction\n uni = self.unitary(direction)\n # uni = valor positivo do vetor unitario\n kvol = np.dot(np.dot(kvol,uni),uni)\n kadj = np.dot(np.dot(kadj,uni),uni)\n keq = self.kequiv(kvol, kadj)/(self.mi)\n keq2 = keq\n keq = keq*(np.dot(self.A, uni))\n pvol2 = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\n padj2 = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\n grad_p = (padj - pvol)/float(abs(np.dot(direction, uni)))\n grad_z = (z_adj - z_vol)/float(abs(np.dot(direction, uni)))\n grad_p2 = (padj2 - pvol2)/float(abs(np.dot(direction, uni)))\n q = (grad_p)*keq - grad_z*keq*self.gama\n print((grad_p)*keq)\n print(- grad_z*keq*self.gama)\n print(q)\n print(self.store_flux_pf_gr[volume][tuple(unit)])\n print('\\n')\n import pdb; pdb.set_trace()\n\n if gid_adj > gid_vol:\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\n else:\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\n\n flux[tuple(unit)] = q\n velocity[tuple(unit)] = v\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\n\n #2\n # print(gid_vol)\n # print(velocity)\n # print('\\n')\n # import pdb; pdb.set_trace()\n store_flux[volume] = flux\n self.mb.tag_set_data(self.flux_fine_pms_tag, volume, sum(flux.values()))\n # flt = sum(flux.values())\n # if volume not in self.wells_inj and volume not in self.wells_prod:\n # lim4 = 1e-7\n # if abs(flt) > lim4:\n # print(gid_vol)\n # print(flt)\n # import pdb; pdb.set_trace()\n # flt = sum(flux.values())\n store_velocity[volume] = velocity\n\n for volume in set(self.all_fine_vols) - set(self.wells):\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\n values = store_flux[volume].values()\n if sum(values) > lim4:\n print('fluxo multiescala nao esta dando conservativo')\n print('gid:{0}'.format(gid))\n print(sum(values))\n import pdb; pdb.set_trace()\n\n with open('fluxo_multiescala_gr.txt', 'w') as arq:\n for volume in self.wells:\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat= True)[0]\n values = store_flux[volume].values()\n if volume in self.wells_inj:\n soma_inj += sum(values)\n else:\n soma_prod += sum(values)\n arq.write('gid:{0} , fluxo:{1}\\n'.format(gid, sum(values)))\n arq.write('\\n')\n arq.write('soma_inj:{0}\\n'.format(soma_inj))\n arq.write('soma_prod:{0}\\n'.format(soma_prod))\n\n return store_flux","def _calc_msve(self):\n v = []\n for state in self._env.state_iterator():\n feature_vector = self._features.vector(state)\n v.append(utils.state_value(feature_vector, self.theta))\n\n self.msve.append(utils.rmse(v, self._true_values))","def get_velocity(self, message):\n #print('**************** vel ')\n self.velocity = message.data\n self.state[0:self.ndegres] = self.velocity[0:self.ndegres]","def scale_uv(self):\n self.u = [i * self.scale * self.scaleratio for i in self.u]\n self.v = [i * self.scale for i in self.v]","def add_velocity(self, Mextra=0, period=0, model=1):\n \n if self.npart == 0:\n self.vel = transpose(array([[],[]]))\n return\n \n print(\" Adding velocities...\")\n \n if model==0: vel = zeros((self.npart, 2))\n \n elif model in [1,2]:\n print(\" Setting keplerian velocities...\")\n pos = self.pos - self.center\n radii = norm(pos, axis=1)\n self.v_kep = sqrt(Mextra * G / radii)\n if model==2: Mextra += sum(self.mass)\n v_kep = sqrt(Mextra * G / radii)\n vel = matmul(pos / radii[:, newaxis], array([[0, 1], [-1, 0]])) * v_kep[:, newaxis]\n \n\n elif model==3:\n print(\" Setting velocities from binary period...\")\n if period==0:\n print(\" Incorrect period for setting disk velocities.\")\n print(\" Disk velocities are set to zero.\")\n vel = zeros((self.npart, 2))\n \n else:\n pos = self.pos - self.center\n v_ang = 1 / float(period) \n vel = v_ang * matmul(pos, array([[0, 1], [-1, 0]]))\n \n else:\n print(\"Model must be 0, 1, 2 or 3.\")\n print(\" {:d} was given. Exiting.\".format(model))\n exit()\n \n \n self.vel = vel","def test_set_pv(self):\n s = State(substance=\"water\")\n s.pv = Q_(101325.0, \"Pa\"), Q_(0.4772010021515822, \"m**3/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.pv[0], Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.pv[1], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore\n s.pv = Q_(101325.0, \"Pa\"), Q_(3.189303132125469, \"m**3/kg\")\n assert np.isclose(s.T, Q_(700.9882316847855, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.pv[0], Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.pv[1], Q_(3.189303132125469, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(3013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(8623.283568815832, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(3.189303132125469, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(3336406.139862406, \"J/kg\")) # type: ignore\n assert s.x is None","def scale(self,s):\n return Vector(self.x * s, self.y * s, self.z * s)","def get_uv(u, v):\n uv = np.zeros((2, 2))\n uv[0][0] = u[0]\n uv[1][0] = u[1]\n uv[0][1] = v[0]\n uv[1][1] = v[1]\n return uv","def ev(knotvec, coeffs, u):\n assert len(coeffs) == knotvec.numdofs, 'Wrong size of coefficient vector'\n return scipy.interpolate.splev(u, (knotvec.kv, coeffs, knotvec.p))","def test_set_Tv(self):\n s = State(substance=\"water\")\n s.Tv = Q_(400.0, \"K\"), Q_(1.801983936953226, \"m**3/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.Tv[0], Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.Tv[1], Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(2547715.3635084038, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(7496.2021523754065, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cp, Q_(2009.2902478486988, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cv, Q_(1509.1482452129906, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(2730301.3859201893, \"J/kg\")) # type: ignore\n assert s.x is None","def v(w,s):\n return w","def apply_uvs(mesh, bsp_verts):\n\n mesh.uv_textures.new(\"UVs\")\n bm = bmesh.new()\n bm.from_mesh(mesh)\n\n if hasattr(bm.faces, \"ensure_lookup_table\"): \n bm.faces.ensure_lookup_table()\n\n uv_layer = bm.loops.layers.uv[0]\n\n for face_idx, current_face in enumerate(bm.faces):\n current_face.loops[0][uv_layer].uv = bsp_verts[current_face.loops[0].vert.index][1]\n current_face.loops[1][uv_layer].uv = bsp_verts[current_face.loops[1].vert.index][1]\n current_face.loops[2][uv_layer].uv = bsp_verts[current_face.loops[2].vert.index][1]\n \n bm.to_mesh(mesh)","def multiply_vector(self, dv, spm):\n product = []\n for a, b in zip(dv, spm):\n product.append(a * b)\n return product","def convert_sh_to_vp(sh, patm, hygro_params=HygroParams()):\n\n return sh * patm / ((1.0 - hygro_params.mwr) * sh + hygro_params.mwr)"],"string":"[\n \"def levvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n #levmv = mv.clone() # good if mv has only a lev axis\\n #levmv[:] = lev_axis[:]\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\\n attributes={'units':lev_axis.units},\\n copy=True )\\n return levmv\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def uvsChangeLevel(mot, oldlev, newlev):\\n\\n ####################\\n # TODO - part 3\\n diff = abs(oldlev - newlev)\\n if oldlev > newlev:\\n factor = diff * 2\\n elif oldlev < newlev:\\n factor = 1 / (diff * 2)\\n else:\\n factor = 1\\n\\n nmot = mot * factor\\n ####################\\n return nmot\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def scale_u_and_v(u, v, level, pyr):\\n # TODO: Your code here\\n image = pyr[level-1]\\n expanded_u = ps4.expand_image(u)\\n expanded_v = ps4.expand_image(v)\\n scaled_u = expanded_u * 2\\n scaled_v = expanded_v * 2\\n if image.shape[0] == scaled_u.shape[0] - 1:\\n scaled_u = scaled_u[:-1, :]\\n if image.shape[1] == scaled_u.shape[1] - 1:\\n scaled_u = scaled_u[:, :-1]\\n if image.shape[0] == scaled_v.shape[0] - 1:\\n scaled_v = scaled_v[:-1, :]\\n if image.shape[1] == scaled_v.shape[1] - 1:\\n scaled_v = scaled_v[:, :-1]\\n return scaled_u, scaled_v\",\n \"def heightvar( mv ):\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km\\n heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,\\n attributes={'units':\\\"km\\\"} )\\n return heightmv\",\n \"def _msqrd_v_l_l(s, t, model: SingleRhNeutrinoModel, ml: float):\\n mx = model.mx\\n u = 0.5 * np.tan(2 * model.theta)\\n return (\\n -2\\n * u**2\\n * GF**2\\n * (\\n 2 * ml**4 * (1 + 4 * SW**2 + 8 * SW**4)\\n + 2 * ml**2 * (mx**2 - s - 2 * (1 + 4 * SW**2 + 8 * SW**4) * t)\\n + (1 + 4 * SW**2 + 8 * SW**4)\\n * (s**2 + 2 * s * t + 2 * t**2 - mx**2 * (s + 2 * t))\\n )\\n )\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def test_set_uv(self):\\n s = State(substance=\\\"water\\\")\\n s.uv = Q_(1013250.0, \\\"J/kg\\\"), Q_(0.4772010021515822, \\\"m**3/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.uv[0], Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.uv[1], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\\n return float(-np.sqrt(self.periods_in_a_year) *\\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))\",\n \"def vol_from_var_func(self, level: float = 0.95, months_from_last: int = None,\\n from_date: dt.date = None, to_date: dt.date = None, interpolation: str = 'lower',\\n drift_adjust: bool = False, periods_in_a_year_fixed: int = None) -> float:\\n earlier, later = self.calc_range(months_from_last, from_date, to_date)\\n if periods_in_a_year_fixed:\\n time_factor = periods_in_a_year_fixed\\n else:\\n fraction = (later - earlier).days / 365.25\\n how_many = self.tsdf.loc[earlier:later].count(numeric_only=True)\\n time_factor = how_many / fraction\\n if drift_adjust:\\n return float((-np.sqrt(time_factor) / ss.norm.ppf(level)) *\\n (self.var_down_func(level, months_from_last, from_date, to_date, interpolation) -\\n self.tsdf.loc[earlier:later].pct_change().sum() /\\n len(self.tsdf.loc[earlier:later].pct_change())))\\n else:\\n return float(-np.sqrt(time_factor) *\\n self.var_down_func(level, months_from_last, from_date, to_date,\\n interpolation) / ss.norm.ppf(level))\",\n \"def test_set_vu(self):\\n s = State(substance=\\\"water\\\")\\n s.vu = Q_(0.4772010021515822, \\\"m**3/kg\\\"), Q_(1013250.0, \\\"J/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vu[0], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vu[1], Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def test_set_vs(self):\\n s = State(substance=\\\"water\\\")\\n s.vs = Q_(0.4772010021515822, \\\"m**3/kg\\\"), Q_(3028.9867985920914, \\\"J/(kg*K)\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vs[0], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vs[1], Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"async def uv_level(self, uvi):\\n\\n if uvi is None:\\n return \\\"no-data\\\"\\n\\n if uvi >= 10.5:\\n return self._translations[\\\"uv\\\"][\\\"extreme\\\"]\\n if uvi >= 7.5:\\n return self._translations[\\\"uv\\\"][\\\"very-high\\\"]\\n if uvi >= 5.5:\\n return self._translations[\\\"uv\\\"][\\\"high\\\"]\\n if uvi >= 2.5:\\n return self._translations[\\\"uv\\\"][\\\"moderate\\\"]\\n if uvi > 0:\\n return self._translations[\\\"uv\\\"][\\\"low\\\"]\\n \\n return self._translations[\\\"uv\\\"][\\\"none\\\"]\",\n \"def _newMV(self, newValue=None, *, dtype: np.dtype = None) -> 'MultiVector':\\n if newValue is None and dtype is None:\\n raise TypeError(\\\"Must specify either a type or value\\\")\\n\\n return self.__class__(self.layout, newValue, dtype=dtype)\",\n \"def volume(mid, vols):\\n bt = mid.ticks_per_beat\\n trk = MidiTrack()\\n trk.name = \\\"Volume variation\\\"\\n trk.append(Message(\\\"control_change\\\",\\n control=7,\\n time=0,\\n value=vols[0]))\\n\\n for i, vol in enumerate(vols):\\n trk.append(Message(\\\"control_change\\\",\\n control=7,\\n time=bt,\\n value=vol))\\n\\n mid.tracks.append(trk)\\n return mid\",\n \"def update_units(self):\\n unit_var_value = self.view.vars['unit'].get()\\n if unit_var_value == 'm3ph':\\n self.minran_u_label.config(text='m³/h')\\n self.maxran_u_label.config(text='m³/h')\\n self.points_tview.heading('vflow', text='Przepływ [m³/h]', anchor=tk.CENTER)\\n elif unit_var_value == 'lps':\\n self.minran_u_label.config(text='l/s')\\n self.maxran_u_label.config(text='l/s')\\n self.points_tview.heading('vflow', text='Przepływ [l/s]', anchor=tk.CENTER)\\n self.view.vars['pump_eff_min'].convert_unit(unit_var_value)\\n self.view.vars['pump_eff_max'].convert_unit(unit_var_value)\\n self.view.vars['pump_characteristic'].convert_unit(unit_var_value)\",\n \"def rkm_MS_pathvar(models, s_span, X):\\n W_dst_var=np.ndarray(models.shape[0],np.float64)\\n for i in range(models.shape[0]):\\n W = models[i,:,:]\\n res = W[1:,:]-W[0:-1,:]\\n W_dst=np.linalg.norm(res, axis=1)\\n W_dst_var[i] = np.var(W_dst)\\n\\n return W_dst_var\",\n \"def interp_vel(z, u, v, sva, zi, pPsva, return_diagnostics=False):\\n\\n svac, ir, ic, w1, w2 = interp_quantity(z, sva, zi, pPsva, True)\\n\\n um = u[ir, ic]\\n vm = v[ir, ic]\\n svam = sva[ir, ic]\\n\\n theta = np.arctan2(vm[:, 0] - vm[:, 1], um[:, 0] - um[:, 1])\\n\\n ur = np.empty_like(um)\\n ur[:, 0] = um[:, 0]*np.cos(theta) + vm[:, 0]*np.sin(theta)\\n ur[:, 1] = um[:, 1]*np.cos(theta) + vm[:, 1]*np.sin(theta)\\n vr = -um[:, 0]*np.sin(theta) + vm[:, 0]*np.cos(theta)\\n\\n sc = (ur[:, 0]*(svac - svam[:, 1]) + ur[:, 1]*(svam[:, 0] - svac))\\n sc /= (svam[:, 0] - svam[:, 1])\\n\\n uc = sc*np.cos(theta) - vr*np.sin(theta)\\n vc = sc*np.sin(theta) + vr*np.cos(theta)\\n\\n if return_diagnostics:\\n return uc, vc, ir, ic, w1, w2\\n else:\\n return uc, vc\",\n \"def _msqrd_l_u_d(s, t, model: SingleRhNeutrinoModel, mu, md, ml, ckm):\\n mx = model.mx\\n u = 0.5 * np.tan(2 * model.theta)\\n return (\\n 16.0\\n * GF**2\\n * (ml**2 + mx**2 - s - t)\\n * (s + t - mu**2 - md**2)\\n * u**2\\n * abs(ckm) ** 2\\n )\",\n \"def _v_to_lbs(slope,offset,V):\\n return V # without slope and offset data, keep this a stub\",\n \"def duv(self, u, v):\\n return np.column_stack(\\n [_.ev(u, v, dx=1, dy=1) for _ in (self.splz, self.sply, self.splx)])\",\n \"def test_set_sv(self):\\n s = State(substance=\\\"water\\\")\\n s.sv = Q_(3028.9867985920914, \\\"J/(kg*K)\\\"), Q_(0.4772010021515822, \\\"m**3/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.sv[0], Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.sv[1], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def randomMV(\\n layout, min=-2.0, max=2.0, grades=None, mvClass=MultiVector,\\n uniform=None, n=1, normed=False):\\n\\n if n > 1:\\n # return many multivectors\\n return [randomMV(layout=layout, min=min, max=max, grades=grades,\\n mvClass=mvClass, uniform=uniform, n=1,\\n normed=normed) for k in range(n)]\\n\\n if uniform is None:\\n uniform = np.random.uniform\\n\\n if grades is None:\\n mv = mvClass(layout, uniform(min, max, (layout.gaDims,)))\\n else:\\n if isinstance(grades, int):\\n grades = [grades]\\n newValue = np.zeros((layout.gaDims,))\\n for i in range(layout.gaDims):\\n if layout.gradeList[i] in grades:\\n newValue[i] = uniform(min, max)\\n mv = mvClass(layout, newValue)\\n\\n if normed:\\n mv = mv.normal()\\n\\n return mv\",\n \"def voltmeter_settings(self, scalefactor, offset):\\n if scalefactor is not None and offset is not None:\\n if self._request('SM', str(scalefactor), str(offset))[0]:\\n return scalefactor, offset\\n else:\\n done, data = self._request('GM')\\n if done:\\n return int(data[0]), int(data[1])\\n\\n raise EvseError\",\n \"def modality(v):\\n \\n s = st.skew(vel, bias=False)\\n k = st.kurtosis(vel, bias=False)\\n m = (1+s**2)/(3+k**2)\\n return s, k, m\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def import_velocity(self,fname,units='m'):\\n velmod=pd.read_csv(fname,sep=' ',names=['depth','vp','vs','rho'])\\n \\n if units =='m':\\n \\n velmod.depth=velmod.depth/1000\\n velmod.vp=velmod.vp/1000\\n velmod.vs=velmod.vs/1000\\n velmod.rho=velmod.rho/1000 \\n \\n self.velocity_model['depth']=velmod.depth.values\\n self.velocity_model['vp']=velmod.vp.values\\n self.velocity_model['vs']=velmod.vs.values\\n self.velocity_model['rho']=velmod.rho.values\",\n \"def svd(matrix):\\n u = None\\n s = None\\n v = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return u, s, v\",\n \"def gmv(cov):\\n n = cov.shape[0]\\n return msr(0, np.repeat(1, n), cov)\",\n \"def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\\n self.v=initial_v\\n self.v_select=v_select\\n self.max_dev_semitones=max_dev_semitones\",\n \"def mlv(self,vStart,diff):\\n vCurr=vStart\\n while diff>0.0001 :\\n \\\"\\\"\\\"CHANGE THE ABOVE TO BE AN ARGUMENT\\\"\\\"\\\"\\n likeCurr=self.margprobseq(v=vCurr)\\n vUp=vCurr+diff\\n vDown=vCurr-diff\\n if (vDown < 0):\\n vDown = 0\\n likeUp=self.margprobseq(v=vUp)\\n likeDown=self.margprobseq(v=vDown)\\n if likeDown>likeCurr :\\n vCurr=vDown\\n vUp=vCurr+diff\\n vDown=vCurr-diff\\n elif likeUp>likeCurr :\\n vCurr=vUp\\n vUp=vCurr+diff\\n vDown=vCurr-diff\\n else :\\n diff=(diff/2.0) \\n return vCurr\",\n \"def duu(self, u, v):\\n return np.column_stack(\\n [_.ev(u, v, dx=2) for _ in (self.splz, self.sply, self.splx)])\",\n \"def test_set_vp(self):\\n s = State(substance=\\\"water\\\")\\n s.vp = Q_(0.4772010021515822, \\\"m**3/kg\\\"), Q_(101325.0, \\\"Pa\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vp[0], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vp[1], Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\\n s.vp = Q_(3.189303132125469, \\\"m**3/kg\\\"), Q_(101325.0, \\\"Pa\\\")\\n assert np.isclose(s.T, Q_(700.9882316847855, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vp[0], Q_(3.189303132125469, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vp[1], Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(3013250, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(8623.283568815832, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(3.189303132125469, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(3336406.139862406, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def set_channel_v_unit(self , channel_v_unit:float): \\n self.__channel_v_unit = channel_v_unit\",\n \"def gradeInvol(self) -> 'MultiVector':\\n\\n signs = np.power(-1, self.layout.gradeList)\\n\\n newValue = signs * self.value\\n\\n return self._newMV(newValue)\",\n \"def mults(self, s):\\n prod = Vector.fromSequence(self.mV)\\n prod.scale(s)\\n return prod\",\n \"def dv(self, u, v):\\n return np.column_stack(\\n [_.ev(u, v, dy=1) for _ in (self.splz, self.sply, self.splx)])\",\n \"def reduce2scalar( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def sm_set_Vsource(self,level,compliance):\\n self.sm.set_Vsource()\\n self.sm.set_source_level(level)\\n self.sm.set_compliance_level(compliance)\\n self.sm_output_on()\",\n \"def du(self, u, v):\\n return np.column_stack(\\n [_.ev(u, v, dx=1) for _ in (self.splz, self.sply, self.splx)])\",\n \"def my_mvn(mu_x, mu_y, r):\\n return multivariate_normal([mu_x, mu_y], [[r, 0], [0, r]])\",\n \"def scw_loss(phi, v, m):\\n return max(0, phi * np.sqrt(v) - m)\",\n \"def __idiv__(self,value):\\n if isinstance(value,LiveStat):\\n raise Exception (\\\"Ratio of Statistics is not supported\\\")\\n else:\\n if self.vmin is not None:\\n # mu(s x) = 1/N sum s x = s/N sum x\\n self.vmean /= value\\n if value < 0:\\n m = self.vmin\\n M = self.vmax\\n self.vmin = M/value\\n self.vmax = m/value\\n else:\\n self.vmin /= value\\n self.vmax /= value\\n self.vsum /= value\\n # vm2(s x) = sum (s x - mu(s x))^2 = sum (s x - s mu(x))^2 = sum s^2 (x - mu(x))^2 = s^2 sum (x - mu(x))^2 = s^2 vm^2\\n self.vm2 /= value*value\\n print (\\\"div Missing: M3 and M4\\\")\\n self.dirty = True\\n return self\",\n \"def Distribution_Local_galaxy_DM(self, dmv, vpar):\\n val = vpar[0] * np.exp(-np.power((dmv - vpar[1]) / vpar[2], 2.)) \\\\\\n + vpar[3] * np.exp(-np.power((dmv - vpar[4]) / vpar[5], 2.))\\n return val\",\n \"def reparametrize(self, mu, logvar):\\n std = logvar.div(2).exp()\\n eps = torch.Tensor(std.data.new(std.size()).normal_())\\n return mu + std * eps\",\n \"def __init__(self, level_model: LevelModel, level_low_limit: int, level_high_limit: int):\\n self.level_model = level_model\\n self.level_min = min(level_model.level_bounds[0], level_model.level_bounds[1])\\n self.level_max = max(level_model.level_bounds[0], level_model.level_bounds[1])\\n self.level_low_limit = level_low_limit\\n self.level_high_limit = level_high_limit\\n self.x_axis = ''\\n self.y_axis = ''\\n self.period = ''\\n self.current_level = 'NONE'\\n self.bs_class = 'alert-success'\",\n \"def vol_handler(bot, update, args):\\n if len(args) == 1:\\n if args[0].isdigit():\\n return update.message.reply_text(vol_set(args[0]))\\n elif args[0] == 'mute':\\n return update.message.reply_text(vol_mute())\\n\\n return update.message.reply_text('Syntax: /v [mute|<level(0-100)>]')\",\n \"def width_v_v_v(model: SingleRhNeutrinoModel, genv: Generation):\\n mx = model.mx\\n u = 0.5 * np.tan(2 * model.theta)\\n w = parameters.GF**2 * mx**5 / (768 * np.pi**3) * u**2\\n pre = 2 if genv == model.gen else 1.0\\n return pre * w\",\n \"def dvv(self, u, v):\\n return np.column_stack(\\n [_.ev(u, v, dy=2) for _ in (self.splz, self.sply, self.splx)])\",\n \"def velocity(self,level='cell'):\\r\\n\\r\\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\\r\\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \\r\\n vels = []\\r\\n vols = self.last_sim_step_volume()\\r\\n \\r\\n if level=='cell':\\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n return vels\\r\\n \\r\\n elif level=='section': \\r\\n # 先计算每一个元胞的再按照volume计算加权平均\\r\\n \\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2)) \\r\\n\\r\\n \\r\\n # 将速度按照volume加权平均\\r\\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\\r\\n sum_vol = sum(vols)\\r\\n if sum_vol == 0:\\r\\n avg_vel = 0\\r\\n else:\\r\\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\\r\\n \\r\\n return avg_vel\\r\\n\\r\\n\\r\\n else :\\r\\n raise ValueError('no such level for collecting data')\",\n \"def a_sv(self, phi, tl, psi_l, z, m):\\n\\t\\tif self.MMAX*((self.TH - tl)/(self.TH - self.TW)*(1. - self.ALPHA_2) + self.ALPHA_2) > m and (1. - self.K*(tl - self.TOPT)**2.) >0:\\n\\t\\t\\treturn (self.AMMAX*(1. - self.K*(tl - self.TOPT)**2.) - self.r_dv(phi, tl))*self.f_m(z, m, tl)*self.a_psilc02(psi_l)\\n\\t\\telse:\\n\\t\\t\\treturn 0.\",\n \"def a_sv(self, phi, tl, psi_l, z, m):\\n\\t\\tif self.mmax*((self.TH - tl)/(self.TH - self.TW)*(1. - self.ALPHA_2) + self.ALPHA_2) > m and (1. - self.K*(tl - self.TOPT)**2.) >0:\\n\\t\\t\\treturn (self.AMMAX*(1. - self.K*(tl - self.TOPT)**2.) - self.r_dv(phi, tl))*self.f_m(z, m, tl)*self.a_psilc02(psi_l)\\n\\t\\telse:\\n\\t\\t\\treturn 0.\",\n \"def addVariable(\\n self, desmptr_name, name=None, value=None, lower=None, upper=None, scale=1.0, rows=None, cols=None, dh=0.001\\n ):\\n # if name is none, use the desptmr name instead\\n if name is not None:\\n dvName = name\\n else:\\n dvName = desmptr_name\\n\\n if dvName in self.DVs.keys():\\n raise Error(\\\"Design variable name \\\" + dvName + \\\" already in use.\\\")\\n\\n # find the design parm index in ESP\\n if desmptr_name not in self.csmDesPmtrs.keys():\\n raise Error(\\n 'User specified design parameter name \\\"' + desmptr_name + '\\\" which was not found in the CSM file'\\n )\\n\\n csmDesPmtr = self.csmDesPmtrs[desmptr_name]\\n numRow = csmDesPmtr.numRow\\n numCol = csmDesPmtr.numCol\\n self._validateRowCol(rows, cols, numRow, numCol, dvName)\\n\\n if rows is None:\\n rows = range(1, numRow + 1)\\n if cols is None:\\n cols = range(1, numCol + 1)\\n # if value is None, get the current value from ESP\\n if value is None:\\n value = self._csmToFlat(csmDesPmtr.baseValue, rows, cols, numRow, numCol)\\n else:\\n # validate that it is of correct length\\n if len(value) != len(rows) * len(cols):\\n raise Error(\\n \\\"User-specified DV value does not match the dimensionality\\\"\\n + \\\"of the ESP despmtr. Value is of length \\\"\\n + str(len(value))\\n + \\\" but should be \\\"\\n + str(len(rows) * len(cols))\\n )\\n\\n # check that upper and lower are correct length\\n\\n if upper is not None:\\n if isinstance(upper, (float, int)):\\n upper = np.ones((len(rows) * len(cols),)) * upper\\n if len(upper) != len(rows) * len(cols):\\n raise Error(\\n \\\"User-specified DV upper bound does not match the dimensionality\\\"\\n + \\\"of the ESP despmtr. Upper is of length \\\"\\n + str(len(upper))\\n + \\\" but should be \\\"\\n + str(len(rows) * len(cols))\\n )\\n\\n if lower is not None:\\n if isinstance(lower, (float, int)):\\n lower = np.ones((len(rows) * len(cols),)) * lower\\n if len(lower) != len(rows) * len(cols):\\n raise Error(\\n \\\"User-specified DV lower bound does not match the dimensionality\\\"\\n + \\\"of the ESP despmtr. lower is of length \\\"\\n + str(len(lower))\\n + \\\" but should be \\\"\\n + str(len(rows) * len(cols))\\n )\\n nVal = len(rows) * len(cols)\\n\\n # add an entry in the global DV list to make finite differencing load balancing easy\\n globalStartInd = len(self.globalDVList)\\n for localInd in range(nVal):\\n self.globalDVList.append((dvName, localInd))\\n\\n self.DVs[dvName] = espDV(csmDesPmtr, dvName, value, lower, upper, scale, rows, cols, dh, globalStartInd)\",\n \"def spddir_to_uv(wspd, wdir):\\n if isinstance(wspd, list) or isinstance(wdir, list):\\n wspd = np.array(wspd, dtype=float)\\n wdir = np.array(wdir, dtype=float)\\n\\n rad = 4.0 * np.arctan(1) / 180.0\\n u = -wspd * np.sin(rad * wdir)\\n v = -wspd * np.cos(rad * wdir)\\n\\n # If the speed is zero, then u and v should be set to zero (not NaN)\\n if hasattr(u, \\\"__len__\\\"):\\n u[np.where(wspd == 0)] = 0\\n v[np.where(wspd == 0)] = 0\\n elif wspd == 0:\\n u = float(0)\\n v = float(0)\\n\\n return np.round(u, 3), np.round(v, 3)\",\n \"def get_level_mag(slide, level):\\n return level_mags(slide)[level]\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"async def _design_lvl_shift_inv_pun(self, pseg: int, nseg: int, inv_nseg: int, out_inv_m: int,\\n fanout: float,\\n pinfo: Any, tbm_specs: Dict[str, Any], has_rst, dual_output,\\n vin, vout) -> Tuple[int, int]:\\n inv_beta = get_tech_global_info('bag3_digital')['inv_beta']\\n tb_params = self._get_full_tb_params()\\n # Use a binary iterator to find the PMOS size\\n load_seg = nseg + (pseg if has_rst else 0)\\n inv_pseg_nom = int(np.round(inv_beta * load_seg / ((1 + inv_beta) * fanout)))\\n inv_pseg_nom = 1 if inv_pseg_nom == 0 else inv_pseg_nom\\n iterator = BinaryIterator(-inv_pseg_nom + 1, 0)\\n err_best = float('inf')\\n inv_in_nseg, inv_in_pseg = self._size_input_inv_for_fanout(inv_pseg_nom, inv_nseg, pseg,\\n nseg, fanout, has_rst)\\n all_corners = get_tech_global_info('bag3_digital')['signoff_envs']['all_corners']\\n\\n while iterator.has_next():\\n pseg_off = iterator.get_next()\\n inv_pseg = inv_pseg_nom + pseg_off\\n dut_params = self._get_lvl_shift_params_dict(pinfo, pseg, nseg, inv_pseg, inv_nseg,\\n inv_in_nseg, inv_in_pseg, out_inv_m,\\n has_rst, dual_output)\\n dut = await self.async_new_dut('lvshift', STDCellWrapper, dut_params)\\n\\n err_worst = -1 * float('Inf')\\n for env in all_corners['envs']:\\n tbm_specs['sim_envs'] = [env]\\n tbm_specs['sim_params']['vdd_in'] = all_corners[vin][env]\\n tbm_specs['sim_params']['vdd'] = all_corners[vout][env]\\n tbm = cast(CombLogicTimingTB, self.make_tbm(CombLogicTimingTB, tbm_specs))\\n sim_results = await self.async_simulate_tbm_obj(f'sim_inv_pseg_{inv_pseg}_{env}',\\n dut, tbm, tb_params)\\n tdr_cur, tdf_cur = CombLogicTimingTB.get_output_delay(sim_results.data, tbm.specs,\\n 'in',\\n 'out', False, in_pwr='vdd_in',\\n out_pwr='vdd')\\n\\n '''\\n plt.figure()\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['in'].flatten(), 'b')\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['inb_buf'].flatten(), 'g')\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['in_buf'].flatten(), 'r')\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['midn'].flatten(), 'k')\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['midp'].flatten(), 'c')\\n plt.plot(sim_results.data['time'].flatten(), sim_results.data['out'].flatten(), 'm')\\n plt.legend(['in', 'inb_buf', 'in_buf', 'midn', 'midp', 'out'])\\n plt.title(f'pseg_off: {pseg_off}, pseg: {inv_pseg}, nseg: {inv_nseg-pseg_off}, fanout: {fanout}')\\n plt.show(block=False)\\n '''\\n\\n # Error checking\\n if math.isinf(np.max(tdr_cur)) or math.isinf(np.max(tdf_cur)):\\n raise ValueError(\\\"Got infinite delay!\\\")\\n if np.min(tdr_cur) < 0 or np.min(tdf_cur) < 0:\\n raise ValueError(\\\"Got negative delay.\\\")\\n\\n err_cur = np.abs(tdr_cur[0] - tdf_cur[0])\\n if err_cur > err_worst:\\n err_worst = err_cur\\n worst_env = env\\n tdr = tdr_cur[0]\\n tdf = tdf_cur[0]\\n\\n '''\\n print(f'iter: {inv_pseg}')\\n print(f'env: {worst_env}, tdr: {tdr}, tdf: {tdf}')\\n breakpoint()\\n '''\\n\\n if tdr < tdf:\\n iterator.down(tdr - tdf, False)\\n else:\\n iterator.up(tdr - tdf, False)\\n\\n err_abs = np.abs(tdr - tdf)\\n if err_abs < err_best:\\n err_best = err_abs\\n iterator.save_info(pseg_off)\\n\\n pseg_off = iterator.get_last_save_info()\\n pseg_off = 0 if pseg_off is None else pseg_off # Should only hit this case if inv_pseg_nom = 1\\n inv_pseg = inv_pseg_nom + pseg_off\\n\\n return inv_pseg, inv_nseg - 0 * pseg_off\",\n \"def create_follicle_uv(source_object, u_pos, v_pos):\\n result = _create_follicle(source_object, uv_position = [u_pos, v_pos])\\n return result\",\n \"def getdviolvar(self,whichsol_,sub,viol): # 3\\n if not isinstance(whichsol_,soltype): raise TypeError(\\\"Argument whichsol has wrong type\\\")\\n num_ = None\\n if num_ is None:\\n num_ = len(sub)\\n elif num_ != len(sub):\\n raise IndexError(\\\"Inconsistent length of array sub\\\")\\n if num_ is None: num_ = 0\\n if sub is None: raise TypeError(\\\"Invalid type for argument sub\\\")\\n if sub is None:\\n sub_ = None\\n else:\\n try:\\n sub_ = memoryview(sub)\\n except TypeError:\\n try:\\n _tmparr_sub = array.array(\\\"i\\\",sub)\\n except TypeError:\\n raise TypeError(\\\"Argument sub has wrong type\\\")\\n else:\\n sub_ = memoryview(_tmparr_sub)\\n \\n else:\\n if sub_.format != \\\"i\\\":\\n sub_ = memoryview(array.array(\\\"i\\\",sub))\\n \\n if viol is None: raise TypeError(\\\"Invalid type for argument viol\\\")\\n _copyback_viol = False\\n if viol is None:\\n viol_ = None\\n else:\\n try:\\n viol_ = memoryview(viol)\\n except TypeError:\\n try:\\n _tmparr_viol = array.array(\\\"d\\\",viol)\\n except TypeError:\\n raise TypeError(\\\"Argument viol has wrong type\\\")\\n else:\\n viol_ = memoryview(_tmparr_viol)\\n _copyback_viol = True\\n else:\\n if viol_.format != \\\"d\\\":\\n viol_ = memoryview(array.array(\\\"d\\\",viol))\\n _copyback_viol = True\\n if viol_ is not None and len(viol_) != (num_):\\n raise ValueError(\\\"Array argument viol has wrong length\\\")\\n res = self.__obj.getdviolvar(whichsol_,num_,sub_,viol_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _copyback_viol:\\n viol[:] = _tmparr_viol\",\n \"def __init__(self, m,r,v):\\n self.m = m\\n self.r = r\\n self.v = v\\n self.rv = np.array([r,0,0,v])\",\n \"def wind_uv_to_spd(U, V):\\n WSPD = np.sqrt(np.square(U) + np.square(V))\\n return WSPD\",\n \"def vi2ev(v,mu):\\n return 0.5*mu*mp*v**2/eV2J\",\n \"def sigma2w_lenschow(velo_sel):\\n\\n sigma2_w = np.nanvar(velo_sel[:]) # - np.nanvar(velo_error_sel[:]) --> negative values, TBD\\n my_acf_norm = acf_fast_normalized(velo_sel[:])\\n\\n # Robustly fit linear model with RANSAC algorithm\\n ransac = linear_model.RANSACRegressor()\\n x = np.empty([6, 2])\\n x[:, 0] = 1\\n x[:, 1] = np.arange(1, 7, 1)\\n ransac.fit(x, np.multiply(my_acf_norm[1:7], sigma2_w))\\n line_x = np.empty([7, 2])\\n line_x[:, 0] = 1\\n line_x[:, 1] = np.arange(0, 7, 1)\\n line_y_ransac = ransac.predict(line_x)\\n # if unbiased variance less than 'biased' variance, no significant amount of noise --> used 'biased' variance\\n if line_y_ransac[0] < sigma2_w:\\n velo_var = line_y_ransac[0]\\n else:\\n velo_var = sigma2_w\\n\\n return velo_var\",\n \"def getpviolvar(self,whichsol_,sub,viol): # 3\\n if not isinstance(whichsol_,soltype): raise TypeError(\\\"Argument whichsol has wrong type\\\")\\n num_ = None\\n if num_ is None:\\n num_ = len(sub)\\n elif num_ != len(sub):\\n raise IndexError(\\\"Inconsistent length of array sub\\\")\\n if num_ is None: num_ = 0\\n if sub is None: raise TypeError(\\\"Invalid type for argument sub\\\")\\n if sub is None:\\n sub_ = None\\n else:\\n try:\\n sub_ = memoryview(sub)\\n except TypeError:\\n try:\\n _tmparr_sub = array.array(\\\"i\\\",sub)\\n except TypeError:\\n raise TypeError(\\\"Argument sub has wrong type\\\")\\n else:\\n sub_ = memoryview(_tmparr_sub)\\n \\n else:\\n if sub_.format != \\\"i\\\":\\n sub_ = memoryview(array.array(\\\"i\\\",sub))\\n \\n if viol is None: raise TypeError(\\\"Invalid type for argument viol\\\")\\n _copyback_viol = False\\n if viol is None:\\n viol_ = None\\n else:\\n try:\\n viol_ = memoryview(viol)\\n except TypeError:\\n try:\\n _tmparr_viol = array.array(\\\"d\\\",viol)\\n except TypeError:\\n raise TypeError(\\\"Argument viol has wrong type\\\")\\n else:\\n viol_ = memoryview(_tmparr_viol)\\n _copyback_viol = True\\n else:\\n if viol_.format != \\\"d\\\":\\n viol_ = memoryview(array.array(\\\"d\\\",viol))\\n _copyback_viol = True\\n if viol_ is not None and len(viol_) != (num_):\\n raise ValueError(\\\"Array argument viol has wrong length\\\")\\n res = self.__obj.getpviolvar(whichsol_,num_,sub_,viol_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _copyback_viol:\\n viol[:] = _tmparr_viol\",\n \"def test_set_vT(self):\\n s = State(substance=\\\"water\\\")\\n s.vT = Q_(1.801983936953226, \\\"m**3/kg\\\"), Q_(400.0, \\\"K\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vT[1], Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.vT[0], Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(2547715.3635084038, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(7496.2021523754065, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cp, Q_(2009.2902478486988, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cv, Q_(1509.1482452129906, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(2730301.3859201893, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def test_set_vh(self):\\n s = State(substance=\\\"water\\\")\\n s.vh = Q_(0.4772010021515822, \\\"m**3/kg\\\"), Q_(1061602.391543017, \\\"J/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vh[0], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vh[1], Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def reparametrize(self, mu, log_var):\\n eps = to_var(torch.randn(mu.size(0), mu.size(1)))\\n z = mu + eps * torch.exp(0.5 * log_var) # 0.5 to convert var to std\\n return z\",\n \"def get_velocity_sink(strength, xs, ys, X, Y):\\r\\n u = strength / (2 * math.pi) * (X - xs) / ((X - xs)**2 + (Y - ys)**2)\\r\\n v = strength / (2 * math.pi) * (Y - ys) / ((X - xs)**2 + (Y - ys)**2)\\r\\n \\r\\n return u, v\",\n \"def doParametersOfInterest(self):\\n ''' ref : physicsmodel -> rvf\\n self.modelBuilder.out.var(\\\"MH\\\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\\n self.modelBuilder.out.var(\\\"MH\\\").setConstant(False)\\n '''\\n\\n self.modelBuilder.doVar(\\\"mu[0,0,1000]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doVar(\\\"Fvbf[0,0,1]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu,Fvbf\\\")\\n self.modelBuilder.doVar(\\\"\\\")\\n self.modelBuilder.factory_('expr::ggH_s_func(\\\"(@0-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_b_func(\\\"(1-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\\\"sqrt(@0)*(1.-@1)\\\", mu,Fvbf)')\\n\\n self.modelBuilder.factory_('expr::vbfH_s_func(\\\"(@0-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\\\"(1-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\\\"sqrt(@0)*(@1)\\\", mu,Fvbf)')\",\n \"def normalize_zoomlvl(lvl):\\n if lvl < gMinZoomLevel:\\n return gMinZoomLevel\\n elif lvl > gMaxZoomLevel:\\n return gMaxZoomLevel\\n else:\\n return lvl - gMinZoomLevel\",\n \"def test_velocity(self):\\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\\n # r must contain 2 elements, otherwise the density and pressure are nan\\n r = np.array([0.7, 0.8])\\n t = 6.25e-6\\n solrt = sol(r, t)\\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def set_variables(self,dv,scale=False):\\n\\n if type(dv) == np.ndarray:\\n dv = dv.tolist()\\n\\n var_list = self.get_variables()\\n\\n for ivar, var in enumerate(var_list):\\n if type(dv[0]) == Variable:\\n var.value = dv[ivar].value * var.scaling if scale else dv[ivar].value\\n else:\\n value = dv.pop(0)\\n var.value = value * var.scaling if scale else value\\n\\n # Make sure the coupled variables get set too\\n self._enforce_coupling()\",\n \"def subvs2(vis=None, outputvis=None, timerange='', spw='',\\n mode='linear', subtime1='', subtime2='',\\n smoothaxis='time', smoothtype='flat', smoothwidth='5',\\n splitsel=True, reverse=False, overwrite=False):\\n # check the visbility ms\\n casalog.post('input parameters:')\\n casalog.post('vis: ' + vis)\\n casalog.post('outputvis: ' + outputvis)\\n if mode not in ['linear']:\\n casalog.post('smoothaxis: ' + smoothaxis)\\n casalog.post('smoothtype: ' + smoothtype)\\n casalog.post('smoothwidth: ' + str(smoothwidth))\\n if not outputvis or outputvis.isspace():\\n raise ValueError('Please specify outputvis')\\n\\n if os.path.exists(outputvis):\\n if overwrite:\\n print(\\\"The already existing output measurement set will be updated.\\\")\\n else:\\n raise ValueError(\\\"Output MS {} already exists - will not overwrite.\\\".format(outputvis))\\n else:\\n if not splitsel:\\n shutil.copytree(vis, outputvis)\\n else:\\n ms_in.open(vis, nomodify=True)\\n ms_in.split(outputvis, spw=spw, time=timerange, whichcol='DATA')\\n ms_in.close()\\n\\n if timerange and (type(timerange) == str):\\n [btimeo, etimeo] = timerange.split('~')\\n btimeosec = qa.getvalue(qa.convert(qa.totime(btimeo), 's'))\\n etimeosec = qa.getvalue(qa.convert(qa.totime(etimeo), 's'))\\n timebinosec = etimeosec - btimeosec\\n if timebinosec < 0:\\n raise Exception('Negative timebin! Please check the \\\"timerange\\\" parameter.')\\n casalog.post('Selected timerange: ' + timerange + ' as the time for UV subtraction.')\\n else:\\n casalog.post('Output timerange not specified, using the entire timerange')\\n\\n if spw and (type(spw) == str):\\n spwlist = spw.split(';')\\n else:\\n casalog.post('spw not specified, use all frequency channels')\\n\\n # read the output data\\n\\n datams.open(outputvis, nomodify=False)\\n\\n datamsmd.open(outputvis)\\n spwinfod = datams.getspectralwindowinfo()\\n spwinfok = spwinfod.keys()\\n spwinfok = sorted(spwinfok, key=int)\\n spwinfol = [spwinfod[k] for k in spwinfok]\\n for s, spi in enumerate(spwinfol):\\n print('processing spectral window {}'.format(spi['SpectralWindowId']))\\n datams.selectinit(reset=True)\\n staql = {'time': '', 'spw': ''}\\n if not splitsel:\\n # outputvis is identical to input visibility, do the selection\\n if timerange and (type(timerange == str)):\\n staql['time'] = timerange\\n if spw and (type(spw) == str):\\n staql['spw'] = spwlist[s]\\n if not spw and not timerange:\\n # data selection is not made\\n print('selecting all spws and times')\\n staql['spw'] = str(spi['SpectralWindowId'])\\n else:\\n # outputvis is splitted, selections have already applied, select all the data\\n print('split the selected spws and times')\\n staql['spw'] = str(spi['SpectralWindowId'])\\n datams.msselect(staql)\\n orec = datams.getdata(['data', 'time', 'axis_info'], ifraxis=True)\\n npol, nchan, nbl, ntim = orec['data'].shape\\n print('dimension of output data', orec['data'].shape)\\n casalog.post('Number of baselines: ' + str(nbl))\\n casalog.post('Number of spectral channels: ' + str(nchan))\\n casalog.post('Number of time pixels: ' + str(ntim))\\n\\n try:\\n if mode == 'linear':\\n # define and check the background time ranges\\n if subtime1 and (type(subtime1) == str):\\n [bsubtime1, esubtime1] = subtime1.split('~')\\n bsubtime1sec = qa.getvalue(qa.convert(qa.totime(bsubtime1), 's'))\\n esubtime1sec = qa.getvalue(qa.convert(qa.totime(esubtime1), 's'))\\n timebin1sec = esubtime1sec - bsubtime1sec\\n if timebin1sec < 0:\\n raise Exception('Negative timebin! Please check the \\\"subtime1\\\" parameter.')\\n casalog.post('Selected timerange 1: ' + subtime1 + ' as background for uv subtraction.')\\n else:\\n raise Exception('Please enter at least one timerange as the background')\\n if subtime2 and (type(subtime2) == str):\\n [bsubtime2, esubtime2] = subtime2.split('~')\\n bsubtime2sec = qa.getvalue(qa.convert(qa.totime(bsubtime2), 's'))\\n esubtime2sec = qa.getvalue(qa.convert(qa.totime(esubtime2), 's'))\\n timebin2sec = esubtime2sec - bsubtime2sec\\n if timebin2sec < 0:\\n raise Exception('Negative timebin! Please check the \\\"subtime2\\\" parameter.')\\n timebin2 = str(timebin2sec) + 's'\\n casalog.post('Selected timerange 2: ' + subtime2 + ' as background for uv subtraction.')\\n # plus 1s is to ensure averaging over the entire timerange\\n else:\\n casalog.post('Timerange 2 not selected, using only timerange 1 as background')\\n\\n # Select the background indicated by subtime1\\n ms_in.open(vis, nomodify=True)\\n # Select the spw id\\n # ms_in.msselect({'time': subtime1})\\n staql0 = {'time': subtime1, 'spw': ''}\\n if spw and (type(spw) == str):\\n staql0['spw'] = spwlist[s]\\n else:\\n staql0['spw'] = staql['spw']\\n ms_in.msselect(staql0)\\n rec1 = ms_in.getdata(['data', 'time', 'axis_info'], ifraxis=True)\\n # print('shape of the frequency matrix ',rec1['axis_info']['freq_axis']['chan_freq'].shape)\\n sz1 = rec1['data'].shape\\n print('dimension of selected background 1', rec1['data'].shape)\\n # the data shape is (n_pol,n_channel,n_baseline,n_time), no need to reshape\\n # rec1['data']=rec1['data'].reshape(sz1[0],sz1[1],sz1[2],nspw,sz1[3]/nspw,order='F')\\n # print('reshaped rec1 ', rec1['data'].shape)\\n rec1avg = np.average(rec1['data'], axis=3)\\n casalog.post('Averaging the visibilities in subtime1: ' + subtime1)\\n ms_in.close()\\n if subtime2 and (type(subtime2) == str):\\n ms_in.open(vis, nomodify=True)\\n # Select the spw id\\n staql0 = {'time': subtime2, 'spw': ''}\\n if spw and (type(spw) == str):\\n staql0['spw'] = spwlist[s]\\n else:\\n staql0['spw'] = staql['spw']\\n ms_in.msselect(staql0)\\n rec2 = ms_in.getdata(['data', 'time', 'axis_info'], ifraxis=True)\\n sz2 = rec2['data'].shape\\n print('dimension of selected background 2', rec2['data'].shape)\\n # rec2['data']=rec2['data'].reshape(sz2[0],sz2[1],sz2[2],nspw,sz2[3]/nspw,order='F')\\n # print('reshaped rec1 ', rec2['data'].shape)\\n rec2avg = np.average(rec2['data'], axis=3)\\n ms_in.close()\\n casalog.post('Averaged the visibilities in subtime2: ' + subtime2)\\n if subtime1 and (not subtime2):\\n casalog.post('Only \\\"subtime1\\\" is defined, subtracting background defined in subtime1: ' + subtime1)\\n t1 = (np.amax(rec1['time']) + np.amin(rec1['time'])) / 2.\\n print('t1: ', qa.time(qa.quantity(t1, 's'), form='ymd', prec=10))\\n for i in range(ntim):\\n orec['data'][:, :, :, i] -= rec1avg\\n if reverse:\\n orec['data'][:, :, :, i] = -orec['data'][:, :, :, i]\\n if subtime1 and subtime2 and (type(subtime2) == str):\\n casalog.post(\\n 'Both subtime1 and subtime2 are specified, doing linear interpolation between \\\"subtime1\\\" and \\\"subtime2\\\"')\\n t1 = (np.amax(rec1['time']) + np.amin(rec1['time'])) / 2.\\n t2 = (np.amax(rec2['time']) + np.amin(rec2['time'])) / 2.\\n touts = orec['time']\\n print('t1: ', qa.time(qa.quantity(t1, 's'), form='ymd', prec=10))\\n print('t2: ', qa.time(qa.quantity(t2, 's'), form='ymd', prec=10))\\n for i in range(ntim):\\n tout = touts[i]\\n if tout > np.amax([t1, t2]):\\n tout = np.amax([t1, t2])\\n elif tout < np.amin([t1, t2]):\\n tout = np.amin([t1, t2])\\n orec['data'][:, :, :, i] -= (rec2avg - rec1avg) * (tout - t1) / (t2 - t1) + rec1avg\\n if reverse:\\n orec['data'][:, :, :, i] = -orec['data'][:, :, :, i]\\n elif mode == 'highpass':\\n if smoothtype != 'flat' and smoothtype != 'hanning' and smoothtype != 'hamming' and smoothtype != 'bartlett' and smoothtype != 'blackman':\\n raise Exception('Unknown smoothtype ' + str(smoothtype))\\n if smoothaxis == 'time':\\n if smoothwidth <= 0 or smoothwidth >= ntim:\\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\\n else:\\n for i in range(orec['data'].shape[0]):\\n for j in range(nchan):\\n for k in range(nbl):\\n orec['data'][i, j, k, :] -= su.smooth(orec['data'][i, j, k, :],\\n smoothwidth,\\n smoothtype)\\n if smoothaxis == 'freq':\\n if smoothwidth <= 0 or smoothwidth >= nchan:\\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\\n else:\\n for i in range(orec['data'].shape[0]):\\n for j in range(nbl):\\n for k in range(ntim):\\n orec['data'][i, :, j, k] -= su.smooth(orec['data'][i, :, j, k],\\n smoothwidth,\\n smoothtype)\\n elif mode == 'lowpass':\\n if smoothtype != 'flat' and smoothtype != 'hanning' and smoothtype != 'hamming' and smoothtype != 'bartlett' and smoothtype != 'blackman':\\n raise Exception('Unknown smoothtype ' + str(smoothtype))\\n if smoothaxis == 'time':\\n if smoothwidth <= 0 or smoothwidth >= ntim:\\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\\n else:\\n for i in range(orec['data'].shape[0]):\\n for j in range(nchan):\\n for k in range(nbl):\\n orec['data'][i, j, k, :] = su.smooth(orec['data'][i, j, k, :],\\n smoothwidth,\\n smoothtype)\\n if smoothaxis == 'freq':\\n if smoothwidth <= 0 or smoothwidth >= nchan:\\n raise Exception('Specified smooth width is <=0 or >= the total number of ' + smoothaxis)\\n else:\\n for i in range(orec['data'].shape[0]):\\n for j in range(nbl):\\n for k in range(ntim):\\n orec['data'][i, :, j, k] = su.smooth(orec['data'][i, :, j, k],\\n smoothwidth,\\n smoothtype)\\n else:\\n raise Exception('Unknown mode' + str(mode))\\n except Exception as instance:\\n print('*** Error ***', instance)\\n\\n # orec['data']=orec['data'].reshape(szo[0],szo[1],szo[2],szo[3],order='F')\\n # put the modified data back into the output visibility set\\n del orec['time']\\n del orec['axis_info']\\n # ms_in.open(outputvis,nomodify=False)\\n # if not splitsel:\\n # outputvis is identical to input visibility, do the selection\\n # if timerange and (type(timerange==str)):\\n # datams.msselect({'time':timerange})\\n # if spw and (type(spw)==str):\\n # datams.selectinit(datadescid=int(spwid))\\n # nchan=int(echan)-int(bchan)+1\\n # datams.selectchannel(nchan,int(bchan),1,1)\\n # if not spw and not timerange:\\n # data selection is not made\\n # datams.selectinit(datadescid=0)\\n # else:\\n # outputvis is splitted, selections have already applied, select all the data\\n # datams.selectinit(datadescid=0)\\n datams.putdata(orec)\\n datams.close()\\n datamsmd.done()\",\n \"def vec2scal(self, property='curl'):\\n # replace few common names\\n property='vorticity' if property == 'curl' else property\\n property = 'tke' if property == 'ken' else property\\n property='vorticity' if property == 'vort' else property\\n \\n method_name = str(property)\\n method = getattr(self, method_name, lambda: \\\"nothing\\\")\\n \\n if len(self._obj.attrs['variables']) <= 4: # only x,y,u,v\\n self._obj.attrs['variables'].append(property)\\n else:\\n self._obj.attrs['variables'][-1] = property\\n \\n return method()\",\n \"def _make_msqrd_and_masses_v_l_l(\\n model: SingleRhNeutrinoModel, genv: Generation, genl1: Generation, genl2: Generation\\n):\\n\\n genn = model.gen\\n ml1 = _lepton_masses[genl1]\\n ml2 = _lepton_masses[genl2]\\n\\n if genn == genv == genl1 == genl2:\\n masses = (0.0, ml1, ml1)\\n\\n def msqrd(s, t):\\n return _msqrd_v_l_l(s, t, model, ml1)\\n\\n elif (genn == genv) and (genl1 == genl2):\\n masses = (0.0, ml1, ml1)\\n\\n def msqrd(s, t):\\n return _msqrd_v_f_f(s, t, model, ml1)\\n\\n elif (genn == genl1) and (genv == genl2):\\n mu, md, ml = 0.0, ml2, ml1\\n masses = (mu, md, ml)\\n\\n def msqrd(s, t):\\n return _msqrd_l_u_d(s, t, model, mu, md, ml, 1.0)\\n\\n elif (genn == genl2) and (genv == genl1):\\n mu, md, ml = 0.0, ml1, ml2\\n masses = (mu, md, ml)\\n\\n def msqrd(s, t):\\n return _msqrd_l_u_d(s, t, model, mu, md, ml, 1.0)\\n\\n else:\\n masses = (0.0, ml1, ml2)\\n\\n def msqrd(s, t):\\n return np.zeros_like(s)\\n\\n return msqrd, masses\",\n \"def uvsInv(mot):\\n ####################\\n # TODO - part 1a\\n # x' to x and y' to y is just reverse direction\\n u1 = -mot[0]\\n v1 = -mot[1]\\n \\n # w' to w is solved via getting (w-w')/w' in terms of the original s\\n sNew = -mot[2]/(mot[2]+1)\\n \\n # new motion has moved center aka projection of x0, y0 by motion\\n x0 = mot[3] + mot[0]\\n y0 = mot[4] + mot[1]\\n motinv = np.array([u1, v1, sNew, x0, y0])\\n ####################\\n\\n return motinv\",\n \"def multiscale(m, r):\\n from neuropype_ephy.mse import get_mse_multiple_sensors\\n from nipype.interfaces.utility import Function\\n mse = pe.Node(interface=Function(input_names=['ts_file', 'm', 'r'],\\n output_names=['mse_file'],\\n function=get_mse_multiple_sensors),\\n name='mse')\\n\\n mse.inputs.m = m\\n mse.inputs.r = r\\n return mse\",\n \"def vxvyvz(ra, dec, l, b, mura, mudec, vrad, dist, parallax=False, vlsr=220, vsun=(-11.1, 12.24, 7.25), zsun=0, rsun=8,\\n\\t\\t emura=None, emudec=None, evrad=None, edist=None, MCerror=False):\\n\\n\\tif parallax:\\n\\t\\tdist_new = ut.parallax_to_distance(dist)\\n\\t\\tif edist is not None: edist_new = edist * dist * dist\\n\\telse:\\n\\t\\tdist_new = dist\\n\\t\\tedist_new = edist\\n\\n\\tmul, mub = co.pmrapmdec_to_pmllpmbb(mura, mudec, ra, dec, degree=True).T\\n\\n\\txs, ys, zs, vxs, vys, vzs = co.sphergal_to_rectgal(l, b, dist_new, vrad, mul, mub, degree=True).T\\n\\n\\tRs = np.sqrt(xs * xs + ys * ys)\\n\\n\\tvsun = np.array([0., vlsr, 0., ]) + np.array(vsun)\\n\\t# vsun=(0,0,0)\\n\\n\\tR, phi, Z = co.XYZ_to_galcencyl(xs, ys, zs, Zsun=zsun, Xsun=rsun).T\\n\\n\\tif edist is not None:\\n\\t\\teR = np.abs(edist_new * np.cos(b * np.pi / 180))\\n\\t\\teZ = np.abs(edist_new * np.sin(b * np.pi / 180))\\n\\telse:\\n\\t\\teR = np.nan\\n\\t\\teZ = np.nan\\n\\n\\tvR, vT, vZ = co.vxvyvz_to_galcencyl(vxs, vys, vzs, R, phi, Z, vsun=vsun, Xsun=rsun, Zsun=zsun,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tgalcen=True).T\\n\\n\\tif emura is not None and emudec is not None and evrad is not None and edist is not None:\\n\\t\\tcovpmrapmdec = np.zeros((len(emura), 2, 2))\\n\\t\\tcovpmrapmdec[:, 0, 0] = emura\\n\\t\\tcovpmrapmdec[:, 1, 1] = emudec\\n\\t\\tcovpmlpmb = co.cov_pmrapmdec_to_pmllpmbb(covpmrapmdec, ra, dec, degree=True)\\n\\t\\tcovV = co.cov_dvrpmllbb_to_vxyz(dist, edist, evrad, mul, mub, covpmlpmb, l, b, plx=parallax, degree=True)\\n\\n\\t\\teVx, eVy, eVz = covV[:, 0, 0], covV[:, 1, 1], covV[:, 2, 2]\\n\\t\\txg = xs - rsun\\n\\t\\ttheta = np.arctan2(ys, xg)\\n\\t\\tct = np.cos(theta)\\n\\t\\tst = np.sin(theta)\\n\\t\\teVR = np.sqrt(eVx * eVx * ct * ct + eVy * eVy * st * st)\\n\\t\\teVT = np.sqrt(eVx * eVx * st * st + eVy * eVy * ct * ct)\\n\\n\\t\\treturn Rs, R, Z, vZ, vR, vT, eR, eZ, eVR, eVT, eVz\\n\\n\\treturn Rs, R, Z, vZ, vR, vT\",\n \"def Vminpu(*args):\\n # Getter\\n if len(args) == 0:\\n return CheckForError(lib.Generators_Get_Vminpu())\\n\\n # Setter\\n Value, = args\\n CheckForError(lib.Generators_Set_Vminpu(Value))\",\n \"def mi_pressure_vessel(self, u):\\n assert len(u) == 4, 'MI Pressure vessel design needs to specify 4 parameters.'\\n R = u[0]\\n L = u[1]\\n ts = u[2]\\n th = u[3]\\n fitness = 0.6224 * R * ts * L + 1.7781 * R ** 2 * th + 3.1611 * ts ** 2 * L + 19.8621 * R * ts ** 2\\n return fitness\",\n \"def _msqrd_v_f_f(s, t, model: SingleRhNeutrinoModel, mf: float):\\n mx = model.mx\\n u = 0.5 * np.tan(2 * model.theta)\\n\\n return (\\n -2\\n * u**2\\n * GF**2\\n * (\\n 2 * mf**4 * (1 - 4 * SW**2 + 8 * SW**4)\\n + 2 * mf**2 * (mx**2 - s - 2 * (1 - 4 * SW**2 + 8 * SW**4) * t)\\n + (1 - 4 * SW**2 + 8 * SW**4)\\n * (s**2 + 2 * s * t + 2 * t**2 - mx**2 * (s + 2 * t))\\n )\\n )\",\n \"def target_velocity(self, s):\\n # YOUR CODE HERE\\n if s > self.total_length:\\n s = self.total_length\\n angular = np.array([0, 0 ,0])\\n else:\\n angular = np.array([0,0,self.targ_angular])\\n\\n theta = s/self.total_length*self.angle\\n v_x = np.cos(theta)*self.targ_speed\\n if self.left_turn:\\n v_y = np.sin(theta)*self.targ_speed\\n else:\\n v_y = -np.sin(theta)*self.targ_speed\\n \\n linear = np.array([v_x, v_y, 0])\\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\\n \\n toRet = [linear, angular]\\n \\n return toRet\",\n \"def create_flux_vector_pms_gr(self):\\n soma_prod = 0\\n soma_inj = 0\\n lim4 = 1e-4\\n store_velocity = {}\\n store_flux = {}\\n for primal in self.primals:\\n #1\\n primal_id = self.mb.tag_get_data(self.primal_id_tag, primal, flat=True)[0]\\n primal_id = self.ident_primal[primal_id]\\n fine_elems_in_primal = self.mb.get_entities_by_handle(primal)\\n for volume in fine_elems_in_primal:\\n #2\\n flux = {}\\n velocity = {}\\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\\n centroid_volume = self.mesh_topo_util.get_average_position([volume])\\n z_vol = self.tz - centroid_volume[2]\\n adjs_vol = self.mesh_topo_util.get_bridge_adjacencies(volume, 2, 3)\\n gid_vol = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\\n for adj in adjs_vol:\\n #3\\n gid_adj = self.mb.tag_get_data(self.global_id_tag, adj, flat=True)[0]\\n if adj not in fine_elems_in_primal:\\n #4\\n pvol = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\\n padj = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\\n #3\\n else:\\n #4\\n pvol = self.mb.tag_get_data(self.pcorr_tag, volume, flat=True)[0]\\n padj = self.mb.tag_get_data(self.pcorr_tag, adj, flat=True)[0]\\n #3\\n kadj = self.mb.tag_get_data(self.perm_tag, adj).reshape([3, 3])\\n centroid_adj = self.mesh_topo_util.get_average_position([adj])\\n z_adj = self.tz - centroid_adj[2]\\n direction = centroid_adj - centroid_volume\\n unit = direction/np.linalg.norm(direction)\\n #unit = vetor unitario na direcao de direction\\n uni = self.unitary(direction)\\n # uni = valor positivo do vetor unitario\\n kvol = np.dot(np.dot(kvol,uni),uni)\\n kadj = np.dot(np.dot(kadj,uni),uni)\\n keq = self.kequiv(kvol, kadj)/(self.mi)\\n keq2 = keq\\n keq = keq*(np.dot(self.A, uni))\\n pvol2 = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\\n padj2 = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\\n grad_p = (padj - pvol)/float(abs(np.dot(direction, uni)))\\n grad_z = (z_adj - z_vol)/float(abs(np.dot(direction, uni)))\\n grad_p2 = (padj2 - pvol2)/float(abs(np.dot(direction, uni)))\\n q = (grad_p)*keq - grad_z*keq*self.gama\\n print((grad_p)*keq)\\n print(- grad_z*keq*self.gama)\\n print(q)\\n print(self.store_flux_pf_gr[volume][tuple(unit)])\\n print('\\\\n')\\n import pdb; pdb.set_trace()\\n\\n if gid_adj > gid_vol:\\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\\n else:\\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\\n\\n flux[tuple(unit)] = q\\n velocity[tuple(unit)] = v\\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\\n\\n #2\\n # print(gid_vol)\\n # print(velocity)\\n # print('\\\\n')\\n # import pdb; pdb.set_trace()\\n store_flux[volume] = flux\\n self.mb.tag_set_data(self.flux_fine_pms_tag, volume, sum(flux.values()))\\n # flt = sum(flux.values())\\n # if volume not in self.wells_inj and volume not in self.wells_prod:\\n # lim4 = 1e-7\\n # if abs(flt) > lim4:\\n # print(gid_vol)\\n # print(flt)\\n # import pdb; pdb.set_trace()\\n # flt = sum(flux.values())\\n store_velocity[volume] = velocity\\n\\n for volume in set(self.all_fine_vols) - set(self.wells):\\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\\n values = store_flux[volume].values()\\n if sum(values) > lim4:\\n print('fluxo multiescala nao esta dando conservativo')\\n print('gid:{0}'.format(gid))\\n print(sum(values))\\n import pdb; pdb.set_trace()\\n\\n with open('fluxo_multiescala_gr.txt', 'w') as arq:\\n for volume in self.wells:\\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat= True)[0]\\n values = store_flux[volume].values()\\n if volume in self.wells_inj:\\n soma_inj += sum(values)\\n else:\\n soma_prod += sum(values)\\n arq.write('gid:{0} , fluxo:{1}\\\\n'.format(gid, sum(values)))\\n arq.write('\\\\n')\\n arq.write('soma_inj:{0}\\\\n'.format(soma_inj))\\n arq.write('soma_prod:{0}\\\\n'.format(soma_prod))\\n\\n return store_flux\",\n \"def _calc_msve(self):\\n v = []\\n for state in self._env.state_iterator():\\n feature_vector = self._features.vector(state)\\n v.append(utils.state_value(feature_vector, self.theta))\\n\\n self.msve.append(utils.rmse(v, self._true_values))\",\n \"def get_velocity(self, message):\\n #print('**************** vel ')\\n self.velocity = message.data\\n self.state[0:self.ndegres] = self.velocity[0:self.ndegres]\",\n \"def scale_uv(self):\\n self.u = [i * self.scale * self.scaleratio for i in self.u]\\n self.v = [i * self.scale for i in self.v]\",\n \"def add_velocity(self, Mextra=0, period=0, model=1):\\n \\n if self.npart == 0:\\n self.vel = transpose(array([[],[]]))\\n return\\n \\n print(\\\" Adding velocities...\\\")\\n \\n if model==0: vel = zeros((self.npart, 2))\\n \\n elif model in [1,2]:\\n print(\\\" Setting keplerian velocities...\\\")\\n pos = self.pos - self.center\\n radii = norm(pos, axis=1)\\n self.v_kep = sqrt(Mextra * G / radii)\\n if model==2: Mextra += sum(self.mass)\\n v_kep = sqrt(Mextra * G / radii)\\n vel = matmul(pos / radii[:, newaxis], array([[0, 1], [-1, 0]])) * v_kep[:, newaxis]\\n \\n\\n elif model==3:\\n print(\\\" Setting velocities from binary period...\\\")\\n if period==0:\\n print(\\\" Incorrect period for setting disk velocities.\\\")\\n print(\\\" Disk velocities are set to zero.\\\")\\n vel = zeros((self.npart, 2))\\n \\n else:\\n pos = self.pos - self.center\\n v_ang = 1 / float(period) \\n vel = v_ang * matmul(pos, array([[0, 1], [-1, 0]]))\\n \\n else:\\n print(\\\"Model must be 0, 1, 2 or 3.\\\")\\n print(\\\" {:d} was given. Exiting.\\\".format(model))\\n exit()\\n \\n \\n self.vel = vel\",\n \"def test_set_pv(self):\\n s = State(substance=\\\"water\\\")\\n s.pv = Q_(101325.0, \\\"Pa\\\"), Q_(0.4772010021515822, \\\"m**3/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.pv[0], Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.pv[1], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\\n s.pv = Q_(101325.0, \\\"Pa\\\"), Q_(3.189303132125469, \\\"m**3/kg\\\")\\n assert np.isclose(s.T, Q_(700.9882316847855, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.pv[0], Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.pv[1], Q_(3.189303132125469, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(3013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(8623.283568815832, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(3.189303132125469, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(3336406.139862406, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def scale(self,s):\\n return Vector(self.x * s, self.y * s, self.z * s)\",\n \"def get_uv(u, v):\\n uv = np.zeros((2, 2))\\n uv[0][0] = u[0]\\n uv[1][0] = u[1]\\n uv[0][1] = v[0]\\n uv[1][1] = v[1]\\n return uv\",\n \"def ev(knotvec, coeffs, u):\\n assert len(coeffs) == knotvec.numdofs, 'Wrong size of coefficient vector'\\n return scipy.interpolate.splev(u, (knotvec.kv, coeffs, knotvec.p))\",\n \"def test_set_Tv(self):\\n s = State(substance=\\\"water\\\")\\n s.Tv = Q_(400.0, \\\"K\\\"), Q_(1.801983936953226, \\\"m**3/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.Tv[0], Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.Tv[1], Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(2547715.3635084038, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(7496.2021523754065, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cp, Q_(2009.2902478486988, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cv, Q_(1509.1482452129906, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(2730301.3859201893, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def v(w,s):\\n return w\",\n \"def apply_uvs(mesh, bsp_verts):\\n\\n mesh.uv_textures.new(\\\"UVs\\\")\\n bm = bmesh.new()\\n bm.from_mesh(mesh)\\n\\n if hasattr(bm.faces, \\\"ensure_lookup_table\\\"): \\n bm.faces.ensure_lookup_table()\\n\\n uv_layer = bm.loops.layers.uv[0]\\n\\n for face_idx, current_face in enumerate(bm.faces):\\n current_face.loops[0][uv_layer].uv = bsp_verts[current_face.loops[0].vert.index][1]\\n current_face.loops[1][uv_layer].uv = bsp_verts[current_face.loops[1].vert.index][1]\\n current_face.loops[2][uv_layer].uv = bsp_verts[current_face.loops[2].vert.index][1]\\n \\n bm.to_mesh(mesh)\",\n \"def multiply_vector(self, dv, spm):\\n product = []\\n for a, b in zip(dv, spm):\\n product.append(a * b)\\n return product\",\n \"def convert_sh_to_vp(sh, patm, hygro_params=HygroParams()):\\n\\n return sh * patm / ((1.0 - hygro_params.mwr) * sh + hygro_params.mwr)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67565304","0.6339013","0.5813282","0.55218333","0.55123705","0.54566956","0.54150814","0.5345006","0.53043866","0.52986836","0.5298433","0.5282433","0.5152977","0.5144597","0.50879806","0.50478345","0.50315887","0.5008072","0.5002643","0.49997583","0.49930182","0.49737152","0.4970707","0.4952324","0.49502742","0.49151593","0.49150982","0.49031606","0.48963678","0.48896614","0.48766762","0.48716906","0.48673844","0.48636678","0.48465672","0.48263618","0.480913","0.47908273","0.47827542","0.47745848","0.47510663","0.4728377","0.47193262","0.47063947","0.46800846","0.4675409","0.46725273","0.46572274","0.46547654","0.46490234","0.46441552","0.46409485","0.4634252","0.46313134","0.46299484","0.46267632","0.46259594","0.46226352","0.4613823","0.4608441","0.4607038","0.4604633","0.46014306","0.45932344","0.4585809","0.45786256","0.45766968","0.45672083","0.45612255","0.45581704","0.4557912","0.45490676","0.45433486","0.45342126","0.45306548","0.45238855","0.45215586","0.45213294","0.45202073","0.45169798","0.45162413","0.45116296","0.45045614","0.45024544","0.44962364","0.4486159","0.44850996","0.44809815","0.4476018","0.44717306","0.44670445","0.44669214","0.44625884","0.44521165","0.44508713","0.44495684","0.4449203","0.44469854","0.44454083","0.44425985"],"string":"[\n \"0.67565304\",\n \"0.6339013\",\n \"0.5813282\",\n \"0.55218333\",\n \"0.55123705\",\n \"0.54566956\",\n \"0.54150814\",\n \"0.5345006\",\n \"0.53043866\",\n \"0.52986836\",\n \"0.5298433\",\n \"0.5282433\",\n \"0.5152977\",\n \"0.5144597\",\n \"0.50879806\",\n \"0.50478345\",\n \"0.50315887\",\n \"0.5008072\",\n \"0.5002643\",\n \"0.49997583\",\n \"0.49930182\",\n \"0.49737152\",\n \"0.4970707\",\n \"0.4952324\",\n \"0.49502742\",\n \"0.49151593\",\n \"0.49150982\",\n \"0.49031606\",\n \"0.48963678\",\n \"0.48896614\",\n \"0.48766762\",\n \"0.48716906\",\n \"0.48673844\",\n \"0.48636678\",\n \"0.48465672\",\n \"0.48263618\",\n \"0.480913\",\n \"0.47908273\",\n \"0.47827542\",\n \"0.47745848\",\n \"0.47510663\",\n \"0.4728377\",\n \"0.47193262\",\n \"0.47063947\",\n \"0.46800846\",\n \"0.4675409\",\n \"0.46725273\",\n \"0.46572274\",\n \"0.46547654\",\n \"0.46490234\",\n \"0.46441552\",\n \"0.46409485\",\n \"0.4634252\",\n \"0.46313134\",\n \"0.46299484\",\n \"0.46267632\",\n \"0.46259594\",\n \"0.46226352\",\n \"0.4613823\",\n \"0.4608441\",\n \"0.4607038\",\n \"0.4604633\",\n \"0.46014306\",\n \"0.45932344\",\n \"0.4585809\",\n \"0.45786256\",\n \"0.45766968\",\n \"0.45672083\",\n \"0.45612255\",\n \"0.45581704\",\n \"0.4557912\",\n \"0.45490676\",\n \"0.45433486\",\n \"0.45342126\",\n \"0.45306548\",\n \"0.45238855\",\n \"0.45215586\",\n \"0.45213294\",\n \"0.45202073\",\n \"0.45169798\",\n \"0.45162413\",\n \"0.45116296\",\n \"0.45045614\",\n \"0.45024544\",\n \"0.44962364\",\n \"0.4486159\",\n \"0.44850996\",\n \"0.44809815\",\n \"0.4476018\",\n \"0.44717306\",\n \"0.44670445\",\n \"0.44669214\",\n \"0.44625884\",\n \"0.44521165\",\n \"0.44508713\",\n \"0.44495684\",\n \"0.4449203\",\n \"0.44469854\",\n \"0.44454083\",\n \"0.44425985\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77553666"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19874,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned along the lat axis but whose values are the latitudes"},"document":{"kind":"string","value":"def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv"},"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 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 lat_lons(self):","def vector(self):\n return np.array([self.lat, self.lng])","def spatial_var(map_):\n expx, expy = spatial_expval(map_)\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def get_latitude0(self):\n return self.B","def geo(self):\n return vec2geo_linear_signed(self)","def lat(self):\n return self['lat']","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def get_lats(self, variables):\n\n return self._get_variable(variables, self.LATS_VARIABLE)","def spatial(self):","def lat(self):\n return self._grid.lat[self._lat_indices]","def _getlats(self):\n lats = 90. - np.degrees(self.zeros)\n return lats","def spatial(self):\n return self.spatial_x, self.spatial_y, self.spatial_data","def location(self):\n return np.array((self.latitude, self.longitude))","def location(self):\n return np.array((self.latitude, self.longitude))","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 latitude(self):\n return self.coordinates[0]","def spatial(self):\n return self._spatial","def latitude(self, lat):\n data = float(lat[1:])\n if lat[0] == \"N\":\n return data\n else:\n return -data","def project(self, (lng, lat)):\n x = lng * DEG_TO_RAD\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\n y = lat * DEG_TO_RAD\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)","def ns(self):\n return self.lat","def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\n\n latent_coords = []\n\n for batch in data_sample:\n # run encoder\n coords = model.encoder(batch)\n latent_coords.append(coords)\n\n # return latent (per jet?)\n return np.concatenate(latent_coords, axis=0)","def lat(self):\n return self._lat","def get_latitude(self):\n return self.B + self.dB","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 spatialData(self):\n return self.__spatial_data","def broadcast_lonlat(ds, verbose=True):\n if 'lon' not in ds.variables:\n ds.coords['lon'] = ds['x']\n if 'lat' not in ds.variables:\n ds.coords['lat'] = ds['y']\n \n if len(ds['lon'].dims) < 2:\n ds.coords[\"lon\"] = ds[\"lon\"] * xr.ones_like(ds[\"lat\"])\n if len(ds['lat'].dims) < 2:\n ds.coords[\"lat\"] = xr.ones_like(ds[\"lon\"]) * ds[\"lat\"]\n return ds","def effective_latitude_xr(self):\n\n grid_areas_ddf = self.grid_area_xr.to_dataframe().reset_index()\n grid_areas_ddf = grid_areas_ddf[\n ['temp_bucket', 'cdf_eff_lat_deg', 'time']\n ]\n\n merge_ddf = (\n self.data_array_dask_df\n .reset_index(drop=True)\n #.repartition(npartitions=100)\n .merge(grid_areas_ddf,\n on=['time', 'temp_bucket'],\n how='left')\n )\n\n eff_lat_xr = self.dask_data_to_xarray(merge_ddf,\n var='cdf_eff_lat_deg')\n\n eff_lat_xr.name = 'effective_latitude'\n\n return eff_lat_xr","def __init__(self, lat, long):\n\n self.lat = float(lat)\n self.long = float(long)\n self.cartesian = None","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","def spatial_dimension(self):\r\n pass","def g0(lat):\n return (980.6160 * (1. - 0.0026372 * np.cos(2*lat*np.pi/180.)\n + 0.0000059 * np.cos(2*lat*np.pi/180.)**2))","def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\n\n if var.ndim == 3: # 3D variable\n zmax, imax, jmax = var.shape\n threeD = True\n elif var.ndim == 2: # 2D variable\n imax, jmax = var.shape\n threeD = False\n else:\n print 'extract_loc: check variable dimensions'\n return\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 # arrays to store weights and data to be averaged\n if threeD: # 3D variable\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n if MA.isMA(var): # mask weights\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\n else:\n dist_m = N.array(N.resize(dist,var.shape))\n else: # 2D variable\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\n if MA.isMA(var):\n dist_m = MA.array(dist,mask=var.mask) # mask weights\n else:\n dist_m = N.array(dist)\n\n # get the 4 model grid points and compute weights\n n = 0\n for i in Ilist:\n for j in Jlist:\n wghts[...,n] = 1./dist_m[...,i,j]\n data[...,n] = var[...,i,j]\n n += 1\n\n # compute weighted average\n wavg = MA.average(data,axis=-1,weights=wghts)\n return wavg","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 northing(self):\r\n x, y = self.lonlat2xy(self.longitude, self.latitude)\r\n return y","def getPoint(self, a):\n lng = self.source.center.lng + (self.target.center.lng - self.source.center.lng) * min(a, 1)\n lat = self.source.center.lat + (self.target.center.lat - self.source.center.lat) * min(a, 1)\n return lng, lat","def extract_region_latlon(cube, lat_bounds):\n\n southern_lat, northern_lat = lat_bounds\n lat_constraint = iris.Constraint(latitude=lambda cell: southern_lat <= cell < northern_lat)\n cube = cube.extract(lat_constraint)\n\n return cube","def convert(self, lat, lon):\r\n a = self.a\r\n b = self.b\r\n long0 = self.long0\r\n k0 = self.k0\r\n dx = self.dx\r\n\r\n e = (1 - b ** 2 / a ** 2) ** 0.5\r\n e2 = e ** 2 / (1 - e ** 2)\r\n n = (a - b) / (a + b)\r\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\r\n p = lon - long0\r\n\r\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\r\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\r\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\r\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\r\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\r\n\r\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\r\n\r\n K1 = S * k0\r\n K2 = k0 * nu * sin(2 * lat)/4.0\r\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\r\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\r\n\r\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\r\n\r\n K4 = k0 * nu * cos(lat)\r\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\r\n\r\n x = K4 * p + K5 * (p ** 3) + dx\r\n return x, y","def _getXYZ ( lon, lat ):\n d2r = pi / 180.\n rlon, rlat = ( d2r * lon, d2r * lat )\n x = cos(rlat) * cos(rlon)\n y = cos(rlat) * sin(rlon)\n z = sin(rlat)\n return (x,y,z)","def __getitem__(self, idx):\n # stored image have binary and shape (H x W) so multiply by 255 to get pixel\n # values + add dimension\n sample = np.expand_dims(self.imgs[idx] * 255, axis=-1)\n\n # ToTensor transforms numpy.ndarray (H x W x C) in the range\n # [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]\n sample = self.transforms(sample)\n\n lat_value = self.lat_values[idx]\n return sample, lat_value","def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\n # Get Value\n vrow = invar[kpt,:]\n \n # Place into variable\n mappt = np.zeros(nlat5*nlon5)*np.nan\n mappt[okpts] = vrow\n mappt = mappt.reshape(nlat5,nlon5)\n return mappt","def lat_lon(self):\n if self._lat_lon is None:\n if 'coordinates' in self:\n self._lat_lon = self.coordinates\n else:\n self._lat_lon = self.meta\n lat_lon_cols = ['latitude', 'longitude']\n for c in self.meta.columns:\n if c.lower().startswith('lat'):\n lat_lon_cols[0] = c\n elif c.lower().startswith('lon'):\n lat_lon_cols[1] = c\n\n self._lat_lon = self._lat_lon[lat_lon_cols].values\n\n return self._lat_lon","def x(self) -> ir.FloatingValue:\n return ops.GeoX(self).to_expr()","def latitude(self):\n return self._state[0]","def global_coords(self) -> GlobalCoordsABC:","def __init__(self, true_lat, earth_radius):\n self.k = np.cos(np.radians(true_lat))\n self.true_scale_lats = [true_lat]\n self.earth_radius = earth_radius","def coordinates(self):","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_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 shot_lon_lat(self) -> list[tuple[float, float]]:\n if self._shot_lon_lat is None:\n if self.parent_granule.product == \"GEDI_L2A\":\n self._shot_lon_lat = list(\n zip(self[\"lon_lowestmode\"], self[\"lat_lowestmode\"])\n )\n elif self.parent_granule.product == \"GEDI_L1B\":\n self._shot_lon_lat = list(\n zip(\n self[\"geolocation/longitude_lastbin\"],\n self[\"geolocation/latitude_lastbin\"],\n )\n )\n else:\n raise NotImplementedError(\n \"No method to get main data for \"\n f\"product {self.parent_granule.product}\"\n )\n return self._shot_lon_lat","def ground_vec(Lat, Lon, eccentricity=None, major_axis=None):\n Lat, Lon = lat_lon_angle_check(Lat, Lon)\n are_two_arrays_equal(Lat,Lon)\n if (major_axis is None) or (eccentricity is None):\n major_axis, flattening = wgs84_param()\n eccentricity = (2*flattening) - (flattening**2)\n\n Lat, Lon = np.deg2rad(Lat.flatten()), np.deg2rad(Lon.flatten())\n Radius = np.divide(major_axis,\n np.sqrt(1.0 - eccentricity*np.sin(Lat)*np.sin(Lat)))\n Gx = np.array([Radius*np.cos(Lat)*np.cos(Lon),\n Radius*np.cos(Lat)*np.sin(Lon),\n Radius* (1 - eccentricity) * np.sin(Lat)])\n return Gx","def get_locality(self):\n return self.reference[REF_LOCALITY][REF_VALUE]","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 lat_lng(row):\r\n lat = row[\"latitude\"]\r\n lng = row[\"longitude\"]\r\n n = int(lat/GRANULARITY)\r\n nlat_start = n * GRANULARITY\r\n nlat_end = nlat_start + GRANULARITY\r\n nlg=int(lng/GRANULARITY)\r\n nlng_start = nlg * GRANULARITY\r\n nlng_end = nlng_start + GRANULARITY\r\n latlng=[(nlat_start,nlng_start), (nlat_start,nlng_end), (nlat_end,nlng_end), (nlat_end,nlng_start)]\r\n return latlng","def geo_transform(self):\n pass","def get_latitude(self, latitude):\n self.Latitude = latitude\n return self.Latitude","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 latents(self):\n self.assert_sampled()\n return self._representations","def find_longitude_var(nc,name):\n var_obj = nc.variables[name] # Find the corresponding variable object \n dimens = var_obj.dimensions # Find the names of the dimensions of variable\n for i in range(len(dimens)):\n # For each dimension find the corresponding variable\n var_dim = nc.variables[dimens[i]]\n if is_longitude_var(var_dim) == True:\n return var_obj # If longitude exists, return the variable object\n \n return None","def geo_topo_vector(longitude, latitude, elevation, jd):\n from astropy.coordinates import GCRS, EarthLocation\n from astropy.time import Time\n import numpy as np\n\n loc = EarthLocation(longitude, latitude, elevation)\n\n time = Time(jd, scale=\"utc\", format=\"jd\")\n itrs = loc.get_itrs(obstime=time)\n gcrs = itrs.transform_to(GCRS(obstime=time))\n\n r = gcrs.cartesian\n\n # convert from m to km\n x = r.x.value / 1000.0\n y = r.y.value / 1000.0\n z = r.z.value / 1000.0\n\n return np.array([x, y, z])","def GetParametricCoords(self):\n ...","def si_values(self):\n element_list = [\n self.x.to(u.m),\n self.y.to(u.m),\n self.z.to(u.m),\n self.v_x.to(u.m / u.s),\n self.v_y.to(u.m / u.s),\n self.v_z.to(u.m / u.s),\n ]\n return np.array([e.value for e in element_list], dtype=float)","def readDataLatLon(self, varName, lat, lon, **kwargs):\n # TODO: interpolate between lat and lon if necessary\n \n retList = []\n \n records = self._readRecords(varName, **kwargs)\n\n # get the index of the (lat,lon) pair\n lats, lons = records[0].latlons() \n latIdx, lonIdx = self._getIndex(lats, lons, lat, lon)\n\n for record in records:\n # We only care about the pressure levels\n if record.typeOfLevel == 'isobaricInhPa':\n # Append this value as a 2D 1x1 grid, NOTE: right now, just a value\n retList.append((record.level, record.values[latIdx][lonIdx]))\n\n retList.sort()\n\n presVec = np.ndarray((len(retList)))\n dataVec = np.ndarray((len(retList)))\n for i in range(len(retList)):\n presVec[i] = retList[i][0]\n dataVec[i] = retList[i][1]\n\n return presVec, dataVec","def geo(self):\n return self.query.geo","def unproject(self, (x, y)):\n lng = x/EARTH_RADIUS * RAD_TO_DEG\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\n return (lng, lat)","def position(self, longitudinal: float, lateral: float) -> np.ndarray:\n raise NotImplementedError()","def lats(self):\n return self._origin.lat","def lats(self):\n return self._origin.lat","def nancay():\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)","def select(ds, longitude, latitude, varname, T=None, Z=None, \n iT=None, iZ=None, extrap=False, extrap_val=None, locstream=False):\n \n assert not ((Z is not None) and (iZ is not None))\n assert not ((T is not None) and (iT is not None))\n \n if (isinstance(longitude, int)) or (isinstance(longitude, float)):\n longitude = [longitude]\n if (isinstance(latitude, int)) or (isinstance(latitude, float)):\n latitude = [latitude]\n latitude = np.asarray(latitude)\n longitude = np.asarray(longitude)\n\n if extrap:\n extrap_method = \"nearest_s2d\"\n else:\n extrap_method = None\n \n \n cf_var = get_var_cf(ds, varname)\n \n dr = ds.cf[cf_var]\n \n if not extrap:\n assertion = 'the input longitude range is outside the model domain'\n assert (longitude.min() >= dr.cf['longitude'].min()) and (longitude.max() <= dr.cf['longitude'].max()), assertion\n assertion = 'the input latitude range is outside the model domain'\n assert (latitude.min() >= dr.cf['latitude'].min()) and (latitude.max() <= dr.cf['latitude'].max()), assertion\n \n ## Horizontal interpolation ##\n \n # grid of lon/lat to interpolate to, with desired ending attributes\n if latitude.ndim == 1:\n ds_out = xr.Dataset(\n {\n \"lat\": ([\"lat\"], latitude, dict(axis=\"Y\", units='degrees_north', standard_name=\"latitude\")),\n \"lon\": ([\"lon\"], longitude, dict(axis=\"X\", units='degrees_east', standard_name=\"longitude\")),\n }\n )\n elif latitude.ndim == 2:\n ds_out = xr.Dataset(\n {\n \"lat\": ([\"Y\",\"X\"], latitude, dict(units='degrees_north', standard_name=\"latitude\")),\n \"lon\": ([\"Y\",\"X\"], longitude, dict(units='degrees_east', standard_name=\"longitude\")),\n }\n )\n \n\n # set up regridder, which would work for multiple interpolations if desired\n regridder = xe.Regridder(dr, ds_out, \"bilinear\", extrap_method=extrap_method, locstream_out=locstream)\n\n # do regridding\n dr_out = regridder(dr, keep_attrs=True)\n \n \n ## Time and depth interpolation or iselection ##\n if iZ is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.isel(Z=iZ)\n \n if Z is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.interp(Z=Z)\n\n if iT is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.isel(T=iT)\n \n if T is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.interp(T=T)\n \n if extrap_val is not None:\n # returns 0 outside the domain by default. Assumes that no other values are exactly 0\n # and replaces all 0's with extrap_val if chosen.\n dr_out = dr_out.where(dr_out != 0, extrap_val)\n \n return dr_out","def get_latent(self):\n return copy.deepcopy(self._latent)","def lon(self):\n return self['lon']","def get_lonlat(self, row, col):\n\n if self.ndim != 2:\n raise DimensionError(('operation undefined '\n 'for %sD geometry ') % self.ndim)\n elif self.lons is None or self.lats is None:\n raise ValueError('lon/lat values are not defined')\n return self.lons[row, col], self.lats[row, col]","def get_map_values(self, lons, lats, ibin=None):\n theta = np.pi / 2. - np.radians(lats)\n phi = np.radians(lons)\n\n pix = hp.ang2pix(self.hpx.nside, theta, phi, nest=self.hpx.nest)\n\n if self.data.ndim == 2:\n return self.data[:, pix] if ibin is None else self.data[ibin, pix]\n else:\n return self.data[pix]","def transform(self, srid: ir.IntegerValue) -> GeoSpatialValue:\n return ops.GeoTransform(self, srid).to_expr()","def map(self, lat, long):\r\n rxy = self._r*np.sqrt(1-np.cos(lat))\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def sample_latent(self, x):\n latent_dist = self.encoder(x)\n latent_sample = self.reparameterize(*latent_dist)\n return latent_sample","def coords(self) -> Tuple[float, float]:\n return self.lat, self.lng","def get_geospatial(self):\n self.unimpl_base_class()","def CreateTargetGeoField(nbtimestep,latlen,lonlen):\n\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\n\n return pres_grid,u_grid,v_grid","def get_var(dataset, varname):\n \n import xarray as xr\n \n var = dataset[varname]\n time = dataset['TIME']\n lat = dataset['YDim']\n lon = dataset['XDim']\n\n da = xr.DataArray(var[:,:,:], coords=[time[:],lat[:],lon[:]], dims=['time','lat','lon'],\n attrs=var.attributes, name=varname)\n \n da['time'].attrs = time.attributes\n da['lat'].attrs = lat.attributes\n da['lon'].attrs = lon.attributes\n\n # Set _FillValue for coordinate arrays\n da.lat.encoding['_FillValue'] = 9.969209968386869e+36\n da.lon.encoding['_FillValue'] = 9.969209968386869e+36\n\n # To avoid conflicts between _FillValue and missing_value attributes when file is read\n da.attrs.pop('fmissing_value')\n da.attrs.pop('missing_value')\n \n return da","def get_spatial_info(cube, add_cyclic=False):\n\n if add_cyclic:\n data, x = add_cyclic_point(cube.data, coord=cube.coord('longitude').points)\n else:\n data = cube.data\n x = cube.coord('longitude').points\n\n y = cube.coord('latitude').points\n inproj = input_projections[cube.attributes['input_projection']]\n\n return data, x, y, inproj","def map(self, lat, long):\r\n rxy = self._r*lat/(np.pi/2)\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def __init__(self, unit_vector_3d):\n \n self.unit_vector = unit_vector_3d\n transposed_uv = np.transpose(self.unit_vector)\n self.x = transposed_uv[0] \n self.y = transposed_uv[1] \n self.z = transposed_uv[2]\n self.d = SkyCoord(self.x, self.y, self.z, \n unit = 'mpc', \n representation_type = 'cartesian', \n frame = 'icrs')\n self.d.representation_type = 'spherical'\n self.lons = self.d.galactic.l.wrap_at(360 * u.deg).deg\n self.lats = self.d.galactic.b.wrap_at(180 * u.deg).deg","def build_coordinates_map(self):\n\t\t# We need to keep track of which dimensions we can map\n\t\tmapped = []\n\t\t\n\t\t# First lets check for standard 1D coordinate variables. These are variables\n\t\t# that have the same name as one of the variables dimensions or 1D variables\n\t\t# sharing a dimension with the variable \n\t\tfor di in range (0,len(self.variable.dimensions)):\n\n\t\t\tdimension = self.variable.dimensions[di]\n\t\t\tdim_name = dimension.name\n\n\t\t\t# Find variables with same name as the dimension\n\t\t\tif dim_name in self.variable.group.variables.keys():\n\n\t\t\t\tcoord_variable = self.variable.group.variables[dim_name]\n\t\t\t\tself.coordinates_variables.append(coord_variable)\n\t\t\t\tmapped.append(dim_name)\n\t\t\t\t\n\t\t\t\t# See if we can use the units to find out what spatial/temporal variable this is from \n\t\t\t\t# the CF conventions\n\t\t\t\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\n\t\t\t\t\n\t\t\t\t# If we can't we just default to the dimension name\n\t\t\t\tif not coordinate_name:\n\t\t\t\t\tcoordinate_name = dim_name\n\t\t\t\t\n\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\t\t\t\n\t\t\t\t\n\t\t# Next lets see if we have a \"coordinates\" attribute we can use (CF convention)\n\t\tif self.variable.get_attribute('coordinates'):\n\t\t\t\n\t\t\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\n\t\t\t\t\t\t\n\t\t\t# Find each associated variable\n\t\t\tfor name in self.coordinates_names:\n\t\t\t\t\n\t\t\t\tif name in self.variable.group.variables.keys():\n\t\t\t\t\t\n\t\t\t\t\tcoord_variable = self.variable.group.variables[name]\n\t\t\t\t\tself.coordinates_variables.append(coord_variable)\n\n\t\t\t\t\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\n\t\t\t\t\t# See if we can find out what spatial/temporal variable this is\n\t\t\t\t\ttry:\n\t\t\t\t\t\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\n\t\t\t\t\texcept:\n\t\t\t\t\t\tcoordinate_name = name\n\n\t\t\t\t\t# Create the coordinates_mapping entry but with an empty dimensions map for now\n\t\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\n\t\t\t\t\t\t\n\t\t\t\t\t# Add each coordinates variable dimension to the mappable list and generate the map\n\t\t\t\t\t#print 'generating dimensions map for ', coord_variable.dimensions\n\t\t\t\t\tfor dimension in coord_variable.dimensions:\n\t\t\t\t\t\t#print dimension, coord_variable.dimensions\n\t\t\t\t\t\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\n\t\t\t\t\t\tif not dimension.name in mapped:\n\t\t\t\t\t\t\tmapped.append(dimension.name)\n\t\t\t\t\t\t\t\n\t\t# Setup shortcut to identify time coordinate variable\n\t\ttry:\n\t\t\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\n\t\t\tself.time_dim = self.coordinates_mapping['time']['map'][0]\n\t\texcept:\n\t\t\tself.time_variable = None\n\t\t\tself.time_dim = None\n\t\t\t\n\t\t# Shortcuts for latitude and longitude coordinate variables\n\t\ttry:\n\t\t\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\n\t\texcept:\n\t\t\tself.latitude_variable = None\n\n\t\ttry:\n\t\t\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\n\t\texcept:\n\t\t\tself.longitude_variable = None\n\n\t\ttry:\n\t\t\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\n\t\t\tself.level_dim = self.coordinates_mapping['level']['map'][0]\n\t\texcept:\n\t\t\tself.level_variable = None\n\t\t\tself.level_dim = None","def latitude_value(self):\n\n\t\t#Check if there is more than 1 result for the given location\n\t\tlocations = Nominatim().geocode(self.address, False)\n\n\t\tif len(locations) > 1:\n\t\t\tprint 'Please enter a more specific location. ie: City and State'\n\n\t\telse:\n\t\t\treturn Nominatim().geocode(self.address).latitude","def coord_proj(self):\r\n return self._coord_proj","def getlatlon(self):\n lat = np.pi/2.0 - self._th\n time = self.gettime()\n lon = self._phi - 2*np.pi*time/86164.09164\n return lat, lon","def lat_lons(self):\n return _lat_lons_from_geojson(self._geojson['geometry']['coordinates'])","def location(self):\n return [self.lat, self.lon]","def latitude(self):\n return self._latitude","def latitude(self):\n return self._latitude","def latitude(self):\n return self._latitude","def get_coords(self, field):\n return_list = []\n\n coords = self.coords()\n for i, coord in enumerate(self[field].dims):\n if coord in coords:\n return_list.append(self[coord])\n else:\n return_list.append(np.arange(len(self[field].shape[i])))\n\n return return_list","def M(latitude):\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);","def get_coords(self):\n return self.coords","def xyz(self) -> np.ndarray:\n return self._vector[0:3]","def coordExtrema(a):\n # Extreme values of longitude and latitude in the survey.\n longiMin = sp.inf\n latMin = sp.inf\n longiMax = -sp.inf\n latMax = -sp.inf\n for t in range(len(a)):\n if a[t].pktCount > 0:\n arraMin = sp.amin(a[t].longi)\n if arraMin < longiMin:\n longiMin = sp.amin(a[t].longi)\n arraMin = sp.amin(a[t].lat)\n if arraMin < latMin:\n latMin = arraMin\n arraMax = sp.amax(a[t].longi)\n if arraMax > longiMax:\n longiMax = arraMax\n arraMax = sp.amax(a[t].lat)\n if arraMax > latMax:\n latMax = arraMax\n\n ext = cs.emptyClass()\n ext.longiMin = longiMin\n ext.longiMax = longiMax\n ext.latMin = latMin\n ext.latMax = latMax\n return ext","def coordinates(self):\n return self.latitude, self.longitude"],"string":"[\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 lat_lons(self):\",\n \"def vector(self):\\n return np.array([self.lat, self.lng])\",\n \"def spatial_var(map_):\\n expx, expy = spatial_expval(map_)\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def get_latitude0(self):\\n return self.B\",\n \"def geo(self):\\n return vec2geo_linear_signed(self)\",\n \"def lat(self):\\n return self['lat']\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def get_lats(self, variables):\\n\\n return self._get_variable(variables, self.LATS_VARIABLE)\",\n \"def spatial(self):\",\n \"def lat(self):\\n return self._grid.lat[self._lat_indices]\",\n \"def _getlats(self):\\n lats = 90. - np.degrees(self.zeros)\\n return lats\",\n \"def spatial(self):\\n return self.spatial_x, self.spatial_y, self.spatial_data\",\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 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 latitude(self):\\n return self.coordinates[0]\",\n \"def spatial(self):\\n return self._spatial\",\n \"def latitude(self, lat):\\n data = float(lat[1:])\\n if lat[0] == \\\"N\\\":\\n return data\\n else:\\n return -data\",\n \"def project(self, (lng, lat)):\\n x = lng * DEG_TO_RAD\\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\\n y = lat * DEG_TO_RAD\\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)\",\n \"def ns(self):\\n return self.lat\",\n \"def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\\n\\n latent_coords = []\\n\\n for batch in data_sample:\\n # run encoder\\n coords = model.encoder(batch)\\n latent_coords.append(coords)\\n\\n # return latent (per jet?)\\n return np.concatenate(latent_coords, axis=0)\",\n \"def lat(self):\\n return self._lat\",\n \"def get_latitude(self):\\n return self.B + self.dB\",\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 spatialData(self):\\n return self.__spatial_data\",\n \"def broadcast_lonlat(ds, verbose=True):\\n if 'lon' not in ds.variables:\\n ds.coords['lon'] = ds['x']\\n if 'lat' not in ds.variables:\\n ds.coords['lat'] = ds['y']\\n \\n if len(ds['lon'].dims) < 2:\\n ds.coords[\\\"lon\\\"] = ds[\\\"lon\\\"] * xr.ones_like(ds[\\\"lat\\\"])\\n if len(ds['lat'].dims) < 2:\\n ds.coords[\\\"lat\\\"] = xr.ones_like(ds[\\\"lon\\\"]) * ds[\\\"lat\\\"]\\n return ds\",\n \"def effective_latitude_xr(self):\\n\\n grid_areas_ddf = self.grid_area_xr.to_dataframe().reset_index()\\n grid_areas_ddf = grid_areas_ddf[\\n ['temp_bucket', 'cdf_eff_lat_deg', 'time']\\n ]\\n\\n merge_ddf = (\\n self.data_array_dask_df\\n .reset_index(drop=True)\\n #.repartition(npartitions=100)\\n .merge(grid_areas_ddf,\\n on=['time', 'temp_bucket'],\\n how='left')\\n )\\n\\n eff_lat_xr = self.dask_data_to_xarray(merge_ddf,\\n var='cdf_eff_lat_deg')\\n\\n eff_lat_xr.name = 'effective_latitude'\\n\\n return eff_lat_xr\",\n \"def __init__(self, lat, long):\\n\\n self.lat = float(lat)\\n self.long = float(long)\\n self.cartesian = None\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def spatial_dimension(self):\\r\\n pass\",\n \"def g0(lat):\\n return (980.6160 * (1. - 0.0026372 * np.cos(2*lat*np.pi/180.)\\n + 0.0000059 * np.cos(2*lat*np.pi/180.)**2))\",\n \"def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\\n\\n if var.ndim == 3: # 3D variable\\n zmax, imax, jmax = var.shape\\n threeD = True\\n elif var.ndim == 2: # 2D variable\\n imax, jmax = var.shape\\n threeD = False\\n else:\\n print 'extract_loc: check variable dimensions'\\n return\\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 # arrays to store weights and data to be averaged\\n if threeD: # 3D variable\\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var): # mask weights\\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\\n else:\\n dist_m = N.array(N.resize(dist,var.shape))\\n else: # 2D variable\\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var):\\n dist_m = MA.array(dist,mask=var.mask) # mask weights\\n else:\\n dist_m = N.array(dist)\\n\\n # get the 4 model grid points and compute weights\\n n = 0\\n for i in Ilist:\\n for j in Jlist:\\n wghts[...,n] = 1./dist_m[...,i,j]\\n data[...,n] = var[...,i,j]\\n n += 1\\n\\n # compute weighted average\\n wavg = MA.average(data,axis=-1,weights=wghts)\\n return wavg\",\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 northing(self):\\r\\n x, y = self.lonlat2xy(self.longitude, self.latitude)\\r\\n return y\",\n \"def getPoint(self, a):\\n lng = self.source.center.lng + (self.target.center.lng - self.source.center.lng) * min(a, 1)\\n lat = self.source.center.lat + (self.target.center.lat - self.source.center.lat) * min(a, 1)\\n return lng, lat\",\n \"def extract_region_latlon(cube, lat_bounds):\\n\\n southern_lat, northern_lat = lat_bounds\\n lat_constraint = iris.Constraint(latitude=lambda cell: southern_lat <= cell < northern_lat)\\n cube = cube.extract(lat_constraint)\\n\\n return cube\",\n \"def convert(self, lat, lon):\\r\\n a = self.a\\r\\n b = self.b\\r\\n long0 = self.long0\\r\\n k0 = self.k0\\r\\n dx = self.dx\\r\\n\\r\\n e = (1 - b ** 2 / a ** 2) ** 0.5\\r\\n e2 = e ** 2 / (1 - e ** 2)\\r\\n n = (a - b) / (a + b)\\r\\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\\r\\n p = lon - long0\\r\\n\\r\\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\\r\\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\\r\\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\\r\\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\\r\\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\\r\\n\\r\\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\\r\\n\\r\\n K1 = S * k0\\r\\n K2 = k0 * nu * sin(2 * lat)/4.0\\r\\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\\\\r\\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\\r\\n\\r\\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\\r\\n\\r\\n K4 = k0 * nu * cos(lat)\\r\\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\\r\\n\\r\\n x = K4 * p + K5 * (p ** 3) + dx\\r\\n return x, y\",\n \"def _getXYZ ( lon, lat ):\\n d2r = pi / 180.\\n rlon, rlat = ( d2r * lon, d2r * lat )\\n x = cos(rlat) * cos(rlon)\\n y = cos(rlat) * sin(rlon)\\n z = sin(rlat)\\n return (x,y,z)\",\n \"def __getitem__(self, idx):\\n # stored image have binary and shape (H x W) so multiply by 255 to get pixel\\n # values + add dimension\\n sample = np.expand_dims(self.imgs[idx] * 255, axis=-1)\\n\\n # ToTensor transforms numpy.ndarray (H x W x C) in the range\\n # [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]\\n sample = self.transforms(sample)\\n\\n lat_value = self.lat_values[idx]\\n return sample, lat_value\",\n \"def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\\n # Get Value\\n vrow = invar[kpt,:]\\n \\n # Place into variable\\n mappt = np.zeros(nlat5*nlon5)*np.nan\\n mappt[okpts] = vrow\\n mappt = mappt.reshape(nlat5,nlon5)\\n return mappt\",\n \"def lat_lon(self):\\n if self._lat_lon is None:\\n if 'coordinates' in self:\\n self._lat_lon = self.coordinates\\n else:\\n self._lat_lon = self.meta\\n lat_lon_cols = ['latitude', 'longitude']\\n for c in self.meta.columns:\\n if c.lower().startswith('lat'):\\n lat_lon_cols[0] = c\\n elif c.lower().startswith('lon'):\\n lat_lon_cols[1] = c\\n\\n self._lat_lon = self._lat_lon[lat_lon_cols].values\\n\\n return self._lat_lon\",\n \"def x(self) -> ir.FloatingValue:\\n return ops.GeoX(self).to_expr()\",\n \"def latitude(self):\\n return self._state[0]\",\n \"def global_coords(self) -> GlobalCoordsABC:\",\n \"def __init__(self, true_lat, earth_radius):\\n self.k = np.cos(np.radians(true_lat))\\n self.true_scale_lats = [true_lat]\\n self.earth_radius = earth_radius\",\n \"def coordinates(self):\",\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_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 shot_lon_lat(self) -> list[tuple[float, float]]:\\n if self._shot_lon_lat is None:\\n if self.parent_granule.product == \\\"GEDI_L2A\\\":\\n self._shot_lon_lat = list(\\n zip(self[\\\"lon_lowestmode\\\"], self[\\\"lat_lowestmode\\\"])\\n )\\n elif self.parent_granule.product == \\\"GEDI_L1B\\\":\\n self._shot_lon_lat = list(\\n zip(\\n self[\\\"geolocation/longitude_lastbin\\\"],\\n self[\\\"geolocation/latitude_lastbin\\\"],\\n )\\n )\\n else:\\n raise NotImplementedError(\\n \\\"No method to get main data for \\\"\\n f\\\"product {self.parent_granule.product}\\\"\\n )\\n return self._shot_lon_lat\",\n \"def ground_vec(Lat, Lon, eccentricity=None, major_axis=None):\\n Lat, Lon = lat_lon_angle_check(Lat, Lon)\\n are_two_arrays_equal(Lat,Lon)\\n if (major_axis is None) or (eccentricity is None):\\n major_axis, flattening = wgs84_param()\\n eccentricity = (2*flattening) - (flattening**2)\\n\\n Lat, Lon = np.deg2rad(Lat.flatten()), np.deg2rad(Lon.flatten())\\n Radius = np.divide(major_axis,\\n np.sqrt(1.0 - eccentricity*np.sin(Lat)*np.sin(Lat)))\\n Gx = np.array([Radius*np.cos(Lat)*np.cos(Lon),\\n Radius*np.cos(Lat)*np.sin(Lon),\\n Radius* (1 - eccentricity) * np.sin(Lat)])\\n return Gx\",\n \"def get_locality(self):\\n return self.reference[REF_LOCALITY][REF_VALUE]\",\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 lat_lng(row):\\r\\n lat = row[\\\"latitude\\\"]\\r\\n lng = row[\\\"longitude\\\"]\\r\\n n = int(lat/GRANULARITY)\\r\\n nlat_start = n * GRANULARITY\\r\\n nlat_end = nlat_start + GRANULARITY\\r\\n nlg=int(lng/GRANULARITY)\\r\\n nlng_start = nlg * GRANULARITY\\r\\n nlng_end = nlng_start + GRANULARITY\\r\\n latlng=[(nlat_start,nlng_start), (nlat_start,nlng_end), (nlat_end,nlng_end), (nlat_end,nlng_start)]\\r\\n return latlng\",\n \"def geo_transform(self):\\n pass\",\n \"def get_latitude(self, latitude):\\n self.Latitude = latitude\\n return self.Latitude\",\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 latents(self):\\n self.assert_sampled()\\n return self._representations\",\n \"def find_longitude_var(nc,name):\\n var_obj = nc.variables[name] # Find the corresponding variable object \\n dimens = var_obj.dimensions # Find the names of the dimensions of variable\\n for i in range(len(dimens)):\\n # For each dimension find the corresponding variable\\n var_dim = nc.variables[dimens[i]]\\n if is_longitude_var(var_dim) == True:\\n return var_obj # If longitude exists, return the variable object\\n \\n return None\",\n \"def geo_topo_vector(longitude, latitude, elevation, jd):\\n from astropy.coordinates import GCRS, EarthLocation\\n from astropy.time import Time\\n import numpy as np\\n\\n loc = EarthLocation(longitude, latitude, elevation)\\n\\n time = Time(jd, scale=\\\"utc\\\", format=\\\"jd\\\")\\n itrs = loc.get_itrs(obstime=time)\\n gcrs = itrs.transform_to(GCRS(obstime=time))\\n\\n r = gcrs.cartesian\\n\\n # convert from m to km\\n x = r.x.value / 1000.0\\n y = r.y.value / 1000.0\\n z = r.z.value / 1000.0\\n\\n return np.array([x, y, z])\",\n \"def GetParametricCoords(self):\\n ...\",\n \"def si_values(self):\\n element_list = [\\n self.x.to(u.m),\\n self.y.to(u.m),\\n self.z.to(u.m),\\n self.v_x.to(u.m / u.s),\\n self.v_y.to(u.m / u.s),\\n self.v_z.to(u.m / u.s),\\n ]\\n return np.array([e.value for e in element_list], dtype=float)\",\n \"def readDataLatLon(self, varName, lat, lon, **kwargs):\\n # TODO: interpolate between lat and lon if necessary\\n \\n retList = []\\n \\n records = self._readRecords(varName, **kwargs)\\n\\n # get the index of the (lat,lon) pair\\n lats, lons = records[0].latlons() \\n latIdx, lonIdx = self._getIndex(lats, lons, lat, lon)\\n\\n for record in records:\\n # We only care about the pressure levels\\n if record.typeOfLevel == 'isobaricInhPa':\\n # Append this value as a 2D 1x1 grid, NOTE: right now, just a value\\n retList.append((record.level, record.values[latIdx][lonIdx]))\\n\\n retList.sort()\\n\\n presVec = np.ndarray((len(retList)))\\n dataVec = np.ndarray((len(retList)))\\n for i in range(len(retList)):\\n presVec[i] = retList[i][0]\\n dataVec[i] = retList[i][1]\\n\\n return presVec, dataVec\",\n \"def geo(self):\\n return self.query.geo\",\n \"def unproject(self, (x, y)):\\n lng = x/EARTH_RADIUS * RAD_TO_DEG\\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\\n return (lng, lat)\",\n \"def position(self, longitudinal: float, lateral: float) -> np.ndarray:\\n raise NotImplementedError()\",\n \"def lats(self):\\n return self._origin.lat\",\n \"def lats(self):\\n return self._origin.lat\",\n \"def nancay():\\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)\",\n \"def select(ds, longitude, latitude, varname, T=None, Z=None, \\n iT=None, iZ=None, extrap=False, extrap_val=None, locstream=False):\\n \\n assert not ((Z is not None) and (iZ is not None))\\n assert not ((T is not None) and (iT is not None))\\n \\n if (isinstance(longitude, int)) or (isinstance(longitude, float)):\\n longitude = [longitude]\\n if (isinstance(latitude, int)) or (isinstance(latitude, float)):\\n latitude = [latitude]\\n latitude = np.asarray(latitude)\\n longitude = np.asarray(longitude)\\n\\n if extrap:\\n extrap_method = \\\"nearest_s2d\\\"\\n else:\\n extrap_method = None\\n \\n \\n cf_var = get_var_cf(ds, varname)\\n \\n dr = ds.cf[cf_var]\\n \\n if not extrap:\\n assertion = 'the input longitude range is outside the model domain'\\n assert (longitude.min() >= dr.cf['longitude'].min()) and (longitude.max() <= dr.cf['longitude'].max()), assertion\\n assertion = 'the input latitude range is outside the model domain'\\n assert (latitude.min() >= dr.cf['latitude'].min()) and (latitude.max() <= dr.cf['latitude'].max()), assertion\\n \\n ## Horizontal interpolation ##\\n \\n # grid of lon/lat to interpolate to, with desired ending attributes\\n if latitude.ndim == 1:\\n ds_out = xr.Dataset(\\n {\\n \\\"lat\\\": ([\\\"lat\\\"], latitude, dict(axis=\\\"Y\\\", units='degrees_north', standard_name=\\\"latitude\\\")),\\n \\\"lon\\\": ([\\\"lon\\\"], longitude, dict(axis=\\\"X\\\", units='degrees_east', standard_name=\\\"longitude\\\")),\\n }\\n )\\n elif latitude.ndim == 2:\\n ds_out = xr.Dataset(\\n {\\n \\\"lat\\\": ([\\\"Y\\\",\\\"X\\\"], latitude, dict(units='degrees_north', standard_name=\\\"latitude\\\")),\\n \\\"lon\\\": ([\\\"Y\\\",\\\"X\\\"], longitude, dict(units='degrees_east', standard_name=\\\"longitude\\\")),\\n }\\n )\\n \\n\\n # set up regridder, which would work for multiple interpolations if desired\\n regridder = xe.Regridder(dr, ds_out, \\\"bilinear\\\", extrap_method=extrap_method, locstream_out=locstream)\\n\\n # do regridding\\n dr_out = regridder(dr, keep_attrs=True)\\n \\n \\n ## Time and depth interpolation or iselection ##\\n if iZ is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.isel(Z=iZ)\\n \\n if Z is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.interp(Z=Z)\\n\\n if iT is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.isel(T=iT)\\n \\n if T is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.interp(T=T)\\n \\n if extrap_val is not None:\\n # returns 0 outside the domain by default. Assumes that no other values are exactly 0\\n # and replaces all 0's with extrap_val if chosen.\\n dr_out = dr_out.where(dr_out != 0, extrap_val)\\n \\n return dr_out\",\n \"def get_latent(self):\\n return copy.deepcopy(self._latent)\",\n \"def lon(self):\\n return self['lon']\",\n \"def get_lonlat(self, row, col):\\n\\n if self.ndim != 2:\\n raise DimensionError(('operation undefined '\\n 'for %sD geometry ') % self.ndim)\\n elif self.lons is None or self.lats is None:\\n raise ValueError('lon/lat values are not defined')\\n return self.lons[row, col], self.lats[row, col]\",\n \"def get_map_values(self, lons, lats, ibin=None):\\n theta = np.pi / 2. - np.radians(lats)\\n phi = np.radians(lons)\\n\\n pix = hp.ang2pix(self.hpx.nside, theta, phi, nest=self.hpx.nest)\\n\\n if self.data.ndim == 2:\\n return self.data[:, pix] if ibin is None else self.data[ibin, pix]\\n else:\\n return self.data[pix]\",\n \"def transform(self, srid: ir.IntegerValue) -> GeoSpatialValue:\\n return ops.GeoTransform(self, srid).to_expr()\",\n \"def map(self, lat, long):\\r\\n rxy = self._r*np.sqrt(1-np.cos(lat))\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def sample_latent(self, x):\\n latent_dist = self.encoder(x)\\n latent_sample = self.reparameterize(*latent_dist)\\n return latent_sample\",\n \"def coords(self) -> Tuple[float, float]:\\n return self.lat, self.lng\",\n \"def get_geospatial(self):\\n self.unimpl_base_class()\",\n \"def CreateTargetGeoField(nbtimestep,latlen,lonlen):\\n\\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\\n\\n return pres_grid,u_grid,v_grid\",\n \"def get_var(dataset, varname):\\n \\n import xarray as xr\\n \\n var = dataset[varname]\\n time = dataset['TIME']\\n lat = dataset['YDim']\\n lon = dataset['XDim']\\n\\n da = xr.DataArray(var[:,:,:], coords=[time[:],lat[:],lon[:]], dims=['time','lat','lon'],\\n attrs=var.attributes, name=varname)\\n \\n da['time'].attrs = time.attributes\\n da['lat'].attrs = lat.attributes\\n da['lon'].attrs = lon.attributes\\n\\n # Set _FillValue for coordinate arrays\\n da.lat.encoding['_FillValue'] = 9.969209968386869e+36\\n da.lon.encoding['_FillValue'] = 9.969209968386869e+36\\n\\n # To avoid conflicts between _FillValue and missing_value attributes when file is read\\n da.attrs.pop('fmissing_value')\\n da.attrs.pop('missing_value')\\n \\n return da\",\n \"def get_spatial_info(cube, add_cyclic=False):\\n\\n if add_cyclic:\\n data, x = add_cyclic_point(cube.data, coord=cube.coord('longitude').points)\\n else:\\n data = cube.data\\n x = cube.coord('longitude').points\\n\\n y = cube.coord('latitude').points\\n inproj = input_projections[cube.attributes['input_projection']]\\n\\n return data, x, y, inproj\",\n \"def map(self, lat, long):\\r\\n rxy = self._r*lat/(np.pi/2)\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def __init__(self, unit_vector_3d):\\n \\n self.unit_vector = unit_vector_3d\\n transposed_uv = np.transpose(self.unit_vector)\\n self.x = transposed_uv[0] \\n self.y = transposed_uv[1] \\n self.z = transposed_uv[2]\\n self.d = SkyCoord(self.x, self.y, self.z, \\n unit = 'mpc', \\n representation_type = 'cartesian', \\n frame = 'icrs')\\n self.d.representation_type = 'spherical'\\n self.lons = self.d.galactic.l.wrap_at(360 * u.deg).deg\\n self.lats = self.d.galactic.b.wrap_at(180 * u.deg).deg\",\n \"def build_coordinates_map(self):\\n\\t\\t# We need to keep track of which dimensions we can map\\n\\t\\tmapped = []\\n\\t\\t\\n\\t\\t# First lets check for standard 1D coordinate variables. These are variables\\n\\t\\t# that have the same name as one of the variables dimensions or 1D variables\\n\\t\\t# sharing a dimension with the variable \\n\\t\\tfor di in range (0,len(self.variable.dimensions)):\\n\\n\\t\\t\\tdimension = self.variable.dimensions[di]\\n\\t\\t\\tdim_name = dimension.name\\n\\n\\t\\t\\t# Find variables with same name as the dimension\\n\\t\\t\\tif dim_name in self.variable.group.variables.keys():\\n\\n\\t\\t\\t\\tcoord_variable = self.variable.group.variables[dim_name]\\n\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\t\\t\\t\\tmapped.append(dim_name)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# See if we can use the units to find out what spatial/temporal variable this is from \\n\\t\\t\\t\\t# the CF conventions\\n\\t\\t\\t\\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If we can't we just default to the dimension name\\n\\t\\t\\t\\tif not coordinate_name:\\n\\t\\t\\t\\t\\tcoordinate_name = dim_name\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t# Next lets see if we have a \\\"coordinates\\\" attribute we can use (CF convention)\\n\\t\\tif self.variable.get_attribute('coordinates'):\\n\\t\\t\\t\\n\\t\\t\\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# Find each associated variable\\n\\t\\t\\tfor name in self.coordinates_names:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif name in self.variable.group.variables.keys():\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tcoord_variable = self.variable.group.variables[name]\\n\\t\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\n\\t\\t\\t\\t\\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\\n\\t\\t\\t\\t\\t# See if we can find out what spatial/temporal variable this is\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = name\\n\\n\\t\\t\\t\\t\\t# Create the coordinates_mapping entry but with an empty dimensions map for now\\n\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Add each coordinates variable dimension to the mappable list and generate the map\\n\\t\\t\\t\\t\\t#print 'generating dimensions map for ', coord_variable.dimensions\\n\\t\\t\\t\\t\\tfor dimension in coord_variable.dimensions:\\n\\t\\t\\t\\t\\t\\t#print dimension, coord_variable.dimensions\\n\\t\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\\n\\t\\t\\t\\t\\t\\tif not dimension.name in mapped:\\n\\t\\t\\t\\t\\t\\t\\tmapped.append(dimension.name)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t# Setup shortcut to identify time coordinate variable\\n\\t\\ttry:\\n\\t\\t\\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\\n\\t\\t\\tself.time_dim = self.coordinates_mapping['time']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.time_variable = None\\n\\t\\t\\tself.time_dim = None\\n\\t\\t\\t\\n\\t\\t# Shortcuts for latitude and longitude coordinate variables\\n\\t\\ttry:\\n\\t\\t\\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.latitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.longitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\\n\\t\\t\\tself.level_dim = self.coordinates_mapping['level']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.level_variable = None\\n\\t\\t\\tself.level_dim = None\",\n \"def latitude_value(self):\\n\\n\\t\\t#Check if there is more than 1 result for the given location\\n\\t\\tlocations = Nominatim().geocode(self.address, False)\\n\\n\\t\\tif len(locations) > 1:\\n\\t\\t\\tprint 'Please enter a more specific location. ie: City and State'\\n\\n\\t\\telse:\\n\\t\\t\\treturn Nominatim().geocode(self.address).latitude\",\n \"def coord_proj(self):\\r\\n return self._coord_proj\",\n \"def getlatlon(self):\\n lat = np.pi/2.0 - self._th\\n time = self.gettime()\\n lon = self._phi - 2*np.pi*time/86164.09164\\n return lat, lon\",\n \"def lat_lons(self):\\n return _lat_lons_from_geojson(self._geojson['geometry']['coordinates'])\",\n \"def location(self):\\n return [self.lat, self.lon]\",\n \"def latitude(self):\\n return self._latitude\",\n \"def latitude(self):\\n return self._latitude\",\n \"def latitude(self):\\n return self._latitude\",\n \"def get_coords(self, field):\\n return_list = []\\n\\n coords = self.coords()\\n for i, coord in enumerate(self[field].dims):\\n if coord in coords:\\n return_list.append(self[coord])\\n else:\\n return_list.append(np.arange(len(self[field].shape[i])))\\n\\n return return_list\",\n \"def M(latitude):\\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);\",\n \"def get_coords(self):\\n return self.coords\",\n \"def xyz(self) -> np.ndarray:\\n return self._vector[0:3]\",\n \"def coordExtrema(a):\\n # Extreme values of longitude and latitude in the survey.\\n longiMin = sp.inf\\n latMin = sp.inf\\n longiMax = -sp.inf\\n latMax = -sp.inf\\n for t in range(len(a)):\\n if a[t].pktCount > 0:\\n arraMin = sp.amin(a[t].longi)\\n if arraMin < longiMin:\\n longiMin = sp.amin(a[t].longi)\\n arraMin = sp.amin(a[t].lat)\\n if arraMin < latMin:\\n latMin = arraMin\\n arraMax = sp.amax(a[t].longi)\\n if arraMax > longiMax:\\n longiMax = arraMax\\n arraMax = sp.amax(a[t].lat)\\n if arraMax > latMax:\\n latMax = arraMax\\n\\n ext = cs.emptyClass()\\n ext.longiMin = longiMin\\n ext.longiMax = longiMax\\n ext.latMin = latMin\\n ext.latMax = latMax\\n return ext\",\n \"def coordinates(self):\\n return self.latitude, self.longitude\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67513454","0.66928744","0.6395381","0.63260347","0.61951125","0.61491525","0.613318","0.6064862","0.6063187","0.6053654","0.6050005","0.6028488","0.5952476","0.58669955","0.5862181","0.5862181","0.58513904","0.58510435","0.5826054","0.58009094","0.58002454","0.57809854","0.57540536","0.5703555","0.56965405","0.56725276","0.5664976","0.563764","0.56285477","0.56011355","0.56008804","0.55861664","0.55590445","0.5556105","0.55537385","0.5523659","0.5522001","0.55038023","0.5502925","0.5501789","0.5492565","0.5480906","0.5479155","0.5455678","0.54554313","0.5451224","0.5446116","0.54358345","0.5426561","0.5426131","0.542399","0.542244","0.5414869","0.5414036","0.54138887","0.54120743","0.54087377","0.5406188","0.54057145","0.5405488","0.5405151","0.5397558","0.53970754","0.5396099","0.53749317","0.537209","0.5371906","0.53716093","0.53716093","0.53666717","0.53574896","0.5356682","0.53537387","0.53533274","0.53467655","0.53418416","0.5337833","0.53290033","0.5316157","0.53159034","0.5314269","0.5310928","0.5302698","0.5300984","0.5293081","0.52917856","0.52885145","0.52820444","0.5280893","0.52805674","0.5279551","0.5270366","0.5270366","0.5270366","0.52675194","0.5263874","0.5261045","0.5256929","0.52562666","0.5254961"],"string":"[\n \"0.67513454\",\n \"0.66928744\",\n \"0.6395381\",\n \"0.63260347\",\n \"0.61951125\",\n \"0.61491525\",\n \"0.613318\",\n \"0.6064862\",\n \"0.6063187\",\n \"0.6053654\",\n \"0.6050005\",\n \"0.6028488\",\n \"0.5952476\",\n \"0.58669955\",\n \"0.5862181\",\n \"0.5862181\",\n \"0.58513904\",\n \"0.58510435\",\n \"0.5826054\",\n \"0.58009094\",\n \"0.58002454\",\n \"0.57809854\",\n \"0.57540536\",\n \"0.5703555\",\n \"0.56965405\",\n \"0.56725276\",\n \"0.5664976\",\n \"0.563764\",\n \"0.56285477\",\n \"0.56011355\",\n \"0.56008804\",\n \"0.55861664\",\n \"0.55590445\",\n \"0.5556105\",\n \"0.55537385\",\n \"0.5523659\",\n \"0.5522001\",\n \"0.55038023\",\n \"0.5502925\",\n \"0.5501789\",\n \"0.5492565\",\n \"0.5480906\",\n \"0.5479155\",\n \"0.5455678\",\n \"0.54554313\",\n \"0.5451224\",\n \"0.5446116\",\n \"0.54358345\",\n \"0.5426561\",\n \"0.5426131\",\n \"0.542399\",\n \"0.542244\",\n \"0.5414869\",\n \"0.5414036\",\n \"0.54138887\",\n \"0.54120743\",\n \"0.54087377\",\n \"0.5406188\",\n \"0.54057145\",\n \"0.5405488\",\n \"0.5405151\",\n \"0.5397558\",\n \"0.53970754\",\n \"0.5396099\",\n \"0.53749317\",\n \"0.537209\",\n \"0.5371906\",\n \"0.53716093\",\n \"0.53716093\",\n \"0.53666717\",\n \"0.53574896\",\n \"0.5356682\",\n \"0.53537387\",\n \"0.53533274\",\n \"0.53467655\",\n \"0.53418416\",\n \"0.5337833\",\n \"0.53290033\",\n \"0.5316157\",\n \"0.53159034\",\n \"0.5314269\",\n \"0.5310928\",\n \"0.5302698\",\n \"0.5300984\",\n \"0.5293081\",\n \"0.52917856\",\n \"0.52885145\",\n \"0.52820444\",\n \"0.5280893\",\n \"0.52805674\",\n \"0.5279551\",\n \"0.5270366\",\n \"0.5270366\",\n \"0.5270366\",\n \"0.52675194\",\n \"0.5263874\",\n \"0.5261045\",\n \"0.5256929\",\n \"0.52562666\",\n \"0.5254961\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74743557"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19875,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned along the lon axis but whose values are the longitudes"},"document":{"kind":"string","value":"def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv"},"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 latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def lat_lons(self):","def lon(self):\n return self['lon']","def find_longitude_var(nc,name):\n var_obj = nc.variables[name] # Find the corresponding variable object \n dimens = var_obj.dimensions # Find the names of the dimensions of variable\n for i in range(len(dimens)):\n # For each dimension find the corresponding variable\n var_dim = nc.variables[dimens[i]]\n if is_longitude_var(var_dim) == True:\n return var_obj # If longitude exists, return the variable object\n \n return None","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 lon(self):\n return self._lon","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 spatial_var(map_):\n expx, expy = spatial_expval(map_)\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))","def readDataLatLon(self, varName, lat, lon, **kwargs):\n # TODO: interpolate between lat and lon if necessary\n \n retList = []\n \n records = self._readRecords(varName, **kwargs)\n\n # get the index of the (lat,lon) pair\n lats, lons = records[0].latlons() \n latIdx, lonIdx = self._getIndex(lats, lons, lat, lon)\n\n for record in records:\n # We only care about the pressure levels\n if record.typeOfLevel == 'isobaricInhPa':\n # Append this value as a 2D 1x1 grid, NOTE: right now, just a value\n retList.append((record.level, record.values[latIdx][lonIdx]))\n\n retList.sort()\n\n presVec = np.ndarray((len(retList)))\n dataVec = np.ndarray((len(retList)))\n for i in range(len(retList)):\n presVec[i] = retList[i][0]\n dataVec[i] = retList[i][1]\n\n return presVec, dataVec","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 _getlons(self):\n dlon = 360. / self.nlon\n lons = np.linspace(0. + dlon / 2., 360. - dlon / 2., self.nlon)\n return lons","def _getXYZ ( lon, lat ):\n d2r = pi / 180.\n rlon, rlat = ( d2r * lon, d2r * lat )\n x = cos(rlat) * cos(rlon)\n y = cos(rlat) * sin(rlon)\n z = sin(rlat)\n return (x,y,z)","def vector(self):\n return np.array([self.lat, self.lng])","def load_2D_netCDF(filename, var_name, lat_name, lon_name):\n data = Dataset(filename, 'r')\n var = data[var_name][:]\n lats = data[lat_name][:]\n lons = data[lon_name][:]\n data.close()\n return var, lats, lons","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 longitude(self, lon):\n data = float(lon[1:])\n if lon[0] == \"E\":\n return data\n else:\n return -data","def merc_x(lon):\n r_major = 6378137.000\n x = r_major * math.radians(lon)\n return x","def getlatlon(self):\n lat = np.pi/2.0 - self._th\n time = self.gettime()\n lon = self._phi - 2*np.pi*time/86164.09164\n return lat, lon","def project(self, (lng, lat)):\n x = lng * DEG_TO_RAD\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\n y = lat * DEG_TO_RAD\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)","def northing(self):\r\n x, y = self.lonlat2xy(self.longitude, self.latitude)\r\n return y","def lons(self):\n return self._origin.lon","def lons(self):\n return self._origin.lon","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def broadcast_lonlat(ds, verbose=True):\n if 'lon' not in ds.variables:\n ds.coords['lon'] = ds['x']\n if 'lat' not in ds.variables:\n ds.coords['lat'] = ds['y']\n \n if len(ds['lon'].dims) < 2:\n ds.coords[\"lon\"] = ds[\"lon\"] * xr.ones_like(ds[\"lat\"])\n if len(ds['lat'].dims) < 2:\n ds.coords[\"lat\"] = xr.ones_like(ds[\"lon\"]) * ds[\"lat\"]\n return ds","def solar_longitude(cls, tee):\n return cls.true_position(tee, cls.SIDEREAL_YEAR, 14/360, cls.ANOMALISTIC_YEAR, 1/42)","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 nancay():\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)","def lat_lon(self):\n if self._lat_lon is None:\n if 'coordinates' in self:\n self._lat_lon = self.coordinates\n else:\n self._lat_lon = self.meta\n lat_lon_cols = ['latitude', 'longitude']\n for c in self.meta.columns:\n if c.lower().startswith('lat'):\n lat_lon_cols[0] = c\n elif c.lower().startswith('lon'):\n lat_lon_cols[1] = c\n\n self._lat_lon = self._lat_lon[lat_lon_cols].values\n\n return self._lat_lon","def geo_topo_vector(longitude, latitude, elevation, jd):\n from astropy.coordinates import GCRS, EarthLocation\n from astropy.time import Time\n import numpy as np\n\n loc = EarthLocation(longitude, latitude, elevation)\n\n time = Time(jd, scale=\"utc\", format=\"jd\")\n itrs = loc.get_itrs(obstime=time)\n gcrs = itrs.transform_to(GCRS(obstime=time))\n\n r = gcrs.cartesian\n\n # convert from m to km\n x = r.x.value / 1000.0\n y = r.y.value / 1000.0\n z = r.z.value / 1000.0\n\n return np.array([x, y, z])","def get_map_values(self, lons, lats, ibin=None):\n theta = np.pi / 2. - np.radians(lats)\n phi = np.radians(lons)\n\n pix = hp.ang2pix(self.hpx.nside, theta, phi, nest=self.hpx.nest)\n\n if self.data.ndim == 2:\n return self.data[:, pix] if ibin is None else self.data[ibin, pix]\n else:\n return self.data[pix]","def longitude(self):\n return self.coordinates[1]","def geo(self):\n return vec2geo_linear_signed(self)","def get_coord(path, n_i, n_k):\n fnm = \"%s/coord_mpi%02i%02i.nc\" % (path, n_i, n_k)\n fnc = netcdf.netcdf_file(fnm, 'r')\n x = fnc.variables['x'][:, :]\n z = fnc.variables['z'][:, :]\n return x, z","def lonlat2xy(s_lon, s_lat): # x: easting, y: northing\r\n # convert decimals to seconds...\r\n s_lon = dec2sec(s_lon)\r\n s_lat = dec2sec(s_lat)\r\n\r\n ## Auxiliary values \r\n # i.e. differences of latitude and longitude relative to Bern in the unit [10000'']\r\n s_lng_aux = (s_lon - 26782.5)/10000.\r\n s_lat_aux = (s_lat - 169028.66)/10000.\r\n \r\n # easting\r\n s_x = (600072.37 \r\n + 211455.93*s_lng_aux \r\n - 10938.51*s_lng_aux*s_lat_aux \r\n - 0.36*s_lng_aux*(s_lat_aux**2) \r\n - 44.54*(s_lng_aux**3))\r\n \r\n # northing\r\n s_y = (200147.07 \r\n + 308807.95*s_lat_aux \r\n + 3745.25*(s_lng_aux**2) \r\n + 76.63*(s_lat_aux**2) \r\n - 194.56*(s_lng_aux**2)*s_lat_aux \r\n + 119.79*(s_lat_aux**3))\r\n\r\n return s_x, s_y","def replace_x_y_nominal_lat_lon(ds):\n ds = ds.copy()\n if 'x' in ds.dims and 'y' in ds.dims:\n \n nominal_y = ds.lat.mean('x')\n # extract the equatorial lat and take those lon values as nominal lon\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\n nominal_x = ds.lon.isel(y=eq_ind)\n ds.coords['x'].data = nominal_x.data\n ds.coords['y'].data = nominal_y.data\n\n ds = ds.sortby('x')\n ds = ds.sortby('y')\n \n else:\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\n return ds","def position(self, longitudinal: float, lateral: float) -> np.ndarray:\n raise NotImplementedError()","def location(self):\n return np.array((self.latitude, self.longitude))","def location(self):\n return np.array((self.latitude, self.longitude))","def convert(self, lat, lon):\r\n a = self.a\r\n b = self.b\r\n long0 = self.long0\r\n k0 = self.k0\r\n dx = self.dx\r\n\r\n e = (1 - b ** 2 / a ** 2) ** 0.5\r\n e2 = e ** 2 / (1 - e ** 2)\r\n n = (a - b) / (a + b)\r\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\r\n p = lon - long0\r\n\r\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\r\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\r\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\r\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\r\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\r\n\r\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\r\n\r\n K1 = S * k0\r\n K2 = k0 * nu * sin(2 * lat)/4.0\r\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\r\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\r\n\r\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\r\n\r\n K4 = k0 * nu * cos(lat)\r\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\r\n\r\n x = K4 * p + K5 * (p ** 3) + dx\r\n return x, y","def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\n\n if var.ndim == 3: # 3D variable\n zmax, imax, jmax = var.shape\n threeD = True\n elif var.ndim == 2: # 2D variable\n imax, jmax = var.shape\n threeD = False\n else:\n print 'extract_loc: check variable dimensions'\n return\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 # arrays to store weights and data to be averaged\n if threeD: # 3D variable\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n if MA.isMA(var): # mask weights\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\n else:\n dist_m = N.array(N.resize(dist,var.shape))\n else: # 2D variable\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\n if MA.isMA(var):\n dist_m = MA.array(dist,mask=var.mask) # mask weights\n else:\n dist_m = N.array(dist)\n\n # get the 4 model grid points and compute weights\n n = 0\n for i in Ilist:\n for j in Jlist:\n wghts[...,n] = 1./dist_m[...,i,j]\n data[...,n] = var[...,i,j]\n n += 1\n\n # compute weighted average\n wavg = MA.average(data,axis=-1,weights=wghts)\n return wavg","def get_lonlat(self, row, col):\n\n if self.ndim != 2:\n raise DimensionError(('operation undefined '\n 'for %sD geometry ') % self.ndim)\n elif self.lons is None or self.lats is None:\n raise ValueError('lon/lat values are not defined')\n return self.lons[row, col], self.lats[row, col]","def spatial(self):","def longitude(self):\n return self._state[1]","def _extract_location_xyz(self, log):\n\n if \"location\" in log:\n x = log[\"location\"][\"latitude\"]\n y = log[\"location\"][\"longitude\"]\n z = log[\"location\"][\"altitude\"]\n else:\n self.logger.debug(\"NaN case\")\n x = \"NaN\" # matlab Nan?\n y = \"NaN\"\n z = \"NaN\"\n pass\n return str(x) + \",\" + str(y) + \",\" + str(z)","def nc_getLatsandLons(fn):\r\n\tfrom netCDF4 import Dataset\r\n\t# load the netcdf file\r\n\tncf1 = Dataset(fn, mode='r')\r\n\r\n\t# Pull out the lon and lat data\r\n\tlats = ncf1.variables[\"lat\"][:]\r\n\tlons = ncf1.variables[\"lon\"][:]\r\n\r\n\treturn lats, lons","def _get_las_xyz(fpath):\n with laspy.file.File(fpath) as f:\n return [f.x, f.y, f.z]","def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\n # Get Value\n vrow = invar[kpt,:]\n \n # Place into variable\n mappt = np.zeros(nlat5*nlon5)*np.nan\n mappt[okpts] = vrow\n mappt = mappt.reshape(nlat5,nlon5)\n return mappt","def latlong(self, lat, lon):\n url = \"/prediction\"\n\n # construct_aoi_latlong()\n aoi = f\"POINT({lat} {lon}\"\n\n # construct params\n params = {\"aoi\": aoi}\n\n req = self._request(url, params)\n\n return req","def unproject(self, (x, y)):\n lng = x/EARTH_RADIUS * RAD_TO_DEG\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\n return (lng, lat)","def mercX(lon):\r\n zoom = 1.0\r\n lon = math.radians(lon)\r\n a = (256.0 / math.pi) * pow(2.0, zoom)\r\n b = lon + math.pi\r\n return int(a * b)","def lon(self):\n return self._state['lastLocations'][0]['longitude']","def LongLat(x, y, z):\n r = (x**2 + y**2 + z**2)**0.5\n long = numpy.arctan2(y, x)\n lat = numpy.arcsin(z / r)\n return long, lat, r","def lonToPhi(lon):\n return (np.pi/180.0) * lon","def safeProj(proj, lon, lat):\n x, y = proj(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 lonlat(n_lon: int, n_lat: int) -> List[Tuple[float, float]]:\n grid = []\n for lon in np.linspace(0, 360.0 - 360.0 / n_lon, n_lon):\n for lat in np.linspace(-90, 90, n_lat):\n grid.append((lon, lat))\n return grid","def get_longitude0(self):\n return self.L","def CreateTargetGeoField(nbtimestep,latlen,lonlen):\n\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\n\n return pres_grid,u_grid,v_grid","def set_coord_values(ds, wrf_out, footprint_nbins):\n xdim_var = ds.variables[\"dim_x\"]\n ydim_var = ds.variables[\"dim_y\"]\n xdim_bounds_var = ds.variables[\"dim_x_bnds\"]\n ydim_bounds_var = ds.variables[\"dim_y_bnds\"]\n lon_var = ds.variables[\"longitude\"]\n lat_var = ds.variables[\"latitude\"]\n\n time_back_var = ds.variables[\"time_before_observation\"]\n time_back_bounds_var = ds.variables[\"time_before_observation_bnds\"]\n\n height_var = ds.variables[\"height\"]\n height_bounds_var = ds.variables[\"height_bnds\"]\n\n dx = wrf_out[\"dx\"]\n\n xdim_data = wrf_out[\"proj_x_coord\"][0]\n ydim_data = wrf_out[\"proj_y_coord\"][0]\n xdim_var[:] = xdim_data[:]\n ydim_var[:] = ydim_data[:]\n\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\n xdim_bounds_var[-1,0] = xdim_data[-1]\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\n ydim_bounds_var[-1,0] = ydim_data[-1]\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\n\n wrf_lats = wrf_out[\"wrf_lat\"][0][0, :, :]\n wrf_lons = wrf_out[\"wrf_lon\"][0][0, :, :]\n lat_var[:, :] = wrf_lats[:, :]\n lon_var[:, :] = wrf_lons[:, :]\n\n ds.geospatial_lat_min = wrf_lats.min()\n ds.geospatial_lat_max = wrf_lats.max()\n ds.geospatial_lat_units = \"degree_north\"\n ds.geospatial_lon_min = wrf_lons.min()\n ds.geospatial_lon_max = wrf_lons.max()\n ds.geospatial_lon_units = \"degree_east\"\n\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\n time_back_var[:] = time_back_vals\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\n time_back_vals[1:]))\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\n\n height_var[...] = 0\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)","def get_locality(self):\n return self.reference[REF_LOCALITY][REF_VALUE]","def solar_noon_local(LonDegE):\n return 12.","def map(self, lat, long):\r\n rxy = self._r*lat/(np.pi/2)\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def get_lon(self):\n p = self._get_sub_text('lon')\n if not p:\n return None\n else:\n try:\n return float(p)\n except ValueError:\n return None","def build_coordinates_map(self):\n\t\t# We need to keep track of which dimensions we can map\n\t\tmapped = []\n\t\t\n\t\t# First lets check for standard 1D coordinate variables. These are variables\n\t\t# that have the same name as one of the variables dimensions or 1D variables\n\t\t# sharing a dimension with the variable \n\t\tfor di in range (0,len(self.variable.dimensions)):\n\n\t\t\tdimension = self.variable.dimensions[di]\n\t\t\tdim_name = dimension.name\n\n\t\t\t# Find variables with same name as the dimension\n\t\t\tif dim_name in self.variable.group.variables.keys():\n\n\t\t\t\tcoord_variable = self.variable.group.variables[dim_name]\n\t\t\t\tself.coordinates_variables.append(coord_variable)\n\t\t\t\tmapped.append(dim_name)\n\t\t\t\t\n\t\t\t\t# See if we can use the units to find out what spatial/temporal variable this is from \n\t\t\t\t# the CF conventions\n\t\t\t\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\n\t\t\t\t\n\t\t\t\t# If we can't we just default to the dimension name\n\t\t\t\tif not coordinate_name:\n\t\t\t\t\tcoordinate_name = dim_name\n\t\t\t\t\n\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\t\t\t\n\t\t\t\t\n\t\t# Next lets see if we have a \"coordinates\" attribute we can use (CF convention)\n\t\tif self.variable.get_attribute('coordinates'):\n\t\t\t\n\t\t\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\n\t\t\t\t\t\t\n\t\t\t# Find each associated variable\n\t\t\tfor name in self.coordinates_names:\n\t\t\t\t\n\t\t\t\tif name in self.variable.group.variables.keys():\n\t\t\t\t\t\n\t\t\t\t\tcoord_variable = self.variable.group.variables[name]\n\t\t\t\t\tself.coordinates_variables.append(coord_variable)\n\n\t\t\t\t\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\n\t\t\t\t\t# See if we can find out what spatial/temporal variable this is\n\t\t\t\t\ttry:\n\t\t\t\t\t\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\n\t\t\t\t\texcept:\n\t\t\t\t\t\tcoordinate_name = name\n\n\t\t\t\t\t# Create the coordinates_mapping entry but with an empty dimensions map for now\n\t\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\n\t\t\t\t\t\t\n\t\t\t\t\t# Add each coordinates variable dimension to the mappable list and generate the map\n\t\t\t\t\t#print 'generating dimensions map for ', coord_variable.dimensions\n\t\t\t\t\tfor dimension in coord_variable.dimensions:\n\t\t\t\t\t\t#print dimension, coord_variable.dimensions\n\t\t\t\t\t\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\n\t\t\t\t\t\tif not dimension.name in mapped:\n\t\t\t\t\t\t\tmapped.append(dimension.name)\n\t\t\t\t\t\t\t\n\t\t# Setup shortcut to identify time coordinate variable\n\t\ttry:\n\t\t\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\n\t\t\tself.time_dim = self.coordinates_mapping['time']['map'][0]\n\t\texcept:\n\t\t\tself.time_variable = None\n\t\t\tself.time_dim = None\n\t\t\t\n\t\t# Shortcuts for latitude and longitude coordinate variables\n\t\ttry:\n\t\t\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\n\t\texcept:\n\t\t\tself.latitude_variable = None\n\n\t\ttry:\n\t\t\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\n\t\texcept:\n\t\t\tself.longitude_variable = None\n\n\t\ttry:\n\t\t\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\n\t\t\tself.level_dim = self.coordinates_mapping['level']['map'][0]\n\t\texcept:\n\t\t\tself.level_variable = None\n\t\t\tself.level_dim = None","def global_coords(self) -> GlobalCoordsABC:","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 map(self, lat, long):\r\n rxy = self._r*np.sqrt(1-np.cos(lat))\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def lat_lons(self):\n return _lat_lons_from_geojson(self._geojson['geometry']['coordinates'])","def col_to_lon(self, col):\n return -180 + col * self.lon_step","def lspe_coordinates (self, time):\n\n return (self.base_lat,\n self.base_long\n + time * 2 * np.pi * (1 + 1 / self.rev_days) / SECONDS_PER_DAY)","def correct_lon(ds):\n ds = ds.copy()\n x = ds['x'].data\n ds['x'].data = np.where(x < 0 , 360 + x, x)\n\n lon = ds['lon'].data\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\n \n ds = ds.sortby('x')\n return ds","def merc(lat, lon):\n\tr_major = 6378137.000\n\tx = r_major * math.radians(lon)\n\tscale = x/lon\n\ty = 180.0/math.pi * math.log(math.tan(math.pi/4.0 + lat * (math.pi/180.0)/2.0)) * scale\n\treturn (x, y)","def ns(self):\n return self.lat","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_ntl(lon, lat, ntl_dim=7):\n r, c = ntl_file.index(lon, lat)\n ntl_win = ((r-ntl_dim/2+1, r+ntl_dim/2+1), (c-ntl_dim/2+1, c+ntl_dim/2+1))\n ntl_data = ntl_file.read(1, window=ntl_win)\n ntl_mean = ntl_data.mean()\n return ntl_mean","def __init__(self, lat, long):\n\n self.lat = float(lat)\n self.long = float(long)\n self.cartesian = None","def moonlongitude(time):\n B0 = 481267.8809\n C0 = 218.3162\n # fmt: off\n A = np.array([62888.e-4, 12740.e-4, 6583.e-4, 2136.e-4, 1851.e-4, \\\n 1144.e-4, 588.e-4, 571.e-4, 533.e-4, 458.e-4, 409.e-4, \\\n 347.e-4, 304.e-4, 154.e-4, 125.e-4, 110.e-4, 107.e-4, \\\n 100.e-4, 85.e-4, 79.e-4, 68.e-4, 52.e-4, 50.e-4, 40.e-4, \\\n 40.e-4, 40.e-4, 38.e-4, 37.e-4, 28.e-4, 27.e-4, 26.e-4, \\\n 24.e-4, 23.e-4, 22.e-4, 21.e-4, 21.e-4, 21.e-4, 18.e-4, \\\n 16.e-4, 12.e-4, 11.e-4, 9.e-4, 8.e-4, 7.e-4, 7.e-4, \\\n 7.e-4, 7.e-4, 6.e-4, 6.e-4, 5.e-4, 5.e-4, 5.e-4, \\\n 4.e-4, 4.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, \\\n 3.e-4, 3.e-4])\n B = np.array([477198.868, 413335.35, 890534.22, 954397.74, \\\n 35999.05, 966404.0, 63863.5, 377336.3, \\\n 1367733.1, 854535.2, 441199.8, 445267.1, \\\n 513197.9, 75870, 1443603, 489205, 1303870, \\\n 1431597, 826671, 449334, 926533, 31932, \\\n 481266, 1331734, 1844932, 133, 1781068, \\\n 541062, 1934, 918399, 1379739, 99863, \\\n 922466, 818536, 990397, 71998, 341337, \\\n 401329, 1856938, 1267871, 1920802, 858602, \\\n 1403732, 790672, 405201, 485333, 27864, \\\n 111869, 2258267, 1908795, 1745069, 509131, \\\n 39871, 12006, 958465, 381404, 349472, \\\n 1808933, 549197, 4067, 2322131.])\n C = np.array([44.963, 10.74, 145.70, 179.93, 87.53, 276.5, \\\n 124.2, 13.2, 280.7, 148.2, 47.4, 27.9, 222.5, \\\n 41, 52, 142, 246, 315, 111, 188, \\\n 323, 107, 205, 283, 56, 29, 21, \\\n 259, 145, 182, 17, 122, 163, 151, \\\n 357, 85, 16, 274, 152, 249, 186, \\\n 129, 98, 114, 50, 186, 127, 38, \\\n 156, 90, 24, 242, 223, 187, 340, \\\n 354, 337, 58, 220, 70, 191])\n # fmt: on\n RAD = 0.0174532925199433\n tempb = (B * time + C) * RAD\n amp = A * np.cos(tempb)\n moonlon = np.sum(amp)\n moonlon = (moonlon + B0 * time + C0) * RAD\n return moonlon","def coordinates(self):","def ll_coordinates(self):\n\n x, y = self.xy_coordinates\n proj_out = check_crs('EPSG:4326')\n\n return transform_proj(self.proj, proj_out, x, y)","def read_model_coord_var(case,varname):\n filelist = create_file_list(case)\n fpin = Nio.open_file(filelist[0],'r')\n data = fpin.variables[varname][:]\n fpin.close()\n return data","def get_longitude(self):\n return self.L + self.dL","def ll2xyz(lon_pt,lat_pt):\n\n xPt = np.cos(lat_pt) * np.cos(lon_pt)\n yPt = np.cos(lat_pt) * np.sin(lon_pt)\n zPt = np.sin(lat_pt)\n return [xPt,yPt,zPt]","def get_projection(lon, lat, city=\"victoria\"):\n # TODO: Doesn't work if a city is on the boundary of two UTM zones (per Benoit). Figure out solution for future.\n code = PROJ_CODES[city.strip().lower()]\n\n def transf(x, y):\n return transform(PROJ_LATLONG, Proj(init=code), x, y)\n\n utm_e, utm_n = np.vectorize(transf)(lat, lon)\n return utm_e, utm_n","def get_center(self,lonlat=False):\n lon, lat = np.asarray(self.rotator.rots[0][0:2])*180/pi\n if lonlat: return lon,lat\n else: return pi/2.-lat*dtor, lon*dtor","def spatial_dimension(self):\r\n pass","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 coord_proj(self):\r\n return self._coord_proj","def get_offices_locat2(lon, lat): # This function works on POINTS creation (for Mongodb)\n offices_locat = {\n \"type\":\"Point\",\n \"coordinates\":[lon, lat]\n }\n return offices_locat","def get_lons(self, variables):\n\n return self._get_variable(variables, self.LONS_VARIABLE)","def lonToTile(lon, zoom):\n n = 2.0 ** zoom\n return ((lon + 180.0) / 360.0) * n","def pole(self):\n return (self.pol_lon, self.pol_lat)","def fn2lonlat(filename):\n tokens = filename.split(\"/\")[-1].rsplit(\".\", 1)[0].split(\"x\")\n return [0 - float(tokens[0]), float(tokens[1])]","def lunar_longitude(cls, tee):\n return cls.true_position(tee, cls.SIDEREAL_MONTH, 32/360, cls.ANOMALISTIC_MONTH, 1/96)","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 ecliptic_latlon(self):\n vector = _ECLIPJ2000.dot(self.position.au)\n d, lat, lon = to_polar(vector)\n return (Angle(radians=lat, signed=True),\n Angle(radians=lon),\n Distance(au=d))","def tropical_longitude(cls, fixed_date):\n days = ifloor(fixed_date - OldHindu.EPOCH)\n precession = 27 - abs(54 - mod(27 + (108 * 600/1577917828 * days), 108))\n return mod(cls.solar_longitude(fixed_date) - precession, 360)","def extract_region_latlon(cube, lat_bounds):\n\n southern_lat, northern_lat = lat_bounds\n lat_constraint = iris.Constraint(latitude=lambda cell: southern_lat <= cell < northern_lat)\n cube = cube.extract(lat_constraint)\n\n return cube","def is_longitude_var(obj):\n if (obj.name =='longitude'):\n return True\n else:\n return False","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 latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def select(ds, longitude, latitude, varname, T=None, Z=None, \n iT=None, iZ=None, extrap=False, extrap_val=None, locstream=False):\n \n assert not ((Z is not None) and (iZ is not None))\n assert not ((T is not None) and (iT is not None))\n \n if (isinstance(longitude, int)) or (isinstance(longitude, float)):\n longitude = [longitude]\n if (isinstance(latitude, int)) or (isinstance(latitude, float)):\n latitude = [latitude]\n latitude = np.asarray(latitude)\n longitude = np.asarray(longitude)\n\n if extrap:\n extrap_method = \"nearest_s2d\"\n else:\n extrap_method = None\n \n \n cf_var = get_var_cf(ds, varname)\n \n dr = ds.cf[cf_var]\n \n if not extrap:\n assertion = 'the input longitude range is outside the model domain'\n assert (longitude.min() >= dr.cf['longitude'].min()) and (longitude.max() <= dr.cf['longitude'].max()), assertion\n assertion = 'the input latitude range is outside the model domain'\n assert (latitude.min() >= dr.cf['latitude'].min()) and (latitude.max() <= dr.cf['latitude'].max()), assertion\n \n ## Horizontal interpolation ##\n \n # grid of lon/lat to interpolate to, with desired ending attributes\n if latitude.ndim == 1:\n ds_out = xr.Dataset(\n {\n \"lat\": ([\"lat\"], latitude, dict(axis=\"Y\", units='degrees_north', standard_name=\"latitude\")),\n \"lon\": ([\"lon\"], longitude, dict(axis=\"X\", units='degrees_east', standard_name=\"longitude\")),\n }\n )\n elif latitude.ndim == 2:\n ds_out = xr.Dataset(\n {\n \"lat\": ([\"Y\",\"X\"], latitude, dict(units='degrees_north', standard_name=\"latitude\")),\n \"lon\": ([\"Y\",\"X\"], longitude, dict(units='degrees_east', standard_name=\"longitude\")),\n }\n )\n \n\n # set up regridder, which would work for multiple interpolations if desired\n regridder = xe.Regridder(dr, ds_out, \"bilinear\", extrap_method=extrap_method, locstream_out=locstream)\n\n # do regridding\n dr_out = regridder(dr, keep_attrs=True)\n \n \n ## Time and depth interpolation or iselection ##\n if iZ is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.isel(Z=iZ)\n \n if Z is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.interp(Z=Z)\n\n if iT is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.isel(T=iT)\n \n if T is not None:\n with xr.set_options(keep_attrs=True):\n dr_out = dr_out.cf.interp(T=T)\n \n if extrap_val is not None:\n # returns 0 outside the domain by default. Assumes that no other values are exactly 0\n # and replaces all 0's with extrap_val if chosen.\n dr_out = dr_out.where(dr_out != 0, extrap_val)\n \n return dr_out"],"string":"[\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def lat_lons(self):\",\n \"def lon(self):\\n return self['lon']\",\n \"def find_longitude_var(nc,name):\\n var_obj = nc.variables[name] # Find the corresponding variable object \\n dimens = var_obj.dimensions # Find the names of the dimensions of variable\\n for i in range(len(dimens)):\\n # For each dimension find the corresponding variable\\n var_dim = nc.variables[dimens[i]]\\n if is_longitude_var(var_dim) == True:\\n return var_obj # If longitude exists, return the variable object\\n \\n return None\",\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 lon(self):\\n return self._lon\",\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 spatial_var(map_):\\n expx, expy = spatial_expval(map_)\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))\",\n \"def readDataLatLon(self, varName, lat, lon, **kwargs):\\n # TODO: interpolate between lat and lon if necessary\\n \\n retList = []\\n \\n records = self._readRecords(varName, **kwargs)\\n\\n # get the index of the (lat,lon) pair\\n lats, lons = records[0].latlons() \\n latIdx, lonIdx = self._getIndex(lats, lons, lat, lon)\\n\\n for record in records:\\n # We only care about the pressure levels\\n if record.typeOfLevel == 'isobaricInhPa':\\n # Append this value as a 2D 1x1 grid, NOTE: right now, just a value\\n retList.append((record.level, record.values[latIdx][lonIdx]))\\n\\n retList.sort()\\n\\n presVec = np.ndarray((len(retList)))\\n dataVec = np.ndarray((len(retList)))\\n for i in range(len(retList)):\\n presVec[i] = retList[i][0]\\n dataVec[i] = retList[i][1]\\n\\n return presVec, dataVec\",\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 _getlons(self):\\n dlon = 360. / self.nlon\\n lons = np.linspace(0. + dlon / 2., 360. - dlon / 2., self.nlon)\\n return lons\",\n \"def _getXYZ ( lon, lat ):\\n d2r = pi / 180.\\n rlon, rlat = ( d2r * lon, d2r * lat )\\n x = cos(rlat) * cos(rlon)\\n y = cos(rlat) * sin(rlon)\\n z = sin(rlat)\\n return (x,y,z)\",\n \"def vector(self):\\n return np.array([self.lat, self.lng])\",\n \"def load_2D_netCDF(filename, var_name, lat_name, lon_name):\\n data = Dataset(filename, 'r')\\n var = data[var_name][:]\\n lats = data[lat_name][:]\\n lons = data[lon_name][:]\\n data.close()\\n return var, lats, lons\",\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 longitude(self, lon):\\n data = float(lon[1:])\\n if lon[0] == \\\"E\\\":\\n return data\\n else:\\n return -data\",\n \"def merc_x(lon):\\n r_major = 6378137.000\\n x = r_major * math.radians(lon)\\n return x\",\n \"def getlatlon(self):\\n lat = np.pi/2.0 - self._th\\n time = self.gettime()\\n lon = self._phi - 2*np.pi*time/86164.09164\\n return lat, lon\",\n \"def project(self, (lng, lat)):\\n x = lng * DEG_TO_RAD\\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\\n y = lat * DEG_TO_RAD\\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)\",\n \"def northing(self):\\r\\n x, y = self.lonlat2xy(self.longitude, self.latitude)\\r\\n return y\",\n \"def lons(self):\\n return self._origin.lon\",\n \"def lons(self):\\n return self._origin.lon\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def broadcast_lonlat(ds, verbose=True):\\n if 'lon' not in ds.variables:\\n ds.coords['lon'] = ds['x']\\n if 'lat' not in ds.variables:\\n ds.coords['lat'] = ds['y']\\n \\n if len(ds['lon'].dims) < 2:\\n ds.coords[\\\"lon\\\"] = ds[\\\"lon\\\"] * xr.ones_like(ds[\\\"lat\\\"])\\n if len(ds['lat'].dims) < 2:\\n ds.coords[\\\"lat\\\"] = xr.ones_like(ds[\\\"lon\\\"]) * ds[\\\"lat\\\"]\\n return ds\",\n \"def solar_longitude(cls, tee):\\n return cls.true_position(tee, cls.SIDEREAL_YEAR, 14/360, cls.ANOMALISTIC_YEAR, 1/42)\",\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 nancay():\\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)\",\n \"def lat_lon(self):\\n if self._lat_lon is None:\\n if 'coordinates' in self:\\n self._lat_lon = self.coordinates\\n else:\\n self._lat_lon = self.meta\\n lat_lon_cols = ['latitude', 'longitude']\\n for c in self.meta.columns:\\n if c.lower().startswith('lat'):\\n lat_lon_cols[0] = c\\n elif c.lower().startswith('lon'):\\n lat_lon_cols[1] = c\\n\\n self._lat_lon = self._lat_lon[lat_lon_cols].values\\n\\n return self._lat_lon\",\n \"def geo_topo_vector(longitude, latitude, elevation, jd):\\n from astropy.coordinates import GCRS, EarthLocation\\n from astropy.time import Time\\n import numpy as np\\n\\n loc = EarthLocation(longitude, latitude, elevation)\\n\\n time = Time(jd, scale=\\\"utc\\\", format=\\\"jd\\\")\\n itrs = loc.get_itrs(obstime=time)\\n gcrs = itrs.transform_to(GCRS(obstime=time))\\n\\n r = gcrs.cartesian\\n\\n # convert from m to km\\n x = r.x.value / 1000.0\\n y = r.y.value / 1000.0\\n z = r.z.value / 1000.0\\n\\n return np.array([x, y, z])\",\n \"def get_map_values(self, lons, lats, ibin=None):\\n theta = np.pi / 2. - np.radians(lats)\\n phi = np.radians(lons)\\n\\n pix = hp.ang2pix(self.hpx.nside, theta, phi, nest=self.hpx.nest)\\n\\n if self.data.ndim == 2:\\n return self.data[:, pix] if ibin is None else self.data[ibin, pix]\\n else:\\n return self.data[pix]\",\n \"def longitude(self):\\n return self.coordinates[1]\",\n \"def geo(self):\\n return vec2geo_linear_signed(self)\",\n \"def get_coord(path, n_i, n_k):\\n fnm = \\\"%s/coord_mpi%02i%02i.nc\\\" % (path, n_i, n_k)\\n fnc = netcdf.netcdf_file(fnm, 'r')\\n x = fnc.variables['x'][:, :]\\n z = fnc.variables['z'][:, :]\\n return x, z\",\n \"def lonlat2xy(s_lon, s_lat): # x: easting, y: northing\\r\\n # convert decimals to seconds...\\r\\n s_lon = dec2sec(s_lon)\\r\\n s_lat = dec2sec(s_lat)\\r\\n\\r\\n ## Auxiliary values \\r\\n # i.e. differences of latitude and longitude relative to Bern in the unit [10000'']\\r\\n s_lng_aux = (s_lon - 26782.5)/10000.\\r\\n s_lat_aux = (s_lat - 169028.66)/10000.\\r\\n \\r\\n # easting\\r\\n s_x = (600072.37 \\r\\n + 211455.93*s_lng_aux \\r\\n - 10938.51*s_lng_aux*s_lat_aux \\r\\n - 0.36*s_lng_aux*(s_lat_aux**2) \\r\\n - 44.54*(s_lng_aux**3))\\r\\n \\r\\n # northing\\r\\n s_y = (200147.07 \\r\\n + 308807.95*s_lat_aux \\r\\n + 3745.25*(s_lng_aux**2) \\r\\n + 76.63*(s_lat_aux**2) \\r\\n - 194.56*(s_lng_aux**2)*s_lat_aux \\r\\n + 119.79*(s_lat_aux**3))\\r\\n\\r\\n return s_x, s_y\",\n \"def replace_x_y_nominal_lat_lon(ds):\\n ds = ds.copy()\\n if 'x' in ds.dims and 'y' in ds.dims:\\n \\n nominal_y = ds.lat.mean('x')\\n # extract the equatorial lat and take those lon values as nominal lon\\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\\n nominal_x = ds.lon.isel(y=eq_ind)\\n ds.coords['x'].data = nominal_x.data\\n ds.coords['y'].data = nominal_y.data\\n\\n ds = ds.sortby('x')\\n ds = ds.sortby('y')\\n \\n else:\\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\\n return ds\",\n \"def position(self, longitudinal: float, lateral: float) -> np.ndarray:\\n raise NotImplementedError()\",\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 convert(self, lat, lon):\\r\\n a = self.a\\r\\n b = self.b\\r\\n long0 = self.long0\\r\\n k0 = self.k0\\r\\n dx = self.dx\\r\\n\\r\\n e = (1 - b ** 2 / a ** 2) ** 0.5\\r\\n e2 = e ** 2 / (1 - e ** 2)\\r\\n n = (a - b) / (a + b)\\r\\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\\r\\n p = lon - long0\\r\\n\\r\\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\\r\\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\\r\\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\\r\\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\\r\\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\\r\\n\\r\\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\\r\\n\\r\\n K1 = S * k0\\r\\n K2 = k0 * nu * sin(2 * lat)/4.0\\r\\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\\\\r\\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\\r\\n\\r\\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\\r\\n\\r\\n K4 = k0 * nu * cos(lat)\\r\\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\\r\\n\\r\\n x = K4 * p + K5 * (p ** 3) + dx\\r\\n return x, y\",\n \"def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\\n\\n if var.ndim == 3: # 3D variable\\n zmax, imax, jmax = var.shape\\n threeD = True\\n elif var.ndim == 2: # 2D variable\\n imax, jmax = var.shape\\n threeD = False\\n else:\\n print 'extract_loc: check variable dimensions'\\n return\\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 # arrays to store weights and data to be averaged\\n if threeD: # 3D variable\\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var): # mask weights\\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\\n else:\\n dist_m = N.array(N.resize(dist,var.shape))\\n else: # 2D variable\\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var):\\n dist_m = MA.array(dist,mask=var.mask) # mask weights\\n else:\\n dist_m = N.array(dist)\\n\\n # get the 4 model grid points and compute weights\\n n = 0\\n for i in Ilist:\\n for j in Jlist:\\n wghts[...,n] = 1./dist_m[...,i,j]\\n data[...,n] = var[...,i,j]\\n n += 1\\n\\n # compute weighted average\\n wavg = MA.average(data,axis=-1,weights=wghts)\\n return wavg\",\n \"def get_lonlat(self, row, col):\\n\\n if self.ndim != 2:\\n raise DimensionError(('operation undefined '\\n 'for %sD geometry ') % self.ndim)\\n elif self.lons is None or self.lats is None:\\n raise ValueError('lon/lat values are not defined')\\n return self.lons[row, col], self.lats[row, col]\",\n \"def spatial(self):\",\n \"def longitude(self):\\n return self._state[1]\",\n \"def _extract_location_xyz(self, log):\\n\\n if \\\"location\\\" in log:\\n x = log[\\\"location\\\"][\\\"latitude\\\"]\\n y = log[\\\"location\\\"][\\\"longitude\\\"]\\n z = log[\\\"location\\\"][\\\"altitude\\\"]\\n else:\\n self.logger.debug(\\\"NaN case\\\")\\n x = \\\"NaN\\\" # matlab Nan?\\n y = \\\"NaN\\\"\\n z = \\\"NaN\\\"\\n pass\\n return str(x) + \\\",\\\" + str(y) + \\\",\\\" + str(z)\",\n \"def nc_getLatsandLons(fn):\\r\\n\\tfrom netCDF4 import Dataset\\r\\n\\t# load the netcdf file\\r\\n\\tncf1 = Dataset(fn, mode='r')\\r\\n\\r\\n\\t# Pull out the lon and lat data\\r\\n\\tlats = ncf1.variables[\\\"lat\\\"][:]\\r\\n\\tlons = ncf1.variables[\\\"lon\\\"][:]\\r\\n\\r\\n\\treturn lats, lons\",\n \"def _get_las_xyz(fpath):\\n with laspy.file.File(fpath) as f:\\n return [f.x, f.y, f.z]\",\n \"def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\\n # Get Value\\n vrow = invar[kpt,:]\\n \\n # Place into variable\\n mappt = np.zeros(nlat5*nlon5)*np.nan\\n mappt[okpts] = vrow\\n mappt = mappt.reshape(nlat5,nlon5)\\n return mappt\",\n \"def latlong(self, lat, lon):\\n url = \\\"/prediction\\\"\\n\\n # construct_aoi_latlong()\\n aoi = f\\\"POINT({lat} {lon}\\\"\\n\\n # construct params\\n params = {\\\"aoi\\\": aoi}\\n\\n req = self._request(url, params)\\n\\n return req\",\n \"def unproject(self, (x, y)):\\n lng = x/EARTH_RADIUS * RAD_TO_DEG\\n lat = 2 * math.atan(math.exp(y/EARTH_RADIUS)) - math.pi/2 * RAD_TO_DEG\\n return (lng, lat)\",\n \"def mercX(lon):\\r\\n zoom = 1.0\\r\\n lon = math.radians(lon)\\r\\n a = (256.0 / math.pi) * pow(2.0, zoom)\\r\\n b = lon + math.pi\\r\\n return int(a * b)\",\n \"def lon(self):\\n return self._state['lastLocations'][0]['longitude']\",\n \"def LongLat(x, y, z):\\n r = (x**2 + y**2 + z**2)**0.5\\n long = numpy.arctan2(y, x)\\n lat = numpy.arcsin(z / r)\\n return long, lat, r\",\n \"def lonToPhi(lon):\\n return (np.pi/180.0) * lon\",\n \"def safeProj(proj, lon, lat):\\n x, y = proj(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 lonlat(n_lon: int, n_lat: int) -> List[Tuple[float, float]]:\\n grid = []\\n for lon in np.linspace(0, 360.0 - 360.0 / n_lon, n_lon):\\n for lat in np.linspace(-90, 90, n_lat):\\n grid.append((lon, lat))\\n return grid\",\n \"def get_longitude0(self):\\n return self.L\",\n \"def CreateTargetGeoField(nbtimestep,latlen,lonlen):\\n\\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\\n\\n return pres_grid,u_grid,v_grid\",\n \"def set_coord_values(ds, wrf_out, footprint_nbins):\\n xdim_var = ds.variables[\\\"dim_x\\\"]\\n ydim_var = ds.variables[\\\"dim_y\\\"]\\n xdim_bounds_var = ds.variables[\\\"dim_x_bnds\\\"]\\n ydim_bounds_var = ds.variables[\\\"dim_y_bnds\\\"]\\n lon_var = ds.variables[\\\"longitude\\\"]\\n lat_var = ds.variables[\\\"latitude\\\"]\\n\\n time_back_var = ds.variables[\\\"time_before_observation\\\"]\\n time_back_bounds_var = ds.variables[\\\"time_before_observation_bnds\\\"]\\n\\n height_var = ds.variables[\\\"height\\\"]\\n height_bounds_var = ds.variables[\\\"height_bnds\\\"]\\n\\n dx = wrf_out[\\\"dx\\\"]\\n\\n xdim_data = wrf_out[\\\"proj_x_coord\\\"][0]\\n ydim_data = wrf_out[\\\"proj_y_coord\\\"][0]\\n xdim_var[:] = xdim_data[:]\\n ydim_var[:] = ydim_data[:]\\n\\n xdim_bounds_var[:-1,:] = np.column_stack((xdim_data[:-1], xdim_data[1:]))\\n xdim_bounds_var[-1,0] = xdim_data[-1]\\n xdim_bounds_var[-1,1] = xdim_data[-1] + dx\\n ydim_bounds_var[:-1,:] = np.column_stack((ydim_data[:-1], ydim_data[1:]))\\n ydim_bounds_var[-1,0] = ydim_data[-1]\\n ydim_bounds_var[-1,1] = ydim_data[-1] + dx\\n\\n wrf_lats = wrf_out[\\\"wrf_lat\\\"][0][0, :, :]\\n wrf_lons = wrf_out[\\\"wrf_lon\\\"][0][0, :, :]\\n lat_var[:, :] = wrf_lats[:, :]\\n lon_var[:, :] = wrf_lons[:, :]\\n\\n ds.geospatial_lat_min = wrf_lats.min()\\n ds.geospatial_lat_max = wrf_lats.max()\\n ds.geospatial_lat_units = \\\"degree_north\\\"\\n ds.geospatial_lon_min = wrf_lons.min()\\n ds.geospatial_lon_max = wrf_lons.max()\\n ds.geospatial_lon_units = \\\"degree_east\\\"\\n\\n time_back_vals = np.arange(0, footprint_nbins * FLUX_WINDOW, FLUX_WINDOW)\\n time_back_var[:] = time_back_vals\\n time_back_bounds_var[:-1,:] = np.column_stack((time_back_vals[:-1],\\n time_back_vals[1:]))\\n time_back_bounds_var[-1,:] = time_back_vals[-2:] + FLUX_WINDOW\\n\\n height_var[...] = 0\\n height_bounds_var[:] = (0, CLOSE_TO_GROUND)\",\n \"def get_locality(self):\\n return self.reference[REF_LOCALITY][REF_VALUE]\",\n \"def solar_noon_local(LonDegE):\\n return 12.\",\n \"def map(self, lat, long):\\r\\n rxy = self._r*lat/(np.pi/2)\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def get_lon(self):\\n p = self._get_sub_text('lon')\\n if not p:\\n return None\\n else:\\n try:\\n return float(p)\\n except ValueError:\\n return None\",\n \"def build_coordinates_map(self):\\n\\t\\t# We need to keep track of which dimensions we can map\\n\\t\\tmapped = []\\n\\t\\t\\n\\t\\t# First lets check for standard 1D coordinate variables. These are variables\\n\\t\\t# that have the same name as one of the variables dimensions or 1D variables\\n\\t\\t# sharing a dimension with the variable \\n\\t\\tfor di in range (0,len(self.variable.dimensions)):\\n\\n\\t\\t\\tdimension = self.variable.dimensions[di]\\n\\t\\t\\tdim_name = dimension.name\\n\\n\\t\\t\\t# Find variables with same name as the dimension\\n\\t\\t\\tif dim_name in self.variable.group.variables.keys():\\n\\n\\t\\t\\t\\tcoord_variable = self.variable.group.variables[dim_name]\\n\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\t\\t\\t\\tmapped.append(dim_name)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# See if we can use the units to find out what spatial/temporal variable this is from \\n\\t\\t\\t\\t# the CF conventions\\n\\t\\t\\t\\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If we can't we just default to the dimension name\\n\\t\\t\\t\\tif not coordinate_name:\\n\\t\\t\\t\\t\\tcoordinate_name = dim_name\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t# Next lets see if we have a \\\"coordinates\\\" attribute we can use (CF convention)\\n\\t\\tif self.variable.get_attribute('coordinates'):\\n\\t\\t\\t\\n\\t\\t\\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# Find each associated variable\\n\\t\\t\\tfor name in self.coordinates_names:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif name in self.variable.group.variables.keys():\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tcoord_variable = self.variable.group.variables[name]\\n\\t\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\n\\t\\t\\t\\t\\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\\n\\t\\t\\t\\t\\t# See if we can find out what spatial/temporal variable this is\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = name\\n\\n\\t\\t\\t\\t\\t# Create the coordinates_mapping entry but with an empty dimensions map for now\\n\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Add each coordinates variable dimension to the mappable list and generate the map\\n\\t\\t\\t\\t\\t#print 'generating dimensions map for ', coord_variable.dimensions\\n\\t\\t\\t\\t\\tfor dimension in coord_variable.dimensions:\\n\\t\\t\\t\\t\\t\\t#print dimension, coord_variable.dimensions\\n\\t\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\\n\\t\\t\\t\\t\\t\\tif not dimension.name in mapped:\\n\\t\\t\\t\\t\\t\\t\\tmapped.append(dimension.name)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t# Setup shortcut to identify time coordinate variable\\n\\t\\ttry:\\n\\t\\t\\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\\n\\t\\t\\tself.time_dim = self.coordinates_mapping['time']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.time_variable = None\\n\\t\\t\\tself.time_dim = None\\n\\t\\t\\t\\n\\t\\t# Shortcuts for latitude and longitude coordinate variables\\n\\t\\ttry:\\n\\t\\t\\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.latitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.longitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\\n\\t\\t\\tself.level_dim = self.coordinates_mapping['level']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.level_variable = None\\n\\t\\t\\tself.level_dim = None\",\n \"def global_coords(self) -> GlobalCoordsABC:\",\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 map(self, lat, long):\\r\\n rxy = self._r*np.sqrt(1-np.cos(lat))\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def lat_lons(self):\\n return _lat_lons_from_geojson(self._geojson['geometry']['coordinates'])\",\n \"def col_to_lon(self, col):\\n return -180 + col * self.lon_step\",\n \"def lspe_coordinates (self, time):\\n\\n return (self.base_lat,\\n self.base_long\\n + time * 2 * np.pi * (1 + 1 / self.rev_days) / SECONDS_PER_DAY)\",\n \"def correct_lon(ds):\\n ds = ds.copy()\\n x = ds['x'].data\\n ds['x'].data = np.where(x < 0 , 360 + x, x)\\n\\n lon = ds['lon'].data\\n ds['lon'].data = np.where(lon < 0 , 360 + lon, lon)\\n \\n ds = ds.sortby('x')\\n return ds\",\n \"def merc(lat, lon):\\n\\tr_major = 6378137.000\\n\\tx = r_major * math.radians(lon)\\n\\tscale = x/lon\\n\\ty = 180.0/math.pi * math.log(math.tan(math.pi/4.0 + lat * (math.pi/180.0)/2.0)) * scale\\n\\treturn (x, y)\",\n \"def ns(self):\\n return self.lat\",\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_ntl(lon, lat, ntl_dim=7):\\n r, c = ntl_file.index(lon, lat)\\n ntl_win = ((r-ntl_dim/2+1, r+ntl_dim/2+1), (c-ntl_dim/2+1, c+ntl_dim/2+1))\\n ntl_data = ntl_file.read(1, window=ntl_win)\\n ntl_mean = ntl_data.mean()\\n return ntl_mean\",\n \"def __init__(self, lat, long):\\n\\n self.lat = float(lat)\\n self.long = float(long)\\n self.cartesian = None\",\n \"def moonlongitude(time):\\n B0 = 481267.8809\\n C0 = 218.3162\\n # fmt: off\\n A = np.array([62888.e-4, 12740.e-4, 6583.e-4, 2136.e-4, 1851.e-4, \\\\\\n 1144.e-4, 588.e-4, 571.e-4, 533.e-4, 458.e-4, 409.e-4, \\\\\\n 347.e-4, 304.e-4, 154.e-4, 125.e-4, 110.e-4, 107.e-4, \\\\\\n 100.e-4, 85.e-4, 79.e-4, 68.e-4, 52.e-4, 50.e-4, 40.e-4, \\\\\\n 40.e-4, 40.e-4, 38.e-4, 37.e-4, 28.e-4, 27.e-4, 26.e-4, \\\\\\n 24.e-4, 23.e-4, 22.e-4, 21.e-4, 21.e-4, 21.e-4, 18.e-4, \\\\\\n 16.e-4, 12.e-4, 11.e-4, 9.e-4, 8.e-4, 7.e-4, 7.e-4, \\\\\\n 7.e-4, 7.e-4, 6.e-4, 6.e-4, 5.e-4, 5.e-4, 5.e-4, \\\\\\n 4.e-4, 4.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, \\\\\\n 3.e-4, 3.e-4])\\n B = np.array([477198.868, 413335.35, 890534.22, 954397.74, \\\\\\n 35999.05, 966404.0, 63863.5, 377336.3, \\\\\\n 1367733.1, 854535.2, 441199.8, 445267.1, \\\\\\n 513197.9, 75870, 1443603, 489205, 1303870, \\\\\\n 1431597, 826671, 449334, 926533, 31932, \\\\\\n 481266, 1331734, 1844932, 133, 1781068, \\\\\\n 541062, 1934, 918399, 1379739, 99863, \\\\\\n 922466, 818536, 990397, 71998, 341337, \\\\\\n 401329, 1856938, 1267871, 1920802, 858602, \\\\\\n 1403732, 790672, 405201, 485333, 27864, \\\\\\n 111869, 2258267, 1908795, 1745069, 509131, \\\\\\n 39871, 12006, 958465, 381404, 349472, \\\\\\n 1808933, 549197, 4067, 2322131.])\\n C = np.array([44.963, 10.74, 145.70, 179.93, 87.53, 276.5, \\\\\\n 124.2, 13.2, 280.7, 148.2, 47.4, 27.9, 222.5, \\\\\\n 41, 52, 142, 246, 315, 111, 188, \\\\\\n 323, 107, 205, 283, 56, 29, 21, \\\\\\n 259, 145, 182, 17, 122, 163, 151, \\\\\\n 357, 85, 16, 274, 152, 249, 186, \\\\\\n 129, 98, 114, 50, 186, 127, 38, \\\\\\n 156, 90, 24, 242, 223, 187, 340, \\\\\\n 354, 337, 58, 220, 70, 191])\\n # fmt: on\\n RAD = 0.0174532925199433\\n tempb = (B * time + C) * RAD\\n amp = A * np.cos(tempb)\\n moonlon = np.sum(amp)\\n moonlon = (moonlon + B0 * time + C0) * RAD\\n return moonlon\",\n \"def coordinates(self):\",\n \"def ll_coordinates(self):\\n\\n x, y = self.xy_coordinates\\n proj_out = check_crs('EPSG:4326')\\n\\n return transform_proj(self.proj, proj_out, x, y)\",\n \"def read_model_coord_var(case,varname):\\n filelist = create_file_list(case)\\n fpin = Nio.open_file(filelist[0],'r')\\n data = fpin.variables[varname][:]\\n fpin.close()\\n return data\",\n \"def get_longitude(self):\\n return self.L + self.dL\",\n \"def ll2xyz(lon_pt,lat_pt):\\n\\n xPt = np.cos(lat_pt) * np.cos(lon_pt)\\n yPt = np.cos(lat_pt) * np.sin(lon_pt)\\n zPt = np.sin(lat_pt)\\n return [xPt,yPt,zPt]\",\n \"def get_projection(lon, lat, city=\\\"victoria\\\"):\\n # TODO: Doesn't work if a city is on the boundary of two UTM zones (per Benoit). Figure out solution for future.\\n code = PROJ_CODES[city.strip().lower()]\\n\\n def transf(x, y):\\n return transform(PROJ_LATLONG, Proj(init=code), x, y)\\n\\n utm_e, utm_n = np.vectorize(transf)(lat, lon)\\n return utm_e, utm_n\",\n \"def get_center(self,lonlat=False):\\n lon, lat = np.asarray(self.rotator.rots[0][0:2])*180/pi\\n if lonlat: return lon,lat\\n else: return pi/2.-lat*dtor, lon*dtor\",\n \"def spatial_dimension(self):\\r\\n pass\",\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 coord_proj(self):\\r\\n return self._coord_proj\",\n \"def get_offices_locat2(lon, lat): # This function works on POINTS creation (for Mongodb)\\n offices_locat = {\\n \\\"type\\\":\\\"Point\\\",\\n \\\"coordinates\\\":[lon, lat]\\n }\\n return offices_locat\",\n \"def get_lons(self, variables):\\n\\n return self._get_variable(variables, self.LONS_VARIABLE)\",\n \"def lonToTile(lon, zoom):\\n n = 2.0 ** zoom\\n return ((lon + 180.0) / 360.0) * n\",\n \"def pole(self):\\n return (self.pol_lon, self.pol_lat)\",\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 lunar_longitude(cls, tee):\\n return cls.true_position(tee, cls.SIDEREAL_MONTH, 32/360, cls.ANOMALISTIC_MONTH, 1/96)\",\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 ecliptic_latlon(self):\\n vector = _ECLIPJ2000.dot(self.position.au)\\n d, lat, lon = to_polar(vector)\\n return (Angle(radians=lat, signed=True),\\n Angle(radians=lon),\\n Distance(au=d))\",\n \"def tropical_longitude(cls, fixed_date):\\n days = ifloor(fixed_date - OldHindu.EPOCH)\\n precession = 27 - abs(54 - mod(27 + (108 * 600/1577917828 * days), 108))\\n return mod(cls.solar_longitude(fixed_date) - precession, 360)\",\n \"def extract_region_latlon(cube, lat_bounds):\\n\\n southern_lat, northern_lat = lat_bounds\\n lat_constraint = iris.Constraint(latitude=lambda cell: southern_lat <= cell < northern_lat)\\n cube = cube.extract(lat_constraint)\\n\\n return cube\",\n \"def is_longitude_var(obj):\\n if (obj.name =='longitude'):\\n return True\\n else:\\n return False\",\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 latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def select(ds, longitude, latitude, varname, T=None, Z=None, \\n iT=None, iZ=None, extrap=False, extrap_val=None, locstream=False):\\n \\n assert not ((Z is not None) and (iZ is not None))\\n assert not ((T is not None) and (iT is not None))\\n \\n if (isinstance(longitude, int)) or (isinstance(longitude, float)):\\n longitude = [longitude]\\n if (isinstance(latitude, int)) or (isinstance(latitude, float)):\\n latitude = [latitude]\\n latitude = np.asarray(latitude)\\n longitude = np.asarray(longitude)\\n\\n if extrap:\\n extrap_method = \\\"nearest_s2d\\\"\\n else:\\n extrap_method = None\\n \\n \\n cf_var = get_var_cf(ds, varname)\\n \\n dr = ds.cf[cf_var]\\n \\n if not extrap:\\n assertion = 'the input longitude range is outside the model domain'\\n assert (longitude.min() >= dr.cf['longitude'].min()) and (longitude.max() <= dr.cf['longitude'].max()), assertion\\n assertion = 'the input latitude range is outside the model domain'\\n assert (latitude.min() >= dr.cf['latitude'].min()) and (latitude.max() <= dr.cf['latitude'].max()), assertion\\n \\n ## Horizontal interpolation ##\\n \\n # grid of lon/lat to interpolate to, with desired ending attributes\\n if latitude.ndim == 1:\\n ds_out = xr.Dataset(\\n {\\n \\\"lat\\\": ([\\\"lat\\\"], latitude, dict(axis=\\\"Y\\\", units='degrees_north', standard_name=\\\"latitude\\\")),\\n \\\"lon\\\": ([\\\"lon\\\"], longitude, dict(axis=\\\"X\\\", units='degrees_east', standard_name=\\\"longitude\\\")),\\n }\\n )\\n elif latitude.ndim == 2:\\n ds_out = xr.Dataset(\\n {\\n \\\"lat\\\": ([\\\"Y\\\",\\\"X\\\"], latitude, dict(units='degrees_north', standard_name=\\\"latitude\\\")),\\n \\\"lon\\\": ([\\\"Y\\\",\\\"X\\\"], longitude, dict(units='degrees_east', standard_name=\\\"longitude\\\")),\\n }\\n )\\n \\n\\n # set up regridder, which would work for multiple interpolations if desired\\n regridder = xe.Regridder(dr, ds_out, \\\"bilinear\\\", extrap_method=extrap_method, locstream_out=locstream)\\n\\n # do regridding\\n dr_out = regridder(dr, keep_attrs=True)\\n \\n \\n ## Time and depth interpolation or iselection ##\\n if iZ is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.isel(Z=iZ)\\n \\n if Z is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.interp(Z=Z)\\n\\n if iT is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.isel(T=iT)\\n \\n if T is not None:\\n with xr.set_options(keep_attrs=True):\\n dr_out = dr_out.cf.interp(T=T)\\n \\n if extrap_val is not None:\\n # returns 0 outside the domain by default. Assumes that no other values are exactly 0\\n # and replaces all 0's with extrap_val if chosen.\\n dr_out = dr_out.where(dr_out != 0, extrap_val)\\n \\n return dr_out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67902434","0.6771255","0.67498714","0.6621353","0.6568897","0.6417901","0.617368","0.61442626","0.6087874","0.60350233","0.5941551","0.59397936","0.5933728","0.5912952","0.5898972","0.58715075","0.5850327","0.57997036","0.579611","0.5794126","0.57769763","0.57769763","0.5775408","0.5766215","0.57597625","0.57468134","0.57133734","0.5712144","0.5705799","0.5692999","0.568768","0.56614053","0.565405","0.56229246","0.5622275","0.5621776","0.5611711","0.5611711","0.5600885","0.55876553","0.5576786","0.5576553","0.5575354","0.55701953","0.5556718","0.5547243","0.55438566","0.5535936","0.5528058","0.55153954","0.5513879","0.55104566","0.5509961","0.5508461","0.5487296","0.54858583","0.54845124","0.54646915","0.5463194","0.5431812","0.5427347","0.54248375","0.54176897","0.54122806","0.53901833","0.53871614","0.53799295","0.53785366","0.5376781","0.5367991","0.536106","0.53537405","0.5350859","0.534924","0.5348636","0.5348446","0.5345302","0.53402823","0.53267825","0.53214115","0.53141856","0.531338","0.530738","0.52979946","0.52936846","0.5290586","0.5283014","0.5273521","0.5272447","0.52719903","0.5268667","0.52679753","0.5266618","0.5264059","0.5259903","0.52560085","0.52534115","0.5249488","0.5246395","0.5242832"],"string":"[\n \"0.67902434\",\n \"0.6771255\",\n \"0.67498714\",\n \"0.6621353\",\n \"0.6568897\",\n \"0.6417901\",\n \"0.617368\",\n \"0.61442626\",\n \"0.6087874\",\n \"0.60350233\",\n \"0.5941551\",\n \"0.59397936\",\n \"0.5933728\",\n \"0.5912952\",\n \"0.5898972\",\n \"0.58715075\",\n \"0.5850327\",\n \"0.57997036\",\n \"0.579611\",\n \"0.5794126\",\n \"0.57769763\",\n \"0.57769763\",\n \"0.5775408\",\n \"0.5766215\",\n \"0.57597625\",\n \"0.57468134\",\n \"0.57133734\",\n \"0.5712144\",\n \"0.5705799\",\n \"0.5692999\",\n \"0.568768\",\n \"0.56614053\",\n \"0.565405\",\n \"0.56229246\",\n \"0.5622275\",\n \"0.5621776\",\n \"0.5611711\",\n \"0.5611711\",\n \"0.5600885\",\n \"0.55876553\",\n \"0.5576786\",\n \"0.5576553\",\n \"0.5575354\",\n \"0.55701953\",\n \"0.5556718\",\n \"0.5547243\",\n \"0.55438566\",\n \"0.5535936\",\n \"0.5528058\",\n \"0.55153954\",\n \"0.5513879\",\n \"0.55104566\",\n \"0.5509961\",\n \"0.5508461\",\n \"0.5487296\",\n \"0.54858583\",\n \"0.54845124\",\n \"0.54646915\",\n \"0.5463194\",\n \"0.5431812\",\n \"0.5427347\",\n \"0.54248375\",\n \"0.54176897\",\n \"0.54122806\",\n \"0.53901833\",\n \"0.53871614\",\n \"0.53799295\",\n \"0.53785366\",\n \"0.5376781\",\n \"0.5367991\",\n \"0.536106\",\n \"0.53537405\",\n \"0.5350859\",\n \"0.534924\",\n \"0.5348636\",\n \"0.5348446\",\n \"0.5345302\",\n \"0.53402823\",\n \"0.53267825\",\n \"0.53214115\",\n \"0.53141856\",\n \"0.531338\",\n \"0.530738\",\n \"0.52979946\",\n \"0.52936846\",\n \"0.5290586\",\n \"0.5283014\",\n \"0.5273521\",\n \"0.5272447\",\n \"0.52719903\",\n \"0.5268667\",\n \"0.52679753\",\n \"0.5266618\",\n \"0.5264059\",\n \"0.5259903\",\n \"0.52560085\",\n \"0.52534115\",\n \"0.5249488\",\n \"0.5246395\",\n \"0.5242832\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7568185"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19876,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned along the lev (level) axis but whose values are the levels"},"document":{"kind":"string","value":"def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv"},"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 select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\n else:\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\n if ids is None or len(ids)==0:\n ig = len(levax)-1\n else:\n ig = ids[0][0]\n # Crude fist cut: don't interpolate, just return a value\n if levax == mv.getAxisList()[0]:\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\n elif levax == mv.getAxisList()[1]:\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\n else:\n print \"ERROR, select_lev() does not support level axis except as first or second dimentions\"\n return None\n return mvs","def _get_level_values(self, level: int, unique: bool = False) -> Index:\n lev = self.levels[level]\n level_codes = self.codes[level]\n name = self._names[level]\n if unique:\n level_codes = algos.unique(level_codes)\n filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)\n return lev._shallow_copy(filled, name=name)","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def var(self,i): # TODO: change to property to access (read only?) X?\n return Var(i,self.dims[i])","def levels(self):\n return np.array(self._levels()).T","def levshape(self) -> Shape:\n return tuple(len(x) for x in self.levels)","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def getLevel(unique_name):","def getLevels():","def get_var_level_index(sample_size, threshold):\n if sample_size <= 0:\n raise ValueError(\"Sample size cannot be non-positive:\", sample_size)\n if threshold <= 0.0:\n return 0\n if threshold >= 1.0:\n return sample_size - 1\n return int(math.floor(sample_size * threshold))","def enforce(self, wave, variables, parameters):\n return np.hstack([variables[0] - self.level])","def est_maxlevel(dims,bandwidth):\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\n lev=int(lev)\n return lev","def var(self, name):\n return self.get_ground_vector('!Var:{}'.format(name))","def var(self, name):\n return self.get_ground_vector('!Var:{}'.format(name))","def var(self, name):\n return self.get_ground_vector('!Var:{}'.format(name))","def map_lvar(self, *args):\n return _ida_hexrays.vdui_t_map_lvar(self, *args)","def __getitem__(self, *args):\n return _ida_hexrays.qvector_lvar_t___getitem__(self, *args)","def add_extra_level(self, variable, xlevel):\n \n if variable not in [\"geopotential\", \"temperature\"]:\n raise Exception(\"variable should be one of [geopotential,temperature]\")\n \n if variable == \"geopotential\":\n # geopotential \n A = self.z.z[:, -1, :, :].to_dataset() # copy lowest pressure level\n A[\"level\"] = xlevel\n self.z = (xarray.concat([self.z, A], dim=\"level\"))\n \n # convert pressure to geopotential\n self.z.z[0, -1, :, :] = pres2alt(xlevel * 100) * g\n \n else: \n # temperature\n A = self.t.t[:, -1, :, :].to_dataset() # copy lowest pressure level\n A[\"level\"] = xlevel\n self.t = (xarray.concat([self.t, A], dim=\"level\"))","def mult_var_by_prior(self, x_scaled):\n model_var = self.likelihood(x_scaled)[1]\n tensor_log_prior = self.log_prior(x_scaled)\n return tf.reshape(model_var, shape=tensor_log_prior.shape) * tf.math.exp(tensor_log_prior)","def vars(self):\n return [Var(i,self.dims[i]) for i in range(self.nvar)] # TODO: use stored state info (=1 sometimes)","def level(self):\n return self.init_v[2]","def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\n return float(-np.sqrt(self.periods_in_a_year) *\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))","def variance_kl(var: base.Array, pred_log_var: base.Array) -> base.Array:\n log_var = jnp.log(var)\n pred_var = jnp.exp(pred_log_var)\n return 0.5 * (pred_log_var - log_var + var / pred_var - 1)","def GetLinearDimension(dimension):\r\n pass","def get_levels(self):\n return self.levels[self.game]","def get_ground_vector(self, label):\n\n if ':' in label:\n # This is an identifier\n\n parent, _, specifier = label.rpartition(':')\n top, _, _ = parent.partition(':')\n parentvec = self.get_ground_vector(parent)\n\n rs = np.random.RandomState(\n zlib.adler32(\n (str(self.hrr_size)+label).encode('utf-8')\n ) & 0xffffffff)\n rs.randint(2)\n\n specifier_vec = normalize(\n self.specifier_variances['var_{}_{}'.format(top, parent.count(':'))] *\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\n\n newvec = normalize(\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\n torch.cat([\n parentvec,\n specifier_vec,\n ]).reshape(-1, self.hrr_size))\n\n return newvec\n else:\n # Top level terms are fixed encodings\n\n return normalize(self.fixed_encodings[label])","def get_ground_vector(self, label):\n\n if ':' in label:\n # This is an identifier\n\n parent, _, specifier = label.rpartition(':')\n top, _, _ = parent.partition(':')\n parentvec = self.get_ground_vector(parent)\n\n rs = np.random.RandomState(\n zlib.adler32(\n (str(self.hrr_size)+label).encode('utf-8')\n ) & 0xffffffff)\n rs.randint(2)\n\n specifier_vec = normalize_comp(\n self.specifier_variances['var_{}_{}'.format(top, parent.count(':'))] *\n torch.tensor(rs.standard_normal((2, self.hrr_size))).float())\n\n newvec = normalize_comp(\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\n torch.cat([\n parentvec,\n specifier_vec,\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\n\n return newvec\n else:\n # Top level terms are fixed encodings\n\n return normalize_comp(self.fixed_encodings[label])","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def lvec(self):\n lv = ROOT.TLorentzVector()\n# if self.pt < 0 or abs(self.eta) > 6:\n# raise Exception(\"Invalid values for TLorentzVector\")\n lv.SetPtEtaPhiM(self.pt, self.eta, self.phi, self.mass)\n# if abs(lv.Pt()) > 100000 or abs(lv.Eta()) > 100000:\n# raise Exception(\"Invalid values for TLorentzVector\")\n return lv","def at(self, *args):\n return _ida_hexrays.qvector_lvar_t_at(self, *args)","def get_ground_vector(self, label):\n raise NotImplementedError","def _get_va(self, dim):\n assert len(dim) == 2\n dim = N.array(dim)\n if dim.any() < 0 or dim.any() >= self.d:\n raise ValueError(\"dim elements should be between 0 and dimension\"\n \" of the mixture.\")\n\n if self.mode == 'diag':\n return self.va[:, dim]\n elif self.mode == 'full':\n ld = dim.size\n vaselid = N.empty((ld * self.k, ld), N.int)\n for i in range(self.k):\n vaselid[ld*i] = dim[0] + i * self.d\n vaselid[ld*i+1] = dim[1] + i * self.d\n vadid = N.empty((ld * self.k, ld), N.int)\n for i in range(self.k):\n vadid[ld*i] = dim\n vadid[ld*i+1] = dim\n return self.va[vaselid, vadid]\n else:\n raise ValueError(\"Unkown mode\")","def get_ivar(data, s):\n return data.ivar.value / (1 + s**2 * data.ivar.value)","def get_level(rol):\n\treturn rol.level","def get_ground_vector(self, label):\n\n if ':' in label:\n # This is an identifier\n\n parent, _, specifier = label.rpartition(':')\n top, _, _ = parent.partition(':')\n parentvec = self.get_ground_vector(parent)\n\n rs = np.random.RandomState(\n zlib.adler32(\n (str(self.hrr_size)+label).encode('utf-8')\n ) & 0xffffffff)\n rs.randint(2)\n\n specifier_vec = normalize(\n self.specifier_covariances['cov_{}_{}'.format(top, parent.count(':'))] @\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\n\n newvec = normalize(\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\n torch.cat([\n parentvec,\n specifier_vec,\n ]).reshape(-1, self.hrr_size))\n\n return newvec\n else:\n # Top level terms are fixed encodings\n\n return normalize(self.fixed_encodings[label])","def get_ground_vector(self, label):\n\n if ':' in label:\n # This is an identifier\n\n parent, _, specifier = label.rpartition(':')\n top, _, _ = parent.partition(':')\n parentvec = self.get_ground_vector(parent)\n\n rs = np.random.RandomState(\n zlib.adler32(\n (str(self.hrr_size)+label).encode('utf-8')\n ) & 0xffffffff)\n rs.randint(2)\n\n specifier_vec = normalize(\n self.specifier_covariances['cov_{}_{}'.format(top, parent.count(':'))] @\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\n\n newvec = normalize(\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\n torch.cat([\n parentvec,\n specifier_vec,\n ]).reshape(-1, self.hrr_size))\n\n return newvec\n else:\n # Top level terms are fixed encodings\n\n return normalize(self.fixed_encodings[label])","def dims(self):\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)","def get_layer_var_names(self):\n return(self.params)","def level(self, obj):\n if isinstance(obj, compat.string_type):\n if obj not in self._levels:\n raise KeyError(\"No level %s in dimension %s\" %\n (obj, self.name))\n return self._levels[obj]\n elif isinstance(obj, Level):\n return obj\n else:\n raise ValueError(\"Unknown level object %s (should be a string \"\n \"or Level)\" % obj)","def vars(self):\n return self.v","def get_state(self, bsz):\r\n return Variable(torch.zeros(bsz, self.embedding_dim))","def find_lvar(self, *args):\n return _ida_hexrays.lvars_t_find_lvar(self, *args)","def var(self, init_repr, name):\n randomness = self.get_ground_vector('!Var:{}-Var'.format(name))\n return self.varmodel(torch.cat([init_repr, randomness]))","def repackage_var(h):\n if IS_TORCH_04: \n return h.detach() if type(h) == torch.Tensor \\\n else tuple(repackage_var(v) for v in h)\n else: return Variable(h.data) if type(h) == Variable \\\n else tuple(repackage_var(v) for v in h)","def dim3():\n return Integer(\"yolo3\", \"uniform\", 3, 7, shape=(1,))","def var(self):\n\n return self.scale ** -2 \\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)","def get_array(self,vname):\n v=self.f.variables[vname]\n v=pylab.flipud(v)\n return v","def load_variable_profile(\n self,\n varname,\n ):\n if self.depth is None:\n raise LookupError('Profile variables not available in this dataset')\n var = self.dataset.data_vars[varname]\n if 'nVertLevelsLES' in var.dims:\n # LES variables with different vertical levels\n with xr.open_dataset(self._filepath_mesh) as fmesh:\n z = fmesh.data_vars['zLES'].values[0,0,:]\n depth = xr.DataArray(\n z,\n dims=('nVertLevelsLES'),\n coords={'nVertLevelsLES': z},\n attrs={'units': 'm', 'long_name': 'depth'},\n )\n var = var.assign_coords({'nVertLevelsLES': depth})\n elif 'nVertLevelsP1' in var.dims:\n var = var.assign_coords({'nVertLevelsP1': self.depth_iface})\n elif 'nVertLevels' in var.dims:\n var = var.assign_coords({'nVertLevels': self.depth})\n # mask topography\n if 'nCells' in var.dims:\n with xr.open_dataset(self._filepath_mesh) as fmesh:\n maxlevelcell = fmesh.data_vars['maxLevelCell']\n var = var.where(var.nVertLevels>=var.nVertLevels[maxlevelcell-1])\n else:\n raise LookupError('\\'{}\\' is not a profile variables'.format(varname))\n return var.transpose()","def _compute_kl(self, lvl):\n kl = [] # kernal length\n for n in range(lvl):\n fct = self.scaling**n # up-sampling factor\n kl.append(fct*(self.nfreq-1)+1)\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\n return kl[::-1]","def get_level(self, level):\n return","def log(self): # just use base?\n return Factor().__build( VarSet(self.v) , np.log(self.t) )","def getLevel(self):\n return self.level","def dim2():\n probs = (0.1, 0.2, 0.3, 0.4)\n categories = (\"asdfa\", \"2\", \"3\", \"4\")\n categories = OrderedDict(zip(categories, probs))\n dim2 = Categorical(\"yolo2\", categories, default_value=\"2\")\n return dim2","def get_variables(self) -> np.array:\n pass","def AsVector(self) -> ngsolve.la.BaseVector:","def get_var_soln(self, label):\n\n assert self.var_array is not None, 'calculate_diagnostics has not been run'\n i_label = self.var_labels.index(label)\n return self.var_array[:, i_label]","def estimate_var(sample, threshold):\n sample_size = len(sample)\n index_at = get_var_level_index(sample_size, threshold)\n sample.sort()\n return sample[index_at]","def mk_VAR(v):\n if not v.is_var():\n raise InvalidDerivationException(\"mk_VAR\")\n return Thm([], Const(\"_VAR\", TFun(v.T, BoolType))(v))","def model_onelayer_pert(r):\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\tif (r > 6361000.0):\n\t\trho = 2.7\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 2.0 + 0.02\n\t\tvsh = vsv \n\t\teta = 1.0\n\n\telse:\n\t\trho = 3.1\n\t\tvpv = 7.8\n\t\tvph = vpv\n\t\tvsv = 3.0\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def discretize(self, x):\n encoded = self.est.forward(x)\n # encoded will be (A,B,C ... K)\n # take argmax along dim k, and take that from levels\n indices = np.argmax(encoded, axis=-1)\n return np.take(self.levels, indices)","def polynomial_variables(self):\n return self._polynomial_variables","def logdim():\n dim = Real(\"yolo4\", \"reciprocal\", 1.0, 10.0, shape=(3, 2))\n return dim","def nvar(self):\n return self.h.shape[0]","def define_iid_random_variable(rv, num_vars):\n unique_variables = [rv]\n unique_var_indices = [np.arange(num_vars)]\n return IndependentMarginalsVariable(\n unique_variables, unique_var_indices)","def vorticity(self):\n \n ux,_ = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n _,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n # self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y'])\n self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y','t'])\n \n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append('1/dt')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = ('1/dt')\n\n\n return self._obj","def get_var_explained(self, idx, v):\n return 3 * self.get_scaling(idx)**2 * v * self.pars[2]**2 / np.pi**2","def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\n # Lookup parameters per serie\n #seasonality = self.seasonality\n embeds = self.embeds(idxs)\n lev_sms = t.sigmoid(embeds[:, 0])\n\n # Initialize seasonalities\n seas_prod = t.ones(len(Y[:,0]), device=Y.device)\n seasonalities1 = []\n seasonalities2 = []\n seas_sms1 = t.ones(1, device=Y.device)\n seas_sms2 = t.ones(1, device=Y.device)\n\n if len(self.seasonality)>0:\n seas_sms1 = t.sigmoid(embeds[:, 1])\n init_seas1 = t.exp(embeds[:, 2:(2+self.seasonality[0])]).unbind(1)\n assert len(init_seas1) == self.seasonality[0]\n\n for i in range(len(init_seas1)):\n seasonalities1 += [init_seas1[i]]\n seasonalities1 += [init_seas1[0]]\n seas_prod = seas_prod * init_seas1[0]\n\n if len(self.seasonality)==2:\n seas_sms2 = t.sigmoid(embeds[:, 2+self.seasonality[0]])\n init_seas2 = t.exp(embeds[:, 3+self.seasonality[0]:]).unbind(1)\n assert len(init_seas2) == self.seasonality[1]\n\n for i in range(len(init_seas2)):\n seasonalities2 += [init_seas2[i]]\n seasonalities2 += [init_seas2[0]]\n seas_prod = seas_prod * init_seas2[0]\n\n # Initialize levels\n levels = []\n levels += [Y[:,0]/seas_prod]\n\n # Recursive seasonalities and levels\n ys = Y.unbind(1)\n n_time = len(ys)\n for t_idx in range(1, n_time):\n seas_prod_t = t.ones(len(Y[:,t_idx]), device=Y.device)\n if len(self.seasonality)>0:\n seas_prod_t = seas_prod_t * seasonalities1[t_idx]\n if len(self.seasonality)==2:\n seas_prod_t = seas_prod_t * seasonalities2[t_idx]\n\n newlev = lev_sms * (ys[t_idx] / seas_prod_t) + (1-lev_sms) * levels[t_idx-1]\n levels += [newlev]\n\n if len(self.seasonality)==1:\n newseason1 = seas_sms1 * (ys[t_idx] / newlev) + (1-seas_sms1) * seasonalities1[t_idx]\n seasonalities1 += [newseason1]\n\n if len(self.seasonality)==2:\n newseason1 = seas_sms1 * (ys[t_idx] / (newlev * seasonalities2[t_idx])) + \\\n (1-seas_sms1) * seasonalities1[t_idx]\n seasonalities1 += [newseason1]\n newseason2 = seas_sms2 * (ys[t_idx] / (newlev * seasonalities1[t_idx])) + \\\n (1-seas_sms2) * seasonalities2[t_idx]\n seasonalities2 += [newseason2]\n\n levels = t.stack(levels).transpose(1,0)\n\n seasonalities = []\n\n if len(self.seasonality)>0:\n seasonalities += [t.stack(seasonalities1).transpose(1,0)]\n\n if len(self.seasonality)==2:\n seasonalities += [t.stack(seasonalities2).transpose(1,0)]\n\n return levels, seasonalities","def _get_indexer_level_0(self, target) -> npt.NDArray[np.intp]:\n lev = self.levels[0]\n codes = self._codes[0]\n cat = Categorical.from_codes(codes=codes, categories=lev, validate=False)\n ci = Index(cat)\n return ci.get_indexer_for(target)","def get_level(k):\r\n return int(log2(k))","def Flux_levels(self, flux, r_lim=0.45):\n if flux == 'mass':\n set_integrand = lambda x: x\n\n elif flux == 'momentum':\n set_integrand = lambda x: x**2\n\n elif flux == 'buoyancy':\n b = self.read_vars(['b'])['b']\n set_integrand = lambda x: x*b\n\n npx = self.params['npx']\n Lx = self.params['Lx']\n Ly = self.params['Ly']\n Lz = self.params['Lz']\n nz = self.params['nz']\n dx = self.params['dx']\n dy = self.params['dy']\n\n t = self.read_vars(['t'])['t']\n n_time = t.shape[0]\n\n r_max = r_lim # as in forced_plume_nudging.py\n z_max = 0.95\n\n\n flux = np.zeros((n_time, nz))\n\n fields = self.read_vars(['w', 'x', 'y', 'z'])\n w = velocity_interpolation(fields['w'], axis=1)\n\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\n fields['y']/Ly - 0.5)\n\n r = np.sqrt(XX**2 + YY**2)\n mask_1 = ma.masked_outside(r, 0, r_max)\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\n\n # defining integrand\n integrand = set_integrand(w)\n\n for t in range(n_time):\n for z_i in range(nz):\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\n flux[t, z_i] = field_new.sum()\n\n return flux","def t(self):\n index = self.var_index()\n return self.var_data(index)","def var_data(self, index):\n data = np.ma.array(np.zeros(self.n_levels()), mask=True)\n if index is not None:\n for i in range(self.n_levels()):\n if self.profile_data[i]['variables'][index]['Missing']: continue\n data[i] = self.profile_data[i]['variables'][index]['Value']\n return data","def get_level_mag(slide, level):\n return level_mags(slide)[level]","def auxiliary_trail_vector(self):\n return self.attributes[\"_aux_vector\"]","def levels(ohlc_day):\r\n high = round(ohlc_day[\"high\"][-1],2)\r\n low = round(ohlc_day[\"low\"][-1],2)\r\n close = round(ohlc_day[\"close\"][-1],2)\r\n pivot = round((high + low + close)/3,2)\r\n r1 = round((2*pivot - low),2)\r\n r2 = round((pivot + (high - low)),2)\r\n r3 = round((high + 2*(pivot - low)),2)\r\n s1 = round((2*pivot - high),2)\r\n s2 = round((pivot - (high - low)),2)\r\n s3 = round((low - 2*(high - pivot)),2)\r\n return (pivot,r1,r2,r3,s1,s2,s3)","def _dense_var_to_tensor(self, dtype=None, name=None, as_ref=False):\n # pylint: disable=protected-access\n if tpu_util.enclosing_tpu_context() is None:\n return self.read_value()\n else:\n return self._read_variable_op()","def level(self):\n index = self._ordered_input_names.index('level')\n return self._inputs[index]","def vec_node(self):\r\n\r\n xv = np.arange(self.ox, self.lx + self.ox + self.dx, self.dx)\r\n yv = np.arange(self.oy, self.ly + self.oy + self.dy, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz + self.dz, self.dz)\r\n\r\n return xv, yv, zv","def get_variables(self):\n return [self.g_t, self.m_t]","def var(self):\n return np.diag(self.covar)","def onBase():\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))","def _levelChanged(self, event):\n if event == items.Item3DChangedType.ISO_LEVEL:\n model = self.model()\n if model is not None:\n index = self.index(column=1)\n model.dataChanged.emit(index, index)","def V_var(self) -> Optional[np.ndarray]:\n\n def _retrieve(fm: VariationalFM) -> np.ndarray:\n return fm.V_var\n\n return runtime_error_to_optional(self, _retrieve)","def rolling_var_down(self, level: float = 0.95, observations: int = 252,\n interpolation: str = 'lower') -> pd.DataFrame:\n vardf = self.tsdf.rolling(observations, min_periods=observations).apply(\n lambda x: var_down(x, level=level, interpolation=interpolation))\n vardf = vardf.dropna()\n vardf.columns = pd.MultiIndex.from_product([[self.label], ['Rolling VaR']])\n return vardf","def index(self):\n return prod([p**e + p**(e-1) for (p,e) in self.level().factor()])","def levels(ohlc_day):\n high = round(ohlc_day[\"high\"][-1],2)\n low = round(ohlc_day[\"low\"][-1],2)\n close = round(ohlc_day[\"close\"][-1],2)\n pivot = round((high + low + close)/3,2)\n r1 = round((2*pivot - low),2)\n r2 = round((pivot + (high - low)),2)\n r3 = round((high + 2*(pivot - low)),2)\n s1 = round((2*pivot - high),2)\n s2 = round((pivot - (high - low)),2)\n s3 = round((low - 2*(high - pivot)),2)\n return (pivot,r1,r2,r3,s1,s2,s3)","def unkV(self):\n if self._unkV is None:\n self._unkV = self.V.mean(0)\n return self._unkV","def get_lux(self):\n\n svc = \"urn:micasaverde-com:serviceId:LightSensor1\"\n if not svc in self.services:\n raise RuntimeError, \"Device doesn't support the service\"\n\n return self.get_variable(svc, \"CurrentLevel\")","def map_roi_levels(self, rois, num_levels):\r\n scale = torch.sqrt(\r\n (rois[:, 3] - rois[:, 1] + 1) * (rois[:, 4] - rois[:, 2] + 1))\r\n target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6))\r\n target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()\r\n return target_lvls","def vel_inicial(x): #Velocidad inicial como un vector de ceros\r\n return np.zeros_like(x)","def velocity_field(self):\n return scipy.dstack((self._u_int, self._v_int))","def get_luminosity(self, vel_disp):\n\t\tlog_L_V = self.slope*np.log10(vel_disp) + self.intercept\n\t\treturn log_L_V","def get_level_size(slide, level):\n return slide.level_dimensions[level]","def log(obj):\n\tif isinstance(obj, Variable):\n\t\tval = np.log(obj.val)\n\t\tder = np.divide(1,obj.val)\n\t\t# print(obj.der)\n\t\t# print(der)\n\t\t# print(obj.der.shape)\n\t\t# print(der.shape)\n\t\tif len(obj.der.shape)>len(der.shape):\n\t\t\tder = np.expand_dims(der,1)\n\t\tder = np.multiply(der, obj.der)\n\t\treturn Variable(val, der)\n\telse:\n\t\treturn np.log(obj)","def get_level(self, channel=None):\n return int(self.getSensorData(\"VALVE_STATE\", channel))","def level_sets(self):\n in_degrees = self.in_degree(labels=True)\n level = [x for x in in_degrees if in_degrees[x]==0]\n Levels = []\n while len(level) != 0:\n Levels.append(level)\n new_level = []\n for x in level:\n for y in self.neighbors_out(x):\n in_degrees[y] -= 1\n if in_degrees[y] == 0:\n new_level.append(y)\n level = new_level\n return Levels","def label_lvl(a, thlds, labels):\n if len(labels) != len(thlds) + 1:\n raise ValueError(\"Must be one more label than number of thresholds\")\n lvl_indexes = index_lvl(a, thlds)\n return np.take(labels, lvl_indexes)","def dim():\n dim = Real(\"yolo\", \"norm\", 0.9, shape=(3, 2))\n return dim","def make_level(self):\n level = Level(self.data['levelname'])\n self._set_common_attributes(level)\n self.level = level\n return level","def cie_luv(self):\n K = Fraction(29, 3) ** 3\n e = Fraction(6, 29) ** 3\n XYZ = self.cie_xyz\n yr = XYZ[1] / D65[1]\n L = 116 * yr ** Fraction(1, 3) - 16 if yr > e else K * yr\n u = 13 * L * (U(*XYZ) - U(*D65))\n v = 13 * L * (V(*XYZ) - V(*D65))\n return (L, u, v)"],"string":"[\n \"def select_lev( mv, slev ):\\n levax = levAxis(mv)\\n # Get ig, the first index for which levax[ig]>slev\\n # Assume that levax values are monotonic.\\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\\n if levax[0]<=levax[-1]:\\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\\n else:\\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\\n if ids is None or len(ids)==0:\\n ig = len(levax)-1\\n else:\\n ig = ids[0][0]\\n # Crude fist cut: don't interpolate, just return a value\\n if levax == mv.getAxisList()[0]:\\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\\n elif levax == mv.getAxisList()[1]:\\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\\n else:\\n print \\\"ERROR, select_lev() does not support level axis except as first or second dimentions\\\"\\n return None\\n return mvs\",\n \"def _get_level_values(self, level: int, unique: bool = False) -> Index:\\n lev = self.levels[level]\\n level_codes = self.codes[level]\\n name = self._names[level]\\n if unique:\\n level_codes = algos.unique(level_codes)\\n filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)\\n return lev._shallow_copy(filled, name=name)\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def var(self,i): # TODO: change to property to access (read only?) X?\\n return Var(i,self.dims[i])\",\n \"def levels(self):\\n return np.array(self._levels()).T\",\n \"def levshape(self) -> Shape:\\n return tuple(len(x) for x in self.levels)\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def getLevel(unique_name):\",\n \"def getLevels():\",\n \"def get_var_level_index(sample_size, threshold):\\n if sample_size <= 0:\\n raise ValueError(\\\"Sample size cannot be non-positive:\\\", sample_size)\\n if threshold <= 0.0:\\n return 0\\n if threshold >= 1.0:\\n return sample_size - 1\\n return int(math.floor(sample_size * threshold))\",\n \"def enforce(self, wave, variables, parameters):\\n return np.hstack([variables[0] - self.level])\",\n \"def est_maxlevel(dims,bandwidth):\\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\\n lev=int(lev)\\n return lev\",\n \"def var(self, name):\\n return self.get_ground_vector('!Var:{}'.format(name))\",\n \"def var(self, name):\\n return self.get_ground_vector('!Var:{}'.format(name))\",\n \"def var(self, name):\\n return self.get_ground_vector('!Var:{}'.format(name))\",\n \"def map_lvar(self, *args):\\n return _ida_hexrays.vdui_t_map_lvar(self, *args)\",\n \"def __getitem__(self, *args):\\n return _ida_hexrays.qvector_lvar_t___getitem__(self, *args)\",\n \"def add_extra_level(self, variable, xlevel):\\n \\n if variable not in [\\\"geopotential\\\", \\\"temperature\\\"]:\\n raise Exception(\\\"variable should be one of [geopotential,temperature]\\\")\\n \\n if variable == \\\"geopotential\\\":\\n # geopotential \\n A = self.z.z[:, -1, :, :].to_dataset() # copy lowest pressure level\\n A[\\\"level\\\"] = xlevel\\n self.z = (xarray.concat([self.z, A], dim=\\\"level\\\"))\\n \\n # convert pressure to geopotential\\n self.z.z[0, -1, :, :] = pres2alt(xlevel * 100) * g\\n \\n else: \\n # temperature\\n A = self.t.t[:, -1, :, :].to_dataset() # copy lowest pressure level\\n A[\\\"level\\\"] = xlevel\\n self.t = (xarray.concat([self.t, A], dim=\\\"level\\\"))\",\n \"def mult_var_by_prior(self, x_scaled):\\n model_var = self.likelihood(x_scaled)[1]\\n tensor_log_prior = self.log_prior(x_scaled)\\n return tf.reshape(model_var, shape=tensor_log_prior.shape) * tf.math.exp(tensor_log_prior)\",\n \"def vars(self):\\n return [Var(i,self.dims[i]) for i in range(self.nvar)] # TODO: use stored state info (=1 sometimes)\",\n \"def level(self):\\n return self.init_v[2]\",\n \"def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\\n return float(-np.sqrt(self.periods_in_a_year) *\\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))\",\n \"def variance_kl(var: base.Array, pred_log_var: base.Array) -> base.Array:\\n log_var = jnp.log(var)\\n pred_var = jnp.exp(pred_log_var)\\n return 0.5 * (pred_log_var - log_var + var / pred_var - 1)\",\n \"def GetLinearDimension(dimension):\\r\\n pass\",\n \"def get_levels(self):\\n return self.levels[self.game]\",\n \"def get_ground_vector(self, label):\\n\\n if ':' in label:\\n # This is an identifier\\n\\n parent, _, specifier = label.rpartition(':')\\n top, _, _ = parent.partition(':')\\n parentvec = self.get_ground_vector(parent)\\n\\n rs = np.random.RandomState(\\n zlib.adler32(\\n (str(self.hrr_size)+label).encode('utf-8')\\n ) & 0xffffffff)\\n rs.randint(2)\\n\\n specifier_vec = normalize(\\n self.specifier_variances['var_{}_{}'.format(top, parent.count(':'))] *\\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\\n\\n newvec = normalize(\\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\\n torch.cat([\\n parentvec,\\n specifier_vec,\\n ]).reshape(-1, self.hrr_size))\\n\\n return newvec\\n else:\\n # Top level terms are fixed encodings\\n\\n return normalize(self.fixed_encodings[label])\",\n \"def get_ground_vector(self, label):\\n\\n if ':' in label:\\n # This is an identifier\\n\\n parent, _, specifier = label.rpartition(':')\\n top, _, _ = parent.partition(':')\\n parentvec = self.get_ground_vector(parent)\\n\\n rs = np.random.RandomState(\\n zlib.adler32(\\n (str(self.hrr_size)+label).encode('utf-8')\\n ) & 0xffffffff)\\n rs.randint(2)\\n\\n specifier_vec = normalize_comp(\\n self.specifier_variances['var_{}_{}'.format(top, parent.count(':'))] *\\n torch.tensor(rs.standard_normal((2, self.hrr_size))).float())\\n\\n newvec = normalize_comp(\\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\\n torch.cat([\\n parentvec,\\n specifier_vec,\\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\\n\\n return newvec\\n else:\\n # Top level terms are fixed encodings\\n\\n return normalize_comp(self.fixed_encodings[label])\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def lvec(self):\\n lv = ROOT.TLorentzVector()\\n# if self.pt < 0 or abs(self.eta) > 6:\\n# raise Exception(\\\"Invalid values for TLorentzVector\\\")\\n lv.SetPtEtaPhiM(self.pt, self.eta, self.phi, self.mass)\\n# if abs(lv.Pt()) > 100000 or abs(lv.Eta()) > 100000:\\n# raise Exception(\\\"Invalid values for TLorentzVector\\\")\\n return lv\",\n \"def at(self, *args):\\n return _ida_hexrays.qvector_lvar_t_at(self, *args)\",\n \"def get_ground_vector(self, label):\\n raise NotImplementedError\",\n \"def _get_va(self, dim):\\n assert len(dim) == 2\\n dim = N.array(dim)\\n if dim.any() < 0 or dim.any() >= self.d:\\n raise ValueError(\\\"dim elements should be between 0 and dimension\\\"\\n \\\" of the mixture.\\\")\\n\\n if self.mode == 'diag':\\n return self.va[:, dim]\\n elif self.mode == 'full':\\n ld = dim.size\\n vaselid = N.empty((ld * self.k, ld), N.int)\\n for i in range(self.k):\\n vaselid[ld*i] = dim[0] + i * self.d\\n vaselid[ld*i+1] = dim[1] + i * self.d\\n vadid = N.empty((ld * self.k, ld), N.int)\\n for i in range(self.k):\\n vadid[ld*i] = dim\\n vadid[ld*i+1] = dim\\n return self.va[vaselid, vadid]\\n else:\\n raise ValueError(\\\"Unkown mode\\\")\",\n \"def get_ivar(data, s):\\n return data.ivar.value / (1 + s**2 * data.ivar.value)\",\n \"def get_level(rol):\\n\\treturn rol.level\",\n \"def get_ground_vector(self, label):\\n\\n if ':' in label:\\n # This is an identifier\\n\\n parent, _, specifier = label.rpartition(':')\\n top, _, _ = parent.partition(':')\\n parentvec = self.get_ground_vector(parent)\\n\\n rs = np.random.RandomState(\\n zlib.adler32(\\n (str(self.hrr_size)+label).encode('utf-8')\\n ) & 0xffffffff)\\n rs.randint(2)\\n\\n specifier_vec = normalize(\\n self.specifier_covariances['cov_{}_{}'.format(top, parent.count(':'))] @\\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\\n\\n newvec = normalize(\\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\\n torch.cat([\\n parentvec,\\n specifier_vec,\\n ]).reshape(-1, self.hrr_size))\\n\\n return newvec\\n else:\\n # Top level terms are fixed encodings\\n\\n return normalize(self.fixed_encodings[label])\",\n \"def get_ground_vector(self, label):\\n\\n if ':' in label:\\n # This is an identifier\\n\\n parent, _, specifier = label.rpartition(':')\\n top, _, _ = parent.partition(':')\\n parentvec = self.get_ground_vector(parent)\\n\\n rs = np.random.RandomState(\\n zlib.adler32(\\n (str(self.hrr_size)+label).encode('utf-8')\\n ) & 0xffffffff)\\n rs.randint(2)\\n\\n specifier_vec = normalize(\\n self.specifier_covariances['cov_{}_{}'.format(top, parent.count(':'))] @\\n torch.tensor(rs.standard_normal(self.hrr_size)).float())\\n\\n newvec = normalize(\\n self.ground_vec_merge_ratios['ground_{}_{}'.format(top, parent.count(':'))] @\\n torch.cat([\\n parentvec,\\n specifier_vec,\\n ]).reshape(-1, self.hrr_size))\\n\\n return newvec\\n else:\\n # Top level terms are fixed encodings\\n\\n return normalize(self.fixed_encodings[label])\",\n \"def dims(self):\\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)\",\n \"def get_layer_var_names(self):\\n return(self.params)\",\n \"def level(self, obj):\\n if isinstance(obj, compat.string_type):\\n if obj not in self._levels:\\n raise KeyError(\\\"No level %s in dimension %s\\\" %\\n (obj, self.name))\\n return self._levels[obj]\\n elif isinstance(obj, Level):\\n return obj\\n else:\\n raise ValueError(\\\"Unknown level object %s (should be a string \\\"\\n \\\"or Level)\\\" % obj)\",\n \"def vars(self):\\n return self.v\",\n \"def get_state(self, bsz):\\r\\n return Variable(torch.zeros(bsz, self.embedding_dim))\",\n \"def find_lvar(self, *args):\\n return _ida_hexrays.lvars_t_find_lvar(self, *args)\",\n \"def var(self, init_repr, name):\\n randomness = self.get_ground_vector('!Var:{}-Var'.format(name))\\n return self.varmodel(torch.cat([init_repr, randomness]))\",\n \"def repackage_var(h):\\n if IS_TORCH_04: \\n return h.detach() if type(h) == torch.Tensor \\\\\\n else tuple(repackage_var(v) for v in h)\\n else: return Variable(h.data) if type(h) == Variable \\\\\\n else tuple(repackage_var(v) for v in h)\",\n \"def dim3():\\n return Integer(\\\"yolo3\\\", \\\"uniform\\\", 3, 7, shape=(1,))\",\n \"def var(self):\\n\\n return self.scale ** -2 \\\\\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)\",\n \"def get_array(self,vname):\\n v=self.f.variables[vname]\\n v=pylab.flipud(v)\\n return v\",\n \"def load_variable_profile(\\n self,\\n varname,\\n ):\\n if self.depth is None:\\n raise LookupError('Profile variables not available in this dataset')\\n var = self.dataset.data_vars[varname]\\n if 'nVertLevelsLES' in var.dims:\\n # LES variables with different vertical levels\\n with xr.open_dataset(self._filepath_mesh) as fmesh:\\n z = fmesh.data_vars['zLES'].values[0,0,:]\\n depth = xr.DataArray(\\n z,\\n dims=('nVertLevelsLES'),\\n coords={'nVertLevelsLES': z},\\n attrs={'units': 'm', 'long_name': 'depth'},\\n )\\n var = var.assign_coords({'nVertLevelsLES': depth})\\n elif 'nVertLevelsP1' in var.dims:\\n var = var.assign_coords({'nVertLevelsP1': self.depth_iface})\\n elif 'nVertLevels' in var.dims:\\n var = var.assign_coords({'nVertLevels': self.depth})\\n # mask topography\\n if 'nCells' in var.dims:\\n with xr.open_dataset(self._filepath_mesh) as fmesh:\\n maxlevelcell = fmesh.data_vars['maxLevelCell']\\n var = var.where(var.nVertLevels>=var.nVertLevels[maxlevelcell-1])\\n else:\\n raise LookupError('\\\\'{}\\\\' is not a profile variables'.format(varname))\\n return var.transpose()\",\n \"def _compute_kl(self, lvl):\\n kl = [] # kernal length\\n for n in range(lvl):\\n fct = self.scaling**n # up-sampling factor\\n kl.append(fct*(self.nfreq-1)+1)\\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\\n return kl[::-1]\",\n \"def get_level(self, level):\\n return\",\n \"def log(self): # just use base?\\n return Factor().__build( VarSet(self.v) , np.log(self.t) )\",\n \"def getLevel(self):\\n return self.level\",\n \"def dim2():\\n probs = (0.1, 0.2, 0.3, 0.4)\\n categories = (\\\"asdfa\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n categories = OrderedDict(zip(categories, probs))\\n dim2 = Categorical(\\\"yolo2\\\", categories, default_value=\\\"2\\\")\\n return dim2\",\n \"def get_variables(self) -> np.array:\\n pass\",\n \"def AsVector(self) -> ngsolve.la.BaseVector:\",\n \"def get_var_soln(self, label):\\n\\n assert self.var_array is not None, 'calculate_diagnostics has not been run'\\n i_label = self.var_labels.index(label)\\n return self.var_array[:, i_label]\",\n \"def estimate_var(sample, threshold):\\n sample_size = len(sample)\\n index_at = get_var_level_index(sample_size, threshold)\\n sample.sort()\\n return sample[index_at]\",\n \"def mk_VAR(v):\\n if not v.is_var():\\n raise InvalidDerivationException(\\\"mk_VAR\\\")\\n return Thm([], Const(\\\"_VAR\\\", TFun(v.T, BoolType))(v))\",\n \"def model_onelayer_pert(r):\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\tif (r > 6361000.0):\\n\\t\\trho = 2.7\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.0 + 0.02\\n\\t\\tvsh = vsv \\n\\t\\teta = 1.0\\n\\n\\telse:\\n\\t\\trho = 3.1\\n\\t\\tvpv = 7.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.0\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def discretize(self, x):\\n encoded = self.est.forward(x)\\n # encoded will be (A,B,C ... K)\\n # take argmax along dim k, and take that from levels\\n indices = np.argmax(encoded, axis=-1)\\n return np.take(self.levels, indices)\",\n \"def polynomial_variables(self):\\n return self._polynomial_variables\",\n \"def logdim():\\n dim = Real(\\\"yolo4\\\", \\\"reciprocal\\\", 1.0, 10.0, shape=(3, 2))\\n return dim\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def define_iid_random_variable(rv, num_vars):\\n unique_variables = [rv]\\n unique_var_indices = [np.arange(num_vars)]\\n return IndependentMarginalsVariable(\\n unique_variables, unique_var_indices)\",\n \"def vorticity(self):\\n \\n ux,_ = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n _,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n # self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y'])\\n self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y','t'])\\n \\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append('1/dt')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = ('1/dt')\\n\\n\\n return self._obj\",\n \"def get_var_explained(self, idx, v):\\n return 3 * self.get_scaling(idx)**2 * v * self.pars[2]**2 / np.pi**2\",\n \"def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\\n # Lookup parameters per serie\\n #seasonality = self.seasonality\\n embeds = self.embeds(idxs)\\n lev_sms = t.sigmoid(embeds[:, 0])\\n\\n # Initialize seasonalities\\n seas_prod = t.ones(len(Y[:,0]), device=Y.device)\\n seasonalities1 = []\\n seasonalities2 = []\\n seas_sms1 = t.ones(1, device=Y.device)\\n seas_sms2 = t.ones(1, device=Y.device)\\n\\n if len(self.seasonality)>0:\\n seas_sms1 = t.sigmoid(embeds[:, 1])\\n init_seas1 = t.exp(embeds[:, 2:(2+self.seasonality[0])]).unbind(1)\\n assert len(init_seas1) == self.seasonality[0]\\n\\n for i in range(len(init_seas1)):\\n seasonalities1 += [init_seas1[i]]\\n seasonalities1 += [init_seas1[0]]\\n seas_prod = seas_prod * init_seas1[0]\\n\\n if len(self.seasonality)==2:\\n seas_sms2 = t.sigmoid(embeds[:, 2+self.seasonality[0]])\\n init_seas2 = t.exp(embeds[:, 3+self.seasonality[0]:]).unbind(1)\\n assert len(init_seas2) == self.seasonality[1]\\n\\n for i in range(len(init_seas2)):\\n seasonalities2 += [init_seas2[i]]\\n seasonalities2 += [init_seas2[0]]\\n seas_prod = seas_prod * init_seas2[0]\\n\\n # Initialize levels\\n levels = []\\n levels += [Y[:,0]/seas_prod]\\n\\n # Recursive seasonalities and levels\\n ys = Y.unbind(1)\\n n_time = len(ys)\\n for t_idx in range(1, n_time):\\n seas_prod_t = t.ones(len(Y[:,t_idx]), device=Y.device)\\n if len(self.seasonality)>0:\\n seas_prod_t = seas_prod_t * seasonalities1[t_idx]\\n if len(self.seasonality)==2:\\n seas_prod_t = seas_prod_t * seasonalities2[t_idx]\\n\\n newlev = lev_sms * (ys[t_idx] / seas_prod_t) + (1-lev_sms) * levels[t_idx-1]\\n levels += [newlev]\\n\\n if len(self.seasonality)==1:\\n newseason1 = seas_sms1 * (ys[t_idx] / newlev) + (1-seas_sms1) * seasonalities1[t_idx]\\n seasonalities1 += [newseason1]\\n\\n if len(self.seasonality)==2:\\n newseason1 = seas_sms1 * (ys[t_idx] / (newlev * seasonalities2[t_idx])) + \\\\\\n (1-seas_sms1) * seasonalities1[t_idx]\\n seasonalities1 += [newseason1]\\n newseason2 = seas_sms2 * (ys[t_idx] / (newlev * seasonalities1[t_idx])) + \\\\\\n (1-seas_sms2) * seasonalities2[t_idx]\\n seasonalities2 += [newseason2]\\n\\n levels = t.stack(levels).transpose(1,0)\\n\\n seasonalities = []\\n\\n if len(self.seasonality)>0:\\n seasonalities += [t.stack(seasonalities1).transpose(1,0)]\\n\\n if len(self.seasonality)==2:\\n seasonalities += [t.stack(seasonalities2).transpose(1,0)]\\n\\n return levels, seasonalities\",\n \"def _get_indexer_level_0(self, target) -> npt.NDArray[np.intp]:\\n lev = self.levels[0]\\n codes = self._codes[0]\\n cat = Categorical.from_codes(codes=codes, categories=lev, validate=False)\\n ci = Index(cat)\\n return ci.get_indexer_for(target)\",\n \"def get_level(k):\\r\\n return int(log2(k))\",\n \"def Flux_levels(self, flux, r_lim=0.45):\\n if flux == 'mass':\\n set_integrand = lambda x: x\\n\\n elif flux == 'momentum':\\n set_integrand = lambda x: x**2\\n\\n elif flux == 'buoyancy':\\n b = self.read_vars(['b'])['b']\\n set_integrand = lambda x: x*b\\n\\n npx = self.params['npx']\\n Lx = self.params['Lx']\\n Ly = self.params['Ly']\\n Lz = self.params['Lz']\\n nz = self.params['nz']\\n dx = self.params['dx']\\n dy = self.params['dy']\\n\\n t = self.read_vars(['t'])['t']\\n n_time = t.shape[0]\\n\\n r_max = r_lim # as in forced_plume_nudging.py\\n z_max = 0.95\\n\\n\\n flux = np.zeros((n_time, nz))\\n\\n fields = self.read_vars(['w', 'x', 'y', 'z'])\\n w = velocity_interpolation(fields['w'], axis=1)\\n\\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\\n fields['y']/Ly - 0.5)\\n\\n r = np.sqrt(XX**2 + YY**2)\\n mask_1 = ma.masked_outside(r, 0, r_max)\\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\\n\\n # defining integrand\\n integrand = set_integrand(w)\\n\\n for t in range(n_time):\\n for z_i in range(nz):\\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\\n flux[t, z_i] = field_new.sum()\\n\\n return flux\",\n \"def t(self):\\n index = self.var_index()\\n return self.var_data(index)\",\n \"def var_data(self, index):\\n data = np.ma.array(np.zeros(self.n_levels()), mask=True)\\n if index is not None:\\n for i in range(self.n_levels()):\\n if self.profile_data[i]['variables'][index]['Missing']: continue\\n data[i] = self.profile_data[i]['variables'][index]['Value']\\n return data\",\n \"def get_level_mag(slide, level):\\n return level_mags(slide)[level]\",\n \"def auxiliary_trail_vector(self):\\n return self.attributes[\\\"_aux_vector\\\"]\",\n \"def levels(ohlc_day):\\r\\n high = round(ohlc_day[\\\"high\\\"][-1],2)\\r\\n low = round(ohlc_day[\\\"low\\\"][-1],2)\\r\\n close = round(ohlc_day[\\\"close\\\"][-1],2)\\r\\n pivot = round((high + low + close)/3,2)\\r\\n r1 = round((2*pivot - low),2)\\r\\n r2 = round((pivot + (high - low)),2)\\r\\n r3 = round((high + 2*(pivot - low)),2)\\r\\n s1 = round((2*pivot - high),2)\\r\\n s2 = round((pivot - (high - low)),2)\\r\\n s3 = round((low - 2*(high - pivot)),2)\\r\\n return (pivot,r1,r2,r3,s1,s2,s3)\",\n \"def _dense_var_to_tensor(self, dtype=None, name=None, as_ref=False):\\n # pylint: disable=protected-access\\n if tpu_util.enclosing_tpu_context() is None:\\n return self.read_value()\\n else:\\n return self._read_variable_op()\",\n \"def level(self):\\n index = self._ordered_input_names.index('level')\\n return self._inputs[index]\",\n \"def vec_node(self):\\r\\n\\r\\n xv = np.arange(self.ox, self.lx + self.ox + self.dx, self.dx)\\r\\n yv = np.arange(self.oy, self.ly + self.oy + self.dy, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz + self.dz, self.dz)\\r\\n\\r\\n return xv, yv, zv\",\n \"def get_variables(self):\\n return [self.g_t, self.m_t]\",\n \"def var(self):\\n return np.diag(self.covar)\",\n \"def onBase():\\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))\",\n \"def _levelChanged(self, event):\\n if event == items.Item3DChangedType.ISO_LEVEL:\\n model = self.model()\\n if model is not None:\\n index = self.index(column=1)\\n model.dataChanged.emit(index, index)\",\n \"def V_var(self) -> Optional[np.ndarray]:\\n\\n def _retrieve(fm: VariationalFM) -> np.ndarray:\\n return fm.V_var\\n\\n return runtime_error_to_optional(self, _retrieve)\",\n \"def rolling_var_down(self, level: float = 0.95, observations: int = 252,\\n interpolation: str = 'lower') -> pd.DataFrame:\\n vardf = self.tsdf.rolling(observations, min_periods=observations).apply(\\n lambda x: var_down(x, level=level, interpolation=interpolation))\\n vardf = vardf.dropna()\\n vardf.columns = pd.MultiIndex.from_product([[self.label], ['Rolling VaR']])\\n return vardf\",\n \"def index(self):\\n return prod([p**e + p**(e-1) for (p,e) in self.level().factor()])\",\n \"def levels(ohlc_day):\\n high = round(ohlc_day[\\\"high\\\"][-1],2)\\n low = round(ohlc_day[\\\"low\\\"][-1],2)\\n close = round(ohlc_day[\\\"close\\\"][-1],2)\\n pivot = round((high + low + close)/3,2)\\n r1 = round((2*pivot - low),2)\\n r2 = round((pivot + (high - low)),2)\\n r3 = round((high + 2*(pivot - low)),2)\\n s1 = round((2*pivot - high),2)\\n s2 = round((pivot - (high - low)),2)\\n s3 = round((low - 2*(high - pivot)),2)\\n return (pivot,r1,r2,r3,s1,s2,s3)\",\n \"def unkV(self):\\n if self._unkV is None:\\n self._unkV = self.V.mean(0)\\n return self._unkV\",\n \"def get_lux(self):\\n\\n svc = \\\"urn:micasaverde-com:serviceId:LightSensor1\\\"\\n if not svc in self.services:\\n raise RuntimeError, \\\"Device doesn't support the service\\\"\\n\\n return self.get_variable(svc, \\\"CurrentLevel\\\")\",\n \"def map_roi_levels(self, rois, num_levels):\\r\\n scale = torch.sqrt(\\r\\n (rois[:, 3] - rois[:, 1] + 1) * (rois[:, 4] - rois[:, 2] + 1))\\r\\n target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6))\\r\\n target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()\\r\\n return target_lvls\",\n \"def vel_inicial(x): #Velocidad inicial como un vector de ceros\\r\\n return np.zeros_like(x)\",\n \"def velocity_field(self):\\n return scipy.dstack((self._u_int, self._v_int))\",\n \"def get_luminosity(self, vel_disp):\\n\\t\\tlog_L_V = self.slope*np.log10(vel_disp) + self.intercept\\n\\t\\treturn log_L_V\",\n \"def get_level_size(slide, level):\\n return slide.level_dimensions[level]\",\n \"def log(obj):\\n\\tif isinstance(obj, Variable):\\n\\t\\tval = np.log(obj.val)\\n\\t\\tder = np.divide(1,obj.val)\\n\\t\\t# print(obj.der)\\n\\t\\t# print(der)\\n\\t\\t# print(obj.der.shape)\\n\\t\\t# print(der.shape)\\n\\t\\tif len(obj.der.shape)>len(der.shape):\\n\\t\\t\\tder = np.expand_dims(der,1)\\n\\t\\tder = np.multiply(der, obj.der)\\n\\t\\treturn Variable(val, der)\\n\\telse:\\n\\t\\treturn np.log(obj)\",\n \"def get_level(self, channel=None):\\n return int(self.getSensorData(\\\"VALVE_STATE\\\", channel))\",\n \"def level_sets(self):\\n in_degrees = self.in_degree(labels=True)\\n level = [x for x in in_degrees if in_degrees[x]==0]\\n Levels = []\\n while len(level) != 0:\\n Levels.append(level)\\n new_level = []\\n for x in level:\\n for y in self.neighbors_out(x):\\n in_degrees[y] -= 1\\n if in_degrees[y] == 0:\\n new_level.append(y)\\n level = new_level\\n return Levels\",\n \"def label_lvl(a, thlds, labels):\\n if len(labels) != len(thlds) + 1:\\n raise ValueError(\\\"Must be one more label than number of thresholds\\\")\\n lvl_indexes = index_lvl(a, thlds)\\n return np.take(labels, lvl_indexes)\",\n \"def dim():\\n dim = Real(\\\"yolo\\\", \\\"norm\\\", 0.9, shape=(3, 2))\\n return dim\",\n \"def make_level(self):\\n level = Level(self.data['levelname'])\\n self._set_common_attributes(level)\\n self.level = level\\n return level\",\n \"def cie_luv(self):\\n K = Fraction(29, 3) ** 3\\n e = Fraction(6, 29) ** 3\\n XYZ = self.cie_xyz\\n yr = XYZ[1] / D65[1]\\n L = 116 * yr ** Fraction(1, 3) - 16 if yr > e else K * yr\\n u = 13 * L * (U(*XYZ) - U(*D65))\\n v = 13 * L * (V(*XYZ) - V(*D65))\\n return (L, u, v)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61772287","0.60954696","0.6019012","0.5921437","0.57173896","0.56935555","0.55191696","0.55090266","0.5501754","0.5488749","0.5447241","0.5427211","0.54218185","0.54218185","0.54218185","0.5372012","0.5331837","0.52983266","0.52873015","0.5285758","0.5281006","0.52809644","0.52152973","0.5198821","0.5191172","0.51868975","0.51668894","0.51548123","0.5153946","0.5131576","0.5129716","0.509268","0.5083267","0.50755364","0.50740445","0.50740445","0.50707537","0.5064297","0.5055292","0.5053533","0.50291914","0.502661","0.50245726","0.50090826","0.50082374","0.49892473","0.49760762","0.49716195","0.49643067","0.49629313","0.49623582","0.49618682","0.49573818","0.49553248","0.4944119","0.4936506","0.49189475","0.49111572","0.48978248","0.4891586","0.48842755","0.48734686","0.48698622","0.48633894","0.4857815","0.4856698","0.4852397","0.48493516","0.48473904","0.4845518","0.48451412","0.4843268","0.4837827","0.48233417","0.48199528","0.4819371","0.48192686","0.48169833","0.48143712","0.48137262","0.48132187","0.48037472","0.4803063","0.47954038","0.4788732","0.47882935","0.47842035","0.4779937","0.4778462","0.47737777","0.47697207","0.47663823","0.4764352","0.4764218","0.47615683","0.47595227","0.47498775","0.47469947","0.4745941","0.47457203"],"string":"[\n \"0.61772287\",\n \"0.60954696\",\n \"0.6019012\",\n \"0.5921437\",\n \"0.57173896\",\n \"0.56935555\",\n \"0.55191696\",\n \"0.55090266\",\n \"0.5501754\",\n \"0.5488749\",\n \"0.5447241\",\n \"0.5427211\",\n \"0.54218185\",\n \"0.54218185\",\n \"0.54218185\",\n \"0.5372012\",\n \"0.5331837\",\n \"0.52983266\",\n \"0.52873015\",\n \"0.5285758\",\n \"0.5281006\",\n \"0.52809644\",\n \"0.52152973\",\n \"0.5198821\",\n \"0.5191172\",\n \"0.51868975\",\n \"0.51668894\",\n \"0.51548123\",\n \"0.5153946\",\n \"0.5131576\",\n \"0.5129716\",\n \"0.509268\",\n \"0.5083267\",\n \"0.50755364\",\n \"0.50740445\",\n \"0.50740445\",\n \"0.50707537\",\n \"0.5064297\",\n \"0.5055292\",\n \"0.5053533\",\n \"0.50291914\",\n \"0.502661\",\n \"0.50245726\",\n \"0.50090826\",\n \"0.50082374\",\n \"0.49892473\",\n \"0.49760762\",\n \"0.49716195\",\n \"0.49643067\",\n \"0.49629313\",\n \"0.49623582\",\n \"0.49618682\",\n \"0.49573818\",\n \"0.49553248\",\n \"0.4944119\",\n \"0.4936506\",\n \"0.49189475\",\n \"0.49111572\",\n \"0.48978248\",\n \"0.4891586\",\n \"0.48842755\",\n \"0.48734686\",\n \"0.48698622\",\n \"0.48633894\",\n \"0.4857815\",\n \"0.4856698\",\n \"0.4852397\",\n \"0.48493516\",\n \"0.48473904\",\n \"0.4845518\",\n \"0.48451412\",\n \"0.4843268\",\n \"0.4837827\",\n \"0.48233417\",\n \"0.48199528\",\n \"0.4819371\",\n \"0.48192686\",\n \"0.48169833\",\n \"0.48143712\",\n \"0.48137262\",\n \"0.48132187\",\n \"0.48037472\",\n \"0.4803063\",\n \"0.47954038\",\n \"0.4788732\",\n \"0.47882935\",\n \"0.47842035\",\n \"0.4779937\",\n \"0.4778462\",\n \"0.47737777\",\n \"0.47697207\",\n \"0.47663823\",\n \"0.4764352\",\n \"0.4764218\",\n \"0.47615683\",\n \"0.47595227\",\n \"0.47498775\",\n \"0.47469947\",\n \"0.4745941\",\n \"0.47457203\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7218306"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19877,"cells":{"query":{"kind":"string","value":"From a variable or axis of pressures, this function converts to millibars, and returns the result as a numpy array."},"document":{"kind":"string","value":"def pressures_in_mb( pressures ):\n if not hasattr( pressures, 'units' ): return None\n if pressures.units=='mb':\n pressures.units = 'mbar' # udunits uses mb for something else\n return pressures[:]\n tmp = udunits(1.0,pressures.units)\n s,i = tmp.how('mbar')\n pressmb = s*pressures[:] + i\n return pressmb"},"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 scale_mag_1(x):\n return np.array([np.true_divide(ui, mag(x)) for ui in x])","def cm2inch(x: Union[float, Sequence[float], NDArray]) -> Sequence[float]:\n return list(np.array(x) / 2.54)","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def _convert_bar_width(x, width=1, ncols=1):\n # WARNING: This will fail for non-numeric non-datetime64 singleton\n # datatypes but this is good enough for vast majority of cases.\n x_test = np.atleast_1d(_to_ndarray(x))\n if len(x_test) >= 2:\n x_step = x_test[1:] - x_test[:-1]\n x_step = np.concatenate((x_step, x_step[-1:]))\n elif x_test.dtype == np.datetime64:\n x_step = np.timedelta64(1, 'D')\n else:\n x_step = np.array(0.5)\n if np.issubdtype(x_test.dtype, np.datetime64):\n # Avoid integer timedelta truncation\n x_step = x_step.astype('timedelta64[ns]')\n return width * x_step / ncols","def signal_xs(mass, width_frac):\n width = mass*width_frac/100.\n return ROOT.getHiggsXS(mass, width)","async def infer_shape_scalar_to_array(track, x):\n return ()","def fluxes_to_labels(fluxes: np.ndarray) -> np.ndarray:\n return ((1 - fluxes) // 2).astype(np.int8)","def convert_wave_to_units(self, wave):\n return [self.convert_point_to_units(i) for i in wave]","def load_nifty_volume_as_array(filename):\n img = sitk.ReadImage(filename)\n img_arr = sitk.GetArrayFromImage(img)\n return img_arr","def rescale_toa(arr, dtype=np.float32):\n # First look at raw value dists along bands\n\n arr_trans = np.subtract(arr, arr.min(axis=(1, 2))[:, np.newaxis, np.newaxis])\n arr_rs = np.divide(arr_trans, arr_trans.max(axis=(1, 2))[:, np.newaxis, np.newaxis])\n if dtype == np.uint8:\n arr_rs = np.array(arr_rs*255, dtype=np.uint8)\n return arr_rs","def get_time_series_1d(data, bin_width):\n return np.array([x for x in zip(*(data[i:] for i in range(bin_width)))])","def _make_array(x):\n try:\n x = np.asfarray(x).squeeze()\n except ValueError:\n pass\n return x","def to_volume(self, verbose=True):\n images = self.load_all_dicom_images(verbose=verbose)\n\n volume = np.stack(\n [\n x.pixel_array * x.RescaleSlope + x.RescaleIntercept\n for x in images\n ],\n axis=-1,\n ).astype(np.int16)\n return volume","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def scalebox(self, b):\n return [int(b[0]*self.video_w/self.detection_image_size[0]),\n int(b[1]*self.video_h/self.detection_image_size[1]),\n int(b[2]*self.video_w/self.detection_image_size[0]),\n int(b[3]*self.video_h/self.detection_image_size[1])]","def array_converter(roodataobject,obs_name):\n try:\n from numpy import array\n except ImportError:\n from array import array as array\n\n # Create the histogram with respect the observable\n histo = roodataobject.createHistogram(obs_name)\n # Normalize\n histo.Scale(1.0/histo.Integral())\n _provlist = []\n for i in xrange(1,histo.GetNbinsX()+1):\n _provlist.append(histo.GetBinContent(i))\n\n # the output array\n try:\n harray = array([ x for x in _provlist ],dtype='d')\n except TypeError:\n harray = array('d',[ x for x in _provlist ])\n return harray","def convert(value, unit, axis):\n converted_value = value\n if isinstance(unit, str) or isinstance(unit, Unit):\n unit = (unit,)\n if isinstance(value, (unyt_array, unyt_quantity)):\n converted_value = value.to(*unit)\n else:\n value_type = type(value)\n converted_value = []\n for obj in value:\n converted_value.append(obj.to(*unit))\n converted_value = value_type(converted_value)\n return converted_value","def auto_convert(boxes: Type[Union[Tensor, np.ndarray]], w: int, h: int):\n\n if boxes.max() < 2:\n # to pixel coordinates\n boxes[:, 0::2] *= w\n boxes[:, 1::2] *= h\n else:\n # to normalized 0-1\n boxes[:, 0::2] /= w\n boxes[:, 1::2] /= h\n return boxes","def convert(report):\n M = []\n for row in report['data']['rows']:\n dimensions = row['dimensions']\n metrics = row['metrics'][0]['values']\n M.append(dimensions + metrics)\n return M","def to_unitless(value, new_unit=None):\n integer_one = 1\n if new_unit is None:\n new_unit = pq.dimensionless\n\n if isinstance(value, (list, tuple)):\n return np.array([to_unitless(elem, new_unit) for elem in value])\n elif isinstance(value, np.ndarray) and not hasattr(value, \"rescale\"):\n if is_unitless(new_unit) and new_unit == 1 and value.dtype != object:\n return value\n return np.array([to_unitless(elem, new_unit) for elem in value])\n elif isinstance(value, dict):\n new_value = dict(value.items()) # value.copy()\n for k in value:\n new_value[k] = to_unitless(value[k], new_unit)\n return new_value\n elif (\n isinstance(value, (int, float)) and new_unit is integer_one or new_unit is None\n ):\n return value\n elif isinstance(value, str):\n raise ValueError(\"str not supported\")\n else:\n try:\n try:\n mag = magnitude(value)\n unt = unit_of(value)\n conv = rescale(unt/new_unit, pq.dimensionless)\n result = np.array(mag)*conv\n except AttributeError:\n if new_unit == pq.dimensionless:\n return value\n else:\n raise\n else:\n if result.ndim == 0:\n return float(result)\n else:\n return np.asarray(result)\n except TypeError:\n return np.array([to_unitless(elem, new_unit) for elem in value])","def tiles_to_volume(self, tiles: list) -> np.ndarray:\n if not self.ascending:\n tiles = tiles[::-1]\n volume = np.stack(tiles, axis=-1).transpose((1, 0, 2))\n return np.flip(volume, axis=1)","def get_metric(ms):\n\treturn '['+','.join(str(m) for m in ms)+']'","def reformat(dataset):\n x = dataset[:, 1] \n x = np.stack(x) # reshape to (n, mel bands, timesteps)\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \n y = dataset[:, 2] \n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\n return x, y","def aspect2bytes(aspect):\n return (0xFF * (aspect/pi + 1)/2).astype(numpy.uint8)","def _process_quantiles(x, dim):\r\n x = np.asarray(x, dtype=float)\r\n\r\n if x.ndim == 0:\r\n x = x[np.newaxis]\r\n elif x.ndim == 1:\r\n if dim == 1:\r\n x = x[:, np.newaxis]\r\n else:\r\n x = x[np.newaxis, :]\r\n\r\n return x","def get_signal_gwgds1072au(a_signal_packed: bytes, a_scale : float ) -> list:\n the_return = None\n the_signal_packed=a_signal_packed\n the_scale=a_scale\n the_signal_sequence=[]\n the_signal=0.0 #TODO reminder check this before allowing it\n the_info=[]\n n=4\n bla=0\n blb=bla+n\n print(the_signal_packed)\n JX=unpack('>%sh' % 2 ,the_signal_packed[bla:blb])\n for ii in range(0,2003):\n the_info.append(unpack('>%sh' % 2 ,the_signal_packed[bla:blb])[0])\n bla=bla+n\n blb=blb+n\n #TODO get the potential scale\n #TODO get the offset\n #TODO get the time scale\n\n return the_info","def waveVector_deBroglie(momentum=1, units=SI):\n\n var = sy.var('p hbar')\n par = momentum, units['hbar']\n\n y = p / hbar\n return dic_result(var,par,y)","def le_binario_mgbq(filebin,nt,nc):\n return np.fromfile(filebin,'<f4').reshape(nt,nc)","def scale01(arr):\r\n walk_arr_01 = numpy.interp(arr, (numpy.amin(arr), numpy.amax(arr)), (-1, +1)) # linear scaling\r\n return walk_arr_01 #return the scaled array\r","def preprocess_xarray(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n args = tuple(a.metpy.unit_array if isinstance(a, xr.DataArray) else a for a in args)\n kwargs = {name: (v.metpy.unit_array if isinstance(v, xr.DataArray) else v)\n for name, v in kwargs.items()}\n return func(*args, **kwargs)\n return wrapper","def _scale_to_mbs_frame(self : \"animation\",\n img : \"np.ndarray\"\n ) -> \"np.ndarray\":\n xnew = img.shape[0] + self._mbs - img.shape[0]%self._mbs\n ynew = img.shape[1] + self._mbs - img.shape[1]%self._mbs\n return (255*resize(img, (xnew, ynew))).astype(np.uint8)","def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\n\n channels = [None, None, None, None]\n for pinName in pinsToMeasure:\n channels[pinMap[pinName]] = ( { \"pinName\": pinName, \"isAudio\": isAudio(pinName), \"min\": [], \"max\": [] } )\n\n i = 0\n for blk in range(0, nMilliBlocks):\n for channel in channels:\n if channel != None:\n channel[\"max\"].append(ord(samples[i]))\n i += 1\n channel[\"min\"].append(ord(samples[i]))\n i += 1\n\n return channels","def window_data(data: np.ndarray):\n\n w_len = 128\n stride = w_len // 2\n\n no_offset_windows = np.split(data, 10)\n offset_windows = np.split(data[stride:-stride], 9)\n windows = [0] * 19\n windows[::2] = no_offset_windows\n windows[1::2] = offset_windows\n windows = np.array(windows, dtype=np.float32)\n\n return windows","def unit_array(self):\n return self._data_array.values * units(self._units)","def speedx(self, sound_array, factor): # http://zulko.github.io/blog/2014/03/29/soundstretching-and-pitch-shifting-in-python/\n indices = np.round(np.arange(0, len(sound_array), factor))\n indices = indices[indices < len(sound_array)].astype(int)\n return sound_array[indices.astype(int)]","def normalize(volume):\n max = np.amax(volume)\n if max == 0:#Fixes dividing by 0 error if nothing in the volume\n return volume.astype(np.uint8)\n\n normalized = volume * (255.0 / max)\n normalized = np.round(normalized).astype(np.uint8)\n return normalized","def get(self, reshape=True):\n data = np.median(self.buffer, axis=0).astype(np.uint8)\n if reshape:\n data = np.reshape(data, self.shape)\n return data","def test_cast_array(self):\n dim = Integer(\"yolo\", \"uniform\", -3, 5)\n assert np.all(dim.cast(np.array([\"1\", \"2\"])) == np.array([1, 2]))","def GetScaleBlocks(width):\n\n rord=numpy.log10(abs(width)/2.0)\n nrord=rord % 1\n\n if nrord < numpy.log10(2):\n spc=0.2*pow(10,numpy.floor(rord))\n smallspc=spc\n bigspc=5*spc\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4,smallspc*5]\n elif nrord < numpy.log10(5):\n spc=0.5*pow(10,numpy.floor(rord))\n smallspc=spc\n bigspc=5*spc\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4]\n else:\n spc=pow(10,numpy.floor(rord))\n smallspc=spc\n bigspc=spc*5\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4,smallspc*5]\n\n if len(newspc) == 5:\n #labels=['0',None,\"%g\" % smallspc*2,None,\"%g\" % (smallspc*4)]\n labels=['0',None,None,None,\"%g\" % (smallspc*4)]\n else:\n labels=['0',None,None,None,None,\"%g\" % (smallspc*5)]\n\n temp_max=newspc[len(newspc)-1]\n start=temp_max\n for temp in numpy.arange(start,width-bigspc/2,bigspc):\n temp_max=temp_max+bigspc\n newspc.append(temp_max)\n labels.append(\"%g\" % temp_max)\n\n #start=temp_max\n #for temp in Numeric.arange(start,width-smallspc/2,smallspc):\n # labels.append(None)\n # temp_max=temp_max+smallspc \n # newspc.append(temp_max) \n\n return (numpy.array(newspc,numpy.float32),labels)","def vec_to_windows(x, wlen):\n n = len(x)\n # number of windows\n m = n // wlen\n # total samples to be kept\n s = m * wlen\n return jnp.reshape(x[:s], (m, wlen)).T","def axis(cnt):\n\t(x,y), (MA, ma), angle = cv2.fitEllipse(cnt)\n\treturn {\"major\":MA, \"minor\":ma}","def _process(self, data: np.ndarray) -> np.ndarray:\n return data[..., 1] * self.scale","def autoscales(N, dt, dj, wf, w0):\n \n if wf == 'morlet':\n s0 = (dt * (w0 + np.sqrt(2 + w0**2))) / (PI2)\n else:\n raise ValueError('wavelet function not available')\n\n J = np.floor(dj**-1 * np.log2((N * dt) / s0))\n s = np.empty(int(J + 1))\n\n for i in range(s.shape[0]):\n s[i] = s0 * 2**(i * dj)\n\n return s","def m_to_mm(): \n # Set blender unit in mm\n bpy.context.scene.unit_settings.scale_length = 0.001\n bpy.context.scene.unit_settings.length_unit = 'MILLIMETERS'","def normalize(volume):\n\n MIN_BOUND = 0\n MAX_BOUND = 256.0\n volume = (volume - MIN_BOUND) /(MAX_BOUND - MIN_BOUND)\n volume[volume > 1] = 1 #Clip everything larger than 1 and 0\n volume[volume < 0] = 0\n volume = (volume*255).astype('uint8')\n\n return volume","def normalize(volume):\n\n MIN_BOUND = 0\n MAX_BOUND = 256.0\n volume = (volume - MIN_BOUND) /(MAX_BOUND - MIN_BOUND)\n volume[volume > 1] = 1 #Clip everything larger than 1 and 0\n volume[volume < 0] = 0\n volume = (volume*255).astype('uint8')\n\n return volume","def _load_volume_from_jpg(files: List[str]) -> np.ndarray:\n volume = []\n for file in files:\n img = cv.imread(file, cv.IMREAD_GRAYSCALE)\n volume.append(img)\n # plt.imshow(img, cmap='gray')\n # plt.show()\n volume = np.stack(volume)\n volume = volume / volume.max() * 1024\n return volume","def convert_volts(self,data,places):\n volts = (data * self.max) / float(255)\n volts = round(volts,places)\n return volts","def _digit_to_10array(x):\n\te = np.zeros((10, 1))\n\te[x] = 1.0\n\treturn e","def __init__(self, mag=0, num_px=128, width=5, brush=None, pen=None,\n offset=None):\n frame_size = self.ref_width/mag\n val = frame_size/5\n ord = math.log10(val)\n val = 10**math.floor(ord) * \\\n round(10**(round((ord - math.floor(ord)) * 10) / 10))\n size = val*num_px/frame_size\n if mag < 1:\n mag = 1\n suffix = 'px'\n else:\n suffix = 'm'\n WorkingScaleBar.__init__(self, size, val=val, width=width, pen=pen,\n brush=brush, suffix=suffix, offset=offset)","def denormalize_data_unit_interval(data):\n if data.dtype == 'uint8':\n return\n return (data * 255.0).astype('uint8')","def test_cast_array(self):\n dim = Real(\"yolo\", \"uniform\", -3, 4)\n assert np.all(dim.cast(np.array([\"1\", \"2\"])) == np.array([1.0, 2.0]))","def xscale(value):\n impl.xscale(**locals())","def normalize(self,arr):\n arr = arr/(arr.max()/255.0)\n return arr","def m2px(x, resolution):\n return m2in(x) * resolution","def monthly_avg_2darray(x):\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()","def convertToGrid(numberString):\r\n numList = [int(ch) for ch in numberString]\r\n numArr = np.reshape(np.array(numList),(9, 9))\r\n return numArr","def joy_to_xbox(joy):\n class Xbox_msg():\n pass\n x = Xbox_msg()\n x.A, x.B, x.X, x.Y, x.LB, x.RB, \\\n x.back, x.start, x.power,\\\n x.stick_button_left, x.stick_button_right, \\\n x.DL, x.DR, x.DU, x.DD = joy.buttons\n x.LH, x.LV, x.LT, x.RH, x.RV, x.RT, x.DH, x.DV = joy.axes\n return x","def get_data_rescaled(self, wave):\n m = (self.max_threshold - self.min_threshold)/(np.max(wave) - np.min(wave))\n b = self.min_threshold - m * np.min(wave)\n wave = m * wave + b\n return np.array([lfilter(self.b, self.a, wave[i]) for i in range(self.n_channels)])","def get_scale(scale='major', key=60):\n SCALE_DICT = get_keys()\n notes = [key] + [(key + i) for i in np.cumsum(SCALE_DICT[scale])]\n return notes","def parseApi(data):\n influxOut = []\n\n for output in data:\n for values in output['data']:\n for k, v in values.items():\n ksec = int(k) / 1000\n valTime = datetime.datetime.fromtimestamp(int(ksec))\n val = v\n cid = output['cid']\n sid = output['sid']\n\n influxOut.append(\n {\"measurement\": \"kWm\",\n \"tags\": {\n \"cid\": cid,\n \"sid\": sid,\n },\n \"time\": valTime.isoformat(),\n \"fields\": {\n \"power\": val,\n },\n }\n )\n\n return(influxOut)","def convert_image_to_1d_array(x):\r\n\r\n #x = cv2.imread(img, cv2.IMREAD_GRAYSCALE)\r\n if x is None:\r\n print( \"ERROR: loading image ' + img + ' failed.\")\r\n return None\r\n \r\n x = cv2.threshold(x, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\r\n if x is None:\r\n print (\"ERROR: thresholding image ' + img + ' failed.\")\r\n return None\r\n\r\n return x.flatten()","def normalize_01(x):\n return x / 255.0","def convertInchTOPixel(self,*args):\n return list(map(lambda x : int(x * 96),args))","def processing_data(raw_data):\n data = np.frombuffer(raw_data, np.uint8)\n data = np.reshape(data, [data.shape[0]//1029, -1])\n data = data[:, 5:]\n data = np.reshape(data, [1, -1])\n data = 256 * data[0, 0::2] + data[0, 1::2]\n data = 10 * (data / 65535)\n data = np.reshape(data, [-1, 8]).T\n return data","def _process(self, data: np.ndarray) -> np.ndarray:\n return data[..., 0] * self.scale","def speedx(sound_array, factor):\n indices = np.round(np.arange(0, len(sound_array), factor))\n indices = indices[indices < len(sound_array)].astype(int)\n return sound_array[indices.astype(int)]","def normalize_array(var):\n if np.issubdtype(var.dtype, 'S1'):\n if var.dtype == str:\n # Python 2 on netCDF4 'string' variables needs this.\n # Python 3 returns false for np.issubdtype(var.dtype, 'S1')\n return var[:]\n\n def decoder(x):\n return str(x.decode('utf-8'))\n vfunc = np.vectorize(decoder)\n return vfunc(nc4.chartostring(var[:]))\n else:\n return var[:]","def to_numpy(x):\r\n return x.squeeze().detach().cpu().numpy()","def meter_to_cart(self, meters):\n # 1 AU = 149.6e9 m\n pixels = meters*self.scale/149.6e9\n return pixels","def get_ticks(self, axis: int = 0) -> np.ndarray:\n if isinstance(axis, str):\n axis = {\"r\": 0, \"phi\": 1}[axis]\n\n axis_bounds = self.reader.GetOutput().GetBounds()[2 * axis : 2 * (axis + 1)]\n npoints = self.shape[axis]\n if axis == 1: # phi\n ticks = np.linspace(*axis_bounds, npoints)\n elif axis == 0: # r\n # emulate AMRVAC\n base = np.linspace(*axis_bounds, npoints + 1)\n ticks = np.empty(npoints)\n for i in range(npoints):\n ticks[i] = 0.5 * (base[i] + base[i + 1])\n return ticks","def test_cast_array_multidim(self):\n categories = list(range(10))\n categories[0] = \"asdfa\"\n categories[2] = \"lalala\"\n dim = Categorical(\"yolo\", categories, shape=2)\n sample = np.array([\"asdfa\", \"1\"], dtype=object)\n assert np.all(dim.cast(sample) == np.array([\"asdfa\", 1], dtype=object))","def mi_bin_time(x, y, bins_x, bins_y):\n n_times, n_trials = x.shape\n mi = np.zeros((n_times), dtype=np.float32)\n for t in range(n_times):\n mi[t] = mi_bin(x[t, :], y, bins_x, bins_y)\n return mi","def mm_to_m(millimeters):\n return millimeters / 1000.0","def generate_scales(self, height, width):\n min_hw = min(height, width)\n m_scale = 12.0 / self.min_size\n min_hw = int(min_hw * m_scale)\n scales = []\n factor_count = 0\n while min_hw >= 50:\n scales.append(m_scale * pow(self.face_factor, factor_count))\n min_hw = int(min_hw * self.face_factor)\n factor_count += 1\n return scales","def axes(*x: Iterable[int]):\n return [_ti_core.Axis(i) for i in x]","def inches_to_mm(inches):\n\tmm=inches*25.4\n\treturn mm","def Make_pixel_metric(data, folder, cadence, argsMV={'cmap':'cool', 'cbar':False}, nside=64, recov=7, nb_day=30, fps=20, SUB=320, BAND=['gri', 'griz', 'g', 'r', 'i', 'z'], FMT=['.:k', '.-k', '.:r', '.:g', '.:b', '.:y'], figsize=(16, 10)):\n\n argsMV['nest'] = True\n \n mjd_i = int(data['mjd'][0])\n mjd_f = int(data['mjd'][-1])\n\n t = np.arange(mjd_i, mjd_f)\n floor = np.floor(data['mjd']+5./24.)\n\n hpx0 = np.zeros(hp.nside2npix(nside)).astype(float) + recov\n tot_pxl = np.size(hpx0)\n f = FocPS()\n p = f.pixellize()\n\n HPX = []\n HPXs = []\n ADDpix = []\n t = t[:nb_day]\n\n MET = np.zeros((np.size(BAND), np.size(t)))\n\n for band in BAND:\n HPX.append(np.copy(hpx0))\n HPXs.append(np.copy(hpx0 * 0))\n ADDpix.append([])\n\n for k, ti in enumerate(t):\n I = np.where(floor == ti)\n d = data[I]\n\n plt.figure(figsize=figsize).suptitle('{} - [{}]'.format(cadence, ti))\n\n for i, band in enumerate(BAND):\n\n hpxN = make_hpmoll(d, HPX[i], recov, band, f, p, SUB + 1 + i, nside, argsMV)\n HPX[i] = np.copy(hpxN)\n\n MET[i, k] = np.size(np.where(HPX[i] != hp.UNSEEN)[0])\n\n fini = HPXs[i][hpxN == hp.UNSEEN]\n ADDpix[i] += list(fini[fini != 0])\n \n HPXs[i][hpxN == hp.UNSEEN] = 0\n HPXs[i][hpxN != hp.UNSEEN] += 1\n\n plt.savefig('Save_Metric/' + folder + cadence + '/fig/fig' + str(k) + '.png')\n plt.close()\n\n\n #Make the film with the figs\n path_folder = 'Save_Metric/' + folder + cadence + '/'\n create_film(nb_day, fps, path_folder+'fig/', prefixe='fig', extension='png')\n\n #Make duration activ pixel metric hsito\n plt.figure(figsize=figsize).suptitle('Count of duration of activ pixel')\n for i, band in enumerate(BAND):\n plt.subplot(SUB + 1 + i)\n plt.hist(ADDpix[i], 200, color='r')\n plt.yscale('log')\n plt.title(band)\n\n plt.savefig('Save_Metric/' + folder + cadence + '/Metric_duration_activ_pixel.png')\n\n #Make the %sky activ pixel metric\n plt.figure(figsize=figsize)\n\n for fmt, band, met in zip(FMT, BAND, MET):\n\n plt.plot(t, met/tot_pxl*100, fmt, label=band)\n\n plt.xlabel('Day')\n plt.ylabel('% of activ pixel in sky')\n plt.title('Metric of Activ pixel of ' + cadence)\n plt.legend()\n\n plt.savefig(path_folder + 'pc_activ_sky.png')\n\n #Save data for cadence set metric\n moy_pcs = np.zeros(np.size(BAND))\n moy_act = np.zeros(np.size(BAND))\n\n for i, met in enumerate(MET):\n moy_pcs[i] = np.mean(met)/tot_pxl*100\n moy_act[i] = np.mean(ADDpix[i])\n\n with open(path_folder + 'save_data.dat', 'rb') as f:\n DATA = pUk(f).load()\n\n DATA['moy_pcs'] = moy_pcs\n DATA['moy_act'] = moy_act\n\n with open(path_folder + 'save_data.dat', 'wb') as f:\n pPk(f).dump(DATA)","def mulaw_quantize(x, quantization_channels=256):\n mu = quantization_channels - 1\n if isinstance(x, np.ndarray):\n x_mu = np.sign(x) * np.log1p(mu * np.abs(x)) / np.log1p(mu)\n x_mu = ((x_mu + 1) / 2 * mu + 0.5).astype(int)\n elif isinstance(x, (torch.Tensor, torch.LongTensor)):\n\n if isinstance(x, torch.LongTensor):\n x = x.float()\n mu = torch.FloatTensor([mu])\n x_mu = torch.sign(x) * torch.log1p(mu * torch.abs(x)) / torch.log1p(mu)\n x_mu = ((x_mu + 1) / 2 * mu + 0.5).long()\n return x_mu","def getScaleValues(a, x):\n raise NotImplementedError('getScaleValues not implemented')","def convertToMatrix(path):\n\n\t\tmultitrack = Multitrack(path, beat_resolution=Converter.beat_resolution, name=os.path.basename(path))\n\n\t\t#Merge into 4 tracks\n\t\tmergedTracks = Converter._merge(multitrack)\n\t\t\n\t\t#merged.save(os.path.join(converter_path, midi_name + '.npz'))\n\t\tmergedTracks.binarize()\n\t\tret = mergedTracks.get_stacked_pianoroll()\n\t\treturn ret","def _prep_window(hwi, its):\n if its != 1:\n d1 = math.log10(hwi)\n d2 = 0\n\n tmp = np.array(range(its-1)) * (d2 - d1) / (its - 1) + d1\n tmp = np.append(tmp, d2)\n windows = np.ceil(10**tmp).astype(int)\n else:\n windows = np.array((hwi))\n return windows","def test_flux_conversion_vega(in_q, out_u, ans):\n result = units.convert_flux(_wave, in_q, out_u, vegaspec=_vspec)\n assert_quantity_allclose(result, ans, rtol=1e-2)\n\n # Scalar\n i = 0\n result = units.convert_flux(_wave[i], in_q[i], out_u, vegaspec=_vspec)\n assert_quantity_allclose(result, ans[i], rtol=1e-2)","def to_image_space(data):\n return np.swapaxes(np.flip(data, 1), 0, 1)","def xscale(self, kind):\n self._xscale = str(kind).strip() # remove whitespace eventually\n if self._xscale not in self.xscaling():\n self._xscale = self.xscaling(1)","def get_size_for_mag(slide, mag):\n max_size = slide.dimensions\n max_mag = highest_mag(slide)\n downsample = max_mag/mag\n return [np.int(np.round(dim/downsample)) for dim in max_size]","def obtenerMedias(X, Y, vName):\n \n medias = []\n for name in vName:\n pos = np.where(Y == name)\n medias.append(np.mean(X[pos], axis=0))\n\n return np.array(medias)","def _reshape(self, arr: np.ndarray) -> np.ndarray:\n return arr.reshape(self.TileHeight.value, self.TileWidth.value, self.bands,)","def unit_to_dva(self, in_file, out_file):\n in_img = nib.load(in_file)\n arr = in_img.get_fdata()\n dva_arr = (arr * self.stimwidth_pix) / self.ppd\n out_img = nib.Nifti1Image(dva_arr, affine=in_img.affine)\n out_img.to_filename(out_file)\n return dva_arr","def imshow2array(imx,imy):\n # NOTE: would be more efficient to not reconstruct 'tr' transform object every time...\n # NOTE: different order comp to 'extent' keyword in imshow\n bbox_in = Bbox.from_extents([x1, y1, x2, y2])\n # NOTE: lower left corner always -0.5,-0.5 by deafult with imshow\n bbox_out = Bbox.from_bounds(-0.5, -0.5, zi.shape[1], zi.shape[0])\n # transform from data coordinate into image coordinate.\n tr = BboxTransform(bbox_in, bbox_out)\n arrXY = tr.transform_point((imx, imy)).astype(int)\n\n return arrXY","def to_cms_rhythm(channel):\n ret = []\n for i, x in enumerate(self.pitches[channel]):\n if x > 0:\n ret.append(x)\n else:\n ret.append(-1)\n return ret","def getDimensions(unique_name=None):","def vol_rameaux(x): \r\n return sum([vol_rameau_cat(x, cat) for cat in ['small', 'medium', 'large']])","def generate_volume(self, x_ax):\n\n x_ax = np.asarray(x_ax, dtype=np.float).flatten()\n\n vol = _generate_boxcar_volume(x_ax, self.radius, self.center)\n\n return vol","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def convertDataForPlot(self, data):\n # Assumes data[:,0] is in eV\n x = data[:,0].copy()\n xType = [str(i.text()) for i in self.menuSpecX.actions() if i.isChecked()][0]\n x = converter[\"eV\"][xType](x)\n\n return [x, data[:,1]/self.uisbDivideBy.value()]","def img_gen_bar():\n data = pd.DataFrame(data=np.random.rand(5,1), index=range(1,6), columns=['Fred'])\n #m,n = np.shape(data)\n\n plt.clf()\n plt.bar(x=data.index.values, height=data.values.ravel(), color='k') # figsize=(10, 6))\n # Options for later from https://matplotlib.org/api/_as_gen/matplotlib.pyplot.bar.html\n # bar_width = 0.35\n # alpha = .3\n fig=plt.gcf()\n fig.set_size_inches(2.24, 2.24)\n plt.axis('off')\n fig.tight_layout()\n fig.canvas.draw()\n # grab the pixel buffer and dump it into a numpy array\n pixels = np.array(fig.canvas.renderer._renderer)[:,:,:3]\n #print(pixels.shape)\n return pixels, data.index.values + data.values.ravel()","def getDimensions():","def load_png16(fname):\n with Image.open(fname) as img:\n if hasattr(img, 'text') and 'min' in img.text and 'max' in img.text:\n vmin = float(img.text['min'])\n vmax = float(img.text['max'])\n arr = np.array(img).astype(np.float64) * \\\n ((vmax-vmin)/(2**16-1)) + vmin\n else:\n arr = np.array(img)\n return arr","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"],"string":"[\n \"def scale_mag_1(x):\\n return np.array([np.true_divide(ui, mag(x)) for ui in x])\",\n \"def cm2inch(x: Union[float, Sequence[float], NDArray]) -> Sequence[float]:\\n return list(np.array(x) / 2.54)\",\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_bar_width(x, width=1, ncols=1):\\n # WARNING: This will fail for non-numeric non-datetime64 singleton\\n # datatypes but this is good enough for vast majority of cases.\\n x_test = np.atleast_1d(_to_ndarray(x))\\n if len(x_test) >= 2:\\n x_step = x_test[1:] - x_test[:-1]\\n x_step = np.concatenate((x_step, x_step[-1:]))\\n elif x_test.dtype == np.datetime64:\\n x_step = np.timedelta64(1, 'D')\\n else:\\n x_step = np.array(0.5)\\n if np.issubdtype(x_test.dtype, np.datetime64):\\n # Avoid integer timedelta truncation\\n x_step = x_step.astype('timedelta64[ns]')\\n return width * x_step / ncols\",\n \"def signal_xs(mass, width_frac):\\n width = mass*width_frac/100.\\n return ROOT.getHiggsXS(mass, width)\",\n \"async def infer_shape_scalar_to_array(track, x):\\n return ()\",\n \"def fluxes_to_labels(fluxes: np.ndarray) -> np.ndarray:\\n return ((1 - fluxes) // 2).astype(np.int8)\",\n \"def convert_wave_to_units(self, wave):\\n return [self.convert_point_to_units(i) for i in wave]\",\n \"def load_nifty_volume_as_array(filename):\\n img = sitk.ReadImage(filename)\\n img_arr = sitk.GetArrayFromImage(img)\\n return img_arr\",\n \"def rescale_toa(arr, dtype=np.float32):\\n # First look at raw value dists along bands\\n\\n arr_trans = np.subtract(arr, arr.min(axis=(1, 2))[:, np.newaxis, np.newaxis])\\n arr_rs = np.divide(arr_trans, arr_trans.max(axis=(1, 2))[:, np.newaxis, np.newaxis])\\n if dtype == np.uint8:\\n arr_rs = np.array(arr_rs*255, dtype=np.uint8)\\n return arr_rs\",\n \"def get_time_series_1d(data, bin_width):\\n return np.array([x for x in zip(*(data[i:] for i in range(bin_width)))])\",\n \"def _make_array(x):\\n try:\\n x = np.asfarray(x).squeeze()\\n except ValueError:\\n pass\\n return x\",\n \"def to_volume(self, verbose=True):\\n images = self.load_all_dicom_images(verbose=verbose)\\n\\n volume = np.stack(\\n [\\n x.pixel_array * x.RescaleSlope + x.RescaleIntercept\\n for x in images\\n ],\\n axis=-1,\\n ).astype(np.int16)\\n return volume\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def scalebox(self, b):\\n return [int(b[0]*self.video_w/self.detection_image_size[0]),\\n int(b[1]*self.video_h/self.detection_image_size[1]),\\n int(b[2]*self.video_w/self.detection_image_size[0]),\\n int(b[3]*self.video_h/self.detection_image_size[1])]\",\n \"def array_converter(roodataobject,obs_name):\\n try:\\n from numpy import array\\n except ImportError:\\n from array import array as array\\n\\n # Create the histogram with respect the observable\\n histo = roodataobject.createHistogram(obs_name)\\n # Normalize\\n histo.Scale(1.0/histo.Integral())\\n _provlist = []\\n for i in xrange(1,histo.GetNbinsX()+1):\\n _provlist.append(histo.GetBinContent(i))\\n\\n # the output array\\n try:\\n harray = array([ x for x in _provlist ],dtype='d')\\n except TypeError:\\n harray = array('d',[ x for x in _provlist ])\\n return harray\",\n \"def convert(value, unit, axis):\\n converted_value = value\\n if isinstance(unit, str) or isinstance(unit, Unit):\\n unit = (unit,)\\n if isinstance(value, (unyt_array, unyt_quantity)):\\n converted_value = value.to(*unit)\\n else:\\n value_type = type(value)\\n converted_value = []\\n for obj in value:\\n converted_value.append(obj.to(*unit))\\n converted_value = value_type(converted_value)\\n return converted_value\",\n \"def auto_convert(boxes: Type[Union[Tensor, np.ndarray]], w: int, h: int):\\n\\n if boxes.max() < 2:\\n # to pixel coordinates\\n boxes[:, 0::2] *= w\\n boxes[:, 1::2] *= h\\n else:\\n # to normalized 0-1\\n boxes[:, 0::2] /= w\\n boxes[:, 1::2] /= h\\n return boxes\",\n \"def convert(report):\\n M = []\\n for row in report['data']['rows']:\\n dimensions = row['dimensions']\\n metrics = row['metrics'][0]['values']\\n M.append(dimensions + metrics)\\n return M\",\n \"def to_unitless(value, new_unit=None):\\n integer_one = 1\\n if new_unit is None:\\n new_unit = pq.dimensionless\\n\\n if isinstance(value, (list, tuple)):\\n return np.array([to_unitless(elem, new_unit) for elem in value])\\n elif isinstance(value, np.ndarray) and not hasattr(value, \\\"rescale\\\"):\\n if is_unitless(new_unit) and new_unit == 1 and value.dtype != object:\\n return value\\n return np.array([to_unitless(elem, new_unit) for elem in value])\\n elif isinstance(value, dict):\\n new_value = dict(value.items()) # value.copy()\\n for k in value:\\n new_value[k] = to_unitless(value[k], new_unit)\\n return new_value\\n elif (\\n isinstance(value, (int, float)) and new_unit is integer_one or new_unit is None\\n ):\\n return value\\n elif isinstance(value, str):\\n raise ValueError(\\\"str not supported\\\")\\n else:\\n try:\\n try:\\n mag = magnitude(value)\\n unt = unit_of(value)\\n conv = rescale(unt/new_unit, pq.dimensionless)\\n result = np.array(mag)*conv\\n except AttributeError:\\n if new_unit == pq.dimensionless:\\n return value\\n else:\\n raise\\n else:\\n if result.ndim == 0:\\n return float(result)\\n else:\\n return np.asarray(result)\\n except TypeError:\\n return np.array([to_unitless(elem, new_unit) for elem in value])\",\n \"def tiles_to_volume(self, tiles: list) -> np.ndarray:\\n if not self.ascending:\\n tiles = tiles[::-1]\\n volume = np.stack(tiles, axis=-1).transpose((1, 0, 2))\\n return np.flip(volume, axis=1)\",\n \"def get_metric(ms):\\n\\treturn '['+','.join(str(m) for m in ms)+']'\",\n \"def reformat(dataset):\\n x = dataset[:, 1] \\n x = np.stack(x) # reshape to (n, mel bands, timesteps)\\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \\n y = dataset[:, 2] \\n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\\n return x, y\",\n \"def aspect2bytes(aspect):\\n return (0xFF * (aspect/pi + 1)/2).astype(numpy.uint8)\",\n \"def _process_quantiles(x, dim):\\r\\n x = np.asarray(x, dtype=float)\\r\\n\\r\\n if x.ndim == 0:\\r\\n x = x[np.newaxis]\\r\\n elif x.ndim == 1:\\r\\n if dim == 1:\\r\\n x = x[:, np.newaxis]\\r\\n else:\\r\\n x = x[np.newaxis, :]\\r\\n\\r\\n return x\",\n \"def get_signal_gwgds1072au(a_signal_packed: bytes, a_scale : float ) -> list:\\n the_return = None\\n the_signal_packed=a_signal_packed\\n the_scale=a_scale\\n the_signal_sequence=[]\\n the_signal=0.0 #TODO reminder check this before allowing it\\n the_info=[]\\n n=4\\n bla=0\\n blb=bla+n\\n print(the_signal_packed)\\n JX=unpack('>%sh' % 2 ,the_signal_packed[bla:blb])\\n for ii in range(0,2003):\\n the_info.append(unpack('>%sh' % 2 ,the_signal_packed[bla:blb])[0])\\n bla=bla+n\\n blb=blb+n\\n #TODO get the potential scale\\n #TODO get the offset\\n #TODO get the time scale\\n\\n return the_info\",\n \"def waveVector_deBroglie(momentum=1, units=SI):\\n\\n var = sy.var('p hbar')\\n par = momentum, units['hbar']\\n\\n y = p / hbar\\n return dic_result(var,par,y)\",\n \"def le_binario_mgbq(filebin,nt,nc):\\n return np.fromfile(filebin,'<f4').reshape(nt,nc)\",\n \"def scale01(arr):\\r\\n walk_arr_01 = numpy.interp(arr, (numpy.amin(arr), numpy.amax(arr)), (-1, +1)) # linear scaling\\r\\n return walk_arr_01 #return the scaled array\\r\",\n \"def preprocess_xarray(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n args = tuple(a.metpy.unit_array if isinstance(a, xr.DataArray) else a for a in args)\\n kwargs = {name: (v.metpy.unit_array if isinstance(v, xr.DataArray) else v)\\n for name, v in kwargs.items()}\\n return func(*args, **kwargs)\\n return wrapper\",\n \"def _scale_to_mbs_frame(self : \\\"animation\\\",\\n img : \\\"np.ndarray\\\"\\n ) -> \\\"np.ndarray\\\":\\n xnew = img.shape[0] + self._mbs - img.shape[0]%self._mbs\\n ynew = img.shape[1] + self._mbs - img.shape[1]%self._mbs\\n return (255*resize(img, (xnew, ynew))).astype(np.uint8)\",\n \"def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\\n\\n channels = [None, None, None, None]\\n for pinName in pinsToMeasure:\\n channels[pinMap[pinName]] = ( { \\\"pinName\\\": pinName, \\\"isAudio\\\": isAudio(pinName), \\\"min\\\": [], \\\"max\\\": [] } )\\n\\n i = 0\\n for blk in range(0, nMilliBlocks):\\n for channel in channels:\\n if channel != None:\\n channel[\\\"max\\\"].append(ord(samples[i]))\\n i += 1\\n channel[\\\"min\\\"].append(ord(samples[i]))\\n i += 1\\n\\n return channels\",\n \"def window_data(data: np.ndarray):\\n\\n w_len = 128\\n stride = w_len // 2\\n\\n no_offset_windows = np.split(data, 10)\\n offset_windows = np.split(data[stride:-stride], 9)\\n windows = [0] * 19\\n windows[::2] = no_offset_windows\\n windows[1::2] = offset_windows\\n windows = np.array(windows, dtype=np.float32)\\n\\n return windows\",\n \"def unit_array(self):\\n return self._data_array.values * units(self._units)\",\n \"def speedx(self, sound_array, factor): # http://zulko.github.io/blog/2014/03/29/soundstretching-and-pitch-shifting-in-python/\\n indices = np.round(np.arange(0, len(sound_array), factor))\\n indices = indices[indices < len(sound_array)].astype(int)\\n return sound_array[indices.astype(int)]\",\n \"def normalize(volume):\\n max = np.amax(volume)\\n if max == 0:#Fixes dividing by 0 error if nothing in the volume\\n return volume.astype(np.uint8)\\n\\n normalized = volume * (255.0 / max)\\n normalized = np.round(normalized).astype(np.uint8)\\n return normalized\",\n \"def get(self, reshape=True):\\n data = np.median(self.buffer, axis=0).astype(np.uint8)\\n if reshape:\\n data = np.reshape(data, self.shape)\\n return data\",\n \"def test_cast_array(self):\\n dim = Integer(\\\"yolo\\\", \\\"uniform\\\", -3, 5)\\n assert np.all(dim.cast(np.array([\\\"1\\\", \\\"2\\\"])) == np.array([1, 2]))\",\n \"def GetScaleBlocks(width):\\n\\n rord=numpy.log10(abs(width)/2.0)\\n nrord=rord % 1\\n\\n if nrord < numpy.log10(2):\\n spc=0.2*pow(10,numpy.floor(rord))\\n smallspc=spc\\n bigspc=5*spc\\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4,smallspc*5]\\n elif nrord < numpy.log10(5):\\n spc=0.5*pow(10,numpy.floor(rord))\\n smallspc=spc\\n bigspc=5*spc\\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4]\\n else:\\n spc=pow(10,numpy.floor(rord))\\n smallspc=spc\\n bigspc=spc*5\\n newspc=[0,smallspc,smallspc*2,smallspc*3,smallspc*4,smallspc*5]\\n\\n if len(newspc) == 5:\\n #labels=['0',None,\\\"%g\\\" % smallspc*2,None,\\\"%g\\\" % (smallspc*4)]\\n labels=['0',None,None,None,\\\"%g\\\" % (smallspc*4)]\\n else:\\n labels=['0',None,None,None,None,\\\"%g\\\" % (smallspc*5)]\\n\\n temp_max=newspc[len(newspc)-1]\\n start=temp_max\\n for temp in numpy.arange(start,width-bigspc/2,bigspc):\\n temp_max=temp_max+bigspc\\n newspc.append(temp_max)\\n labels.append(\\\"%g\\\" % temp_max)\\n\\n #start=temp_max\\n #for temp in Numeric.arange(start,width-smallspc/2,smallspc):\\n # labels.append(None)\\n # temp_max=temp_max+smallspc \\n # newspc.append(temp_max) \\n\\n return (numpy.array(newspc,numpy.float32),labels)\",\n \"def vec_to_windows(x, wlen):\\n n = len(x)\\n # number of windows\\n m = n // wlen\\n # total samples to be kept\\n s = m * wlen\\n return jnp.reshape(x[:s], (m, wlen)).T\",\n \"def axis(cnt):\\n\\t(x,y), (MA, ma), angle = cv2.fitEllipse(cnt)\\n\\treturn {\\\"major\\\":MA, \\\"minor\\\":ma}\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n return data[..., 1] * self.scale\",\n \"def autoscales(N, dt, dj, wf, w0):\\n \\n if wf == 'morlet':\\n s0 = (dt * (w0 + np.sqrt(2 + w0**2))) / (PI2)\\n else:\\n raise ValueError('wavelet function not available')\\n\\n J = np.floor(dj**-1 * np.log2((N * dt) / s0))\\n s = np.empty(int(J + 1))\\n\\n for i in range(s.shape[0]):\\n s[i] = s0 * 2**(i * dj)\\n\\n return s\",\n \"def m_to_mm(): \\n # Set blender unit in mm\\n bpy.context.scene.unit_settings.scale_length = 0.001\\n bpy.context.scene.unit_settings.length_unit = 'MILLIMETERS'\",\n \"def normalize(volume):\\n\\n MIN_BOUND = 0\\n MAX_BOUND = 256.0\\n volume = (volume - MIN_BOUND) /(MAX_BOUND - MIN_BOUND)\\n volume[volume > 1] = 1 #Clip everything larger than 1 and 0\\n volume[volume < 0] = 0\\n volume = (volume*255).astype('uint8')\\n\\n return volume\",\n \"def normalize(volume):\\n\\n MIN_BOUND = 0\\n MAX_BOUND = 256.0\\n volume = (volume - MIN_BOUND) /(MAX_BOUND - MIN_BOUND)\\n volume[volume > 1] = 1 #Clip everything larger than 1 and 0\\n volume[volume < 0] = 0\\n volume = (volume*255).astype('uint8')\\n\\n return volume\",\n \"def _load_volume_from_jpg(files: List[str]) -> np.ndarray:\\n volume = []\\n for file in files:\\n img = cv.imread(file, cv.IMREAD_GRAYSCALE)\\n volume.append(img)\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n volume = np.stack(volume)\\n volume = volume / volume.max() * 1024\\n return volume\",\n \"def convert_volts(self,data,places):\\n volts = (data * self.max) / float(255)\\n volts = round(volts,places)\\n return volts\",\n \"def _digit_to_10array(x):\\n\\te = np.zeros((10, 1))\\n\\te[x] = 1.0\\n\\treturn e\",\n \"def __init__(self, mag=0, num_px=128, width=5, brush=None, pen=None,\\n offset=None):\\n frame_size = self.ref_width/mag\\n val = frame_size/5\\n ord = math.log10(val)\\n val = 10**math.floor(ord) * \\\\\\n round(10**(round((ord - math.floor(ord)) * 10) / 10))\\n size = val*num_px/frame_size\\n if mag < 1:\\n mag = 1\\n suffix = 'px'\\n else:\\n suffix = 'm'\\n WorkingScaleBar.__init__(self, size, val=val, width=width, pen=pen,\\n brush=brush, suffix=suffix, offset=offset)\",\n \"def denormalize_data_unit_interval(data):\\n if data.dtype == 'uint8':\\n return\\n return (data * 255.0).astype('uint8')\",\n \"def test_cast_array(self):\\n dim = Real(\\\"yolo\\\", \\\"uniform\\\", -3, 4)\\n assert np.all(dim.cast(np.array([\\\"1\\\", \\\"2\\\"])) == np.array([1.0, 2.0]))\",\n \"def xscale(value):\\n impl.xscale(**locals())\",\n \"def normalize(self,arr):\\n arr = arr/(arr.max()/255.0)\\n return arr\",\n \"def m2px(x, resolution):\\n return m2in(x) * resolution\",\n \"def monthly_avg_2darray(x):\\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()\",\n \"def convertToGrid(numberString):\\r\\n numList = [int(ch) for ch in numberString]\\r\\n numArr = np.reshape(np.array(numList),(9, 9))\\r\\n return numArr\",\n \"def joy_to_xbox(joy):\\n class Xbox_msg():\\n pass\\n x = Xbox_msg()\\n x.A, x.B, x.X, x.Y, x.LB, x.RB, \\\\\\n x.back, x.start, x.power,\\\\\\n x.stick_button_left, x.stick_button_right, \\\\\\n x.DL, x.DR, x.DU, x.DD = joy.buttons\\n x.LH, x.LV, x.LT, x.RH, x.RV, x.RT, x.DH, x.DV = joy.axes\\n return x\",\n \"def get_data_rescaled(self, wave):\\n m = (self.max_threshold - self.min_threshold)/(np.max(wave) - np.min(wave))\\n b = self.min_threshold - m * np.min(wave)\\n wave = m * wave + b\\n return np.array([lfilter(self.b, self.a, wave[i]) for i in range(self.n_channels)])\",\n \"def get_scale(scale='major', key=60):\\n SCALE_DICT = get_keys()\\n notes = [key] + [(key + i) for i in np.cumsum(SCALE_DICT[scale])]\\n return notes\",\n \"def parseApi(data):\\n influxOut = []\\n\\n for output in data:\\n for values in output['data']:\\n for k, v in values.items():\\n ksec = int(k) / 1000\\n valTime = datetime.datetime.fromtimestamp(int(ksec))\\n val = v\\n cid = output['cid']\\n sid = output['sid']\\n\\n influxOut.append(\\n {\\\"measurement\\\": \\\"kWm\\\",\\n \\\"tags\\\": {\\n \\\"cid\\\": cid,\\n \\\"sid\\\": sid,\\n },\\n \\\"time\\\": valTime.isoformat(),\\n \\\"fields\\\": {\\n \\\"power\\\": val,\\n },\\n }\\n )\\n\\n return(influxOut)\",\n \"def convert_image_to_1d_array(x):\\r\\n\\r\\n #x = cv2.imread(img, cv2.IMREAD_GRAYSCALE)\\r\\n if x is None:\\r\\n print( \\\"ERROR: loading image ' + img + ' failed.\\\")\\r\\n return None\\r\\n \\r\\n x = cv2.threshold(x, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\\r\\n if x is None:\\r\\n print (\\\"ERROR: thresholding image ' + img + ' failed.\\\")\\r\\n return None\\r\\n\\r\\n return x.flatten()\",\n \"def normalize_01(x):\\n return x / 255.0\",\n \"def convertInchTOPixel(self,*args):\\n return list(map(lambda x : int(x * 96),args))\",\n \"def processing_data(raw_data):\\n data = np.frombuffer(raw_data, np.uint8)\\n data = np.reshape(data, [data.shape[0]//1029, -1])\\n data = data[:, 5:]\\n data = np.reshape(data, [1, -1])\\n data = 256 * data[0, 0::2] + data[0, 1::2]\\n data = 10 * (data / 65535)\\n data = np.reshape(data, [-1, 8]).T\\n return data\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n return data[..., 0] * self.scale\",\n \"def speedx(sound_array, factor):\\n indices = np.round(np.arange(0, len(sound_array), factor))\\n indices = indices[indices < len(sound_array)].astype(int)\\n return sound_array[indices.astype(int)]\",\n \"def normalize_array(var):\\n if np.issubdtype(var.dtype, 'S1'):\\n if var.dtype == str:\\n # Python 2 on netCDF4 'string' variables needs this.\\n # Python 3 returns false for np.issubdtype(var.dtype, 'S1')\\n return var[:]\\n\\n def decoder(x):\\n return str(x.decode('utf-8'))\\n vfunc = np.vectorize(decoder)\\n return vfunc(nc4.chartostring(var[:]))\\n else:\\n return var[:]\",\n \"def to_numpy(x):\\r\\n return x.squeeze().detach().cpu().numpy()\",\n \"def meter_to_cart(self, meters):\\n # 1 AU = 149.6e9 m\\n pixels = meters*self.scale/149.6e9\\n return pixels\",\n \"def get_ticks(self, axis: int = 0) -> np.ndarray:\\n if isinstance(axis, str):\\n axis = {\\\"r\\\": 0, \\\"phi\\\": 1}[axis]\\n\\n axis_bounds = self.reader.GetOutput().GetBounds()[2 * axis : 2 * (axis + 1)]\\n npoints = self.shape[axis]\\n if axis == 1: # phi\\n ticks = np.linspace(*axis_bounds, npoints)\\n elif axis == 0: # r\\n # emulate AMRVAC\\n base = np.linspace(*axis_bounds, npoints + 1)\\n ticks = np.empty(npoints)\\n for i in range(npoints):\\n ticks[i] = 0.5 * (base[i] + base[i + 1])\\n return ticks\",\n \"def test_cast_array_multidim(self):\\n categories = list(range(10))\\n categories[0] = \\\"asdfa\\\"\\n categories[2] = \\\"lalala\\\"\\n dim = Categorical(\\\"yolo\\\", categories, shape=2)\\n sample = np.array([\\\"asdfa\\\", \\\"1\\\"], dtype=object)\\n assert np.all(dim.cast(sample) == np.array([\\\"asdfa\\\", 1], dtype=object))\",\n \"def mi_bin_time(x, y, bins_x, bins_y):\\n n_times, n_trials = x.shape\\n mi = np.zeros((n_times), dtype=np.float32)\\n for t in range(n_times):\\n mi[t] = mi_bin(x[t, :], y, bins_x, bins_y)\\n return mi\",\n \"def mm_to_m(millimeters):\\n return millimeters / 1000.0\",\n \"def generate_scales(self, height, width):\\n min_hw = min(height, width)\\n m_scale = 12.0 / self.min_size\\n min_hw = int(min_hw * m_scale)\\n scales = []\\n factor_count = 0\\n while min_hw >= 50:\\n scales.append(m_scale * pow(self.face_factor, factor_count))\\n min_hw = int(min_hw * self.face_factor)\\n factor_count += 1\\n return scales\",\n \"def axes(*x: Iterable[int]):\\n return [_ti_core.Axis(i) for i in x]\",\n \"def inches_to_mm(inches):\\n\\tmm=inches*25.4\\n\\treturn mm\",\n \"def Make_pixel_metric(data, folder, cadence, argsMV={'cmap':'cool', 'cbar':False}, nside=64, recov=7, nb_day=30, fps=20, SUB=320, BAND=['gri', 'griz', 'g', 'r', 'i', 'z'], FMT=['.:k', '.-k', '.:r', '.:g', '.:b', '.:y'], figsize=(16, 10)):\\n\\n argsMV['nest'] = True\\n \\n mjd_i = int(data['mjd'][0])\\n mjd_f = int(data['mjd'][-1])\\n\\n t = np.arange(mjd_i, mjd_f)\\n floor = np.floor(data['mjd']+5./24.)\\n\\n hpx0 = np.zeros(hp.nside2npix(nside)).astype(float) + recov\\n tot_pxl = np.size(hpx0)\\n f = FocPS()\\n p = f.pixellize()\\n\\n HPX = []\\n HPXs = []\\n ADDpix = []\\n t = t[:nb_day]\\n\\n MET = np.zeros((np.size(BAND), np.size(t)))\\n\\n for band in BAND:\\n HPX.append(np.copy(hpx0))\\n HPXs.append(np.copy(hpx0 * 0))\\n ADDpix.append([])\\n\\n for k, ti in enumerate(t):\\n I = np.where(floor == ti)\\n d = data[I]\\n\\n plt.figure(figsize=figsize).suptitle('{} - [{}]'.format(cadence, ti))\\n\\n for i, band in enumerate(BAND):\\n\\n hpxN = make_hpmoll(d, HPX[i], recov, band, f, p, SUB + 1 + i, nside, argsMV)\\n HPX[i] = np.copy(hpxN)\\n\\n MET[i, k] = np.size(np.where(HPX[i] != hp.UNSEEN)[0])\\n\\n fini = HPXs[i][hpxN == hp.UNSEEN]\\n ADDpix[i] += list(fini[fini != 0])\\n \\n HPXs[i][hpxN == hp.UNSEEN] = 0\\n HPXs[i][hpxN != hp.UNSEEN] += 1\\n\\n plt.savefig('Save_Metric/' + folder + cadence + '/fig/fig' + str(k) + '.png')\\n plt.close()\\n\\n\\n #Make the film with the figs\\n path_folder = 'Save_Metric/' + folder + cadence + '/'\\n create_film(nb_day, fps, path_folder+'fig/', prefixe='fig', extension='png')\\n\\n #Make duration activ pixel metric hsito\\n plt.figure(figsize=figsize).suptitle('Count of duration of activ pixel')\\n for i, band in enumerate(BAND):\\n plt.subplot(SUB + 1 + i)\\n plt.hist(ADDpix[i], 200, color='r')\\n plt.yscale('log')\\n plt.title(band)\\n\\n plt.savefig('Save_Metric/' + folder + cadence + '/Metric_duration_activ_pixel.png')\\n\\n #Make the %sky activ pixel metric\\n plt.figure(figsize=figsize)\\n\\n for fmt, band, met in zip(FMT, BAND, MET):\\n\\n plt.plot(t, met/tot_pxl*100, fmt, label=band)\\n\\n plt.xlabel('Day')\\n plt.ylabel('% of activ pixel in sky')\\n plt.title('Metric of Activ pixel of ' + cadence)\\n plt.legend()\\n\\n plt.savefig(path_folder + 'pc_activ_sky.png')\\n\\n #Save data for cadence set metric\\n moy_pcs = np.zeros(np.size(BAND))\\n moy_act = np.zeros(np.size(BAND))\\n\\n for i, met in enumerate(MET):\\n moy_pcs[i] = np.mean(met)/tot_pxl*100\\n moy_act[i] = np.mean(ADDpix[i])\\n\\n with open(path_folder + 'save_data.dat', 'rb') as f:\\n DATA = pUk(f).load()\\n\\n DATA['moy_pcs'] = moy_pcs\\n DATA['moy_act'] = moy_act\\n\\n with open(path_folder + 'save_data.dat', 'wb') as f:\\n pPk(f).dump(DATA)\",\n \"def mulaw_quantize(x, quantization_channels=256):\\n mu = quantization_channels - 1\\n if isinstance(x, np.ndarray):\\n x_mu = np.sign(x) * np.log1p(mu * np.abs(x)) / np.log1p(mu)\\n x_mu = ((x_mu + 1) / 2 * mu + 0.5).astype(int)\\n elif isinstance(x, (torch.Tensor, torch.LongTensor)):\\n\\n if isinstance(x, torch.LongTensor):\\n x = x.float()\\n mu = torch.FloatTensor([mu])\\n x_mu = torch.sign(x) * torch.log1p(mu * torch.abs(x)) / torch.log1p(mu)\\n x_mu = ((x_mu + 1) / 2 * mu + 0.5).long()\\n return x_mu\",\n \"def getScaleValues(a, x):\\n raise NotImplementedError('getScaleValues not implemented')\",\n \"def convertToMatrix(path):\\n\\n\\t\\tmultitrack = Multitrack(path, beat_resolution=Converter.beat_resolution, name=os.path.basename(path))\\n\\n\\t\\t#Merge into 4 tracks\\n\\t\\tmergedTracks = Converter._merge(multitrack)\\n\\t\\t\\n\\t\\t#merged.save(os.path.join(converter_path, midi_name + '.npz'))\\n\\t\\tmergedTracks.binarize()\\n\\t\\tret = mergedTracks.get_stacked_pianoroll()\\n\\t\\treturn ret\",\n \"def _prep_window(hwi, its):\\n if its != 1:\\n d1 = math.log10(hwi)\\n d2 = 0\\n\\n tmp = np.array(range(its-1)) * (d2 - d1) / (its - 1) + d1\\n tmp = np.append(tmp, d2)\\n windows = np.ceil(10**tmp).astype(int)\\n else:\\n windows = np.array((hwi))\\n return windows\",\n \"def test_flux_conversion_vega(in_q, out_u, ans):\\n result = units.convert_flux(_wave, in_q, out_u, vegaspec=_vspec)\\n assert_quantity_allclose(result, ans, rtol=1e-2)\\n\\n # Scalar\\n i = 0\\n result = units.convert_flux(_wave[i], in_q[i], out_u, vegaspec=_vspec)\\n assert_quantity_allclose(result, ans[i], rtol=1e-2)\",\n \"def to_image_space(data):\\n return np.swapaxes(np.flip(data, 1), 0, 1)\",\n \"def xscale(self, kind):\\n self._xscale = str(kind).strip() # remove whitespace eventually\\n if self._xscale not in self.xscaling():\\n self._xscale = self.xscaling(1)\",\n \"def get_size_for_mag(slide, mag):\\n max_size = slide.dimensions\\n max_mag = highest_mag(slide)\\n downsample = max_mag/mag\\n return [np.int(np.round(dim/downsample)) for dim in max_size]\",\n \"def obtenerMedias(X, Y, vName):\\n \\n medias = []\\n for name in vName:\\n pos = np.where(Y == name)\\n medias.append(np.mean(X[pos], axis=0))\\n\\n return np.array(medias)\",\n \"def _reshape(self, arr: np.ndarray) -> np.ndarray:\\n return arr.reshape(self.TileHeight.value, self.TileWidth.value, self.bands,)\",\n \"def unit_to_dva(self, in_file, out_file):\\n in_img = nib.load(in_file)\\n arr = in_img.get_fdata()\\n dva_arr = (arr * self.stimwidth_pix) / self.ppd\\n out_img = nib.Nifti1Image(dva_arr, affine=in_img.affine)\\n out_img.to_filename(out_file)\\n return dva_arr\",\n \"def imshow2array(imx,imy):\\n # NOTE: would be more efficient to not reconstruct 'tr' transform object every time...\\n # NOTE: different order comp to 'extent' keyword in imshow\\n bbox_in = Bbox.from_extents([x1, y1, x2, y2])\\n # NOTE: lower left corner always -0.5,-0.5 by deafult with imshow\\n bbox_out = Bbox.from_bounds(-0.5, -0.5, zi.shape[1], zi.shape[0])\\n # transform from data coordinate into image coordinate.\\n tr = BboxTransform(bbox_in, bbox_out)\\n arrXY = tr.transform_point((imx, imy)).astype(int)\\n\\n return arrXY\",\n \"def to_cms_rhythm(channel):\\n ret = []\\n for i, x in enumerate(self.pitches[channel]):\\n if x > 0:\\n ret.append(x)\\n else:\\n ret.append(-1)\\n return ret\",\n \"def getDimensions(unique_name=None):\",\n \"def vol_rameaux(x): \\r\\n return sum([vol_rameau_cat(x, cat) for cat in ['small', 'medium', 'large']])\",\n \"def generate_volume(self, x_ax):\\n\\n x_ax = np.asarray(x_ax, dtype=np.float).flatten()\\n\\n vol = _generate_boxcar_volume(x_ax, self.radius, self.center)\\n\\n return vol\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def convertDataForPlot(self, data):\\n # Assumes data[:,0] is in eV\\n x = data[:,0].copy()\\n xType = [str(i.text()) for i in self.menuSpecX.actions() if i.isChecked()][0]\\n x = converter[\\\"eV\\\"][xType](x)\\n\\n return [x, data[:,1]/self.uisbDivideBy.value()]\",\n \"def img_gen_bar():\\n data = pd.DataFrame(data=np.random.rand(5,1), index=range(1,6), columns=['Fred'])\\n #m,n = np.shape(data)\\n\\n plt.clf()\\n plt.bar(x=data.index.values, height=data.values.ravel(), color='k') # figsize=(10, 6))\\n # Options for later from https://matplotlib.org/api/_as_gen/matplotlib.pyplot.bar.html\\n # bar_width = 0.35\\n # alpha = .3\\n fig=plt.gcf()\\n fig.set_size_inches(2.24, 2.24)\\n plt.axis('off')\\n fig.tight_layout()\\n fig.canvas.draw()\\n # grab the pixel buffer and dump it into a numpy array\\n pixels = np.array(fig.canvas.renderer._renderer)[:,:,:3]\\n #print(pixels.shape)\\n return pixels, data.index.values + data.values.ravel()\",\n \"def getDimensions():\",\n \"def load_png16(fname):\\n with Image.open(fname) as img:\\n if hasattr(img, 'text') and 'min' in img.text and 'max' in img.text:\\n vmin = float(img.text['min'])\\n vmax = float(img.text['max'])\\n arr = np.array(img).astype(np.float64) * \\\\\\n ((vmax-vmin)/(2**16-1)) + vmin\\n else:\\n arr = np.array(img)\\n return arr\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.50821847","0.50635743","0.5063201","0.5052912","0.50040376","0.49670303","0.48602846","0.47888026","0.47871676","0.47724292","0.47648123","0.47488585","0.46842295","0.46627557","0.46367168","0.46319687","0.4622999","0.46144953","0.46112272","0.45830104","0.45763472","0.4559005","0.45513022","0.45487088","0.4547772","0.45354503","0.45192635","0.45098084","0.4496422","0.44706327","0.44679117","0.44633955","0.4458391","0.44581792","0.44565484","0.44430456","0.4438174","0.44246957","0.44206974","0.44097188","0.4399986","0.43969533","0.43916002","0.43888134","0.4384524","0.4384524","0.43835306","0.4381687","0.43788865","0.43712193","0.43710715","0.43648976","0.43609062","0.435894","0.4353367","0.4337898","0.43269682","0.43253762","0.432189","0.43217695","0.42928162","0.4291329","0.4282158","0.42784297","0.42782113","0.427619","0.4275643","0.42676255","0.42670214","0.42634898","0.4261751","0.42595017","0.42593235","0.42507204","0.42504486","0.42488968","0.42461175","0.4237595","0.4235555","0.42320412","0.42298472","0.4225623","0.42244723","0.42209592","0.42177397","0.4214114","0.421077","0.42098916","0.42098108","0.42080393","0.42070705","0.42048937","0.4204002","0.42024297","0.42024142","0.42009738","0.4199955","0.41994372","0.41950044","0.4191002"],"string":"[\n \"0.50821847\",\n \"0.50635743\",\n \"0.5063201\",\n \"0.5052912\",\n \"0.50040376\",\n \"0.49670303\",\n \"0.48602846\",\n \"0.47888026\",\n \"0.47871676\",\n \"0.47724292\",\n \"0.47648123\",\n \"0.47488585\",\n \"0.46842295\",\n \"0.46627557\",\n \"0.46367168\",\n \"0.46319687\",\n \"0.4622999\",\n \"0.46144953\",\n \"0.46112272\",\n \"0.45830104\",\n \"0.45763472\",\n \"0.4559005\",\n \"0.45513022\",\n \"0.45487088\",\n \"0.4547772\",\n \"0.45354503\",\n \"0.45192635\",\n \"0.45098084\",\n \"0.4496422\",\n \"0.44706327\",\n \"0.44679117\",\n \"0.44633955\",\n \"0.4458391\",\n \"0.44581792\",\n \"0.44565484\",\n \"0.44430456\",\n \"0.4438174\",\n \"0.44246957\",\n \"0.44206974\",\n \"0.44097188\",\n \"0.4399986\",\n \"0.43969533\",\n \"0.43916002\",\n \"0.43888134\",\n \"0.4384524\",\n \"0.4384524\",\n \"0.43835306\",\n \"0.4381687\",\n \"0.43788865\",\n \"0.43712193\",\n \"0.43710715\",\n \"0.43648976\",\n \"0.43609062\",\n \"0.435894\",\n \"0.4353367\",\n \"0.4337898\",\n \"0.43269682\",\n \"0.43253762\",\n \"0.432189\",\n \"0.43217695\",\n \"0.42928162\",\n \"0.4291329\",\n \"0.4282158\",\n \"0.42784297\",\n \"0.42782113\",\n \"0.427619\",\n \"0.4275643\",\n \"0.42676255\",\n \"0.42670214\",\n \"0.42634898\",\n \"0.4261751\",\n \"0.42595017\",\n \"0.42593235\",\n \"0.42507204\",\n \"0.42504486\",\n \"0.42488968\",\n \"0.42461175\",\n \"0.4237595\",\n \"0.4235555\",\n \"0.42320412\",\n \"0.42298472\",\n \"0.4225623\",\n \"0.42244723\",\n \"0.42209592\",\n \"0.42177397\",\n \"0.4214114\",\n \"0.421077\",\n \"0.42098916\",\n \"0.42098108\",\n \"0.42080393\",\n \"0.42070705\",\n \"0.42048937\",\n \"0.4204002\",\n \"0.42024297\",\n \"0.42024142\",\n \"0.42009738\",\n \"0.4199955\",\n \"0.41994372\",\n \"0.41950044\",\n \"0.4191002\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5553397"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19878,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned along the lev (level) axis and whose values are the heights corresponding to the pressure levels found as the lev axis of mv. Levels will be converted to millibars. heights are returned in km"},"document":{"kind":"string","value":"def heightvar( mv ):\n if mv is None: return None\n lev_axis = levAxis(mv)\n heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km\n heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,\n attributes={'units':\"km\"} )\n return heightmv"},"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 levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv","def select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\n else:\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\n if ids is None or len(ids)==0:\n ig = len(levax)-1\n else:\n ig = ids[0][0]\n # Crude fist cut: don't interpolate, just return a value\n if levax == mv.getAxisList()[0]:\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\n elif levax == mv.getAxisList()[1]:\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\n else:\n print \"ERROR, select_lev() does not support level axis except as first or second dimentions\"\n return None\n return mvs","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def calculate_tumor(filename, verbose = False):\n img = nibabel.load(filename)\n data = img.get_data()\n pixdim = img.header['pixdim']\n xyzt_units = img.header['xyzt_units']\n #pixdim[1],pixdim[2],pixdim[3] stores width, depth and height\n volume_per_pix = pixdim[1]*pixdim[2]*pixdim[3]\n\n volumes = {}\n volumes['total vasogenic edema volume'] = round(sum(data[data ==2 ])*volume_per_pix/1000, 3)\n volumes['enhancing portion'] = round(sum(data[data == 4]) * volume_per_pix/1000, 3)\n volumes['non enhancing portion'] = round(sum(data[data == 1]) * volume_per_pix/1000, 3)\n volumes['total tumor volume'] = round(volumes['enhancing portion'] + volumes['non enhancing portion'], 3)\n if xyzt_units == 1:\n volumes['unit'] = 'L'\n if xyzt_units == 2:\n volumes['unit'] = 'ML'\n if xyzt_units == 3:\n volumes['unit'] = 'UL'\n\n return volumes","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def get_level_size(slide, level):\n return slide.level_dimensions[level]","def v(self):\n\n # TODO This translation formula works, but needs simplified.\n\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\n# print(\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\", MuleBot.dcMotorPWMDurationLeft)\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\n# print(\"speed_percentage: \", speed_percentage)\n\n rpm = speed_percentage * self.motorMaxRPM\n# print(\"rpm: \", rpm)\n\n secondsPerMinute = 60\n revs_per_second = rpm / secondsPerMinute\n# print(\"--revs_per_second\", revs_per_second)\n\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\n INCHES_PER_METER = 39.3701\n meters_per_rev = inches_per_rev / INCHES_PER_METER\n# print(\"--meters_per_rev\", meters_per_rev)\n\n meters_per_second = meters_per_rev * revs_per_second\n\n# print(\"--meters_per_second: \", meters_per_second)\n return meters_per_second","def width_v_phi(model: SingleRhNeutrinoModel):\n params = _neutrino_vector_meson_constants[\"phi\"]\n k, g = params[\"k\"], params[\"g\"]\n return _width_v_hv(model, MPHI, k, g)","def get_level_mag(slide, level):\n return level_mags(slide)[level]","def est_maxlevel(dims,bandwidth):\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\n lev=int(lev)\n return lev","def get_dimensional_measurements():\n return Global_Module.global_dimensional_measurements","def model_onelayer_pert(r):\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\tif (r > 6361000.0):\n\t\trho = 2.7\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 2.0 + 0.02\n\t\tvsh = vsv \n\t\teta = 1.0\n\n\telse:\n\t\trho = 3.1\n\t\tvpv = 7.8\n\t\tvph = vpv\n\t\tvsv = 3.0\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def vp_from_ke(m):\n return (m[0, 0]/m[2,0], m[1,0]/m[2,0])","def calc_thickness(self):\n s = \"::: calculating z-varying thickness :::\"\n print_text(s, cls=self)\n #H = project(self.S - self.x[2], self.Q, annotate=False)\n H = self.vert_integrate(Constant(1.0), d='down')\n Hv = H.vector()\n Hv[Hv < 0] = 0.0\n print_min_max(H, 'H', cls=self)\n return H","def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\n return float(-np.sqrt(self.periods_in_a_year) *\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))","def dimension_pv(self):\n return self._dimension_pv","def mTV(self):\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\n # approximated with the wing root chordplane\n return distance / (self.spanW / 2)","def get_properties(self):\n assert self.kekulize, '#ERROR: u need to get explicit BOs for amon generation'\n self.vs = np.array([ ai.GetTotalValence() for ai in self.m0.GetAtoms() ], np.int)\n #self.update_bom()\n self.ias_heav = self.ias[ self.zs > 1 ]\n bom_heav = self.bom[ self.ias_heav, : ][ :, self.ias_heav ]\n self.vs_heav = bom_heav.sum(axis=0)\n self.cns_heav = ( bom_heav > 0 ).sum(axis=0)\n self.nhs = self.vs[:self.nheav] - self.vs_heav - self.chgs[:self.nheav]\n self.dvs = self.vs_heav - self.cns_heav\n self.hybs = np.array([ _hyb[ai.GetHybridization()] for ai in self.m.GetAtoms() ])","def vol(x):\r\n return pi*(topdia(x)/2000.)**2 * length (x)","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def calc_lhv(self):\n hf = {}\n hf['hydrogen'] = 0\n hf['methane'] = -74.85\n hf['ethane'] = -84.68\n hf['propane'] = -103.8\n hf['butane'] = -124.51\n hf['O2'] = 0\n hf['CO2'] = -393.5\n # water (gaseous)\n hf['H2O'] = -241.8\n\n lhv = 0\n\n for f, x in self.fuel.val.items():\n molar_masses[f] = CP.PropsSI('M', f)\n fl = set(list(hf.keys())).intersection(\n set([a.replace(' ', '') for a in CP.get_aliases(f)]))\n if len(fl) == 0:\n continue\n\n if list(fl)[0] in self.fuels():\n structure = fluid_structure(f)\n\n n = {}\n for el in ['C', 'H', 'O']:\n if el in structure:\n n[el] = structure[el]\n else:\n n[el] = 0\n\n lhv += (-(n['H'] / 2 * hf['H2O'] + n['C'] * hf['CO2'] -\n ((n['C'] + n['H'] / 4) * hf['O2'] +\n hf[list(fl)[0]])) / molar_masses[f] * 1000) * x\n\n return lhv","def bv_data():\n heights = [1000., 1500., 2000., 2500.] * units('m')\n potential_temperatures = [[290., 290., 290., 290.],\n [292., 293., 293., 292.],\n [294., 296., 293., 293.],\n [296., 295., 293., 296.]] * units('K')\n return heights, potential_temperatures","def velocity(self,level='cell'):\r\n\r\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\r\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \r\n vels = []\r\n vols = self.last_sim_step_volume()\r\n \r\n if level=='cell':\r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n return vels\r\n \r\n elif level=='section': \r\n # 先计算每一个元胞的再按照volume计算加权平均\r\n \r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2)) \r\n\r\n \r\n # 将速度按照volume加权平均\r\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\r\n sum_vol = sum(vols)\r\n if sum_vol == 0:\r\n avg_vel = 0\r\n else:\r\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\r\n \r\n return avg_vel\r\n\r\n\r\n else :\r\n raise ValueError('no such level for collecting data')","def loading(self, pressure):\n kp = self.params[\"K\"] * pressure\n return self.params[\"n_m\"] * kp / (1.0 + kp)","def getComponentVolume(self):\n lengthO = self.getDimension(\"lengthOuter\")\n widthO = self.getDimension(\"widthOuter\")\n heightO = self.getDimension(\"heightOuter\")\n lengthI = self.getDimension(\"lengthInner\")\n widthI = self.getDimension(\"widthInner\")\n heightI = self.getDimension(\"heightInner\")\n mult = self.getDimension(\"mult\")\n vol = mult * (lengthO * widthO * heightO - lengthI * widthI * heightI)\n return vol","def width_v_v_v(model: SingleRhNeutrinoModel, genv: Generation):\n mx = model.mx\n u = 0.5 * np.tan(2 * model.theta)\n w = parameters.GF**2 * mx**5 / (768 * np.pi**3) * u**2\n pre = 2 if genv == model.gen else 1.0\n return pre * w","def MH(self):\n\n #return math.log10(self.glb[user_params_index[\"Zs\"]]*constants.solar_x/(self.glb[user_params_index[\"Xs\"]]*constants.solar_z))\n return math.log10(self.glb[iz0]*constants.solar_x/(self.glb[ix0]*constants.solar_z))","def height(self, x):\n\t\treturn np.interp(x, self.x, self.z)","def peak_height(self, logM, k = [], pk = []):\n # Checks\n pk=np.atleast_2d(pk)\n assert len(pk[0])==len(k), \"Length of scales is different from power spectra\"\n sigma2 = self.mass_variance(logM,k,pk)\n nu = self.delta_sc/sigma2**.5\n return nu","def vapor_pressure(ds, var):\n eps0 = 0.622 # Ratio of molecular weight of water and dry air [-]\n ds['vp'] = 0.5 * ds[var['pressure']] * (-1 + np.sqrt(1 + 4 * ds[var['mix_ratio']] / eps0))\n ds.vp.attrs = {'units': '???????', 'long_name': 'Vapor pressure', 'standard_name': 'vapor_pressure'}\n return ds","def getVelocity(self):\n return self.v","def _microstrip_v_with_Lk(wire_width, dielectric_thickness, eps_r, Lk_per_sq):\n L_m, C_m = _microstrip_LC_per_meter(wire_width,\n dielectric_thickness,\n eps_r)\n Lk_m = Lk_per_sq * (1.0/wire_width)\n v = 1 / sqrt((L_m+Lk_m) * C_m)\n return v","def linear_momentum(self):\r\n return self.mass * self.vel","def Dekel(mv,mv0,lmax0,vmax0,alpha0,z=0.):\n g_vmax,g_lmax = g_P10(mv/mv0,alpha0)\n lmax = lmax0 * g_lmax\n vmax = vmax0 * g_vmax\n s2 = 2.-alpha0\n s3 = 3.-alpha0\n A = (cfg.G * mv / lmax / vmax**2)**(0.5/s3) * (s2/s3)\n lv = lmax / s2**2 * A**2 / (1.-A)**2\n c = s2**2 * lv / lmax\n rhoc = co.rhoc(z,h=cfg.h,Om=cfg.Om,OL=cfg.OL)\n Delta = 3.*mv / (cfg.FourPi * lv**3 * rhoc)\n return c,Delta","def waveVector_deBroglie(momentum=1, units=SI):\n\n var = sy.var('p hbar')\n par = momentum, units['hbar']\n\n y = p / hbar\n return dic_result(var,par,y)","def _get_depth(self, data): \r\n\r\n data = data.astype(np.float32)\r\n\r\n normalized = np.dot(data, [65536.0, 256.0, 1.0]) \r\n normalized /= (256 * 256 * 256 - 1)\r\n in_meters = 1000 * normalized\r\n\r\n return in_meters","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 E2V(E):\n# for energy in mev returns velocity in m/s\n return sqrt(E/5.227e-6)","def get_luminosity(name):\n all_data = mc.get('sensor_values')\n name = _lookup(name)\n try:\n return all_data[name][3]\n except KeyError:\n raise KeyError(\"No sensor with that name\")","def get_luminosity(self, vel_disp):\n\t\tlog_L_V = self.slope*np.log10(vel_disp) + self.intercept\n\t\treturn log_L_V","def __rho2v(self, vm, beta, rhoc, w, rho):\n if rho < 0:\n return float(vm)\n elif rho <= rhoc:\n return float(vm - vm * rho / beta)\n else:\n rhom = rhoc - (vm * rhoc - vm * (rhoc ** 2) / beta) / w\n # print('rho {0}; rhoc {1}'.format(rho, rhoc))\n return float(w * (rho - rhom) / rho)","async def uv_level(self, uvi):\n\n if uvi is None:\n return \"no-data\"\n\n if uvi >= 10.5:\n return self._translations[\"uv\"][\"extreme\"]\n if uvi >= 7.5:\n return self._translations[\"uv\"][\"very-high\"]\n if uvi >= 5.5:\n return self._translations[\"uv\"][\"high\"]\n if uvi >= 2.5:\n return self._translations[\"uv\"][\"moderate\"]\n if uvi > 0:\n return self._translations[\"uv\"][\"low\"]\n \n return self._translations[\"uv\"][\"none\"]","def get_Y_and_M(self, PP, weight, prec, Yin=None):\n # generalized_level\n if Yin is not None:\n Y0 = Yin\n else:\n Y0 = min(self._group.minimal_height(), 0.5)\n Cmax = 1\n Kmax = 0\n Cmax = max(PP.values())\n for t in PP.keys():\n if isinstance(t, tuple):\n (c, l) = t\n elif isinstance(t, (int, Integer)):\n (c, l) = rn_from_D(self.multiplier(), t)\n else:\n raise ValueError(\"Incorrect principal part: t={0}\".format(t))\n D = self.multiplier().weil_module().D()\n if c in D:\n tmp = l + self.multiplier().Qv[D.index(c)]\n elif c in range(len(self.multiplier().Qv)):\n tmp = l + self.multiplier().Qv[c]\n else:\n raise ValueError(\"Incorrect principal part: c,l={0},{1}\".format(c, l))\n if self._verbose > 0:\n print(\"tmp={0}\".format(tmp))\n if abs(tmp) > Kmax:\n Kmax = abs(tmp)\n # x\n # then get corresponding M\n # print \"Kmax=\",Kmax\n # print \"Cmax=\",Cmax\n M0 = self.get_M(Y0, Kmax, Cmax, prec)\n return [Y0, M0]","def Dekel2(mv,mv0,lmax0,vmax0,alpha0,slope0,z=0.):\n g_vmax,g_lmax = g_P10(mv/mv0,slope0)\n lmax = lmax0 * g_lmax\n vmax = vmax0 * g_vmax\n s2 = 2.-alpha0\n s3 = 3.-alpha0\n A = (cfg.G * mv / lmax / vmax**2)**(0.5/s3) * (s2/s3)\n lv = lmax / s2**2 * A**2 / (1.-A)**2\n c = s2**2 * lv / lmax\n rhoc = co.rhoc(z,h=cfg.h,Om=cfg.Om,OL=cfg.OL)\n Delta = 3.*mv / (cfg.FourPi * lv**3 * rhoc)\n return c,Delta","def vorticity(self):\n \n ux,_ = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n _,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n # self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y'])\n self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y','t'])\n \n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append('1/dt')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = ('1/dt')\n\n\n return self._obj","def test_set_vh(self):\n s = State(substance=\"water\")\n s.vh = Q_(0.4772010021515822, \"m**3/kg\"), Q_(1061602.391543017, \"J/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vh[0], Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.vh[1], Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def width_v_rho(model: SingleRhNeutrinoModel):\n params = _neutrino_vector_meson_constants[\"rho0\"]\n k, g = params[\"k\"], params[\"g\"]\n return _width_v_hv(model, MRHO, k, g)","def UnitCellVolume(ID): \n ID=goodID(ID)\n lp=latticeParameters[ID]\n a=lp[0]/u['ang']\n b=lp[1]/u['ang']\n c=lp[2]/u['ang']\n alpha=lp[3]\n beta=lp[4]\n gamma=lp[5]\n L=latticeType[ID]\n ca=cosd(alpha)\n cb=cosd(beta)\n cg=cosd(gamma)\n V=a*b*c*np.sqrt(1-ca**2-cb**2-cg**2+2*ca*cb*cg)\n return V","def get_velocity(self):\n return self.momentum/self.mass","def var(self):\n\n return self.scale ** -2 \\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)","def get_voxel_size(path: str) -> float:\n dcm = pydicom.dcmread(path, force=True)\n x_str, y_str = dcm.PixelSpacing\n x = Decimal(str(x_str))\n y = Decimal(str(y_str))\n z = Decimal(str(dcm.SpacingBetweenSlices))\n print(float(x * y * z))\n return float(x * y * z)","def unit_of_measurement(self):\n return self.var_units","def test_el_ml():\n levels = np.array([959., 779.2, 751.3, 724.3, 700., 400., 269.]) * units.mbar\n temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -25., -35.]) * units.celsius\n dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -35., -53.2]) * units.celsius\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\n el_pressure, el_temperature = el(levels, temperatures, dewpoints, mixed_parcel_prof)\n assert_almost_equal(el_pressure, 350.0561 * units.mbar, 3)\n assert_almost_equal(el_temperature, -28.36156 * units.degC, 3)","def width_v_omega(model: SingleRhNeutrinoModel):\n params = _neutrino_vector_meson_constants[\"omega\"]\n k, g = params[\"k\"], params[\"g\"]\n return _width_v_hv(model, MOMEGA, k, g)","def get_pedigree_variance(pm, version=\"original\"):\n assert all(isinstance(obj, int) for obj in pm.values())\n return sum(PEDIGREE_MATRIX_VALUES[version][k][v - 1] for k, v in pm.items())","def pH(self):\n index = self.var_index(9)\n return self.var_data(index)","def get_channel_v_unit(self)->float:\n return self.__channel_v_unit","def n_y(self, level):\n resolution = self.resolution(level)\n return (self.y_extent // resolution + 63) // 64","def waveparameterh(L):\r\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3","def Mach(h,Vc,p):\n return np.sqrt(2/(gamma-1)*((1+p0/p*((1+(gamma-1)/(2*gamma)*rho0/p0*Vc**2)**(gamma/(gamma-1))-1))**((gamma-1)/gamma)-1))","def getMeasure(unique_name):","def getMeasure(unique_name):","def voltmeter_settings(self, scalefactor, offset):\n if scalefactor is not None and offset is not None:\n if self._request('SM', str(scalefactor), str(offset))[0]:\n return scalefactor, offset\n else:\n done, data = self._request('GM')\n if done:\n return int(data[0]), int(data[1])\n\n raise EvseError","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def estimate_variance(ds,vert_step,horiz_step):\n obs_map = zeros([ds.shape[0]/vert_step,ds.shape[1]/horiz_step])\n print 'observed map has shape ' + str(obs_map.shape)\n for row in range(obs_map.shape[0]):\n for col in range(obs_map.shape[1]):\n #print 'calculating for %d %d (%d:%d,%d:%d)' % (row,col,row*vert_step,(row+1)*vert_step,\n # col*horiz_step,(col+1)*horiz_step)\n obs_var,rep_var = calc_variances(ds[row*vert_step:(row+1)*vert_step,\n col*horiz_step:(col+1)*horiz_step])\n obs_map[row,col] = sqrt(obs_var/rep_var)\n # Annotate appropriately\n obs_map.axes[0] = Array(range(obs_map.shape[0]))*vert_step\n obs_map.axes[1] = Array(range(obs_map.shape[1]))*horiz_step\n return obs_map","def model_prem(r):\n\n\t#- normalised radius\n\tx = r / 6371000.0\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\t#- upper crust\n\tif (r >= 6356000.0):\n\t\trho = 2.6\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 3.2\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- lower crust\n\telif (r >= 6346000.6) & (r < 6356000.0):\n\t\trho = 2.9\n\t\tvpv = 6.8\n\t\tvph = vpv\n\t\tvsv = 3.9\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- LID\n\telif (r >= 6291000.0) & (r < 6346000.6):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 0.8317 + 7.2180 * x\n\t\tvph = 3.5908 + 4.6172 * x\n\t\tvsv = 5.8582 - 1.4678 * x\n\t\tvsh = -1.0839 + 5.7176 * x\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- LVZ\n\telif (r >= 6151000.0) & (r < 6291000.0):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 0.8317 + 7.2180 * x\n\t\tvph = 3.5908 + 4.6172 * x\n\t\tvsv = 5.8582 - 1.4678 * x\n\t\tvsh = -1.0839 + 5.7176 * x\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- Transition zone 1\n\telif (r >= 5971000.0) & (r < 6151000.0):\n\t\trho = 7.1089 - 3.8045 * x\n\t\tvpv = 20.3926 - 12.2569 * x\n\t\tvph = vpv\n\t\tvsv = 8.9496 - 4.4597 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 2\n\telif (r >= 5771000.0) & (r < 5971000.0):\n\t\trho = 11.2494 - 8.0298 * x\n\t\tvpv = 39.7027 - 32.6166 * x\n\t\tvph = vpv\n\t\tvsv = 22.3512 - 18.5856 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 3\n\telif (r >= 5701000.0) & (r < 5771000.0):\n\t\trho = 5.3197 - 1.4836 * x\n\t\tvpv = 19.0957 - 9.8672 * x\n\t\tvph = vpv\n\t\tvsv = 9.9839 - 4.9324 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 1\n\telif (r >= 5600000.0) & (r < 5701000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- Lower mantle 2\n\telif (r >= 3630000.0) & (r < 5600000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\n\t\tvph = vpv\n\t\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 3\n\telif (r >= 3480000.0) & (r < 3630000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Outer core\n\telif (r >= 1221000.5) & (r < 3480000.0):\n\t\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\n\t\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\n\t\tvph = vpv\n\t\tvsv = 0.0\n\t\tvsh = 0.0\n\t\teta = 1.0\n\n\t#- Inner Core\n\telif (r >= 0.0) & (r < 1221000.5):\n\t\trho = 13.0885 - 8.8381 * x**2\n\t\tvpv = 11.2622 - 6.3640 * x**2\n\t\tvph = vpv\n\t\tvsv = 3.6678 - 4.4475 * x**2\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def V2E(V):\n# for v in m/s returns energy in meV\n return 5.227e-6*V*V","def get_velocity(self):\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s","def zmwMetric(self, name):\n return self.baxH5.zmwMetric(name, self.index)","def tubeVol2vertTubeHeight(v, r):\n sphere_half_vol = (4.0/3.0 * np.pi * r**3)/2.0\n\n if v <= sphere_half_vol:\n # height does not extend to cylinder\n h = _sphereCapVol2height(v, r)\n else:\n # height = sphere_cap_height (r) + cylinder_height\n #sphere_cap_height = r #_sphereCapVol2height(sphere_half_vol, r)\n h = r + _cylVol2height(v - sphere_half_vol, r)\n\n return(h)","def LotkaVolterra_Dynamics(self):\n LV_c = self.toConceptual(self.state) # (nF, nR)\n LV_c = LV_c.mul((1 - LV_c) + self.LV_inhM.mm(LV_c))\n LV_s = self.toNeural(LV_c)\n\n return LV_c, LV_s","def dlnM_dlnobs(self, name, M0_arr=None, z=None):\n if name=='zeta':\n return 1/self.scaling['Bsz']\n elif name=='Yx':\n return 1/(1/self.scaling['Bx'] - self.scaling['dlnMg_dlnr']/3)\n elif name=='Mgas':\n return 1/(self.scaling['Bx'] - self.scaling['dlnMg_dlnr']/3)\n elif (name=='WLMegacam')|(name=='WLHST'):\n return 1.","def width_h_invis(self):\n if m_higgs > 2.0 * self.mx:\n coupling = self.gsxx * self.stheta / np.sqrt(1 - self.stheta**2)\n\n val = (\n (coupling**2 * (m_higgs**2 - 4 * self.mx**2) ** 1.5)\n / (8.0 * m_higgs**2 * np.pi)\n ).real\n\n assert val >= 0\n\n return val\n else:\n return 0.0","def get_var_explained(self, idx, v):\n return 3 * self.get_scaling(idx)**2 * v * self.pars[2]**2 / np.pi**2","def getHt(self) -> float:\n\n return self.p3ddict.p3dz()","def vel(self,M):\n v_peri = np.sqrt((HohmannTransfer.G*M)*((2/self.r1)-(2/(self.r1+self.r2))))\n \n v_aphe = np.sqrt((HohmannTransfer.G*M)*((2/self.r2)-(2/(self.r1+self.r2))))\n \n return v_peri, v_aphe","def get_V(self):\n return self.V","def get_measurement(self):\n return self._convert_to_depth(self._avg_sample())","def get_vsolar(self):\n return self.read_register(4098, 1, 3)","def displacement_wein(temperature=1, units=SI):\n\n var = sy.var('h c k t')\n par = units['h'], units['c'], units['k'], temperature\n\n y = h * c / 4.9663 / k / t\n\n return dic_result(var,par,y)","def v(self):\n return self._properties['v']","def growth_factor_scale_independent(self, z):\n z = np.atleast_1d(z)\n nz = len(z)\n #if self.M_nu_tot == 0. and self.w0 == -1. and self.wa==0.:\n # aa = 1./(1.+z)\n # ww = self.w0 + (1.-aa)*self.wa\n # d1 = aa*ss.hyp2f1(1/3., 1., 11/6., -aa**3/self.Omega_m*(1.-self.Omega_m))/ss.hyp2f1(1/3., 1., 11/6., -(1.-self.Omega_m)/self.Omega_m)\n #else:\n # d1 = np.zeros(nz)\n # for i in range(nz):\n # LCDM, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., z[i], np.inf)\n # d1[i] = LCDM*self.H_massive(z[i])/self.H0\n # LCDM0, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., 0., np.inf)\n # d1 = d1/LCDM0\n d1 = np.zeros(nz)\n for i in range(nz):\n LCDM, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., z[i], np.inf)\n d1[i] = LCDM*self.H_massive(z[i])/self.H0\n LCDM0, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., 0., np.inf)\n d1 = d1/LCDM0\n return d1","def get_v(r_div_R, z_div_L, Pi_div_DLP, k, alpha_ast, Bp, Bm, gp, gm, membrane_geometry):\n return CT.get_v(r_div_R, z_div_L, Pi_div_DLP, k, alpha_ast, Bp, Bm, gp, gm, membrane_geometry)","def lo_vcm(self):\n return self._read(0x12, 5, 0xE0)","def _get_Mll(self):\n\t\t_M_ll = mll.get_mll(self.W_l, self.lmax)\n\t\treturn np.float64(_M_ll)","def _microstrip_LC_per_meter(wire_width, dielectric_thickness, eps_r):\n # Use the fact that v = 1/sqrt(L_m*C_m) = 1/sqrt(eps*mu) and\n # Z = sqrt(L_m/C_m) [Where L_m is inductance per meter]\n Z, eps_eff = _microstrip_Z(wire_width, dielectric_thickness, eps_r)\n eps0 = 8.854e-12\n mu0 = 4*pi*1e-7\n\n eps = eps_eff*eps0\n mu = mu0\n L_m = sqrt(eps*mu) * Z\n C_m = sqrt(eps*mu) / Z\n return L_m, C_m","def define_variables(m):\r\n\r\n # Non-negative candidate capacity\r\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Solar build limits\r\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Wind build limits\r\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage build limits\r\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Min power output (all generators excluding storage units)\r\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing thermal\r\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate thermal\r\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing wind\r\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate wind\r\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing solar\r\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate solar\r\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - hydro\r\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min charging power - storage units\r\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min discharging power - storage_units\r\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - existing storage\r\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - candidate storage\r\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - existing storage\r\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - candidate storage\r\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - storage units\r\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - existing storage units\r\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - candidate storage\r\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - interval end\r\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - interval end\r\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate up (thermal and hydro generators)\r\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate down (thermal and hydro generators)\r\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Non-negative lost load power\r\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min powerflow\r\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max powerflow\r\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage energy transition\r\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\r\n\r\n # Power balance (locational marginal price)\r\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\r\n\r\n return m","def mv_to_typen(mv):\n tab1 = [\n 0.0000000E+00,\n 3.8436847E+01,\n 1.1010485E+00,\n 5.2229312E+00,\n 7.2060525E+00,\n 5.8488586E+00,\n 2.7754916E+00,\n 7.7075166E-01,\n 1.1582665E-01,\n 7.3138868E-03,\n ]\n\n tab2 = [\n 0.00000E+00,\n 3.86896E+01,\n -1.08267E+00,\n 4.70205E-02,\n -2.12169E-06,\n -1.17272E-04,\n 5.39280E-06,\n -7.98156E-08,\n 0.00000E+00,\n 0.00000E+00,\n ]\n \n tab3 = [\n 1.972485E+01,\n 3.300943E+01,\n -3.915159E-01,\n 9.855391E-03,\n -1.274371E-04,\n 7.767022E-07,\n 0.000000E+00,\n 0.000000E+00,\n 0.000000E+00,\n 0.000000E+00,\n ]\n\n if -3.99 <= mv <= 0.0:\n c = tab1\n elif 0.0 < mv <= 20.613:\n c = tab2\n elif 20.613 < mv <= 47.513:\n c = tab3\n else:\n raise ValueError(\"Voltage specified is out of range for Type N thermocouple\")\n\n t = 0.0\n for p in range(0, len(c)):\n t += c[p] * math.pow(mv, p)\n return t","def lvec(self):\n lv = ROOT.TLorentzVector()\n# if self.pt < 0 or abs(self.eta) > 6:\n# raise Exception(\"Invalid values for TLorentzVector\")\n lv.SetPtEtaPhiM(self.pt, self.eta, self.phi, self.mass)\n# if abs(lv.Pt()) > 100000 or abs(lv.Eta()) > 100000:\n# raise Exception(\"Invalid values for TLorentzVector\")\n return lv","def typen_to_mv(degc):\n tab1 = [\n 0.000000000000E+00,\n 0.261591059620E-01,\n 0.109574842280E-04,\n -0.938411115540E-07,\n -0.464120397590E-10,\n -0.263033577160E-11,\n -0.226534380030E-13,\n -0.760893007910E-16,\n -0.934196678350E-19,\n ]\n tab2 = [\n 0.000000000000E+00,\n 0.259293946010E-01,\n 0.157101418800E-04,\n 0.438256272370E-07,\n -0.252611697940E-09,\n 0.643118193390E-12,\n -0.100634715190E-14,\n 0.997453389920E-18,\n -0.608632456070E-21,\n 0.208492293390E-24,\n -0.306821961510E-28,\n ]\n\n if -270 <= degc <= 0:\n c = tab1\n elif 0 < degc <= 1300:\n c = tab2\n else:\n raise ValueError(\"Temperature specified is out of range for Type N thermocouple\")\n\n e = 0\n for p in range(0, len(c)):\n e += c[p] * math.pow(degc, p)\n return e","def get_volt(data):\n volt = (data * 5.0) / 255\n #volt = round(volt, 1)\n return volt","def exit_velocity(self):\n\n return self.exit_mach() * \\\n (self.specific_heat_ratio * self.gas_constant\n * self.exit_temperature()) ** (1 / 2)","def ke(self):\n self._obj['w'] = (self._obj['u'])**2 + (self._obj['v'])**2\n\n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'({vel_units})^2')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = (f'({vel_units})^2')\n return self._obj","def read_vs_1d(vname, depth): \n with open(vname, 'r') as f:\n lines = f.readlines() \n line0=lines[0].split()\n n_col = int(line0[0])\n \n data = []\n\n for line in lines[1:]:\n data.append([float(val) for val in line.split()])\n\n data = np.concatenate(data) \n v_mod = data.reshape([n_col,6])\n \n depth_ref = 0\n for i in range(0, n_col):\n depth_ref = depth_ref+v_mod[i,0]\n #print(depth_ref)\n if(depth_ref>depth):\n vs_1d = v_mod[i-1,2]\n rho_1d = v_mod[i-1,3] \n break\n \n return vs_1d, rho_1d","def __rd_xyz_nmol(self):\n fpin = open(self.config['xyzfile'], \"r\")\n content = fpin.readlines()\n fpin.close()\n first_line = content[0]\n n_line = len(content)\n n_atom = int(first_line.split()[0])\n nmol = n_line / (n_atom + 2)\n self.model['nmol'] = nmol\n return nmol","def width_v_eta(model: SingleRhNeutrinoModel):\n mh = parameters.eta_mass\n fh = parameters.feta\n return _width_v_hp(model, mh, fh)","def get_map_size(level):\n if level < 5:\n return 5, 5\n if level < 70:\n return 10, 10\n if level < 150:\n return 25, 25\n return 50, 50","def get_voltage(self):\n summary = \" \".join(self.get_summary().split())\n pattern = '\\$.... .. (.*?) .*? .*? .*? .*? . .*? .*? . . . .*?'\n voltage = float(re.findall(pattern,summary).pop())\n return voltage","def heston_model_levels(params: 'ModelParameters') -> 'np.array':\n # Get two correlated brownian motion sequences for the volatility parameter and the underlying asset\n # brownian_motion_market, brownian_motion_vol = get_correlated_paths_simple(param)\n brownian, cir_process = cox_ingersoll_ross_heston(params)\n brownian, brownian_motion_market = heston_construct_correlated_path(params, brownian)\n\n heston_market_price_levels = [params.all_s0]\n for i in range(1, params.all_time):\n drift = params.gbm_mu * heston_market_price_levels[i - 1] * params.all_delta\n vol = cir_process[i - 1] * heston_market_price_levels[i - 1] * brownian_motion_market[i - 1]\n heston_market_price_levels.append(heston_market_price_levels[i - 1] + drift + vol)\n return np.array(heston_market_price_levels), np.array(cir_process)"],"string":"[\n \"def levvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n #levmv = mv.clone() # good if mv has only a lev axis\\n #levmv[:] = lev_axis[:]\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\\n attributes={'units':lev_axis.units},\\n copy=True )\\n return levmv\",\n \"def select_lev( mv, slev ):\\n levax = levAxis(mv)\\n # Get ig, the first index for which levax[ig]>slev\\n # Assume that levax values are monotonic.\\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\\n if levax[0]<=levax[-1]:\\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\\n else:\\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\\n if ids is None or len(ids)==0:\\n ig = len(levax)-1\\n else:\\n ig = ids[0][0]\\n # Crude fist cut: don't interpolate, just return a value\\n if levax == mv.getAxisList()[0]:\\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\\n elif levax == mv.getAxisList()[1]:\\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\\n else:\\n print \\\"ERROR, select_lev() does not support level axis except as first or second dimentions\\\"\\n return None\\n return mvs\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def calculate_tumor(filename, verbose = False):\\n img = nibabel.load(filename)\\n data = img.get_data()\\n pixdim = img.header['pixdim']\\n xyzt_units = img.header['xyzt_units']\\n #pixdim[1],pixdim[2],pixdim[3] stores width, depth and height\\n volume_per_pix = pixdim[1]*pixdim[2]*pixdim[3]\\n\\n volumes = {}\\n volumes['total vasogenic edema volume'] = round(sum(data[data ==2 ])*volume_per_pix/1000, 3)\\n volumes['enhancing portion'] = round(sum(data[data == 4]) * volume_per_pix/1000, 3)\\n volumes['non enhancing portion'] = round(sum(data[data == 1]) * volume_per_pix/1000, 3)\\n volumes['total tumor volume'] = round(volumes['enhancing portion'] + volumes['non enhancing portion'], 3)\\n if xyzt_units == 1:\\n volumes['unit'] = 'L'\\n if xyzt_units == 2:\\n volumes['unit'] = 'ML'\\n if xyzt_units == 3:\\n volumes['unit'] = 'UL'\\n\\n return volumes\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def get_level_size(slide, level):\\n return slide.level_dimensions[level]\",\n \"def v(self):\\n\\n # TODO This translation formula works, but needs simplified.\\n\\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\\n# print(\\\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\\\", MuleBot.dcMotorPWMDurationLeft)\\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\\n# print(\\\"speed_percentage: \\\", speed_percentage)\\n\\n rpm = speed_percentage * self.motorMaxRPM\\n# print(\\\"rpm: \\\", rpm)\\n\\n secondsPerMinute = 60\\n revs_per_second = rpm / secondsPerMinute\\n# print(\\\"--revs_per_second\\\", revs_per_second)\\n\\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\\n INCHES_PER_METER = 39.3701\\n meters_per_rev = inches_per_rev / INCHES_PER_METER\\n# print(\\\"--meters_per_rev\\\", meters_per_rev)\\n\\n meters_per_second = meters_per_rev * revs_per_second\\n\\n# print(\\\"--meters_per_second: \\\", meters_per_second)\\n return meters_per_second\",\n \"def width_v_phi(model: SingleRhNeutrinoModel):\\n params = _neutrino_vector_meson_constants[\\\"phi\\\"]\\n k, g = params[\\\"k\\\"], params[\\\"g\\\"]\\n return _width_v_hv(model, MPHI, k, g)\",\n \"def get_level_mag(slide, level):\\n return level_mags(slide)[level]\",\n \"def est_maxlevel(dims,bandwidth):\\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\\n lev=int(lev)\\n return lev\",\n \"def get_dimensional_measurements():\\n return Global_Module.global_dimensional_measurements\",\n \"def model_onelayer_pert(r):\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\tif (r > 6361000.0):\\n\\t\\trho = 2.7\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.0 + 0.02\\n\\t\\tvsh = vsv \\n\\t\\teta = 1.0\\n\\n\\telse:\\n\\t\\trho = 3.1\\n\\t\\tvpv = 7.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.0\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def vp_from_ke(m):\\n return (m[0, 0]/m[2,0], m[1,0]/m[2,0])\",\n \"def calc_thickness(self):\\n s = \\\"::: calculating z-varying thickness :::\\\"\\n print_text(s, cls=self)\\n #H = project(self.S - self.x[2], self.Q, annotate=False)\\n H = self.vert_integrate(Constant(1.0), d='down')\\n Hv = H.vector()\\n Hv[Hv < 0] = 0.0\\n print_min_max(H, 'H', cls=self)\\n return H\",\n \"def vol_from_var(self, level: float = 0.95, interpolation: str = 'lower') -> float:\\n return float(-np.sqrt(self.periods_in_a_year) *\\n self.var_down_func(level, interpolation=interpolation) / ss.norm.ppf(level))\",\n \"def dimension_pv(self):\\n return self._dimension_pv\",\n \"def mTV(self):\\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\\n # approximated with the wing root chordplane\\n return distance / (self.spanW / 2)\",\n \"def get_properties(self):\\n assert self.kekulize, '#ERROR: u need to get explicit BOs for amon generation'\\n self.vs = np.array([ ai.GetTotalValence() for ai in self.m0.GetAtoms() ], np.int)\\n #self.update_bom()\\n self.ias_heav = self.ias[ self.zs > 1 ]\\n bom_heav = self.bom[ self.ias_heav, : ][ :, self.ias_heav ]\\n self.vs_heav = bom_heav.sum(axis=0)\\n self.cns_heav = ( bom_heav > 0 ).sum(axis=0)\\n self.nhs = self.vs[:self.nheav] - self.vs_heav - self.chgs[:self.nheav]\\n self.dvs = self.vs_heav - self.cns_heav\\n self.hybs = np.array([ _hyb[ai.GetHybridization()] for ai in self.m.GetAtoms() ])\",\n \"def vol(x):\\r\\n return pi*(topdia(x)/2000.)**2 * length (x)\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def calc_lhv(self):\\n hf = {}\\n hf['hydrogen'] = 0\\n hf['methane'] = -74.85\\n hf['ethane'] = -84.68\\n hf['propane'] = -103.8\\n hf['butane'] = -124.51\\n hf['O2'] = 0\\n hf['CO2'] = -393.5\\n # water (gaseous)\\n hf['H2O'] = -241.8\\n\\n lhv = 0\\n\\n for f, x in self.fuel.val.items():\\n molar_masses[f] = CP.PropsSI('M', f)\\n fl = set(list(hf.keys())).intersection(\\n set([a.replace(' ', '') for a in CP.get_aliases(f)]))\\n if len(fl) == 0:\\n continue\\n\\n if list(fl)[0] in self.fuels():\\n structure = fluid_structure(f)\\n\\n n = {}\\n for el in ['C', 'H', 'O']:\\n if el in structure:\\n n[el] = structure[el]\\n else:\\n n[el] = 0\\n\\n lhv += (-(n['H'] / 2 * hf['H2O'] + n['C'] * hf['CO2'] -\\n ((n['C'] + n['H'] / 4) * hf['O2'] +\\n hf[list(fl)[0]])) / molar_masses[f] * 1000) * x\\n\\n return lhv\",\n \"def bv_data():\\n heights = [1000., 1500., 2000., 2500.] * units('m')\\n potential_temperatures = [[290., 290., 290., 290.],\\n [292., 293., 293., 292.],\\n [294., 296., 293., 293.],\\n [296., 295., 293., 296.]] * units('K')\\n return heights, potential_temperatures\",\n \"def velocity(self,level='cell'):\\r\\n\\r\\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\\r\\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \\r\\n vels = []\\r\\n vols = self.last_sim_step_volume()\\r\\n \\r\\n if level=='cell':\\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n return vels\\r\\n \\r\\n elif level=='section': \\r\\n # 先计算每一个元胞的再按照volume计算加权平均\\r\\n \\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2)) \\r\\n\\r\\n \\r\\n # 将速度按照volume加权平均\\r\\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\\r\\n sum_vol = sum(vols)\\r\\n if sum_vol == 0:\\r\\n avg_vel = 0\\r\\n else:\\r\\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\\r\\n \\r\\n return avg_vel\\r\\n\\r\\n\\r\\n else :\\r\\n raise ValueError('no such level for collecting data')\",\n \"def loading(self, pressure):\\n kp = self.params[\\\"K\\\"] * pressure\\n return self.params[\\\"n_m\\\"] * kp / (1.0 + kp)\",\n \"def getComponentVolume(self):\\n lengthO = self.getDimension(\\\"lengthOuter\\\")\\n widthO = self.getDimension(\\\"widthOuter\\\")\\n heightO = self.getDimension(\\\"heightOuter\\\")\\n lengthI = self.getDimension(\\\"lengthInner\\\")\\n widthI = self.getDimension(\\\"widthInner\\\")\\n heightI = self.getDimension(\\\"heightInner\\\")\\n mult = self.getDimension(\\\"mult\\\")\\n vol = mult * (lengthO * widthO * heightO - lengthI * widthI * heightI)\\n return vol\",\n \"def width_v_v_v(model: SingleRhNeutrinoModel, genv: Generation):\\n mx = model.mx\\n u = 0.5 * np.tan(2 * model.theta)\\n w = parameters.GF**2 * mx**5 / (768 * np.pi**3) * u**2\\n pre = 2 if genv == model.gen else 1.0\\n return pre * w\",\n \"def MH(self):\\n\\n #return math.log10(self.glb[user_params_index[\\\"Zs\\\"]]*constants.solar_x/(self.glb[user_params_index[\\\"Xs\\\"]]*constants.solar_z))\\n return math.log10(self.glb[iz0]*constants.solar_x/(self.glb[ix0]*constants.solar_z))\",\n \"def height(self, x):\\n\\t\\treturn np.interp(x, self.x, self.z)\",\n \"def peak_height(self, logM, k = [], pk = []):\\n # Checks\\n pk=np.atleast_2d(pk)\\n assert len(pk[0])==len(k), \\\"Length of scales is different from power spectra\\\"\\n sigma2 = self.mass_variance(logM,k,pk)\\n nu = self.delta_sc/sigma2**.5\\n return nu\",\n \"def vapor_pressure(ds, var):\\n eps0 = 0.622 # Ratio of molecular weight of water and dry air [-]\\n ds['vp'] = 0.5 * ds[var['pressure']] * (-1 + np.sqrt(1 + 4 * ds[var['mix_ratio']] / eps0))\\n ds.vp.attrs = {'units': '???????', 'long_name': 'Vapor pressure', 'standard_name': 'vapor_pressure'}\\n return ds\",\n \"def getVelocity(self):\\n return self.v\",\n \"def _microstrip_v_with_Lk(wire_width, dielectric_thickness, eps_r, Lk_per_sq):\\n L_m, C_m = _microstrip_LC_per_meter(wire_width,\\n dielectric_thickness,\\n eps_r)\\n Lk_m = Lk_per_sq * (1.0/wire_width)\\n v = 1 / sqrt((L_m+Lk_m) * C_m)\\n return v\",\n \"def linear_momentum(self):\\r\\n return self.mass * self.vel\",\n \"def Dekel(mv,mv0,lmax0,vmax0,alpha0,z=0.):\\n g_vmax,g_lmax = g_P10(mv/mv0,alpha0)\\n lmax = lmax0 * g_lmax\\n vmax = vmax0 * g_vmax\\n s2 = 2.-alpha0\\n s3 = 3.-alpha0\\n A = (cfg.G * mv / lmax / vmax**2)**(0.5/s3) * (s2/s3)\\n lv = lmax / s2**2 * A**2 / (1.-A)**2\\n c = s2**2 * lv / lmax\\n rhoc = co.rhoc(z,h=cfg.h,Om=cfg.Om,OL=cfg.OL)\\n Delta = 3.*mv / (cfg.FourPi * lv**3 * rhoc)\\n return c,Delta\",\n \"def waveVector_deBroglie(momentum=1, units=SI):\\n\\n var = sy.var('p hbar')\\n par = momentum, units['hbar']\\n\\n y = p / hbar\\n return dic_result(var,par,y)\",\n \"def _get_depth(self, data): \\r\\n\\r\\n data = data.astype(np.float32)\\r\\n\\r\\n normalized = np.dot(data, [65536.0, 256.0, 1.0]) \\r\\n normalized /= (256 * 256 * 256 - 1)\\r\\n in_meters = 1000 * normalized\\r\\n\\r\\n return in_meters\",\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 E2V(E):\\n# for energy in mev returns velocity in m/s\\n return sqrt(E/5.227e-6)\",\n \"def get_luminosity(name):\\n all_data = mc.get('sensor_values')\\n name = _lookup(name)\\n try:\\n return all_data[name][3]\\n except KeyError:\\n raise KeyError(\\\"No sensor with that name\\\")\",\n \"def get_luminosity(self, vel_disp):\\n\\t\\tlog_L_V = self.slope*np.log10(vel_disp) + self.intercept\\n\\t\\treturn log_L_V\",\n \"def __rho2v(self, vm, beta, rhoc, w, rho):\\n if rho < 0:\\n return float(vm)\\n elif rho <= rhoc:\\n return float(vm - vm * rho / beta)\\n else:\\n rhom = rhoc - (vm * rhoc - vm * (rhoc ** 2) / beta) / w\\n # print('rho {0}; rhoc {1}'.format(rho, rhoc))\\n return float(w * (rho - rhom) / rho)\",\n \"async def uv_level(self, uvi):\\n\\n if uvi is None:\\n return \\\"no-data\\\"\\n\\n if uvi >= 10.5:\\n return self._translations[\\\"uv\\\"][\\\"extreme\\\"]\\n if uvi >= 7.5:\\n return self._translations[\\\"uv\\\"][\\\"very-high\\\"]\\n if uvi >= 5.5:\\n return self._translations[\\\"uv\\\"][\\\"high\\\"]\\n if uvi >= 2.5:\\n return self._translations[\\\"uv\\\"][\\\"moderate\\\"]\\n if uvi > 0:\\n return self._translations[\\\"uv\\\"][\\\"low\\\"]\\n \\n return self._translations[\\\"uv\\\"][\\\"none\\\"]\",\n \"def get_Y_and_M(self, PP, weight, prec, Yin=None):\\n # generalized_level\\n if Yin is not None:\\n Y0 = Yin\\n else:\\n Y0 = min(self._group.minimal_height(), 0.5)\\n Cmax = 1\\n Kmax = 0\\n Cmax = max(PP.values())\\n for t in PP.keys():\\n if isinstance(t, tuple):\\n (c, l) = t\\n elif isinstance(t, (int, Integer)):\\n (c, l) = rn_from_D(self.multiplier(), t)\\n else:\\n raise ValueError(\\\"Incorrect principal part: t={0}\\\".format(t))\\n D = self.multiplier().weil_module().D()\\n if c in D:\\n tmp = l + self.multiplier().Qv[D.index(c)]\\n elif c in range(len(self.multiplier().Qv)):\\n tmp = l + self.multiplier().Qv[c]\\n else:\\n raise ValueError(\\\"Incorrect principal part: c,l={0},{1}\\\".format(c, l))\\n if self._verbose > 0:\\n print(\\\"tmp={0}\\\".format(tmp))\\n if abs(tmp) > Kmax:\\n Kmax = abs(tmp)\\n # x\\n # then get corresponding M\\n # print \\\"Kmax=\\\",Kmax\\n # print \\\"Cmax=\\\",Cmax\\n M0 = self.get_M(Y0, Kmax, Cmax, prec)\\n return [Y0, M0]\",\n \"def Dekel2(mv,mv0,lmax0,vmax0,alpha0,slope0,z=0.):\\n g_vmax,g_lmax = g_P10(mv/mv0,slope0)\\n lmax = lmax0 * g_lmax\\n vmax = vmax0 * g_vmax\\n s2 = 2.-alpha0\\n s3 = 3.-alpha0\\n A = (cfg.G * mv / lmax / vmax**2)**(0.5/s3) * (s2/s3)\\n lv = lmax / s2**2 * A**2 / (1.-A)**2\\n c = s2**2 * lv / lmax\\n rhoc = co.rhoc(z,h=cfg.h,Om=cfg.Om,OL=cfg.OL)\\n Delta = 3.*mv / (cfg.FourPi * lv**3 * rhoc)\\n return c,Delta\",\n \"def vorticity(self):\\n \\n ux,_ = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n _,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n # self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y'])\\n self._obj['w'] = xr.DataArray(vy - ux, dims=['x', 'y','t'])\\n \\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append('1/dt')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = ('1/dt')\\n\\n\\n return self._obj\",\n \"def test_set_vh(self):\\n s = State(substance=\\\"water\\\")\\n s.vh = Q_(0.4772010021515822, \\\"m**3/kg\\\"), Q_(1061602.391543017, \\\"J/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vh[0], Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.vh[1], Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def width_v_rho(model: SingleRhNeutrinoModel):\\n params = _neutrino_vector_meson_constants[\\\"rho0\\\"]\\n k, g = params[\\\"k\\\"], params[\\\"g\\\"]\\n return _width_v_hv(model, MRHO, k, g)\",\n \"def UnitCellVolume(ID): \\n ID=goodID(ID)\\n lp=latticeParameters[ID]\\n a=lp[0]/u['ang']\\n b=lp[1]/u['ang']\\n c=lp[2]/u['ang']\\n alpha=lp[3]\\n beta=lp[4]\\n gamma=lp[5]\\n L=latticeType[ID]\\n ca=cosd(alpha)\\n cb=cosd(beta)\\n cg=cosd(gamma)\\n V=a*b*c*np.sqrt(1-ca**2-cb**2-cg**2+2*ca*cb*cg)\\n return V\",\n \"def get_velocity(self):\\n return self.momentum/self.mass\",\n \"def var(self):\\n\\n return self.scale ** -2 \\\\\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)\",\n \"def get_voxel_size(path: str) -> float:\\n dcm = pydicom.dcmread(path, force=True)\\n x_str, y_str = dcm.PixelSpacing\\n x = Decimal(str(x_str))\\n y = Decimal(str(y_str))\\n z = Decimal(str(dcm.SpacingBetweenSlices))\\n print(float(x * y * z))\\n return float(x * y * z)\",\n \"def unit_of_measurement(self):\\n return self.var_units\",\n \"def test_el_ml():\\n levels = np.array([959., 779.2, 751.3, 724.3, 700., 400., 269.]) * units.mbar\\n temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -25., -35.]) * units.celsius\\n dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -35., -53.2]) * units.celsius\\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\\n el_pressure, el_temperature = el(levels, temperatures, dewpoints, mixed_parcel_prof)\\n assert_almost_equal(el_pressure, 350.0561 * units.mbar, 3)\\n assert_almost_equal(el_temperature, -28.36156 * units.degC, 3)\",\n \"def width_v_omega(model: SingleRhNeutrinoModel):\\n params = _neutrino_vector_meson_constants[\\\"omega\\\"]\\n k, g = params[\\\"k\\\"], params[\\\"g\\\"]\\n return _width_v_hv(model, MOMEGA, k, g)\",\n \"def get_pedigree_variance(pm, version=\\\"original\\\"):\\n assert all(isinstance(obj, int) for obj in pm.values())\\n return sum(PEDIGREE_MATRIX_VALUES[version][k][v - 1] for k, v in pm.items())\",\n \"def pH(self):\\n index = self.var_index(9)\\n return self.var_data(index)\",\n \"def get_channel_v_unit(self)->float:\\n return self.__channel_v_unit\",\n \"def n_y(self, level):\\n resolution = self.resolution(level)\\n return (self.y_extent // resolution + 63) // 64\",\n \"def waveparameterh(L):\\r\\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3\",\n \"def Mach(h,Vc,p):\\n return np.sqrt(2/(gamma-1)*((1+p0/p*((1+(gamma-1)/(2*gamma)*rho0/p0*Vc**2)**(gamma/(gamma-1))-1))**((gamma-1)/gamma)-1))\",\n \"def getMeasure(unique_name):\",\n \"def getMeasure(unique_name):\",\n \"def voltmeter_settings(self, scalefactor, offset):\\n if scalefactor is not None and offset is not None:\\n if self._request('SM', str(scalefactor), str(offset))[0]:\\n return scalefactor, offset\\n else:\\n done, data = self._request('GM')\\n if done:\\n return int(data[0]), int(data[1])\\n\\n raise EvseError\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def estimate_variance(ds,vert_step,horiz_step):\\n obs_map = zeros([ds.shape[0]/vert_step,ds.shape[1]/horiz_step])\\n print 'observed map has shape ' + str(obs_map.shape)\\n for row in range(obs_map.shape[0]):\\n for col in range(obs_map.shape[1]):\\n #print 'calculating for %d %d (%d:%d,%d:%d)' % (row,col,row*vert_step,(row+1)*vert_step,\\n # col*horiz_step,(col+1)*horiz_step)\\n obs_var,rep_var = calc_variances(ds[row*vert_step:(row+1)*vert_step,\\n col*horiz_step:(col+1)*horiz_step])\\n obs_map[row,col] = sqrt(obs_var/rep_var)\\n # Annotate appropriately\\n obs_map.axes[0] = Array(range(obs_map.shape[0]))*vert_step\\n obs_map.axes[1] = Array(range(obs_map.shape[1]))*horiz_step\\n return obs_map\",\n \"def model_prem(r):\\n\\n\\t#- normalised radius\\n\\tx = r / 6371000.0\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\t#- upper crust\\n\\tif (r >= 6356000.0):\\n\\t\\trho = 2.6\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- lower crust\\n\\telif (r >= 6346000.6) & (r < 6356000.0):\\n\\t\\trho = 2.9\\n\\t\\tvpv = 6.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.9\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- LID\\n\\telif (r >= 6291000.0) & (r < 6346000.6):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 0.8317 + 7.2180 * x\\n\\t\\tvph = 3.5908 + 4.6172 * x\\n\\t\\tvsv = 5.8582 - 1.4678 * x\\n\\t\\tvsh = -1.0839 + 5.7176 * x\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- LVZ\\n\\telif (r >= 6151000.0) & (r < 6291000.0):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 0.8317 + 7.2180 * x\\n\\t\\tvph = 3.5908 + 4.6172 * x\\n\\t\\tvsv = 5.8582 - 1.4678 * x\\n\\t\\tvsh = -1.0839 + 5.7176 * x\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- Transition zone 1\\n\\telif (r >= 5971000.0) & (r < 6151000.0):\\n\\t\\trho = 7.1089 - 3.8045 * x\\n\\t\\tvpv = 20.3926 - 12.2569 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 8.9496 - 4.4597 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 2\\n\\telif (r >= 5771000.0) & (r < 5971000.0):\\n\\t\\trho = 11.2494 - 8.0298 * x\\n\\t\\tvpv = 39.7027 - 32.6166 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3512 - 18.5856 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 3\\n\\telif (r >= 5701000.0) & (r < 5771000.0):\\n\\t\\trho = 5.3197 - 1.4836 * x\\n\\t\\tvpv = 19.0957 - 9.8672 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 9.9839 - 4.9324 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 1\\n\\telif (r >= 5600000.0) & (r < 5701000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- Lower mantle 2\\n\\telif (r >= 3630000.0) & (r < 5600000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 3\\n\\telif (r >= 3480000.0) & (r < 3630000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Outer core\\n\\telif (r >= 1221000.5) & (r < 3480000.0):\\n\\t\\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\\n\\t\\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 0.0\\n\\t\\tvsh = 0.0\\n\\t\\teta = 1.0\\n\\n\\t#- Inner Core\\n\\telif (r >= 0.0) & (r < 1221000.5):\\n\\t\\trho = 13.0885 - 8.8381 * x**2\\n\\t\\tvpv = 11.2622 - 6.3640 * x**2\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.6678 - 4.4475 * x**2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def V2E(V):\\n# for v in m/s returns energy in meV\\n return 5.227e-6*V*V\",\n \"def get_velocity(self):\\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s\",\n \"def zmwMetric(self, name):\\n return self.baxH5.zmwMetric(name, self.index)\",\n \"def tubeVol2vertTubeHeight(v, r):\\n sphere_half_vol = (4.0/3.0 * np.pi * r**3)/2.0\\n\\n if v <= sphere_half_vol:\\n # height does not extend to cylinder\\n h = _sphereCapVol2height(v, r)\\n else:\\n # height = sphere_cap_height (r) + cylinder_height\\n #sphere_cap_height = r #_sphereCapVol2height(sphere_half_vol, r)\\n h = r + _cylVol2height(v - sphere_half_vol, r)\\n\\n return(h)\",\n \"def LotkaVolterra_Dynamics(self):\\n LV_c = self.toConceptual(self.state) # (nF, nR)\\n LV_c = LV_c.mul((1 - LV_c) + self.LV_inhM.mm(LV_c))\\n LV_s = self.toNeural(LV_c)\\n\\n return LV_c, LV_s\",\n \"def dlnM_dlnobs(self, name, M0_arr=None, z=None):\\n if name=='zeta':\\n return 1/self.scaling['Bsz']\\n elif name=='Yx':\\n return 1/(1/self.scaling['Bx'] - self.scaling['dlnMg_dlnr']/3)\\n elif name=='Mgas':\\n return 1/(self.scaling['Bx'] - self.scaling['dlnMg_dlnr']/3)\\n elif (name=='WLMegacam')|(name=='WLHST'):\\n return 1.\",\n \"def width_h_invis(self):\\n if m_higgs > 2.0 * self.mx:\\n coupling = self.gsxx * self.stheta / np.sqrt(1 - self.stheta**2)\\n\\n val = (\\n (coupling**2 * (m_higgs**2 - 4 * self.mx**2) ** 1.5)\\n / (8.0 * m_higgs**2 * np.pi)\\n ).real\\n\\n assert val >= 0\\n\\n return val\\n else:\\n return 0.0\",\n \"def get_var_explained(self, idx, v):\\n return 3 * self.get_scaling(idx)**2 * v * self.pars[2]**2 / np.pi**2\",\n \"def getHt(self) -> float:\\n\\n return self.p3ddict.p3dz()\",\n \"def vel(self,M):\\n v_peri = np.sqrt((HohmannTransfer.G*M)*((2/self.r1)-(2/(self.r1+self.r2))))\\n \\n v_aphe = np.sqrt((HohmannTransfer.G*M)*((2/self.r2)-(2/(self.r1+self.r2))))\\n \\n return v_peri, v_aphe\",\n \"def get_V(self):\\n return self.V\",\n \"def get_measurement(self):\\n return self._convert_to_depth(self._avg_sample())\",\n \"def get_vsolar(self):\\n return self.read_register(4098, 1, 3)\",\n \"def displacement_wein(temperature=1, units=SI):\\n\\n var = sy.var('h c k t')\\n par = units['h'], units['c'], units['k'], temperature\\n\\n y = h * c / 4.9663 / k / t\\n\\n return dic_result(var,par,y)\",\n \"def v(self):\\n return self._properties['v']\",\n \"def growth_factor_scale_independent(self, z):\\n z = np.atleast_1d(z)\\n nz = len(z)\\n #if self.M_nu_tot == 0. and self.w0 == -1. and self.wa==0.:\\n # aa = 1./(1.+z)\\n # ww = self.w0 + (1.-aa)*self.wa\\n # d1 = aa*ss.hyp2f1(1/3., 1., 11/6., -aa**3/self.Omega_m*(1.-self.Omega_m))/ss.hyp2f1(1/3., 1., 11/6., -(1.-self.Omega_m)/self.Omega_m)\\n #else:\\n # d1 = np.zeros(nz)\\n # for i in range(nz):\\n # LCDM, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., z[i], np.inf)\\n # d1[i] = LCDM*self.H_massive(z[i])/self.H0\\n # LCDM0, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., 0., np.inf)\\n # d1 = d1/LCDM0\\n d1 = np.zeros(nz)\\n for i in range(nz):\\n LCDM, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., z[i], np.inf)\\n d1[i] = LCDM*self.H_massive(z[i])/self.H0\\n LCDM0, _ = sint.quad(lambda x: (1+x)*(self.H0/self.H_massive(x))**3., 0., np.inf)\\n d1 = d1/LCDM0\\n return d1\",\n \"def get_v(r_div_R, z_div_L, Pi_div_DLP, k, alpha_ast, Bp, Bm, gp, gm, membrane_geometry):\\n return CT.get_v(r_div_R, z_div_L, Pi_div_DLP, k, alpha_ast, Bp, Bm, gp, gm, membrane_geometry)\",\n \"def lo_vcm(self):\\n return self._read(0x12, 5, 0xE0)\",\n \"def _get_Mll(self):\\n\\t\\t_M_ll = mll.get_mll(self.W_l, self.lmax)\\n\\t\\treturn np.float64(_M_ll)\",\n \"def _microstrip_LC_per_meter(wire_width, dielectric_thickness, eps_r):\\n # Use the fact that v = 1/sqrt(L_m*C_m) = 1/sqrt(eps*mu) and\\n # Z = sqrt(L_m/C_m) [Where L_m is inductance per meter]\\n Z, eps_eff = _microstrip_Z(wire_width, dielectric_thickness, eps_r)\\n eps0 = 8.854e-12\\n mu0 = 4*pi*1e-7\\n\\n eps = eps_eff*eps0\\n mu = mu0\\n L_m = sqrt(eps*mu) * Z\\n C_m = sqrt(eps*mu) / Z\\n return L_m, C_m\",\n \"def define_variables(m):\\r\\n\\r\\n # Non-negative candidate capacity\\r\\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Solar build limits\\r\\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Wind build limits\\r\\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage build limits\\r\\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min power output (all generators excluding storage units)\\r\\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing thermal\\r\\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate thermal\\r\\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing wind\\r\\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate wind\\r\\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing solar\\r\\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate solar\\r\\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - hydro\\r\\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min charging power - storage units\\r\\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min discharging power - storage_units\\r\\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - existing storage\\r\\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - candidate storage\\r\\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - existing storage\\r\\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - candidate storage\\r\\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - storage units\\r\\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - existing storage units\\r\\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - candidate storage\\r\\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - interval end\\r\\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - interval end\\r\\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate up (thermal and hydro generators)\\r\\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate down (thermal and hydro generators)\\r\\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Non-negative lost load power\\r\\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min powerflow\\r\\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max powerflow\\r\\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage energy transition\\r\\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n # Power balance (locational marginal price)\\r\\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n return m\",\n \"def mv_to_typen(mv):\\n tab1 = [\\n 0.0000000E+00,\\n 3.8436847E+01,\\n 1.1010485E+00,\\n 5.2229312E+00,\\n 7.2060525E+00,\\n 5.8488586E+00,\\n 2.7754916E+00,\\n 7.7075166E-01,\\n 1.1582665E-01,\\n 7.3138868E-03,\\n ]\\n\\n tab2 = [\\n 0.00000E+00,\\n 3.86896E+01,\\n -1.08267E+00,\\n 4.70205E-02,\\n -2.12169E-06,\\n -1.17272E-04,\\n 5.39280E-06,\\n -7.98156E-08,\\n 0.00000E+00,\\n 0.00000E+00,\\n ]\\n \\n tab3 = [\\n 1.972485E+01,\\n 3.300943E+01,\\n -3.915159E-01,\\n 9.855391E-03,\\n -1.274371E-04,\\n 7.767022E-07,\\n 0.000000E+00,\\n 0.000000E+00,\\n 0.000000E+00,\\n 0.000000E+00,\\n ]\\n\\n if -3.99 <= mv <= 0.0:\\n c = tab1\\n elif 0.0 < mv <= 20.613:\\n c = tab2\\n elif 20.613 < mv <= 47.513:\\n c = tab3\\n else:\\n raise ValueError(\\\"Voltage specified is out of range for Type N thermocouple\\\")\\n\\n t = 0.0\\n for p in range(0, len(c)):\\n t += c[p] * math.pow(mv, p)\\n return t\",\n \"def lvec(self):\\n lv = ROOT.TLorentzVector()\\n# if self.pt < 0 or abs(self.eta) > 6:\\n# raise Exception(\\\"Invalid values for TLorentzVector\\\")\\n lv.SetPtEtaPhiM(self.pt, self.eta, self.phi, self.mass)\\n# if abs(lv.Pt()) > 100000 or abs(lv.Eta()) > 100000:\\n# raise Exception(\\\"Invalid values for TLorentzVector\\\")\\n return lv\",\n \"def typen_to_mv(degc):\\n tab1 = [\\n 0.000000000000E+00,\\n 0.261591059620E-01,\\n 0.109574842280E-04,\\n -0.938411115540E-07,\\n -0.464120397590E-10,\\n -0.263033577160E-11,\\n -0.226534380030E-13,\\n -0.760893007910E-16,\\n -0.934196678350E-19,\\n ]\\n tab2 = [\\n 0.000000000000E+00,\\n 0.259293946010E-01,\\n 0.157101418800E-04,\\n 0.438256272370E-07,\\n -0.252611697940E-09,\\n 0.643118193390E-12,\\n -0.100634715190E-14,\\n 0.997453389920E-18,\\n -0.608632456070E-21,\\n 0.208492293390E-24,\\n -0.306821961510E-28,\\n ]\\n\\n if -270 <= degc <= 0:\\n c = tab1\\n elif 0 < degc <= 1300:\\n c = tab2\\n else:\\n raise ValueError(\\\"Temperature specified is out of range for Type N thermocouple\\\")\\n\\n e = 0\\n for p in range(0, len(c)):\\n e += c[p] * math.pow(degc, p)\\n return e\",\n \"def get_volt(data):\\n volt = (data * 5.0) / 255\\n #volt = round(volt, 1)\\n return volt\",\n \"def exit_velocity(self):\\n\\n return self.exit_mach() * \\\\\\n (self.specific_heat_ratio * self.gas_constant\\n * self.exit_temperature()) ** (1 / 2)\",\n \"def ke(self):\\n self._obj['w'] = (self._obj['u'])**2 + (self._obj['v'])**2\\n\\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'({vel_units})^2')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = (f'({vel_units})^2')\\n return self._obj\",\n \"def read_vs_1d(vname, depth): \\n with open(vname, 'r') as f:\\n lines = f.readlines() \\n line0=lines[0].split()\\n n_col = int(line0[0])\\n \\n data = []\\n\\n for line in lines[1:]:\\n data.append([float(val) for val in line.split()])\\n\\n data = np.concatenate(data) \\n v_mod = data.reshape([n_col,6])\\n \\n depth_ref = 0\\n for i in range(0, n_col):\\n depth_ref = depth_ref+v_mod[i,0]\\n #print(depth_ref)\\n if(depth_ref>depth):\\n vs_1d = v_mod[i-1,2]\\n rho_1d = v_mod[i-1,3] \\n break\\n \\n return vs_1d, rho_1d\",\n \"def __rd_xyz_nmol(self):\\n fpin = open(self.config['xyzfile'], \\\"r\\\")\\n content = fpin.readlines()\\n fpin.close()\\n first_line = content[0]\\n n_line = len(content)\\n n_atom = int(first_line.split()[0])\\n nmol = n_line / (n_atom + 2)\\n self.model['nmol'] = nmol\\n return nmol\",\n \"def width_v_eta(model: SingleRhNeutrinoModel):\\n mh = parameters.eta_mass\\n fh = parameters.feta\\n return _width_v_hp(model, mh, fh)\",\n \"def get_map_size(level):\\n if level < 5:\\n return 5, 5\\n if level < 70:\\n return 10, 10\\n if level < 150:\\n return 25, 25\\n return 50, 50\",\n \"def get_voltage(self):\\n summary = \\\" \\\".join(self.get_summary().split())\\n pattern = '\\\\$.... .. (.*?) .*? .*? .*? .*? . .*? .*? . . . .*?'\\n voltage = float(re.findall(pattern,summary).pop())\\n return voltage\",\n \"def heston_model_levels(params: 'ModelParameters') -> 'np.array':\\n # Get two correlated brownian motion sequences for the volatility parameter and the underlying asset\\n # brownian_motion_market, brownian_motion_vol = get_correlated_paths_simple(param)\\n brownian, cir_process = cox_ingersoll_ross_heston(params)\\n brownian, brownian_motion_market = heston_construct_correlated_path(params, brownian)\\n\\n heston_market_price_levels = [params.all_s0]\\n for i in range(1, params.all_time):\\n drift = params.gbm_mu * heston_market_price_levels[i - 1] * params.all_delta\\n vol = cir_process[i - 1] * heston_market_price_levels[i - 1] * brownian_motion_market[i - 1]\\n heston_market_price_levels.append(heston_market_price_levels[i - 1] + drift + vol)\\n return np.array(heston_market_price_levels), np.array(cir_process)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6776988","0.6006147","0.590526","0.5898939","0.55466783","0.54994154","0.547498","0.5466537","0.5447086","0.54124725","0.5391253","0.5389002","0.53862095","0.5358909","0.5290569","0.5286262","0.5192268","0.51763445","0.5174741","0.51733345","0.5168547","0.51670426","0.51535904","0.5152418","0.5145301","0.51448774","0.5137595","0.51373607","0.5126466","0.51196504","0.5110815","0.5110461","0.50984615","0.5096469","0.5085841","0.50756025","0.5056189","0.50471866","0.5046528","0.50377864","0.5033394","0.5027563","0.501975","0.50175256","0.5012891","0.50056577","0.5003363","0.4996989","0.49954244","0.49911505","0.49833414","0.4977749","0.4970646","0.4969488","0.4963116","0.4961619","0.49499273","0.49441585","0.49390703","0.49388388","0.4935889","0.49311048","0.49311048","0.4919783","0.49192908","0.4918969","0.4918659","0.49183762","0.4916446","0.4910547","0.49084723","0.49083793","0.49015796","0.4900525","0.48947918","0.48905325","0.48883244","0.48876554","0.48758268","0.48755586","0.48755467","0.48715037","0.48661083","0.48644233","0.4860971","0.4858238","0.4856593","0.48558062","0.48555964","0.4843572","0.48426244","0.48375937","0.4836451","0.48319274","0.48314133","0.48305705","0.48289025","0.48224625","0.48211193","0.48193192"],"string":"[\n \"0.6776988\",\n \"0.6006147\",\n \"0.590526\",\n \"0.5898939\",\n \"0.55466783\",\n \"0.54994154\",\n \"0.547498\",\n \"0.5466537\",\n \"0.5447086\",\n \"0.54124725\",\n \"0.5391253\",\n \"0.5389002\",\n \"0.53862095\",\n \"0.5358909\",\n \"0.5290569\",\n \"0.5286262\",\n \"0.5192268\",\n \"0.51763445\",\n \"0.5174741\",\n \"0.51733345\",\n \"0.5168547\",\n \"0.51670426\",\n \"0.51535904\",\n \"0.5152418\",\n \"0.5145301\",\n \"0.51448774\",\n \"0.5137595\",\n \"0.51373607\",\n \"0.5126466\",\n \"0.51196504\",\n \"0.5110815\",\n \"0.5110461\",\n \"0.50984615\",\n \"0.5096469\",\n \"0.5085841\",\n \"0.50756025\",\n \"0.5056189\",\n \"0.50471866\",\n \"0.5046528\",\n \"0.50377864\",\n \"0.5033394\",\n \"0.5027563\",\n \"0.501975\",\n \"0.50175256\",\n \"0.5012891\",\n \"0.50056577\",\n \"0.5003363\",\n \"0.4996989\",\n \"0.49954244\",\n \"0.49911505\",\n \"0.49833414\",\n \"0.4977749\",\n \"0.4970646\",\n \"0.4969488\",\n \"0.4963116\",\n \"0.4961619\",\n \"0.49499273\",\n \"0.49441585\",\n \"0.49390703\",\n \"0.49388388\",\n \"0.4935889\",\n \"0.49311048\",\n \"0.49311048\",\n \"0.4919783\",\n \"0.49192908\",\n \"0.4918969\",\n \"0.4918659\",\n \"0.49183762\",\n \"0.4916446\",\n \"0.4910547\",\n \"0.49084723\",\n \"0.49083793\",\n \"0.49015796\",\n \"0.4900525\",\n \"0.48947918\",\n \"0.48905325\",\n \"0.48883244\",\n \"0.48876554\",\n \"0.48758268\",\n \"0.48755586\",\n \"0.48755467\",\n \"0.48715037\",\n \"0.48661083\",\n \"0.48644233\",\n \"0.4860971\",\n \"0.4858238\",\n \"0.4856593\",\n \"0.48558062\",\n \"0.48555964\",\n \"0.4843572\",\n \"0.48426244\",\n \"0.48375937\",\n \"0.4836451\",\n \"0.48319274\",\n \"0.48314133\",\n \"0.48305705\",\n \"0.48289025\",\n \"0.48224625\",\n \"0.48211193\",\n \"0.48193192\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77257425"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19879,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest latitude points but whose values are the latitudes"},"document":{"kind":"string","value":"def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv"},"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 lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def spatial_var(map_):\n expx, expy = spatial_expval(map_)\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","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 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 coordExtrema(a):\n # Extreme values of longitude and latitude in the survey.\n longiMin = sp.inf\n latMin = sp.inf\n longiMax = -sp.inf\n latMax = -sp.inf\n for t in range(len(a)):\n if a[t].pktCount > 0:\n arraMin = sp.amin(a[t].longi)\n if arraMin < longiMin:\n longiMin = sp.amin(a[t].longi)\n arraMin = sp.amin(a[t].lat)\n if arraMin < latMin:\n latMin = arraMin\n arraMax = sp.amax(a[t].longi)\n if arraMax > longiMax:\n longiMax = arraMax\n arraMax = sp.amax(a[t].lat)\n if arraMax > latMax:\n latMax = arraMax\n\n ext = cs.emptyClass()\n ext.longiMin = longiMin\n ext.longiMax = longiMax\n ext.latMin = latMin\n ext.latMax = latMax\n return ext","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def find_area(self):\n min_lat_point = self.latitude_min\n max_lat_point = self.latitude_max\n min_lon_point = self.longitude_min\n max_lon_point = self.longitude_max\n self.rename_latitude()\n self.rename_longitude()\n all_lat_bounds = self.cube.coord('latitude').bounds\n all_lon_bounds = self.cube.coord('longitude').bounds\n # print(all_lat_bounds)\n # print(all_lon_bounds)\n for i, lat in enumerate(all_lat_bounds):\n for j, lon in enumerate(all_lon_bounds):\n lat_bounds = lat # 2D array of the lower and upper lat bounds\n lon_bounds = lon # 2D array of the lower and upper lon bounds\n if lat_bounds[0] <= min_lat_point < lat_bounds[1]:\n if lon_bounds[0] <= min_lon_point < lon_bounds[1]:\n nlat_min = i\n nlon_min = j\n else:\n pass\n else:\n pass\n\n for k, lat in enumerate(all_lat_bounds):\n for l, lon in enumerate(all_lon_bounds):\n lat_bounds = lat # 2D array of the lower and upper lat bounds\n lon_bounds = lon # 2D array of the lower and upper lon bounds\n if lat_bounds[0] <= max_lat_point < lat_bounds[1]:\n if lon_bounds[0] <= max_lon_point < lon_bounds[1]:\n nlat_max = k\n nlon_max = l\n else:\n pass\n else:\n pass\n\n area_subset = self.cube[:, nlat_min:nlat_max+1, nlon_min:nlon_max+1]\n # print(area_subset.coord('latitude').points)\n # print(area_subset.coord('longitude').points)\n area_mean = area_subset.collapsed(['latitude', 'longitude'],\n iris.analysis.MEAN)\n\n return area_mean","def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\n\n if var.ndim == 3: # 3D variable\n zmax, imax, jmax = var.shape\n threeD = True\n elif var.ndim == 2: # 2D variable\n imax, jmax = var.shape\n threeD = False\n else:\n print 'extract_loc: check variable dimensions'\n return\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 # arrays to store weights and data to be averaged\n if threeD: # 3D variable\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n if MA.isMA(var): # mask weights\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\n else:\n dist_m = N.array(N.resize(dist,var.shape))\n else: # 2D variable\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\n if MA.isMA(var):\n dist_m = MA.array(dist,mask=var.mask) # mask weights\n else:\n dist_m = N.array(dist)\n\n # get the 4 model grid points and compute weights\n n = 0\n for i in Ilist:\n for j in Jlist:\n wghts[...,n] = 1./dist_m[...,i,j]\n data[...,n] = var[...,i,j]\n n += 1\n\n # compute weighted average\n wavg = MA.average(data,axis=-1,weights=wghts)\n return wavg","def spatial(self):","def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\n\n geo_extent_vars = {}\n geo_extent_units = []\n\n # variables must have units\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\n \n geo_extent_vars[var.name] = 0\n # units in this set\n if var.units in possible_units:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n # standard name\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n # axis of \"X\"\n if hasattr(var, 'axis') and var.axis == axis_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n if var.name == std_name or var.name == short_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n\n if len(geo_extent_vars) == 0:\n return\n\n # filter out any zero scores\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\n\n # sort by criteria passed\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\n\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n # Let's just pick one\n geo_vals = nc.variables[final_geo_vars[0][:]]\n if geo_vals.size == 1:\n obs_res = [0.0]\n else:\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n geo_min = round(float(min(obs_mins)), 5)\n geo_max = round(float(max(obs_maxs)), 5)\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\n geo_res = \"{} {}\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\n\n print('<attribute name=\"geospatial_{}_min\" value=\"{}\" />'.format(short_name, geo_min))\n print('<attribute name=\"geospatial_{}_max\" value=\"{}\" />'.format(short_name, geo_max))\n print('<attribute name=\"geospatial_{}_resolution\" value=\"{}\" />'.format(short_name, geo_res))\n print('<attribute name=\"geospatial_{}_units\" value=\"{}\" />'.format(short_name, geo_extent_units))","def lat_lons(self):","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def mme_geo(samples, moment=1):\n samples = samples ** moment\n k = len(samples)\n return ( k / np.sum(samples))","def spatial_dimension(self):\r\n pass","def nspatials(self):\n return int(len(self)/2)","def get_min_max(self):\n\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\n mr[:] = np.max(mr)\n\n mxmin = self.mx - mr\n mxmax = self.mx + mr\n mymin = self.my - mr\n mymax = self.my + mr\n mzmin = self.mz - mr\n mzmax = self.mz + mr\n\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\n\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\n\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\n\n return xmin, xmax, ymin, ymax, zmin, zmax","def probaContagius(lat1,lon1,lat2,lon2,M):\n GAMMA = 0.02\n dlon = abs(lon2 - lon1) * 10000\n dlat = abs(lat2 - lat1) * 10000\n distance_Y = int(round(dlon, 0))\n distance_X = int(round(dlat, 0))\n proba = 0\n if ( (distance_X>=0 and distance_X<300) and (distance_Y>=0 and distance_Y<300) ):\n proba = GAMMA * M[distance_X][distance_Y]\n return proba","def getMinMax(self,arr):\n # not implemented for Template SED yet\n return arr[\"z\"], arr[\"z\"]","def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\n res=np.zeros((4),dtype=np.float64)\n minLon=min_lon; maxLon=max_lon\n\n distances1 = []; distances2 = []\n indices=[]; index=1\n\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1 = []; distances2 = []; index=1\n\n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\n return res","def avg_variables(ds1, ds2, lat, lon, z, p):\r\n \r\n T1 = ds1.temp.mean(dim='time').mean(dim='lon')\r\n T2 = ds2.temp.mean(dim='time').mean(dim='lon')\r\n T_avg = average(T1, T2, z, lat, 'lat', 'pfull', 'K')\r\n \r\n uz1 = ds1.ucomp.mean(dim='time').mean(dim='lon')\r\n uz2 = ds2.ucomp.mean(dim='time').mean(dim='lon')\r\n uz_avg = average(uz1, uz2, z, lat, 'lat', 'pfull', 'm/s')\r\n \r\n msf1 = v(ds1, p, lat)\r\n msf2 = v(ds2, p, lat)\r\n msf_avg = average(msf1, msf2, z, lat, 'lat', 'pfull', 'kg/s')\r\n \r\n return T_avg, uz_avg, msf_avg","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 get_min_max(self) -> tuple:\r\n\r\n minimum = float(\"inf\")\r\n maximum = float(\"-inf\")\r\n\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n for name, data in self.trees_data.items():\r\n if self.trees[name][\"point_helper\"] is None:\r\n mapping = self.trees[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n return minimum, maximum","def find_longitude_var(nc,name):\n var_obj = nc.variables[name] # Find the corresponding variable object \n dimens = var_obj.dimensions # Find the names of the dimensions of variable\n for i in range(len(dimens)):\n # For each dimension find the corresponding variable\n var_dim = nc.variables[dimens[i]]\n if is_longitude_var(var_dim) == True:\n return var_obj # If longitude exists, return the variable object\n \n return None","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 getShortestCoordinate (analyzer,startLat, startLon, endLat, endLon):\n estacionOrigen=model.getCloserStation (analyzer, startLat, startLon)\n estacionDestino=model.getCloserStation (analyzer, endLat, endLon)\n ruta,tiempo=model.getShortestCoordinate(analyzer,estacionOrigen, estacionDestino)\n return (estacionOrigen,estacionDestino,ruta,tiempo)","def mlat_finder(self, lat1, lat0, pole = \"north\"):\n\n if pole == \"both\":\n lowerA = np.abs(self.mlatA) < lat1\n higherA = np.abs(self.mlatA) > lat0\n is_poleA = lowerA * higherA\n\n elif pole == \"north\":\n lowerA = (self.mlatA) < lat1\n higherA = (self.mlatA) > lat0\n is_poleA = lowerA * higherA\n\n elif pole == \"south\":\n lowerA = (self.mlatA) > lat1\n higherA = (self.mlatA) < lat0\n is_poleA = lowerA * higherA\n\n high_lat_A = np.where(is_poleA == 1)\n low_lat_A = np.where(is_poleA == 0)\n indsA = [low_lat_A, high_lat_A]\n\n return indsA","def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\n\n\n if min_lon<0 and max_lon>0:\n splitExtract = True; Turns=2\n grdMODEL.splitExtract=splitExtract\n else:\n splitExtract = False; Turns=1\n grdMODEL.splitExtract=splitExtract\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\n \n # Array to store the results returned from the function\n res=np.zeros((Turns,4),dtype=np.float64)\n \n lats=grdMODEL.lat[:,0]\n lons=grdMODEL.lon[0,:]\n\n \n for k in range(Turns):\n\n if k==0 and splitExtract == True:\n minLon=min_lon; maxLon=0\n minLon=minLon+360\n maxLon=maxLon+360\n elif k==1 and splitExtract == True:\n minLon=0; maxLon=max_lon\n else:\n minLon=min_lon; maxLon=max_lon\n \n distances1 = []\n distances2 = []\n indices=[]\n index=1\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n \n distances1 = []\n distances2 = []\n index=1\n \n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n \n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n \n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n grdMODEL.indices=res","def get_maxdistance_landmarktoPointcloud(self):\n if len(self.subsetnodes) == 0: # Make sure tat the landmark set is already constructed.\n self.select()\n landmarktopointcloud_dist = self.getLandmark_Witness_matrix()\n self.MaxMindist = np.nanmax(np.nanmin(landmarktopointcloud_dist, axis=0)) # Compute max of the min of each column\n return self.MaxMindist","def findNearset(x,y,lon,lat):\n dist = np.sqrt( (lon - x)**2 + (lat - y)**2)\n\n return np.argwhere(dist==dist.min())[0][0]","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def getPoint(self, a):\n lng = self.source.center.lng + (self.target.center.lng - self.source.center.lng) * min(a, 1)\n lat = self.source.center.lat + (self.target.center.lat - self.source.center.lat) * min(a, 1)\n return lng, lat","def local_maxima_3D(data, order=3):\n size = 1 + 2 * order\n footprint = np.ones((size, size, size))\n footprint[order, order, order] = 0\n\n filtered = ndi.maximum_filter(data, footprint=footprint)\n mask_local_maxima = data > filtered\n coords = np.asarray(np.where(mask_local_maxima)).T\n values = data[mask_local_maxima]\n\n return coords, values","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_pool = cls.get_var_pool(data1_, data2_)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)","def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_x = cls.get_var(data1_, is_population=True)\n var_y = cls.get_var(data2_, is_population=True)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)","def _projections(self, nvar):\n min_var = self.proje_var.argsort()[:nvar]\n add_coeffs = 1 / self.proje_var[min_var]\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\n np.sum(add_coeffs)\n\n # consider covariance\n coverr = []\n try:\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\n coverr.append(1/np.sum(proje_cov_inv))\n except:\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\n cov_est_proje[:] = np.nan\n coverr.append(np.nan)\n return np.array([indp_est_proje, cov_est_proje])","def get_var_pool(cls, data1: tuple, data2: tuple) -> float:\n cls._data_validation(data1)\n cls._data_validation(data2)\n n1 = cls.get_n(data1)\n var1 = cls.get_var(data1)\n n2 = cls.get_n(data2)\n var2 = cls.get_var(data2)\n return ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2)","def minimum_separation(lon1, lat1, lon2, lat2):\n theta_min = np.empty_like(lon1)\n\n for i1 in range(lon1.size):\n thetas = separation(lon1[i1], lat1[i1], lon2, lat2)\n theta_min[i1] = thetas.min()\n\n return theta_min","def test_spatial_smoothing_xesmf_reduce_spatial_dims_MPI_curv(\r\n PM_ds_control_3d_full,\r\n):\r\n da = PM_ds_control_3d_full\r\n step = 5\r\n actual = spatial_smoothing_xesmf(\r\n da,\r\n d_lon_lat_kws={\"lon\": step},\r\n )\r\n expected_lat_size = 180 // step\r\n assert actual[\"lon\"].size < da.lon.size\r\n assert actual[\"lat\"].size == expected_lat_size","def calculate_min_max_tiles(self):","def get_scale_local_maximas_vectorized(cube_coordinates, laplacian_cube):\n x, y, z = [ cube_coordinates[:, ind] for ind in range(3) ]\n \n point_responses = laplacian_cube[x, y, z]\n lowers = point_responses.copy()\n uppers = point_responses.copy()\n not_layer_0 = z > 0\n lower_responses = laplacian_cube[x[not_layer_0], y[not_layer_0], z[not_layer_0]-1]\n lowers[not_layer_0] = lower_responses \n \n not_max_layer = z < (laplacian_cube.shape[2] - 1)\n upper_responses = laplacian_cube[x[not_max_layer], y[not_max_layer], z[not_max_layer]+1]\n uppers[not_max_layer] = upper_responses\n \n lo_check = np.ones(z.shape, dtype=np.bool)\n lo_check[not_layer_0] = (point_responses > lowers)[not_layer_0]\n hi_check = np.ones(z.shape, dtype=np.bool)\n hi_check[not_max_layer] = (point_responses > uppers)[not_max_layer]\n \n return cube_coordinates[lo_check & hi_check]","def maks2(a, b, c):\n m = a\n if b > m:\n m = b\n if c > m:\n m = c\n \n return m","def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\n\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']","def geo_m_v2(data_array):\n r = 6378.137 #promien ziemi w km\n delta = np.zeros(data_array.size//7-1)\n alo = data_array[0][1]\n ala = data_array[0][2]\n count = 0\n for row in data_array[1:]:\n dLat = (row[2] - ala) * math.pi/180.0\n dLon = (row[1] - alo) * math.pi/180.0\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\n * math.sin(dLon/2.0)**2\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\n count += 1\n alo = row[1]\n ala = row[2]\n return delta","def get_bounds(self):\n\n northing=self.f.variables['y']\n easting=self.f.variables['x']\n\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\n\n return (lon1,lon2,lat1,lat2)","def fun_location(self, l1_xpos, l1_xscale):\n const_1 = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_1\",\n scope=tik.scope_ubuf)\n const_0 = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_0\",\n scope=tik.scope_ubuf)\n index_256 = self.tik_instance.Tensor(\"float32\", (256, 8),\n name=\"index_256\",\n scope=tik.scope_ubuf)\n self.tik_instance.vector_dup(MASK, const_1, float(1), 1, 1, 8)\n self.tik_instance.vector_dup(MASK, const_0, 0, 1, 1, 8)\n int32_256_ub = self.tik_instance.Tensor(\"int32\", (256, 8),\n name=\"int32_256_ub\",\n scope=tik.scope_ubuf)\n scale_512_x = self.tik_instance.Tensor(\"float32\", (512, 8),\n name=\"scale_512_x\",\n scope=tik.scope_ubuf)\n const_weight = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_weight\",\n scope=tik.scope_ubuf)\n self.tik_instance.vector_dup(MASK, const_weight, float(self.weight_in), 1, 1, 8)\n #x zuobiao\n with self.tik_instance.for_range(0, self.w_in_loop) as w_index:\n with self.tik_instance.for_range(0, 256) as num_index:\n self.tik_instance.vector_dup(8, index_256[num_index*8],\n w_index*256+num_index, 1, 1, 8)\n if self.half_pixel_centers:\n self.tik_instance.vadds(MASK, index_256, index_256, float(0.5),\n 32, 1, 1, 8, 8)\n self.tik_instance.vmuls(MASK, scale_512_x, index_256, float(self.weight_out),\n 32, 1, 1, 8, 8)\n self.tik_instance.vdiv(MASK, scale_512_x, scale_512_x, const_weight,\n 32, 1, 1, 1, 8, 8, 0)\n if self.half_pixel_centers:\n self.tik_instance.vadds(MASK, scale_512_x, scale_512_x, float(-0.5),\n 32, 1, 1, 8, 8)\n self.tik_instance.vmax(MASK, scale_512_x[0], scale_512_x[0], const_0[0],\n 32, 1, 1, 1, 8, 8, 0)\n self.tik_instance.vconv(MASK, \"floor\", int32_256_ub[0],\n scale_512_x[0], 32, 1, 1, 8, 8)\n self.tik_instance.vconv(MASK, \"\", scale_512_x[2048],\n int32_256_ub[0], 32, 1, 1, 8, 8)\n self.tik_instance.data_move(l1_xpos[w_index*256*8], int32_256_ub[0],\n 0, 1, 256, 0, 0)\n self.tik_instance.vsub(MASK, scale_512_x[2048],\n scale_512_x[0], scale_512_x[2048],\n 32, 1, 1, 1, 8, 8, 8)\n self.tik_instance.vsub(MASK, scale_512_x[0],\n const_1[0], scale_512_x[2048],\n 32, 1, 1, 1, 8, 0, 8)\n self.tik_instance.data_move(l1_xscale[w_index*512*8],\n scale_512_x[0], 0, 1, 512, 0, 0)","def smallestValue(self, nd1, nd2):\r\n minnd1 = min(nd1.values())\r\n minnd2 = min(nd2.values())\r\n totalmin = min(minnd1,minnd2)\r\n return totalmin","def get_map_sphere_variance(self, i_seq):\n return self._map_variances[i_seq]","def top_k_betweenness_centrality(self):\n d={}\n l=[]\n for v in vertices:\n a=self.betweenness_centrality(v)\n d[v]=a\n l.append(a)\n m=max(l)\n l1=[]\n for key in d:\n if d[key]==m:\n l1.append(key)\n\n return l1","def replace_x_y_nominal_lat_lon(ds):\n ds = ds.copy()\n if 'x' in ds.dims and 'y' in ds.dims:\n \n nominal_y = ds.lat.mean('x')\n # extract the equatorial lat and take those lon values as nominal lon\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\n nominal_x = ds.lon.isel(y=eq_ind)\n ds.coords['x'].data = nominal_x.data\n ds.coords['y'].data = nominal_y.data\n\n ds = ds.sortby('x')\n ds = ds.sortby('y')\n \n else:\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\n return ds","def merge_maps(self, map_2d):\n x = map_2d.data.max(0, keepdim=True)[0]\n y = map_2d.data.max(1, keepdim=True)[0]\n return x, y","def find_local_maxima(tens):\n return tf.squeeze(tf.where(tf.equal(label_local_extrema(tens), 'P')))","def get_location_metres(original_location, dNorth, dEast): \n [r_center, r_level] = eclipse_compensate(original_location)\n \n # coordinate offsets in radians\n dLat = dNorth / r_center\n dLon = dEast / r_level\n \n # new position in decimal degrees\n newlat = original_location.lat + math.degrees(dLat)\n newlon = original_location.lon + math.degrees(dLon)\n \n # return according to the input coordinate Class\n if isinstance(original_location,LocationGlobal):\n targetlocation = LocationGlobal(newlat, newlon,original_location.alt)\n \n elif isinstance(original_location,LocationGlobalRelative):\n targetlocation = LocationGlobalRelative(newlat, newlon,original_location.alt)\n \n else:\n raise Exception(\"Invalid Location object passed\")\n \n return targetlocation","def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\n # Get Value\n vrow = invar[kpt,:]\n \n # Place into variable\n mappt = np.zeros(nlat5*nlon5)*np.nan\n mappt[okpts] = vrow\n mappt = mappt.reshape(nlat5,nlon5)\n return mappt","def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \"north\"):\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n\n mlatA = self.mlatA[inds]\n mlatB = self.mlatB[inds]\n mlatC = self.mlatC[inds]\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 \n N = int((len(NeA)/n*2) - 1) #nr of windows\n \n dx = (secondsB[1]-secondsB[0])*self.velB[0]\n \n nBAs = []\n nBCs = []\n nACs = []\n \n for i in range(N):\n startind = int(i/2*n)\n stopind = int((i/2+1)*n)\n temp_NeA = NeA[startind:stopind]\n temp_NeB = NeB[startind:stopind]\n temp_NeC = NeC[startind:stopind]\n \n temp_secondsA = secondsA[startind:stopind]\n temp_secondsB = secondsB[startind:stopind]\n temp_secondsC = secondsC[startind:stopind]\n \n \n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\n if np.sum(curr_timediff) > 2:\n continue\n \n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\n \n if np.max(gradA) < 0.9:\n continue\n \n stdA = np.std(gradA)\n stdB = np.std(gradB)\n stdC = np.std(gradC)\n \n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\n \n p0A = [1, meanA, stdA]\n p0B = [1, meanB, stdB]\n p0C = [1, meanB, stdB]\n \n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\n \n nBA = poptB[1] - poptA[1]\n nBC = poptB[1] - poptC[1]\n nAC = poptA[1] - poptC[1]\n \n nBAs.append(nBA)\n nBCs.append(nBC)\n nACs.append(nAC)\n \n \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 V = self.velA[0]\n for i in range(len(nBAs)):\n VBA = self.along_track_velo(V, sBA, nBAs[i])\n VBC = self.along_track_velo(V, sBC, nBCs[i])\n VAC = self.along_track_velo(V, sAC, nACs[i])\n \n print(VBA)\n print(VBC)\n print(VAC)\n print(\"________________________________________\")","def max_min_distance(self, T0: SE3, T1: SE3, T2: SE3) -> (float, float, str):\n tol = 10e-10\n # T_rel_01 = T0.inv().dot(T1)\n T_rel_12 = T1.inv().dot(T2)\n\n p0 = T0.as_matrix()[0:3, 3]\n z1 = T1.as_matrix()[0:3, 2]\n x1 = T1.as_matrix()[0:3, 0]\n p1 = T1.as_matrix()[0:3, 3]\n p2 = T2.as_matrix()[0:3, 3]\n\n p0_proj = p0 - (z1.dot(p0 - p1)) * z1 # p0 projected onto T1 plane\n p2_proj = p2 - (z1.dot(p2 - p1)) * z1 # p2 projected onto T1 plane\n\n if norm(p1 - p0_proj) < tol or norm(p2_proj - p1) < tol:\n d = norm(T2.trans - T0.trans)\n return d, d, False\n\n r = norm(p2_proj - p1) # radius of circle p2_proj is on\n delta_th = arctan2(cross(x1, p2_proj - p1).dot(z1), np.dot(x1, p2_proj - p1))\n\n # closest and farthest point from p0_proj\n sol_1 = r * (p0_proj - p1) / norm(p0_proj - p1) + p1\n sol_2 = -r * (p0_proj - p1) / norm(p0_proj - p1) + p1\n sol_min = min(sol_1 - p0_proj, sol_2 - p0_proj, key=norm) + p0_proj\n sol_max = max(sol_1 - p0_proj, sol_2 - p0_proj, key=norm) + p0_proj\n\n th_max = arctan2(cross(x1, sol_max - p1).dot(z1), np.dot(x1, sol_max - p1))\n th_min = arctan2(cross(x1, sol_min - p1).dot(z1), np.dot(x1, sol_min - p1))\n\n rot_min = rot_axis(th_min - delta_th, \"z\")\n d_min = norm(T1.dot(rot_min).dot(T_rel_12).trans - T0.trans)\n\n rot_max = rot_axis(th_max - delta_th, \"z\")\n d_max = norm(T1.dot(rot_max).dot(T_rel_12).trans - T0.trans)\n\n if abs(th_max - delta_th) < tol and d_max > d_min:\n return d_max, d_min, \"below\"\n elif abs(th_min - delta_th) < tol and d_max > d_min:\n return d_max, d_min, \"above\"\n else:\n return d_max, d_min, False","def getMinMax(self,arr):\n minz=arr['zmg']-arr['sigma_pz']*5\n dmin=self.zcat-5*self.sigmacat\n minz[np.where(minz>dmin)]=dmin\n maxz=arr['zmg']+arr['sigma_pz']*5\n dax=self.zcat+5*self.sigmacat\n maxz[np.where(maxz<dmax)]=dmax\n return dmin,dmax","def _resolution(self):\n _, xres, _, _, _, yres = self.geotransform\n return xres, yres","def _coordinate_flex_vocabulary(obj, latname=None, lonname=None):\n if (latname is not None) or (lonname is not None):\n try:\n lat = obj[latname]\n lon = obj[lonname]\n except KeyError:\n raise LookupError\n\n if (np.size(lat) > 1) and (np.size(lon) > 1):\n lat = np.atleast_1d(lat)\n lon = np.atleast_1d(lon)\n return lat, lon\n\n vocab = [\n {\"lat\": \"LATITUDE\", \"lon\": \"LONGITUDE\"},\n {\"lat\": \"latitude\", \"lon\": \"longitude\"},\n {\"lat\": \"lat\", \"lon\": \"lon\"},\n {\"lat\": \"LAT\", \"lon\": \"LON\"},\n ]\n for v in vocab:\n try:\n lat = obj[v[\"lat\"]]\n lon = obj[v[\"lon\"]]\n if (np.size(lat) > 1) and (np.size(lon) > 1):\n lat = np.atleast_1d(lat)\n lon = np.atleast_1d(lon)\n return lat, lon\n except KeyError:\n pass\n raise LookupError","def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\n \n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## shortcut \n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\n #\n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n \n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def dist_sf( lon1, lon2, lat1, lat2 ):\n\n subfalla_i = (lon1, lat1)\n subfalla_j = (lon2, lat2)\n distancia = distance.distance( subfalla_i, subfalla_j ).meters\n\n return distancia","def mu_gm1m2(m1: float, m2: float) -> float:\n from astropy.constants import G\n\n return G * (m1 + m2)","def compute_max(self):\r\n self.x_max = self.ox + self.dx*self.nx\r\n self.y_max = self.oy + self.dy*self.ny\r\n self.z_max = self.oz + self.dz*self.nz","def geo(self):\n return vec2geo_linear_signed(self)","def measure(self, X1, X2, start_index): \n distance = self.distance\n X1 = np.array(X1)\n X2 = np.array(X2)\n vot = self.vot\n\n if vot == False:\n ep = self.ep\n else:\n try:\n ep = self.ep[start_index - self.initial]\n except:\n #sometime start_index is the length of the number \n ep = 0\n value = 1\n if len(X1)==0:\n value =0\n X1= np.zeros(5)\n X2 = X1\n M = np.zeros((len(X1), len(X2)))\n M[:, 0] = np.arange(len(X1))\n M[0, :] = np.arange(len(X1))\n for index_i in range(1, len(X1)):\n for index_j in range(len(X1) - index_i):\n\n L = []\n i = index_i\n j = index_i + index_j\n D = distance(X1[i], X2[j])\n if D < ep:\n M[i, j]= M[i-1, j-1]\n else:\n try:\n L.append(M[i-1, j-1])\n except:\n L.append(np.inf)\n try:\n L.append(M[i, j-1])\n except:\n L.append(np.inf)\n try:\n L.append(M[i-1, j])\n except:\n L.append(np.inf)\n M[i,j] = 1 + min(L)\n if i !=j:\n L = []\n j = index_i\n i = index_i + index_j\n D = distance(X1[i], X2[j])\n if D < ep:\n M[i, j]= M[i-1, j-1]\n else: \n try:\n L.append(M[i-1, j-1])\n except:\n L.append(np.inf)\n try:\n L.append(M[i, j-1])\n except:\n L.append(np.inf)\n try:\n L.append(M[i-1, j])\n except:\n L.append(np.inf)\n M[i,j] = 1 + min(L)\n\n score = M[len(X1)-1, len(X1)-1]/len(X1)\n if value == 0:\n score = 0\n self.decision_scores_.append((start_index, score))\n return score","def test_analysis_of_vector_data_top_N(self):\n\n for vectorname in ['test_buildings.shp',\n 'tsunami_building_exposure.shp']:\n\n filename = '%s/%s' % (TESTDATA, vectorname)\n layer = read_layer(filename)\n attributes = layer.get_data()\n\n # Check exceptions\n try:\n L = layer.get_topN(attribute='FLOOR_AREA', N=0)\n except VerificationError:\n pass\n else:\n msg = 'Exception should have been raised for N == 0'\n raise Exception(msg)\n\n # Check results\n for N in [5, 10, 11, 17]:\n if vectorname == 'test_buildings.shp':\n L = layer.get_topN(attribute='FLOOR_AREA', N=N)\n assert len(L) == N\n\n msg = ('Got projection %s, expected %s' %\n (L.projection, layer.projection))\n assert L.projection == layer.projection, msg\n #print [a['FLOOR_AREA'] for a in L.attributes]\n elif vectorname == 'tsunami_building_exposure.shp':\n L = layer.get_topN(attribute='STR_VALUE', N=N)\n assert len(L) == N\n assert L.get_projection() == layer.get_projection()\n val = [a['STR_VALUE'] for a in L.data]\n\n ref = [a['STR_VALUE'] for a in attributes]\n ref.sort()\n\n assert numpy.allclose(val, ref[-N:],\n atol=1.0e-12, rtol=1.0e-12)\n else:\n raise Exception","def part_distance(supervoxel_labels, supervoxel_locations, part_labels, patfront=None):\n p = part_labels\n xyz = {\"x\": 0, \"y\": 1, \"z\": 2}\n\n # number of additional\n num_parts = len(p)+1\n\n # variance of the additional\n part_var = {\"mean\": np.zeros((num_parts, 3)),\n \"var\": np.zeros((num_parts, 3)),\n \"mean_diff\": np.zeros((num_parts, num_parts, 3)),\n \"var_diff\": np.zeros((num_parts, num_parts, 3))}\n\n for pp in part_labels.keys():\n # calculate mean and variance of the part\n part_coords = supervoxel_locations[supervoxel_labels == p[pp], :]\n part_var[\"mean\"][p[pp], :] = np.mean(part_coords, axis=0)\n part_var[\"var\"][p[pp], :] = np.var(part_coords, axis=0)\n\n part_var[\"tumour\"] = {}\n part_var[\"part_var\"] = {}\n part_var[\"front\"] = {}\n part_var[\"uterus\"] = {}\n\n for key, value in xyz.iteritems():\n # 1) Mean\n # Tumour base: Mean x, y, z\n part_var[\"tumour\"][key] = np.around(part_var[\"mean\"][1:, value] - part_var[\"mean\"][p[\"tumour\"], value], 2)\n # 2) Variance in the part based on supervoxel locations (not currently used)\n # Tumour base: Variance x, y, z\n part_var[\"tumour\"][key + \"var\"] = np.around(part_var[\"var\"][1:, value] + part_var[\"var\"][p[\"tumour\"], value], 2)\n\n # 3) Part var\n # Variance in the part based on supervoxel locations (not currently used)\n # Tumour base: Variance x, y, z\n part_var[\"part_var\"][key] = np.around(part_var[\"var\"][1:, value], 2)\n\n # 4) Find patient front\n if patfront is not None:\n # Tumour base: Mean x, y, z\n part_var[\"front\"][key] = np.around(part_var[\"mean\"][1:, value] - patfront[value], 2)\n\n # 5) Distance from uterus\n if 'uterus' in p.keys():\n # 1) Mean\n # Tumour base: Mean x, y, z\n part_var[\"uterus\"][key] = np.around(part_var[\"mean\"][1:, value] - part_var[\"mean\"][p[\"uterus\"], value], 2)\n # 2) Variance in the part based on supervoxel locations (not currently used)\n # Tumour base: Variance x, y, z\n part_var[\"uterus\"][key + \"var\"] = np.around(part_var[\"var\"][1:, value] + part_var[\"var\"][p[\"uterus\"], value], 2)\n\n # Distance\n return part_var","def prolongation(kv1, kv2):\n g = kv2.greville()\n C1 = collocation(kv1, g).A\n C2 = collocation(kv2, g)\n P = scipy.sparse.linalg.spsolve(C2, C1)\n # prune matrix\n P[np.abs(P) < 1e-15] = 0.0\n return scipy.sparse.csr_matrix(P)","def zminmax ( self ) :\n return self.zvar.minmax()","def pointfind2(plat, plon, lat, lon, pdif=1):\n\n\tdist_min = 1000000.\n\t\n\t\n\tfor i in range(lon.shape[0]):\n\t\tfor j in range(lon.shape[1]):\n\t\t\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\n\t\t\tif dist_min > dist:\n\t\t\t\tdist_min = dist\n\t\t\t\ti_min = i\n\t\t\t\tj_min = j\n\t\t\t\tlat_min = lat[i,j]\n\t\t\t\tlon_min = lon[i,j]\n\t\n\tprint(i_min,j_min,lat_min,lon_min)\n\tgg1 = i_min, j_min\n\t\n\treturn(gg1, lat_min, lon_min)","def getInfo(dir, minlat, maxlat, minlon, maxlon):\n\n data_lon = Dataset(dir+'a1979/salidas/wrfout_c15d_d01_1979-12-28_00:00:00.a1979')\n LON = data_lon.variables['XLONG'][:]\n LAT = data_lon.variables['XLAT'][:]\n\n LON = LON[0][0]\n LAT = LAT[0]\n\n LONsize = len(LON)\n LATsize = len(LAT)\n celda = []\n var_cut = []\n result = ne(LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\n\n return result","def distTip(self,id1,id2):\n #productive #math\n profprint()\n node = slicer.mrmlScene.GetNodeByID('vtkMRMLModelNode'+str(id1))\n polydata=node.GetPolyData()\n node2 = slicer.mrmlScene.GetNodeByID('vtkMRMLModelNode'+str(id2))\n polydata2=node2.GetPolyData()\n p,pbis=[0,0,0],[0,0,0]\n p2=[0,0,0]\n p2bis=[0,0,0]\n axialDistance=[]\n for i in range(100):\n polydata.GetPoint(i,p)\n polydata.GetPoint(2499-i,pbis)\n if pbis[2]>p[2]:\n p=pbis\n polydata2.GetPoint(2499-i,p2)\n polydata2.GetPoint(i,p2bis)\n if p2bis[2]>p2[2]:\n p2=p2bis\n axialDistance.append((( p2[0]-p[0] )**2 + ( p2[1]-p[1] )**2 + (p2[2]-p[2])**2)**0.5)\n return min(axialDistance)","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 check_location_confidence(self):\n\t\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\n\t\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\n\t\tepsilon_meters = .08\n\t\tpixel_distances = []\n\t\tactual_distances = []\n\t\tnum_observed = 0\n\t\tfor ti in self.targs:\n\t\t\tif ti.props_are_set:\n\t\t\t\tfor tj in self.targs:\n\t\t\t\t\tif tj.props_are_set: \n\t\t\t\t\t\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\n\t\t\t\t\t\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\n\t\t\t\t\t\tif pixel_dist == 0:\n\t\t\t\t\t\t\tpixel_dist = 10000 #ignore two of the same points\n\t\t\t\t\t\t\tactual_dist = 10000\n\t\t\t\t\t\tpixel_distances.append(pixel_dist)\t\n\t\t\t\t\t\tactual_distances.append(actual_dist)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\t\tactual_distances.append(10000)\n\t\t\telse:\n\t\t\t\tfor _ in self.targs:\n\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\tactual_distances.append(10000)\n\t\tmin_ind_pixel = np.argmin(pixel_distances)\n\t\tmin_ind_actual = np.argmin(actual_distances)\n\t\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\n\t\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\n\t\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\n\t\t\t#measurements are not trustworthy, return nothing\n\t\t\treturn None\n\n\t\treturn best_guys","def build_coordinates_map(self):\n\t\t# We need to keep track of which dimensions we can map\n\t\tmapped = []\n\t\t\n\t\t# First lets check for standard 1D coordinate variables. These are variables\n\t\t# that have the same name as one of the variables dimensions or 1D variables\n\t\t# sharing a dimension with the variable \n\t\tfor di in range (0,len(self.variable.dimensions)):\n\n\t\t\tdimension = self.variable.dimensions[di]\n\t\t\tdim_name = dimension.name\n\n\t\t\t# Find variables with same name as the dimension\n\t\t\tif dim_name in self.variable.group.variables.keys():\n\n\t\t\t\tcoord_variable = self.variable.group.variables[dim_name]\n\t\t\t\tself.coordinates_variables.append(coord_variable)\n\t\t\t\tmapped.append(dim_name)\n\t\t\t\t\n\t\t\t\t# See if we can use the units to find out what spatial/temporal variable this is from \n\t\t\t\t# the CF conventions\n\t\t\t\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\n\t\t\t\t\n\t\t\t\t# If we can't we just default to the dimension name\n\t\t\t\tif not coordinate_name:\n\t\t\t\t\tcoordinate_name = dim_name\n\t\t\t\t\n\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\t\t\t\n\t\t\t\t\n\t\t# Next lets see if we have a \"coordinates\" attribute we can use (CF convention)\n\t\tif self.variable.get_attribute('coordinates'):\n\t\t\t\n\t\t\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\n\t\t\t\t\t\t\n\t\t\t# Find each associated variable\n\t\t\tfor name in self.coordinates_names:\n\t\t\t\t\n\t\t\t\tif name in self.variable.group.variables.keys():\n\t\t\t\t\t\n\t\t\t\t\tcoord_variable = self.variable.group.variables[name]\n\t\t\t\t\tself.coordinates_variables.append(coord_variable)\n\n\t\t\t\t\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\n\t\t\t\t\t# See if we can find out what spatial/temporal variable this is\n\t\t\t\t\ttry:\n\t\t\t\t\t\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\n\t\t\t\t\texcept:\n\t\t\t\t\t\tcoordinate_name = name\n\n\t\t\t\t\t# Create the coordinates_mapping entry but with an empty dimensions map for now\n\t\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\n\t\t\t\t\t\t\n\t\t\t\t\t# Add each coordinates variable dimension to the mappable list and generate the map\n\t\t\t\t\t#print 'generating dimensions map for ', coord_variable.dimensions\n\t\t\t\t\tfor dimension in coord_variable.dimensions:\n\t\t\t\t\t\t#print dimension, coord_variable.dimensions\n\t\t\t\t\t\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\n\t\t\t\t\t\tif not dimension.name in mapped:\n\t\t\t\t\t\t\tmapped.append(dimension.name)\n\t\t\t\t\t\t\t\n\t\t# Setup shortcut to identify time coordinate variable\n\t\ttry:\n\t\t\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\n\t\t\tself.time_dim = self.coordinates_mapping['time']['map'][0]\n\t\texcept:\n\t\t\tself.time_variable = None\n\t\t\tself.time_dim = None\n\t\t\t\n\t\t# Shortcuts for latitude and longitude coordinate variables\n\t\ttry:\n\t\t\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\n\t\texcept:\n\t\t\tself.latitude_variable = None\n\n\t\ttry:\n\t\t\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\n\t\texcept:\n\t\t\tself.longitude_variable = None\n\n\t\ttry:\n\t\t\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\n\t\t\tself.level_dim = self.coordinates_mapping['level']['map'][0]\n\t\texcept:\n\t\t\tself.level_variable = None\n\t\t\tself.level_dim = None","def calculateDistanceBetweenPoints(lat1,lon1,lat2,lon2):\n\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['s12']","def calculate_vars(data, lat, lon):\n # Keep track of running distance and time calculations\n distance_to_dest = 0.0\n time_estimate = 0.0\n\n # Calculate from starting dest to first point in data\n user_coords = (lat, lon)\n first_path_coords = (data[0][\"lat\"], data[0][\"lon\"])\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\n distance_to_dest += first_distance\n time_estimate += first_distance * 20 # 3mph walking speed\n\n # Calculate for all other points\n for i in range(1, len(data) - 1):\n this_coords = (data[i][\"lat\"], data[i][\"lon\"])\n next_coords = (data[i + 1][\"lat\"], data[i + 1][\"lon\"])\n\n distance = geopy.distance.distance(this_coords, next_coords).miles\n distance_to_dest += distance\n time_estimate += distance * 20 # 3mph walking speed\n\n # Round distance and time estimates\n distance_to_dest = round(distance_to_dest, 1)\n time_estimate = round(time_estimate)\n\n return distance_to_dest, time_estimate","def projection(v1, v2):\n v1 = v1.astype(np.float64)\n\n if np.any(v1):\n result = (np.dot(v1, v2) / np.dot(v1, v1)) * v1\n else:\n result = np.zeros(3)\n\n return result","def dist_sf_alt( lon1, lon2, lat1, lat2 ):\n\n dist = Geodesic.WGS84.Inverse( lat1, lon1, lat2, lon2 )[ \"s12\" ]\n \n return dist","def zmnmx ( self , xmin , xmax ) :\n return self.vmnmx ( self.zvar , zmin , zmax )","def stageData(self,m):\n obs = Variable(filename = self.source,\n variable_name = self.variable,\n alternate_vars = self.alternate_vars)\n if obs.time is None: raise il.NotTemporalVariable()\n self.pruneRegions(obs)\n \n # Try to extract a commensurate quantity from the model\n mod = m.extractTimeSeries(self.variable,\n alt_vars = self.alternate_vars,\n expression = self.derived,\n initial_time = obs.time_bnds[ 0,0],\n final_time = obs.time_bnds[-1,1],\n lats = None if obs.spatial else obs.lat,\n lons = None if obs.spatial else obs.lon)\n obs,mod = il.MakeComparable(obs,mod,\n mask_ref = True,\n clip_ref = True,\n extents = self.extents,\n logstring = \"[%s][%s]\" % (self.longname,m.name))\n \n # Check the order of magnitude of the data and convert to help avoid roundoff errors\n def _reduceRoundoffErrors(var):\n if \"s-1\" in var.unit: return var.convert(var.unit.replace(\"s-1\",\"d-1\"))\n if \"kg\" in var.unit: return var.convert(var.unit.replace(\"kg\" ,\"g\" ))\n return var\n def _getOrder(var):\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\n order = _getOrder(obs)\n count = 0\n while order < -2 and count < 2:\n obs = _reduceRoundoffErrors(obs)\n order = _getOrder(obs)\n count += 1\n \n # convert the model data to the same unit\n mod = mod.convert(obs.unit)\n\n return obs,mod","def test_coord_preceding_fs(self):","def mag2(self) -> numbers.Number:\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\n return mv_val[0]","def M(latitude):\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);","def a_test2_mh():\n model = ARIMAX(formula=\"y ~ x1 + x2\", data=data, ar=1, ma=1, family=Exponential())\n x = model.fit('M-H',nsims=300)\n assert(len(model.latent_variables.z_list) == 5)\n lvs = np.array([i.value for i in model.latent_variables.z_list])\n assert(len(lvs[np.isnan(lvs)]) == 0)","def minimum_distance(object_1, object_2):\n\n # package import\n import numpy as np\n\n # main algorithm\n minimum_distance = 100000\n\n for coord_1 in object_1:\n for coord_2 in object_2:\n distance_btwn_coords = np.linalg.norm(coord_1 - coord_2)\n if distance_btwn_coords == 0:\n minimum_distance = distance_btwn_coords\n return float(minimum_distance)\n elif distance_btwn_coords < minimum_distance:\n minimum_distance = distance_btwn_coords\n\n return float(minimum_distance)","def get_center_of_mass_allies(self,obs):","def coarsen_byavg(invar,lat,lon,deg,tol,latweight=True,verbose=True,ignorenan=False):\n\n # Make new Arrays\n lon5 = np.arange(0,360+deg,deg)\n lat5 = np.arange(-90,90+deg,deg)\n \n \n # Set up latitude weights\n if latweight:\n _,Y = np.meshgrid(lon,lat)\n wgt = np.cos(np.radians(Y)) # [lat x lon]\n invar *= wgt[None,:,:] # Multiply by latitude weight\n \n # Get time dimension and preallocate\n nt = invar.shape[0]\n outvar = np.zeros((nt,len(lat5),len(lon5)))\n \n # Loop and regrid\n i=0\n for o in range(len(lon5)):\n for a in range(len(lat5)):\n lonf = lon5[o]\n latf = lat5[a]\n \n lons = np.where((lon >= lonf-tol) & (lon <= lonf+tol))[0]\n lats = np.where((lat >= latf-tol) & (lat <= latf+tol))[0]\n \n varf = invar[:,lats[:,None],lons[None,:]]\n \n if latweight:\n wgtbox = wgt[lats[:,None],lons[None,:]]\n if ignorenan:\n varf = np.nansum(varf/np.nansum(wgtbox,(0,1)),(1,2)) # Divide by the total weight for the box\n else:\n varf = np.sum(varf/np.sum(wgtbox,(0,1)),(1,2)) # Divide by the total weight for the box\n \n \n else:\n if ignorenan: \n varf = np.nanmean(varf,axis=(1,2))\n else:\n varf = varf.mean((1,2))\n \n outvar[:,a,o] = varf.copy()\n i+= 1\n msg=\"\\rCompleted %i of %i\"% (i,len(lon5)*len(lat5))\n print(msg,end=\"\\r\",flush=True)\n return outvar,lat5,lon5","def spatial_expval(map_):\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * x), np.sum(map_ * y)","def localMin(eccMap, binSize):\r\n\r\n eccMap2 = np.array(eccMap)\r\n cutStep = np.arange(np.nanmin(eccMap2[:]) - binSize,\r\n np.nanmax(eccMap2[:]) + binSize * 2,\r\n binSize)\r\n NumOfMin = 0\r\n i = 0\r\n while (NumOfMin <= 1) and (i < len(cutStep)):\r\n currThr = cutStep[i]\r\n marker = np.zeros(eccMap.shape, dtype=np.int)\r\n marker[eccMap2 <= (currThr)] = 1\r\n marker, NumOfMin = ni.measurements.label(marker)\r\n i = i + 1\r\n\r\n # if NumOfMin == 1:\r\n # print 'Only one local minumum was found!!!'\r\n # elif NumOfMin == 0:\r\n # print 'No local minumum was found!!!'\r\n # else:\r\n # print str(NumOfMin) + ' local minuma were found!!!'\r\n #\r\n # if NumOfMin > 1:\r\n # plt.figure()\r\n # plt.imshow(marker,vmin=np.amin(marker), vmax=np.amax(marker),cmap='jet',interpolation='nearest')\r\n # plt.colorbar()\r\n # plt.title('marker from local min')\r\n\r\n return marker","def frechet_var_approx(dist_proj):\n return torch.mean(dist_proj ** 2).item()","def _calculate_location(self, map_4d):\n\n # MARGINALISE: Determining the 3-D coalescence map\n self.coa_map = np.log(np.sum(np.exp(map_4d), axis=-1))\n\n # Normalise\n self.coa_map = self.coa_map/np.max(self.coa_map)\n\n # Fit 3-D spline function to small window around max coalescence\n # location and interpolate to determine sub-grid maximum coalescence\n # location.\n loc_spline = self._splineloc(np.copy(self.coa_map))\n\n # Apply gaussian smoothing to small window around max coalescence\n # location and fit 3-D gaussian function to determine local\n # expectation location and uncertainty\n smoothed_coa_map = self._gaufilt3d(np.copy(self.coa_map))\n loc_gau, loc_gau_err = self._gaufit3d(np.copy(smoothed_coa_map),\n thresh=0.)\n\n # Calculate global covariance expected location and uncertainty\n loc_cov, loc_cov_err = self._covfit3d(np.copy(self.coa_map))\n\n return loc_spline, loc_gau, loc_gau_err, loc_cov, loc_cov_err","def Distance_orthonormique(lon1, lat1, lon2, lat2):\r\n \r\n #Convert position in radians\r\n lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\r\n #rvmT = Earth radius [km]\r\n rvmT = 6371 \r\n #Project the position on\r\n a = sin((lat2 - lat1)/2)**2 + cos(lat1) * cos(lat2) * sin((lon2 - lon1)/2)**2\r\n c = 2 * asin(sqrt(a)) \r\n \r\n d = c * rvmT\r\n return d","def extractvalues( locs: torch.tensor,\n x_os: torch.tensor,\n y_os: torch.tensor,\n z_os: torch.tensor,\n ints:torch.tensor, dim: int=3):\n\n dim = tuple([1 for i in range(dim)])\n coord = tuple(locs.nonzero().transpose(1,0))\n x_os_val = x_os[coord].reshape(-1, *dim)\n y_os_val = y_os[coord].reshape(-1, *dim)\n z_os_val = z_os[coord].reshape(-1, *dim)\n ints_val = ints[coord].reshape(-1, *dim)\n return x_os_val, y_os_val, z_os_val, ints_val","def calculate_zoom(self):\n distances = [geopy.distance.geodesic(self.centre_location, centroid).km for centroid in self.centroids]\n a = 4 / 20000\n distances = [1 + 4 - a * distance for distance in distances]\n print(min(distances))\n return min(distances)"],"string":"[\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def spatial_var(map_):\\n expx, expy = spatial_expval(map_)\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\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 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 coordExtrema(a):\\n # Extreme values of longitude and latitude in the survey.\\n longiMin = sp.inf\\n latMin = sp.inf\\n longiMax = -sp.inf\\n latMax = -sp.inf\\n for t in range(len(a)):\\n if a[t].pktCount > 0:\\n arraMin = sp.amin(a[t].longi)\\n if arraMin < longiMin:\\n longiMin = sp.amin(a[t].longi)\\n arraMin = sp.amin(a[t].lat)\\n if arraMin < latMin:\\n latMin = arraMin\\n arraMax = sp.amax(a[t].longi)\\n if arraMax > longiMax:\\n longiMax = arraMax\\n arraMax = sp.amax(a[t].lat)\\n if arraMax > latMax:\\n latMax = arraMax\\n\\n ext = cs.emptyClass()\\n ext.longiMin = longiMin\\n ext.longiMax = longiMax\\n ext.latMin = latMin\\n ext.latMax = latMax\\n return ext\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def find_area(self):\\n min_lat_point = self.latitude_min\\n max_lat_point = self.latitude_max\\n min_lon_point = self.longitude_min\\n max_lon_point = self.longitude_max\\n self.rename_latitude()\\n self.rename_longitude()\\n all_lat_bounds = self.cube.coord('latitude').bounds\\n all_lon_bounds = self.cube.coord('longitude').bounds\\n # print(all_lat_bounds)\\n # print(all_lon_bounds)\\n for i, lat in enumerate(all_lat_bounds):\\n for j, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= min_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= min_lon_point < lon_bounds[1]:\\n nlat_min = i\\n nlon_min = j\\n else:\\n pass\\n else:\\n pass\\n\\n for k, lat in enumerate(all_lat_bounds):\\n for l, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= max_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= max_lon_point < lon_bounds[1]:\\n nlat_max = k\\n nlon_max = l\\n else:\\n pass\\n else:\\n pass\\n\\n area_subset = self.cube[:, nlat_min:nlat_max+1, nlon_min:nlon_max+1]\\n # print(area_subset.coord('latitude').points)\\n # print(area_subset.coord('longitude').points)\\n area_mean = area_subset.collapsed(['latitude', 'longitude'],\\n iris.analysis.MEAN)\\n\\n return area_mean\",\n \"def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\\n\\n if var.ndim == 3: # 3D variable\\n zmax, imax, jmax = var.shape\\n threeD = True\\n elif var.ndim == 2: # 2D variable\\n imax, jmax = var.shape\\n threeD = False\\n else:\\n print 'extract_loc: check variable dimensions'\\n return\\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 # arrays to store weights and data to be averaged\\n if threeD: # 3D variable\\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var): # mask weights\\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\\n else:\\n dist_m = N.array(N.resize(dist,var.shape))\\n else: # 2D variable\\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var):\\n dist_m = MA.array(dist,mask=var.mask) # mask weights\\n else:\\n dist_m = N.array(dist)\\n\\n # get the 4 model grid points and compute weights\\n n = 0\\n for i in Ilist:\\n for j in Jlist:\\n wghts[...,n] = 1./dist_m[...,i,j]\\n data[...,n] = var[...,i,j]\\n n += 1\\n\\n # compute weighted average\\n wavg = MA.average(data,axis=-1,weights=wghts)\\n return wavg\",\n \"def spatial(self):\",\n \"def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\\n\\n geo_extent_vars = {}\\n geo_extent_units = []\\n\\n # variables must have units\\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\\n \\n geo_extent_vars[var.name] = 0\\n # units in this set\\n if var.units in possible_units:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n # standard name\\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n # axis of \\\"X\\\"\\n if hasattr(var, 'axis') and var.axis == axis_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n if var.name == std_name or var.name == short_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n\\n if len(geo_extent_vars) == 0:\\n return\\n\\n # filter out any zero scores\\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\\n\\n # sort by criteria passed\\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\\n\\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n # Let's just pick one\\n geo_vals = nc.variables[final_geo_vars[0][:]]\\n if geo_vals.size == 1:\\n obs_res = [0.0]\\n else:\\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n geo_min = round(float(min(obs_mins)), 5)\\n geo_max = round(float(max(obs_maxs)), 5)\\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\\n geo_res = \\\"{} {}\\\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\\n\\n print('<attribute name=\\\"geospatial_{}_min\\\" value=\\\"{}\\\" />'.format(short_name, geo_min))\\n print('<attribute name=\\\"geospatial_{}_max\\\" value=\\\"{}\\\" />'.format(short_name, geo_max))\\n print('<attribute name=\\\"geospatial_{}_resolution\\\" value=\\\"{}\\\" />'.format(short_name, geo_res))\\n print('<attribute name=\\\"geospatial_{}_units\\\" value=\\\"{}\\\" />'.format(short_name, geo_extent_units))\",\n \"def lat_lons(self):\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def mme_geo(samples, moment=1):\\n samples = samples ** moment\\n k = len(samples)\\n return ( k / np.sum(samples))\",\n \"def spatial_dimension(self):\\r\\n pass\",\n \"def nspatials(self):\\n return int(len(self)/2)\",\n \"def get_min_max(self):\\n\\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\\n mr[:] = np.max(mr)\\n\\n mxmin = self.mx - mr\\n mxmax = self.mx + mr\\n mymin = self.my - mr\\n mymax = self.my + mr\\n mzmin = self.mz - mr\\n mzmax = self.mz + mr\\n\\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\\n\\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\\n\\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\\n\\n return xmin, xmax, ymin, ymax, zmin, zmax\",\n \"def probaContagius(lat1,lon1,lat2,lon2,M):\\n GAMMA = 0.02\\n dlon = abs(lon2 - lon1) * 10000\\n dlat = abs(lat2 - lat1) * 10000\\n distance_Y = int(round(dlon, 0))\\n distance_X = int(round(dlat, 0))\\n proba = 0\\n if ( (distance_X>=0 and distance_X<300) and (distance_Y>=0 and distance_Y<300) ):\\n proba = GAMMA * M[distance_X][distance_Y]\\n return proba\",\n \"def getMinMax(self,arr):\\n # not implemented for Template SED yet\\n return arr[\\\"z\\\"], arr[\\\"z\\\"]\",\n \"def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\\n res=np.zeros((4),dtype=np.float64)\\n minLon=min_lon; maxLon=max_lon\\n\\n distances1 = []; distances2 = []\\n indices=[]; index=1\\n\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1 = []; distances2 = []; index=1\\n\\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n\\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\\n return res\",\n \"def avg_variables(ds1, ds2, lat, lon, z, p):\\r\\n \\r\\n T1 = ds1.temp.mean(dim='time').mean(dim='lon')\\r\\n T2 = ds2.temp.mean(dim='time').mean(dim='lon')\\r\\n T_avg = average(T1, T2, z, lat, 'lat', 'pfull', 'K')\\r\\n \\r\\n uz1 = ds1.ucomp.mean(dim='time').mean(dim='lon')\\r\\n uz2 = ds2.ucomp.mean(dim='time').mean(dim='lon')\\r\\n uz_avg = average(uz1, uz2, z, lat, 'lat', 'pfull', 'm/s')\\r\\n \\r\\n msf1 = v(ds1, p, lat)\\r\\n msf2 = v(ds2, p, lat)\\r\\n msf_avg = average(msf1, msf2, z, lat, 'lat', 'pfull', 'kg/s')\\r\\n \\r\\n return T_avg, uz_avg, msf_avg\",\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 get_min_max(self) -> tuple:\\r\\n\\r\\n minimum = float(\\\"inf\\\")\\r\\n maximum = float(\\\"-inf\\\")\\r\\n\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n if self.trees[name][\\\"point_helper\\\"] is None:\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n return minimum, maximum\",\n \"def find_longitude_var(nc,name):\\n var_obj = nc.variables[name] # Find the corresponding variable object \\n dimens = var_obj.dimensions # Find the names of the dimensions of variable\\n for i in range(len(dimens)):\\n # For each dimension find the corresponding variable\\n var_dim = nc.variables[dimens[i]]\\n if is_longitude_var(var_dim) == True:\\n return var_obj # If longitude exists, return the variable object\\n \\n return None\",\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 getShortestCoordinate (analyzer,startLat, startLon, endLat, endLon):\\n estacionOrigen=model.getCloserStation (analyzer, startLat, startLon)\\n estacionDestino=model.getCloserStation (analyzer, endLat, endLon)\\n ruta,tiempo=model.getShortestCoordinate(analyzer,estacionOrigen, estacionDestino)\\n return (estacionOrigen,estacionDestino,ruta,tiempo)\",\n \"def mlat_finder(self, lat1, lat0, pole = \\\"north\\\"):\\n\\n if pole == \\\"both\\\":\\n lowerA = np.abs(self.mlatA) < lat1\\n higherA = np.abs(self.mlatA) > lat0\\n is_poleA = lowerA * higherA\\n\\n elif pole == \\\"north\\\":\\n lowerA = (self.mlatA) < lat1\\n higherA = (self.mlatA) > lat0\\n is_poleA = lowerA * higherA\\n\\n elif pole == \\\"south\\\":\\n lowerA = (self.mlatA) > lat1\\n higherA = (self.mlatA) < lat0\\n is_poleA = lowerA * higherA\\n\\n high_lat_A = np.where(is_poleA == 1)\\n low_lat_A = np.where(is_poleA == 0)\\n indsA = [low_lat_A, high_lat_A]\\n\\n return indsA\",\n \"def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\\n\\n\\n if min_lon<0 and max_lon>0:\\n splitExtract = True; Turns=2\\n grdMODEL.splitExtract=splitExtract\\n else:\\n splitExtract = False; Turns=1\\n grdMODEL.splitExtract=splitExtract\\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\\n \\n # Array to store the results returned from the function\\n res=np.zeros((Turns,4),dtype=np.float64)\\n \\n lats=grdMODEL.lat[:,0]\\n lons=grdMODEL.lon[0,:]\\n\\n \\n for k in range(Turns):\\n\\n if k==0 and splitExtract == True:\\n minLon=min_lon; maxLon=0\\n minLon=minLon+360\\n maxLon=maxLon+360\\n elif k==1 and splitExtract == True:\\n minLon=0; maxLon=max_lon\\n else:\\n minLon=min_lon; maxLon=max_lon\\n \\n distances1 = []\\n distances2 = []\\n indices=[]\\n index=1\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n \\n distances1 = []\\n distances2 = []\\n index=1\\n \\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n \\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n \\n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n grdMODEL.indices=res\",\n \"def get_maxdistance_landmarktoPointcloud(self):\\n if len(self.subsetnodes) == 0: # Make sure tat the landmark set is already constructed.\\n self.select()\\n landmarktopointcloud_dist = self.getLandmark_Witness_matrix()\\n self.MaxMindist = np.nanmax(np.nanmin(landmarktopointcloud_dist, axis=0)) # Compute max of the min of each column\\n return self.MaxMindist\",\n \"def findNearset(x,y,lon,lat):\\n dist = np.sqrt( (lon - x)**2 + (lat - y)**2)\\n\\n return np.argwhere(dist==dist.min())[0][0]\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def getPoint(self, a):\\n lng = self.source.center.lng + (self.target.center.lng - self.source.center.lng) * min(a, 1)\\n lat = self.source.center.lat + (self.target.center.lat - self.source.center.lat) * min(a, 1)\\n return lng, lat\",\n \"def local_maxima_3D(data, order=3):\\n size = 1 + 2 * order\\n footprint = np.ones((size, size, size))\\n footprint[order, order, order] = 0\\n\\n filtered = ndi.maximum_filter(data, footprint=footprint)\\n mask_local_maxima = data > filtered\\n coords = np.asarray(np.where(mask_local_maxima)).T\\n values = data[mask_local_maxima]\\n\\n return coords, values\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_pool = cls.get_var_pool(data1_, data2_)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)\",\n \"def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_x = cls.get_var(data1_, is_population=True)\\n var_y = cls.get_var(data2_, is_population=True)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)\",\n \"def _projections(self, nvar):\\n min_var = self.proje_var.argsort()[:nvar]\\n add_coeffs = 1 / self.proje_var[min_var]\\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\\\\n np.sum(add_coeffs)\\n\\n # consider covariance\\n coverr = []\\n try:\\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\\n coverr.append(1/np.sum(proje_cov_inv))\\n except:\\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\\n cov_est_proje[:] = np.nan\\n coverr.append(np.nan)\\n return np.array([indp_est_proje, cov_est_proje])\",\n \"def get_var_pool(cls, data1: tuple, data2: tuple) -> float:\\n cls._data_validation(data1)\\n cls._data_validation(data2)\\n n1 = cls.get_n(data1)\\n var1 = cls.get_var(data1)\\n n2 = cls.get_n(data2)\\n var2 = cls.get_var(data2)\\n return ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2)\",\n \"def minimum_separation(lon1, lat1, lon2, lat2):\\n theta_min = np.empty_like(lon1)\\n\\n for i1 in range(lon1.size):\\n thetas = separation(lon1[i1], lat1[i1], lon2, lat2)\\n theta_min[i1] = thetas.min()\\n\\n return theta_min\",\n \"def test_spatial_smoothing_xesmf_reduce_spatial_dims_MPI_curv(\\r\\n PM_ds_control_3d_full,\\r\\n):\\r\\n da = PM_ds_control_3d_full\\r\\n step = 5\\r\\n actual = spatial_smoothing_xesmf(\\r\\n da,\\r\\n d_lon_lat_kws={\\\"lon\\\": step},\\r\\n )\\r\\n expected_lat_size = 180 // step\\r\\n assert actual[\\\"lon\\\"].size < da.lon.size\\r\\n assert actual[\\\"lat\\\"].size == expected_lat_size\",\n \"def calculate_min_max_tiles(self):\",\n \"def get_scale_local_maximas_vectorized(cube_coordinates, laplacian_cube):\\n x, y, z = [ cube_coordinates[:, ind] for ind in range(3) ]\\n \\n point_responses = laplacian_cube[x, y, z]\\n lowers = point_responses.copy()\\n uppers = point_responses.copy()\\n not_layer_0 = z > 0\\n lower_responses = laplacian_cube[x[not_layer_0], y[not_layer_0], z[not_layer_0]-1]\\n lowers[not_layer_0] = lower_responses \\n \\n not_max_layer = z < (laplacian_cube.shape[2] - 1)\\n upper_responses = laplacian_cube[x[not_max_layer], y[not_max_layer], z[not_max_layer]+1]\\n uppers[not_max_layer] = upper_responses\\n \\n lo_check = np.ones(z.shape, dtype=np.bool)\\n lo_check[not_layer_0] = (point_responses > lowers)[not_layer_0]\\n hi_check = np.ones(z.shape, dtype=np.bool)\\n hi_check[not_max_layer] = (point_responses > uppers)[not_max_layer]\\n \\n return cube_coordinates[lo_check & hi_check]\",\n \"def maks2(a, b, c):\\n m = a\\n if b > m:\\n m = b\\n if c > m:\\n m = c\\n \\n return m\",\n \"def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\\n\\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']\",\n \"def geo_m_v2(data_array):\\n r = 6378.137 #promien ziemi w km\\n delta = np.zeros(data_array.size//7-1)\\n alo = data_array[0][1]\\n ala = data_array[0][2]\\n count = 0\\n for row in data_array[1:]:\\n dLat = (row[2] - ala) * math.pi/180.0\\n dLon = (row[1] - alo) * math.pi/180.0\\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\\\\n * math.sin(dLon/2.0)**2\\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\\n count += 1\\n alo = row[1]\\n ala = row[2]\\n return delta\",\n \"def get_bounds(self):\\n\\n northing=self.f.variables['y']\\n easting=self.f.variables['x']\\n\\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\\n\\n return (lon1,lon2,lat1,lat2)\",\n \"def fun_location(self, l1_xpos, l1_xscale):\\n const_1 = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_1\\\",\\n scope=tik.scope_ubuf)\\n const_0 = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_0\\\",\\n scope=tik.scope_ubuf)\\n index_256 = self.tik_instance.Tensor(\\\"float32\\\", (256, 8),\\n name=\\\"index_256\\\",\\n scope=tik.scope_ubuf)\\n self.tik_instance.vector_dup(MASK, const_1, float(1), 1, 1, 8)\\n self.tik_instance.vector_dup(MASK, const_0, 0, 1, 1, 8)\\n int32_256_ub = self.tik_instance.Tensor(\\\"int32\\\", (256, 8),\\n name=\\\"int32_256_ub\\\",\\n scope=tik.scope_ubuf)\\n scale_512_x = self.tik_instance.Tensor(\\\"float32\\\", (512, 8),\\n name=\\\"scale_512_x\\\",\\n scope=tik.scope_ubuf)\\n const_weight = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_weight\\\",\\n scope=tik.scope_ubuf)\\n self.tik_instance.vector_dup(MASK, const_weight, float(self.weight_in), 1, 1, 8)\\n #x zuobiao\\n with self.tik_instance.for_range(0, self.w_in_loop) as w_index:\\n with self.tik_instance.for_range(0, 256) as num_index:\\n self.tik_instance.vector_dup(8, index_256[num_index*8],\\n w_index*256+num_index, 1, 1, 8)\\n if self.half_pixel_centers:\\n self.tik_instance.vadds(MASK, index_256, index_256, float(0.5),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vmuls(MASK, scale_512_x, index_256, float(self.weight_out),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vdiv(MASK, scale_512_x, scale_512_x, const_weight,\\n 32, 1, 1, 1, 8, 8, 0)\\n if self.half_pixel_centers:\\n self.tik_instance.vadds(MASK, scale_512_x, scale_512_x, float(-0.5),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vmax(MASK, scale_512_x[0], scale_512_x[0], const_0[0],\\n 32, 1, 1, 1, 8, 8, 0)\\n self.tik_instance.vconv(MASK, \\\"floor\\\", int32_256_ub[0],\\n scale_512_x[0], 32, 1, 1, 8, 8)\\n self.tik_instance.vconv(MASK, \\\"\\\", scale_512_x[2048],\\n int32_256_ub[0], 32, 1, 1, 8, 8)\\n self.tik_instance.data_move(l1_xpos[w_index*256*8], int32_256_ub[0],\\n 0, 1, 256, 0, 0)\\n self.tik_instance.vsub(MASK, scale_512_x[2048],\\n scale_512_x[0], scale_512_x[2048],\\n 32, 1, 1, 1, 8, 8, 8)\\n self.tik_instance.vsub(MASK, scale_512_x[0],\\n const_1[0], scale_512_x[2048],\\n 32, 1, 1, 1, 8, 0, 8)\\n self.tik_instance.data_move(l1_xscale[w_index*512*8],\\n scale_512_x[0], 0, 1, 512, 0, 0)\",\n \"def smallestValue(self, nd1, nd2):\\r\\n minnd1 = min(nd1.values())\\r\\n minnd2 = min(nd2.values())\\r\\n totalmin = min(minnd1,minnd2)\\r\\n return totalmin\",\n \"def get_map_sphere_variance(self, i_seq):\\n return self._map_variances[i_seq]\",\n \"def top_k_betweenness_centrality(self):\\n d={}\\n l=[]\\n for v in vertices:\\n a=self.betweenness_centrality(v)\\n d[v]=a\\n l.append(a)\\n m=max(l)\\n l1=[]\\n for key in d:\\n if d[key]==m:\\n l1.append(key)\\n\\n return l1\",\n \"def replace_x_y_nominal_lat_lon(ds):\\n ds = ds.copy()\\n if 'x' in ds.dims and 'y' in ds.dims:\\n \\n nominal_y = ds.lat.mean('x')\\n # extract the equatorial lat and take those lon values as nominal lon\\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\\n nominal_x = ds.lon.isel(y=eq_ind)\\n ds.coords['x'].data = nominal_x.data\\n ds.coords['y'].data = nominal_y.data\\n\\n ds = ds.sortby('x')\\n ds = ds.sortby('y')\\n \\n else:\\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\\n return ds\",\n \"def merge_maps(self, map_2d):\\n x = map_2d.data.max(0, keepdim=True)[0]\\n y = map_2d.data.max(1, keepdim=True)[0]\\n return x, y\",\n \"def find_local_maxima(tens):\\n return tf.squeeze(tf.where(tf.equal(label_local_extrema(tens), 'P')))\",\n \"def get_location_metres(original_location, dNorth, dEast): \\n [r_center, r_level] = eclipse_compensate(original_location)\\n \\n # coordinate offsets in radians\\n dLat = dNorth / r_center\\n dLon = dEast / r_level\\n \\n # new position in decimal degrees\\n newlat = original_location.lat + math.degrees(dLat)\\n newlon = original_location.lon + math.degrees(dLon)\\n \\n # return according to the input coordinate Class\\n if isinstance(original_location,LocationGlobal):\\n targetlocation = LocationGlobal(newlat, newlon,original_location.alt)\\n \\n elif isinstance(original_location,LocationGlobalRelative):\\n targetlocation = LocationGlobalRelative(newlat, newlon,original_location.alt)\\n \\n else:\\n raise Exception(\\\"Invalid Location object passed\\\")\\n \\n return targetlocation\",\n \"def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\\n # Get Value\\n vrow = invar[kpt,:]\\n \\n # Place into variable\\n mappt = np.zeros(nlat5*nlon5)*np.nan\\n mappt[okpts] = vrow\\n mappt = mappt.reshape(nlat5,nlon5)\\n return mappt\",\n \"def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \\\"north\\\"):\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n\\n mlatA = self.mlatA[inds]\\n mlatB = self.mlatB[inds]\\n mlatC = self.mlatC[inds]\\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 \\n N = int((len(NeA)/n*2) - 1) #nr of windows\\n \\n dx = (secondsB[1]-secondsB[0])*self.velB[0]\\n \\n nBAs = []\\n nBCs = []\\n nACs = []\\n \\n for i in range(N):\\n startind = int(i/2*n)\\n stopind = int((i/2+1)*n)\\n temp_NeA = NeA[startind:stopind]\\n temp_NeB = NeB[startind:stopind]\\n temp_NeC = NeC[startind:stopind]\\n \\n temp_secondsA = secondsA[startind:stopind]\\n temp_secondsB = secondsB[startind:stopind]\\n temp_secondsC = secondsC[startind:stopind]\\n \\n \\n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\\n if np.sum(curr_timediff) > 2:\\n continue\\n \\n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\\n \\n if np.max(gradA) < 0.9:\\n continue\\n \\n stdA = np.std(gradA)\\n stdB = np.std(gradB)\\n stdC = np.std(gradC)\\n \\n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\\n \\n p0A = [1, meanA, stdA]\\n p0B = [1, meanB, stdB]\\n p0C = [1, meanB, stdB]\\n \\n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\\n \\n nBA = poptB[1] - poptA[1]\\n nBC = poptB[1] - poptC[1]\\n nAC = poptA[1] - poptC[1]\\n \\n nBAs.append(nBA)\\n nBCs.append(nBC)\\n nACs.append(nAC)\\n \\n \\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 V = self.velA[0]\\n for i in range(len(nBAs)):\\n VBA = self.along_track_velo(V, sBA, nBAs[i])\\n VBC = self.along_track_velo(V, sBC, nBCs[i])\\n VAC = self.along_track_velo(V, sAC, nACs[i])\\n \\n print(VBA)\\n print(VBC)\\n print(VAC)\\n print(\\\"________________________________________\\\")\",\n \"def max_min_distance(self, T0: SE3, T1: SE3, T2: SE3) -> (float, float, str):\\n tol = 10e-10\\n # T_rel_01 = T0.inv().dot(T1)\\n T_rel_12 = T1.inv().dot(T2)\\n\\n p0 = T0.as_matrix()[0:3, 3]\\n z1 = T1.as_matrix()[0:3, 2]\\n x1 = T1.as_matrix()[0:3, 0]\\n p1 = T1.as_matrix()[0:3, 3]\\n p2 = T2.as_matrix()[0:3, 3]\\n\\n p0_proj = p0 - (z1.dot(p0 - p1)) * z1 # p0 projected onto T1 plane\\n p2_proj = p2 - (z1.dot(p2 - p1)) * z1 # p2 projected onto T1 plane\\n\\n if norm(p1 - p0_proj) < tol or norm(p2_proj - p1) < tol:\\n d = norm(T2.trans - T0.trans)\\n return d, d, False\\n\\n r = norm(p2_proj - p1) # radius of circle p2_proj is on\\n delta_th = arctan2(cross(x1, p2_proj - p1).dot(z1), np.dot(x1, p2_proj - p1))\\n\\n # closest and farthest point from p0_proj\\n sol_1 = r * (p0_proj - p1) / norm(p0_proj - p1) + p1\\n sol_2 = -r * (p0_proj - p1) / norm(p0_proj - p1) + p1\\n sol_min = min(sol_1 - p0_proj, sol_2 - p0_proj, key=norm) + p0_proj\\n sol_max = max(sol_1 - p0_proj, sol_2 - p0_proj, key=norm) + p0_proj\\n\\n th_max = arctan2(cross(x1, sol_max - p1).dot(z1), np.dot(x1, sol_max - p1))\\n th_min = arctan2(cross(x1, sol_min - p1).dot(z1), np.dot(x1, sol_min - p1))\\n\\n rot_min = rot_axis(th_min - delta_th, \\\"z\\\")\\n d_min = norm(T1.dot(rot_min).dot(T_rel_12).trans - T0.trans)\\n\\n rot_max = rot_axis(th_max - delta_th, \\\"z\\\")\\n d_max = norm(T1.dot(rot_max).dot(T_rel_12).trans - T0.trans)\\n\\n if abs(th_max - delta_th) < tol and d_max > d_min:\\n return d_max, d_min, \\\"below\\\"\\n elif abs(th_min - delta_th) < tol and d_max > d_min:\\n return d_max, d_min, \\\"above\\\"\\n else:\\n return d_max, d_min, False\",\n \"def getMinMax(self,arr):\\n minz=arr['zmg']-arr['sigma_pz']*5\\n dmin=self.zcat-5*self.sigmacat\\n minz[np.where(minz>dmin)]=dmin\\n maxz=arr['zmg']+arr['sigma_pz']*5\\n dax=self.zcat+5*self.sigmacat\\n maxz[np.where(maxz<dmax)]=dmax\\n return dmin,dmax\",\n \"def _resolution(self):\\n _, xres, _, _, _, yres = self.geotransform\\n return xres, yres\",\n \"def _coordinate_flex_vocabulary(obj, latname=None, lonname=None):\\n if (latname is not None) or (lonname is not None):\\n try:\\n lat = obj[latname]\\n lon = obj[lonname]\\n except KeyError:\\n raise LookupError\\n\\n if (np.size(lat) > 1) and (np.size(lon) > 1):\\n lat = np.atleast_1d(lat)\\n lon = np.atleast_1d(lon)\\n return lat, lon\\n\\n vocab = [\\n {\\\"lat\\\": \\\"LATITUDE\\\", \\\"lon\\\": \\\"LONGITUDE\\\"},\\n {\\\"lat\\\": \\\"latitude\\\", \\\"lon\\\": \\\"longitude\\\"},\\n {\\\"lat\\\": \\\"lat\\\", \\\"lon\\\": \\\"lon\\\"},\\n {\\\"lat\\\": \\\"LAT\\\", \\\"lon\\\": \\\"LON\\\"},\\n ]\\n for v in vocab:\\n try:\\n lat = obj[v[\\\"lat\\\"]]\\n lon = obj[v[\\\"lon\\\"]]\\n if (np.size(lat) > 1) and (np.size(lon) > 1):\\n lat = np.atleast_1d(lat)\\n lon = np.atleast_1d(lon)\\n return lat, lon\\n except KeyError:\\n pass\\n raise LookupError\",\n \"def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\\n \\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## shortcut \\n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\\n #\\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n \\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def dist_sf( lon1, lon2, lat1, lat2 ):\\n\\n subfalla_i = (lon1, lat1)\\n subfalla_j = (lon2, lat2)\\n distancia = distance.distance( subfalla_i, subfalla_j ).meters\\n\\n return distancia\",\n \"def mu_gm1m2(m1: float, m2: float) -> float:\\n from astropy.constants import G\\n\\n return G * (m1 + m2)\",\n \"def compute_max(self):\\r\\n self.x_max = self.ox + self.dx*self.nx\\r\\n self.y_max = self.oy + self.dy*self.ny\\r\\n self.z_max = self.oz + self.dz*self.nz\",\n \"def geo(self):\\n return vec2geo_linear_signed(self)\",\n \"def measure(self, X1, X2, start_index): \\n distance = self.distance\\n X1 = np.array(X1)\\n X2 = np.array(X2)\\n vot = self.vot\\n\\n if vot == False:\\n ep = self.ep\\n else:\\n try:\\n ep = self.ep[start_index - self.initial]\\n except:\\n #sometime start_index is the length of the number \\n ep = 0\\n value = 1\\n if len(X1)==0:\\n value =0\\n X1= np.zeros(5)\\n X2 = X1\\n M = np.zeros((len(X1), len(X2)))\\n M[:, 0] = np.arange(len(X1))\\n M[0, :] = np.arange(len(X1))\\n for index_i in range(1, len(X1)):\\n for index_j in range(len(X1) - index_i):\\n\\n L = []\\n i = index_i\\n j = index_i + index_j\\n D = distance(X1[i], X2[j])\\n if D < ep:\\n M[i, j]= M[i-1, j-1]\\n else:\\n try:\\n L.append(M[i-1, j-1])\\n except:\\n L.append(np.inf)\\n try:\\n L.append(M[i, j-1])\\n except:\\n L.append(np.inf)\\n try:\\n L.append(M[i-1, j])\\n except:\\n L.append(np.inf)\\n M[i,j] = 1 + min(L)\\n if i !=j:\\n L = []\\n j = index_i\\n i = index_i + index_j\\n D = distance(X1[i], X2[j])\\n if D < ep:\\n M[i, j]= M[i-1, j-1]\\n else: \\n try:\\n L.append(M[i-1, j-1])\\n except:\\n L.append(np.inf)\\n try:\\n L.append(M[i, j-1])\\n except:\\n L.append(np.inf)\\n try:\\n L.append(M[i-1, j])\\n except:\\n L.append(np.inf)\\n M[i,j] = 1 + min(L)\\n\\n score = M[len(X1)-1, len(X1)-1]/len(X1)\\n if value == 0:\\n score = 0\\n self.decision_scores_.append((start_index, score))\\n return score\",\n \"def test_analysis_of_vector_data_top_N(self):\\n\\n for vectorname in ['test_buildings.shp',\\n 'tsunami_building_exposure.shp']:\\n\\n filename = '%s/%s' % (TESTDATA, vectorname)\\n layer = read_layer(filename)\\n attributes = layer.get_data()\\n\\n # Check exceptions\\n try:\\n L = layer.get_topN(attribute='FLOOR_AREA', N=0)\\n except VerificationError:\\n pass\\n else:\\n msg = 'Exception should have been raised for N == 0'\\n raise Exception(msg)\\n\\n # Check results\\n for N in [5, 10, 11, 17]:\\n if vectorname == 'test_buildings.shp':\\n L = layer.get_topN(attribute='FLOOR_AREA', N=N)\\n assert len(L) == N\\n\\n msg = ('Got projection %s, expected %s' %\\n (L.projection, layer.projection))\\n assert L.projection == layer.projection, msg\\n #print [a['FLOOR_AREA'] for a in L.attributes]\\n elif vectorname == 'tsunami_building_exposure.shp':\\n L = layer.get_topN(attribute='STR_VALUE', N=N)\\n assert len(L) == N\\n assert L.get_projection() == layer.get_projection()\\n val = [a['STR_VALUE'] for a in L.data]\\n\\n ref = [a['STR_VALUE'] for a in attributes]\\n ref.sort()\\n\\n assert numpy.allclose(val, ref[-N:],\\n atol=1.0e-12, rtol=1.0e-12)\\n else:\\n raise Exception\",\n \"def part_distance(supervoxel_labels, supervoxel_locations, part_labels, patfront=None):\\n p = part_labels\\n xyz = {\\\"x\\\": 0, \\\"y\\\": 1, \\\"z\\\": 2}\\n\\n # number of additional\\n num_parts = len(p)+1\\n\\n # variance of the additional\\n part_var = {\\\"mean\\\": np.zeros((num_parts, 3)),\\n \\\"var\\\": np.zeros((num_parts, 3)),\\n \\\"mean_diff\\\": np.zeros((num_parts, num_parts, 3)),\\n \\\"var_diff\\\": np.zeros((num_parts, num_parts, 3))}\\n\\n for pp in part_labels.keys():\\n # calculate mean and variance of the part\\n part_coords = supervoxel_locations[supervoxel_labels == p[pp], :]\\n part_var[\\\"mean\\\"][p[pp], :] = np.mean(part_coords, axis=0)\\n part_var[\\\"var\\\"][p[pp], :] = np.var(part_coords, axis=0)\\n\\n part_var[\\\"tumour\\\"] = {}\\n part_var[\\\"part_var\\\"] = {}\\n part_var[\\\"front\\\"] = {}\\n part_var[\\\"uterus\\\"] = {}\\n\\n for key, value in xyz.iteritems():\\n # 1) Mean\\n # Tumour base: Mean x, y, z\\n part_var[\\\"tumour\\\"][key] = np.around(part_var[\\\"mean\\\"][1:, value] - part_var[\\\"mean\\\"][p[\\\"tumour\\\"], value], 2)\\n # 2) Variance in the part based on supervoxel locations (not currently used)\\n # Tumour base: Variance x, y, z\\n part_var[\\\"tumour\\\"][key + \\\"var\\\"] = np.around(part_var[\\\"var\\\"][1:, value] + part_var[\\\"var\\\"][p[\\\"tumour\\\"], value], 2)\\n\\n # 3) Part var\\n # Variance in the part based on supervoxel locations (not currently used)\\n # Tumour base: Variance x, y, z\\n part_var[\\\"part_var\\\"][key] = np.around(part_var[\\\"var\\\"][1:, value], 2)\\n\\n # 4) Find patient front\\n if patfront is not None:\\n # Tumour base: Mean x, y, z\\n part_var[\\\"front\\\"][key] = np.around(part_var[\\\"mean\\\"][1:, value] - patfront[value], 2)\\n\\n # 5) Distance from uterus\\n if 'uterus' in p.keys():\\n # 1) Mean\\n # Tumour base: Mean x, y, z\\n part_var[\\\"uterus\\\"][key] = np.around(part_var[\\\"mean\\\"][1:, value] - part_var[\\\"mean\\\"][p[\\\"uterus\\\"], value], 2)\\n # 2) Variance in the part based on supervoxel locations (not currently used)\\n # Tumour base: Variance x, y, z\\n part_var[\\\"uterus\\\"][key + \\\"var\\\"] = np.around(part_var[\\\"var\\\"][1:, value] + part_var[\\\"var\\\"][p[\\\"uterus\\\"], value], 2)\\n\\n # Distance\\n return part_var\",\n \"def prolongation(kv1, kv2):\\n g = kv2.greville()\\n C1 = collocation(kv1, g).A\\n C2 = collocation(kv2, g)\\n P = scipy.sparse.linalg.spsolve(C2, C1)\\n # prune matrix\\n P[np.abs(P) < 1e-15] = 0.0\\n return scipy.sparse.csr_matrix(P)\",\n \"def zminmax ( self ) :\\n return self.zvar.minmax()\",\n \"def pointfind2(plat, plon, lat, lon, pdif=1):\\n\\n\\tdist_min = 1000000.\\n\\t\\n\\t\\n\\tfor i in range(lon.shape[0]):\\n\\t\\tfor j in range(lon.shape[1]):\\n\\t\\t\\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\\n\\t\\t\\tif dist_min > dist:\\n\\t\\t\\t\\tdist_min = dist\\n\\t\\t\\t\\ti_min = i\\n\\t\\t\\t\\tj_min = j\\n\\t\\t\\t\\tlat_min = lat[i,j]\\n\\t\\t\\t\\tlon_min = lon[i,j]\\n\\t\\n\\tprint(i_min,j_min,lat_min,lon_min)\\n\\tgg1 = i_min, j_min\\n\\t\\n\\treturn(gg1, lat_min, lon_min)\",\n \"def getInfo(dir, minlat, maxlat, minlon, maxlon):\\n\\n data_lon = Dataset(dir+'a1979/salidas/wrfout_c15d_d01_1979-12-28_00:00:00.a1979')\\n LON = data_lon.variables['XLONG'][:]\\n LAT = data_lon.variables['XLAT'][:]\\n\\n LON = LON[0][0]\\n LAT = LAT[0]\\n\\n LONsize = len(LON)\\n LATsize = len(LAT)\\n celda = []\\n var_cut = []\\n result = ne(LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\\n\\n return result\",\n \"def distTip(self,id1,id2):\\n #productive #math\\n profprint()\\n node = slicer.mrmlScene.GetNodeByID('vtkMRMLModelNode'+str(id1))\\n polydata=node.GetPolyData()\\n node2 = slicer.mrmlScene.GetNodeByID('vtkMRMLModelNode'+str(id2))\\n polydata2=node2.GetPolyData()\\n p,pbis=[0,0,0],[0,0,0]\\n p2=[0,0,0]\\n p2bis=[0,0,0]\\n axialDistance=[]\\n for i in range(100):\\n polydata.GetPoint(i,p)\\n polydata.GetPoint(2499-i,pbis)\\n if pbis[2]>p[2]:\\n p=pbis\\n polydata2.GetPoint(2499-i,p2)\\n polydata2.GetPoint(i,p2bis)\\n if p2bis[2]>p2[2]:\\n p2=p2bis\\n axialDistance.append((( p2[0]-p[0] )**2 + ( p2[1]-p[1] )**2 + (p2[2]-p[2])**2)**0.5)\\n return min(axialDistance)\",\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 check_location_confidence(self):\\n\\t\\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\\n\\t\\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\\n\\t\\tepsilon_meters = .08\\n\\t\\tpixel_distances = []\\n\\t\\tactual_distances = []\\n\\t\\tnum_observed = 0\\n\\t\\tfor ti in self.targs:\\n\\t\\t\\tif ti.props_are_set:\\n\\t\\t\\t\\tfor tj in self.targs:\\n\\t\\t\\t\\t\\tif tj.props_are_set: \\n\\t\\t\\t\\t\\t\\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\\n\\t\\t\\t\\t\\t\\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\\n\\t\\t\\t\\t\\t\\tif pixel_dist == 0:\\n\\t\\t\\t\\t\\t\\t\\tpixel_dist = 10000 #ignore two of the same points\\n\\t\\t\\t\\t\\t\\t\\tactual_dist = 10000\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(pixel_dist)\\t\\n\\t\\t\\t\\t\\t\\tactual_distances.append(actual_dist)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor _ in self.targs:\\n\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\tmin_ind_pixel = np.argmin(pixel_distances)\\n\\t\\tmin_ind_actual = np.argmin(actual_distances)\\n\\t\\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\\n\\t\\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\\n\\t\\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\\n\\t\\t\\t#measurements are not trustworthy, return nothing\\n\\t\\t\\treturn None\\n\\n\\t\\treturn best_guys\",\n \"def build_coordinates_map(self):\\n\\t\\t# We need to keep track of which dimensions we can map\\n\\t\\tmapped = []\\n\\t\\t\\n\\t\\t# First lets check for standard 1D coordinate variables. These are variables\\n\\t\\t# that have the same name as one of the variables dimensions or 1D variables\\n\\t\\t# sharing a dimension with the variable \\n\\t\\tfor di in range (0,len(self.variable.dimensions)):\\n\\n\\t\\t\\tdimension = self.variable.dimensions[di]\\n\\t\\t\\tdim_name = dimension.name\\n\\n\\t\\t\\t# Find variables with same name as the dimension\\n\\t\\t\\tif dim_name in self.variable.group.variables.keys():\\n\\n\\t\\t\\t\\tcoord_variable = self.variable.group.variables[dim_name]\\n\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\t\\t\\t\\tmapped.append(dim_name)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# See if we can use the units to find out what spatial/temporal variable this is from \\n\\t\\t\\t\\t# the CF conventions\\n\\t\\t\\t\\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If we can't we just default to the dimension name\\n\\t\\t\\t\\tif not coordinate_name:\\n\\t\\t\\t\\t\\tcoordinate_name = dim_name\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t# Next lets see if we have a \\\"coordinates\\\" attribute we can use (CF convention)\\n\\t\\tif self.variable.get_attribute('coordinates'):\\n\\t\\t\\t\\n\\t\\t\\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# Find each associated variable\\n\\t\\t\\tfor name in self.coordinates_names:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif name in self.variable.group.variables.keys():\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tcoord_variable = self.variable.group.variables[name]\\n\\t\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\n\\t\\t\\t\\t\\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\\n\\t\\t\\t\\t\\t# See if we can find out what spatial/temporal variable this is\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = name\\n\\n\\t\\t\\t\\t\\t# Create the coordinates_mapping entry but with an empty dimensions map for now\\n\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Add each coordinates variable dimension to the mappable list and generate the map\\n\\t\\t\\t\\t\\t#print 'generating dimensions map for ', coord_variable.dimensions\\n\\t\\t\\t\\t\\tfor dimension in coord_variable.dimensions:\\n\\t\\t\\t\\t\\t\\t#print dimension, coord_variable.dimensions\\n\\t\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\\n\\t\\t\\t\\t\\t\\tif not dimension.name in mapped:\\n\\t\\t\\t\\t\\t\\t\\tmapped.append(dimension.name)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t# Setup shortcut to identify time coordinate variable\\n\\t\\ttry:\\n\\t\\t\\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\\n\\t\\t\\tself.time_dim = self.coordinates_mapping['time']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.time_variable = None\\n\\t\\t\\tself.time_dim = None\\n\\t\\t\\t\\n\\t\\t# Shortcuts for latitude and longitude coordinate variables\\n\\t\\ttry:\\n\\t\\t\\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.latitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.longitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\\n\\t\\t\\tself.level_dim = self.coordinates_mapping['level']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.level_variable = None\\n\\t\\t\\tself.level_dim = None\",\n \"def calculateDistanceBetweenPoints(lat1,lon1,lat2,lon2):\\n\\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['s12']\",\n \"def calculate_vars(data, lat, lon):\\n # Keep track of running distance and time calculations\\n distance_to_dest = 0.0\\n time_estimate = 0.0\\n\\n # Calculate from starting dest to first point in data\\n user_coords = (lat, lon)\\n first_path_coords = (data[0][\\\"lat\\\"], data[0][\\\"lon\\\"])\\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\\n distance_to_dest += first_distance\\n time_estimate += first_distance * 20 # 3mph walking speed\\n\\n # Calculate for all other points\\n for i in range(1, len(data) - 1):\\n this_coords = (data[i][\\\"lat\\\"], data[i][\\\"lon\\\"])\\n next_coords = (data[i + 1][\\\"lat\\\"], data[i + 1][\\\"lon\\\"])\\n\\n distance = geopy.distance.distance(this_coords, next_coords).miles\\n distance_to_dest += distance\\n time_estimate += distance * 20 # 3mph walking speed\\n\\n # Round distance and time estimates\\n distance_to_dest = round(distance_to_dest, 1)\\n time_estimate = round(time_estimate)\\n\\n return distance_to_dest, time_estimate\",\n \"def projection(v1, v2):\\n v1 = v1.astype(np.float64)\\n\\n if np.any(v1):\\n result = (np.dot(v1, v2) / np.dot(v1, v1)) * v1\\n else:\\n result = np.zeros(3)\\n\\n return result\",\n \"def dist_sf_alt( lon1, lon2, lat1, lat2 ):\\n\\n dist = Geodesic.WGS84.Inverse( lat1, lon1, lat2, lon2 )[ \\\"s12\\\" ]\\n \\n return dist\",\n \"def zmnmx ( self , xmin , xmax ) :\\n return self.vmnmx ( self.zvar , zmin , zmax )\",\n \"def stageData(self,m):\\n obs = Variable(filename = self.source,\\n variable_name = self.variable,\\n alternate_vars = self.alternate_vars)\\n if obs.time is None: raise il.NotTemporalVariable()\\n self.pruneRegions(obs)\\n \\n # Try to extract a commensurate quantity from the model\\n mod = m.extractTimeSeries(self.variable,\\n alt_vars = self.alternate_vars,\\n expression = self.derived,\\n initial_time = obs.time_bnds[ 0,0],\\n final_time = obs.time_bnds[-1,1],\\n lats = None if obs.spatial else obs.lat,\\n lons = None if obs.spatial else obs.lon)\\n obs,mod = il.MakeComparable(obs,mod,\\n mask_ref = True,\\n clip_ref = True,\\n extents = self.extents,\\n logstring = \\\"[%s][%s]\\\" % (self.longname,m.name))\\n \\n # Check the order of magnitude of the data and convert to help avoid roundoff errors\\n def _reduceRoundoffErrors(var):\\n if \\\"s-1\\\" in var.unit: return var.convert(var.unit.replace(\\\"s-1\\\",\\\"d-1\\\"))\\n if \\\"kg\\\" in var.unit: return var.convert(var.unit.replace(\\\"kg\\\" ,\\\"g\\\" ))\\n return var\\n def _getOrder(var):\\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\\n order = _getOrder(obs)\\n count = 0\\n while order < -2 and count < 2:\\n obs = _reduceRoundoffErrors(obs)\\n order = _getOrder(obs)\\n count += 1\\n \\n # convert the model data to the same unit\\n mod = mod.convert(obs.unit)\\n\\n return obs,mod\",\n \"def test_coord_preceding_fs(self):\",\n \"def mag2(self) -> numbers.Number:\\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\\n return mv_val[0]\",\n \"def M(latitude):\\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);\",\n \"def a_test2_mh():\\n model = ARIMAX(formula=\\\"y ~ x1 + x2\\\", data=data, ar=1, ma=1, family=Exponential())\\n x = model.fit('M-H',nsims=300)\\n assert(len(model.latent_variables.z_list) == 5)\\n lvs = np.array([i.value for i in model.latent_variables.z_list])\\n assert(len(lvs[np.isnan(lvs)]) == 0)\",\n \"def minimum_distance(object_1, object_2):\\n\\n # package import\\n import numpy as np\\n\\n # main algorithm\\n minimum_distance = 100000\\n\\n for coord_1 in object_1:\\n for coord_2 in object_2:\\n distance_btwn_coords = np.linalg.norm(coord_1 - coord_2)\\n if distance_btwn_coords == 0:\\n minimum_distance = distance_btwn_coords\\n return float(minimum_distance)\\n elif distance_btwn_coords < minimum_distance:\\n minimum_distance = distance_btwn_coords\\n\\n return float(minimum_distance)\",\n \"def get_center_of_mass_allies(self,obs):\",\n \"def coarsen_byavg(invar,lat,lon,deg,tol,latweight=True,verbose=True,ignorenan=False):\\n\\n # Make new Arrays\\n lon5 = np.arange(0,360+deg,deg)\\n lat5 = np.arange(-90,90+deg,deg)\\n \\n \\n # Set up latitude weights\\n if latweight:\\n _,Y = np.meshgrid(lon,lat)\\n wgt = np.cos(np.radians(Y)) # [lat x lon]\\n invar *= wgt[None,:,:] # Multiply by latitude weight\\n \\n # Get time dimension and preallocate\\n nt = invar.shape[0]\\n outvar = np.zeros((nt,len(lat5),len(lon5)))\\n \\n # Loop and regrid\\n i=0\\n for o in range(len(lon5)):\\n for a in range(len(lat5)):\\n lonf = lon5[o]\\n latf = lat5[a]\\n \\n lons = np.where((lon >= lonf-tol) & (lon <= lonf+tol))[0]\\n lats = np.where((lat >= latf-tol) & (lat <= latf+tol))[0]\\n \\n varf = invar[:,lats[:,None],lons[None,:]]\\n \\n if latweight:\\n wgtbox = wgt[lats[:,None],lons[None,:]]\\n if ignorenan:\\n varf = np.nansum(varf/np.nansum(wgtbox,(0,1)),(1,2)) # Divide by the total weight for the box\\n else:\\n varf = np.sum(varf/np.sum(wgtbox,(0,1)),(1,2)) # Divide by the total weight for the box\\n \\n \\n else:\\n if ignorenan: \\n varf = np.nanmean(varf,axis=(1,2))\\n else:\\n varf = varf.mean((1,2))\\n \\n outvar[:,a,o] = varf.copy()\\n i+= 1\\n msg=\\\"\\\\rCompleted %i of %i\\\"% (i,len(lon5)*len(lat5))\\n print(msg,end=\\\"\\\\r\\\",flush=True)\\n return outvar,lat5,lon5\",\n \"def spatial_expval(map_):\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * x), np.sum(map_ * y)\",\n \"def localMin(eccMap, binSize):\\r\\n\\r\\n eccMap2 = np.array(eccMap)\\r\\n cutStep = np.arange(np.nanmin(eccMap2[:]) - binSize,\\r\\n np.nanmax(eccMap2[:]) + binSize * 2,\\r\\n binSize)\\r\\n NumOfMin = 0\\r\\n i = 0\\r\\n while (NumOfMin <= 1) and (i < len(cutStep)):\\r\\n currThr = cutStep[i]\\r\\n marker = np.zeros(eccMap.shape, dtype=np.int)\\r\\n marker[eccMap2 <= (currThr)] = 1\\r\\n marker, NumOfMin = ni.measurements.label(marker)\\r\\n i = i + 1\\r\\n\\r\\n # if NumOfMin == 1:\\r\\n # print 'Only one local minumum was found!!!'\\r\\n # elif NumOfMin == 0:\\r\\n # print 'No local minumum was found!!!'\\r\\n # else:\\r\\n # print str(NumOfMin) + ' local minuma were found!!!'\\r\\n #\\r\\n # if NumOfMin > 1:\\r\\n # plt.figure()\\r\\n # plt.imshow(marker,vmin=np.amin(marker), vmax=np.amax(marker),cmap='jet',interpolation='nearest')\\r\\n # plt.colorbar()\\r\\n # plt.title('marker from local min')\\r\\n\\r\\n return marker\",\n \"def frechet_var_approx(dist_proj):\\n return torch.mean(dist_proj ** 2).item()\",\n \"def _calculate_location(self, map_4d):\\n\\n # MARGINALISE: Determining the 3-D coalescence map\\n self.coa_map = np.log(np.sum(np.exp(map_4d), axis=-1))\\n\\n # Normalise\\n self.coa_map = self.coa_map/np.max(self.coa_map)\\n\\n # Fit 3-D spline function to small window around max coalescence\\n # location and interpolate to determine sub-grid maximum coalescence\\n # location.\\n loc_spline = self._splineloc(np.copy(self.coa_map))\\n\\n # Apply gaussian smoothing to small window around max coalescence\\n # location and fit 3-D gaussian function to determine local\\n # expectation location and uncertainty\\n smoothed_coa_map = self._gaufilt3d(np.copy(self.coa_map))\\n loc_gau, loc_gau_err = self._gaufit3d(np.copy(smoothed_coa_map),\\n thresh=0.)\\n\\n # Calculate global covariance expected location and uncertainty\\n loc_cov, loc_cov_err = self._covfit3d(np.copy(self.coa_map))\\n\\n return loc_spline, loc_gau, loc_gau_err, loc_cov, loc_cov_err\",\n \"def Distance_orthonormique(lon1, lat1, lon2, lat2):\\r\\n \\r\\n #Convert position in radians\\r\\n lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\\r\\n #rvmT = Earth radius [km]\\r\\n rvmT = 6371 \\r\\n #Project the position on\\r\\n a = sin((lat2 - lat1)/2)**2 + cos(lat1) * cos(lat2) * sin((lon2 - lon1)/2)**2\\r\\n c = 2 * asin(sqrt(a)) \\r\\n \\r\\n d = c * rvmT\\r\\n return d\",\n \"def extractvalues( locs: torch.tensor,\\n x_os: torch.tensor,\\n y_os: torch.tensor,\\n z_os: torch.tensor,\\n ints:torch.tensor, dim: int=3):\\n\\n dim = tuple([1 for i in range(dim)])\\n coord = tuple(locs.nonzero().transpose(1,0))\\n x_os_val = x_os[coord].reshape(-1, *dim)\\n y_os_val = y_os[coord].reshape(-1, *dim)\\n z_os_val = z_os[coord].reshape(-1, *dim)\\n ints_val = ints[coord].reshape(-1, *dim)\\n return x_os_val, y_os_val, z_os_val, ints_val\",\n \"def calculate_zoom(self):\\n distances = [geopy.distance.geodesic(self.centre_location, centroid).km for centroid in self.centroids]\\n a = 4 / 20000\\n distances = [1 + 4 - a * distance for distance in distances]\\n print(min(distances))\\n return min(distances)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69351184","0.62349105","0.6094042","0.5838326","0.5824384","0.58051234","0.57359993","0.5527261","0.5517576","0.5458443","0.54356056","0.5415327","0.54134643","0.54001105","0.5361201","0.52343124","0.52035445","0.51936215","0.5187855","0.51732856","0.5172442","0.51652145","0.51572615","0.51517236","0.514668","0.51264614","0.5120579","0.51170605","0.5116207","0.5109469","0.51092273","0.50503546","0.50478095","0.5046783","0.5044952","0.503331","0.50225","0.5013744","0.50095075","0.50045425","0.5004418","0.49885496","0.4986544","0.49726576","0.4945402","0.4941345","0.4935779","0.49355325","0.4929325","0.4919793","0.49189553","0.49148226","0.49137524","0.49035853","0.49006802","0.48972994","0.4896231","0.48960233","0.4893838","0.48927078","0.48925483","0.48908195","0.48853981","0.48780054","0.48755315","0.48709327","0.4868559","0.48677847","0.48663","0.48654133","0.4863724","0.48629832","0.4855868","0.48533118","0.4843247","0.48416024","0.48404658","0.48367113","0.48314506","0.482891","0.48219028","0.48165742","0.48154524","0.48151082","0.48150915","0.4810657","0.4809578","0.48083106","0.4807408","0.4804954","0.48011348","0.47984424","0.4797659","0.47957903","0.47944352","0.4787829","0.47787178","0.477027","0.47693527","0.47683597"],"string":"[\n \"0.69351184\",\n \"0.62349105\",\n \"0.6094042\",\n \"0.5838326\",\n \"0.5824384\",\n \"0.58051234\",\n \"0.57359993\",\n \"0.5527261\",\n \"0.5517576\",\n \"0.5458443\",\n \"0.54356056\",\n \"0.5415327\",\n \"0.54134643\",\n \"0.54001105\",\n \"0.5361201\",\n \"0.52343124\",\n \"0.52035445\",\n \"0.51936215\",\n \"0.5187855\",\n \"0.51732856\",\n \"0.5172442\",\n \"0.51652145\",\n \"0.51572615\",\n \"0.51517236\",\n \"0.514668\",\n \"0.51264614\",\n \"0.5120579\",\n \"0.51170605\",\n \"0.5116207\",\n \"0.5109469\",\n \"0.51092273\",\n \"0.50503546\",\n \"0.50478095\",\n \"0.5046783\",\n \"0.5044952\",\n \"0.503331\",\n \"0.50225\",\n \"0.5013744\",\n \"0.50095075\",\n \"0.50045425\",\n \"0.5004418\",\n \"0.49885496\",\n \"0.4986544\",\n \"0.49726576\",\n \"0.4945402\",\n \"0.4941345\",\n \"0.4935779\",\n \"0.49355325\",\n \"0.4929325\",\n \"0.4919793\",\n \"0.49189553\",\n \"0.49148226\",\n \"0.49137524\",\n \"0.49035853\",\n \"0.49006802\",\n \"0.48972994\",\n \"0.4896231\",\n \"0.48960233\",\n \"0.4893838\",\n \"0.48927078\",\n \"0.48925483\",\n \"0.48908195\",\n \"0.48853981\",\n \"0.48780054\",\n \"0.48755315\",\n \"0.48709327\",\n \"0.4868559\",\n \"0.48677847\",\n \"0.48663\",\n \"0.48654133\",\n \"0.4863724\",\n \"0.48629832\",\n \"0.4855868\",\n \"0.48533118\",\n \"0.4843247\",\n \"0.48416024\",\n \"0.48404658\",\n \"0.48367113\",\n \"0.48314506\",\n \"0.482891\",\n \"0.48219028\",\n \"0.48165742\",\n \"0.48154524\",\n \"0.48151082\",\n \"0.48150915\",\n \"0.4810657\",\n \"0.4809578\",\n \"0.48083106\",\n \"0.4807408\",\n \"0.4804954\",\n \"0.48011348\",\n \"0.47984424\",\n \"0.4797659\",\n \"0.47957903\",\n \"0.47944352\",\n \"0.4787829\",\n \"0.47787178\",\n \"0.477027\",\n \"0.47693527\",\n \"0.47683597\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73494667"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19880,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest longitude points but whose values are the longitudes"},"document":{"kind":"string","value":"def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv"},"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 latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def find_longitude_var(nc,name):\n var_obj = nc.variables[name] # Find the corresponding variable object \n dimens = var_obj.dimensions # Find the names of the dimensions of variable\n for i in range(len(dimens)):\n # For each dimension find the corresponding variable\n var_dim = nc.variables[dimens[i]]\n if is_longitude_var(var_dim) == True:\n return var_obj # If longitude exists, return the variable object\n \n return None","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def spatial_var(map_):\n expx, expy = spatial_expval(map_)\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def find_area(self):\n min_lat_point = self.latitude_min\n max_lat_point = self.latitude_max\n min_lon_point = self.longitude_min\n max_lon_point = self.longitude_max\n self.rename_latitude()\n self.rename_longitude()\n all_lat_bounds = self.cube.coord('latitude').bounds\n all_lon_bounds = self.cube.coord('longitude').bounds\n # print(all_lat_bounds)\n # print(all_lon_bounds)\n for i, lat in enumerate(all_lat_bounds):\n for j, lon in enumerate(all_lon_bounds):\n lat_bounds = lat # 2D array of the lower and upper lat bounds\n lon_bounds = lon # 2D array of the lower and upper lon bounds\n if lat_bounds[0] <= min_lat_point < lat_bounds[1]:\n if lon_bounds[0] <= min_lon_point < lon_bounds[1]:\n nlat_min = i\n nlon_min = j\n else:\n pass\n else:\n pass\n\n for k, lat in enumerate(all_lat_bounds):\n for l, lon in enumerate(all_lon_bounds):\n lat_bounds = lat # 2D array of the lower and upper lat bounds\n lon_bounds = lon # 2D array of the lower and upper lon bounds\n if lat_bounds[0] <= max_lat_point < lat_bounds[1]:\n if lon_bounds[0] <= max_lon_point < lon_bounds[1]:\n nlat_max = k\n nlon_max = l\n else:\n pass\n else:\n pass\n\n area_subset = self.cube[:, nlat_min:nlat_max+1, nlon_min:nlon_max+1]\n # print(area_subset.coord('latitude').points)\n # print(area_subset.coord('longitude').points)\n area_mean = area_subset.collapsed(['latitude', 'longitude'],\n iris.analysis.MEAN)\n\n return area_mean","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 lat_lons(self):","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","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 coordExtrema(a):\n # Extreme values of longitude and latitude in the survey.\n longiMin = sp.inf\n latMin = sp.inf\n longiMax = -sp.inf\n latMax = -sp.inf\n for t in range(len(a)):\n if a[t].pktCount > 0:\n arraMin = sp.amin(a[t].longi)\n if arraMin < longiMin:\n longiMin = sp.amin(a[t].longi)\n arraMin = sp.amin(a[t].lat)\n if arraMin < latMin:\n latMin = arraMin\n arraMax = sp.amax(a[t].longi)\n if arraMax > longiMax:\n longiMax = arraMax\n arraMax = sp.amax(a[t].lat)\n if arraMax > latMax:\n latMax = arraMax\n\n ext = cs.emptyClass()\n ext.longiMin = longiMin\n ext.longiMax = longiMax\n ext.latMin = latMin\n ext.latMax = latMax\n return ext","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def local_maxima_3D(data, order=3):\n size = 1 + 2 * order\n footprint = np.ones((size, size, size))\n footprint[order, order, order] = 0\n\n filtered = ndi.maximum_filter(data, footprint=footprint)\n mask_local_maxima = data > filtered\n coords = np.asarray(np.where(mask_local_maxima)).T\n values = data[mask_local_maxima]\n\n return coords, values","def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\n\n if var.ndim == 3: # 3D variable\n zmax, imax, jmax = var.shape\n threeD = True\n elif var.ndim == 2: # 2D variable\n imax, jmax = var.shape\n threeD = False\n else:\n print 'extract_loc: check variable dimensions'\n return\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 # arrays to store weights and data to be averaged\n if threeD: # 3D variable\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\n if MA.isMA(var): # mask weights\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\n else:\n dist_m = N.array(N.resize(dist,var.shape))\n else: # 2D variable\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\n if MA.isMA(var):\n dist_m = MA.array(dist,mask=var.mask) # mask weights\n else:\n dist_m = N.array(dist)\n\n # get the 4 model grid points and compute weights\n n = 0\n for i in Ilist:\n for j in Jlist:\n wghts[...,n] = 1./dist_m[...,i,j]\n data[...,n] = var[...,i,j]\n n += 1\n\n # compute weighted average\n wavg = MA.average(data,axis=-1,weights=wghts)\n return wavg","def get_scale_local_maximas_vectorized(cube_coordinates, laplacian_cube):\n x, y, z = [ cube_coordinates[:, ind] for ind in range(3) ]\n \n point_responses = laplacian_cube[x, y, z]\n lowers = point_responses.copy()\n uppers = point_responses.copy()\n not_layer_0 = z > 0\n lower_responses = laplacian_cube[x[not_layer_0], y[not_layer_0], z[not_layer_0]-1]\n lowers[not_layer_0] = lower_responses \n \n not_max_layer = z < (laplacian_cube.shape[2] - 1)\n upper_responses = laplacian_cube[x[not_max_layer], y[not_max_layer], z[not_max_layer]+1]\n uppers[not_max_layer] = upper_responses\n \n lo_check = np.ones(z.shape, dtype=np.bool)\n lo_check[not_layer_0] = (point_responses > lowers)[not_layer_0]\n hi_check = np.ones(z.shape, dtype=np.bool)\n hi_check[not_max_layer] = (point_responses > uppers)[not_max_layer]\n \n return cube_coordinates[lo_check & hi_check]","def get_bounds(self):\n\n northing=self.f.variables['y']\n easting=self.f.variables['x']\n\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\n\n return (lon1,lon2,lat1,lat2)","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 findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\n res=np.zeros((4),dtype=np.float64)\n minLon=min_lon; maxLon=max_lon\n\n distances1 = []; distances2 = []\n indices=[]; index=1\n\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1 = []; distances2 = []; index=1\n\n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\n return res","def moonlongitude(time):\n B0 = 481267.8809\n C0 = 218.3162\n # fmt: off\n A = np.array([62888.e-4, 12740.e-4, 6583.e-4, 2136.e-4, 1851.e-4, \\\n 1144.e-4, 588.e-4, 571.e-4, 533.e-4, 458.e-4, 409.e-4, \\\n 347.e-4, 304.e-4, 154.e-4, 125.e-4, 110.e-4, 107.e-4, \\\n 100.e-4, 85.e-4, 79.e-4, 68.e-4, 52.e-4, 50.e-4, 40.e-4, \\\n 40.e-4, 40.e-4, 38.e-4, 37.e-4, 28.e-4, 27.e-4, 26.e-4, \\\n 24.e-4, 23.e-4, 22.e-4, 21.e-4, 21.e-4, 21.e-4, 18.e-4, \\\n 16.e-4, 12.e-4, 11.e-4, 9.e-4, 8.e-4, 7.e-4, 7.e-4, \\\n 7.e-4, 7.e-4, 6.e-4, 6.e-4, 5.e-4, 5.e-4, 5.e-4, \\\n 4.e-4, 4.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, \\\n 3.e-4, 3.e-4])\n B = np.array([477198.868, 413335.35, 890534.22, 954397.74, \\\n 35999.05, 966404.0, 63863.5, 377336.3, \\\n 1367733.1, 854535.2, 441199.8, 445267.1, \\\n 513197.9, 75870, 1443603, 489205, 1303870, \\\n 1431597, 826671, 449334, 926533, 31932, \\\n 481266, 1331734, 1844932, 133, 1781068, \\\n 541062, 1934, 918399, 1379739, 99863, \\\n 922466, 818536, 990397, 71998, 341337, \\\n 401329, 1856938, 1267871, 1920802, 858602, \\\n 1403732, 790672, 405201, 485333, 27864, \\\n 111869, 2258267, 1908795, 1745069, 509131, \\\n 39871, 12006, 958465, 381404, 349472, \\\n 1808933, 549197, 4067, 2322131.])\n C = np.array([44.963, 10.74, 145.70, 179.93, 87.53, 276.5, \\\n 124.2, 13.2, 280.7, 148.2, 47.4, 27.9, 222.5, \\\n 41, 52, 142, 246, 315, 111, 188, \\\n 323, 107, 205, 283, 56, 29, 21, \\\n 259, 145, 182, 17, 122, 163, 151, \\\n 357, 85, 16, 274, 152, 249, 186, \\\n 129, 98, 114, 50, 186, 127, 38, \\\n 156, 90, 24, 242, 223, 187, 340, \\\n 354, 337, 58, 220, 70, 191])\n # fmt: on\n RAD = 0.0174532925199433\n tempb = (B * time + C) * RAD\n amp = A * np.cos(tempb)\n moonlon = np.sum(amp)\n moonlon = (moonlon + B0 * time + C0) * RAD\n return moonlon","def geo_m_v2(data_array):\n r = 6378.137 #promien ziemi w km\n delta = np.zeros(data_array.size//7-1)\n alo = data_array[0][1]\n ala = data_array[0][2]\n count = 0\n for row in data_array[1:]:\n dLat = (row[2] - ala) * math.pi/180.0\n dLon = (row[1] - alo) * math.pi/180.0\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\n * math.sin(dLon/2.0)**2\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\n count += 1\n alo = row[1]\n ala = row[2]\n return delta","def merge_maps(self, map_2d):\n x = map_2d.data.max(0, keepdim=True)[0]\n y = map_2d.data.max(1, keepdim=True)[0]\n return x, y","def mlat_finder(self, lat1, lat0, pole = \"north\"):\n\n if pole == \"both\":\n lowerA = np.abs(self.mlatA) < lat1\n higherA = np.abs(self.mlatA) > lat0\n is_poleA = lowerA * higherA\n\n elif pole == \"north\":\n lowerA = (self.mlatA) < lat1\n higherA = (self.mlatA) > lat0\n is_poleA = lowerA * higherA\n\n elif pole == \"south\":\n lowerA = (self.mlatA) > lat1\n higherA = (self.mlatA) < lat0\n is_poleA = lowerA * higherA\n\n high_lat_A = np.where(is_poleA == 1)\n low_lat_A = np.where(is_poleA == 0)\n indsA = [low_lat_A, high_lat_A]\n\n return indsA","def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\n\n geo_extent_vars = {}\n geo_extent_units = []\n\n # variables must have units\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\n \n geo_extent_vars[var.name] = 0\n # units in this set\n if var.units in possible_units:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n # standard name\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n # axis of \"X\"\n if hasattr(var, 'axis') and var.axis == axis_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n if var.name == std_name or var.name == short_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n\n if len(geo_extent_vars) == 0:\n return\n\n # filter out any zero scores\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\n\n # sort by criteria passed\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\n\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n # Let's just pick one\n geo_vals = nc.variables[final_geo_vars[0][:]]\n if geo_vals.size == 1:\n obs_res = [0.0]\n else:\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n geo_min = round(float(min(obs_mins)), 5)\n geo_max = round(float(max(obs_maxs)), 5)\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\n geo_res = \"{} {}\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\n\n print('<attribute name=\"geospatial_{}_min\" value=\"{}\" />'.format(short_name, geo_min))\n print('<attribute name=\"geospatial_{}_max\" value=\"{}\" />'.format(short_name, geo_max))\n print('<attribute name=\"geospatial_{}_resolution\" value=\"{}\" />'.format(short_name, geo_res))\n print('<attribute name=\"geospatial_{}_units\" value=\"{}\" />'.format(short_name, geo_extent_units))","def get_location_metres(original_location, dNorth, dEast): \n [r_center, r_level] = eclipse_compensate(original_location)\n \n # coordinate offsets in radians\n dLat = dNorth / r_center\n dLon = dEast / r_level\n \n # new position in decimal degrees\n newlat = original_location.lat + math.degrees(dLat)\n newlon = original_location.lon + math.degrees(dLon)\n \n # return according to the input coordinate Class\n if isinstance(original_location,LocationGlobal):\n targetlocation = LocationGlobal(newlat, newlon,original_location.alt)\n \n elif isinstance(original_location,LocationGlobalRelative):\n targetlocation = LocationGlobalRelative(newlat, newlon,original_location.alt)\n \n else:\n raise Exception(\"Invalid Location object passed\")\n \n return targetlocation","def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_x = cls.get_var(data1_, is_population=True)\n var_y = cls.get_var(data2_, is_population=True)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)","def find_local_maxima(tens):\n return tf.squeeze(tf.where(tf.equal(label_local_extrema(tens), 'P')))","def get_min_max(self):\n\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\n mr[:] = np.max(mr)\n\n mxmin = self.mx - mr\n mxmax = self.mx + mr\n mymin = self.my - mr\n mymax = self.my + mr\n mzmin = self.mz - mr\n mzmax = self.mz + mr\n\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\n\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\n\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\n\n return xmin, xmax, ymin, ymax, zmin, zmax","def mme_geo(samples, moment=1):\n samples = samples ** moment\n k = len(samples)\n return ( k / np.sum(samples))","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 reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def spatial(self):","def getMinMax(self,arr):\n # not implemented for Template SED yet\n return arr[\"z\"], arr[\"z\"]","def getInfo(dir, minlat, maxlat, minlon, maxlon):\n\n data_lon = Dataset(dir+'a1979/salidas/wrfout_c15d_d01_1979-12-28_00:00:00.a1979')\n LON = data_lon.variables['XLONG'][:]\n LAT = data_lon.variables['XLAT'][:]\n\n LON = LON[0][0]\n LAT = LAT[0]\n\n LONsize = len(LON)\n LATsize = len(LAT)\n celda = []\n var_cut = []\n result = ne(LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\n\n return result","def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_pool = cls.get_var_pool(data1_, data2_)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)","def build_coordinates_map(self):\n\t\t# We need to keep track of which dimensions we can map\n\t\tmapped = []\n\t\t\n\t\t# First lets check for standard 1D coordinate variables. These are variables\n\t\t# that have the same name as one of the variables dimensions or 1D variables\n\t\t# sharing a dimension with the variable \n\t\tfor di in range (0,len(self.variable.dimensions)):\n\n\t\t\tdimension = self.variable.dimensions[di]\n\t\t\tdim_name = dimension.name\n\n\t\t\t# Find variables with same name as the dimension\n\t\t\tif dim_name in self.variable.group.variables.keys():\n\n\t\t\t\tcoord_variable = self.variable.group.variables[dim_name]\n\t\t\t\tself.coordinates_variables.append(coord_variable)\n\t\t\t\tmapped.append(dim_name)\n\t\t\t\t\n\t\t\t\t# See if we can use the units to find out what spatial/temporal variable this is from \n\t\t\t\t# the CF conventions\n\t\t\t\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\n\t\t\t\t\n\t\t\t\t# If we can't we just default to the dimension name\n\t\t\t\tif not coordinate_name:\n\t\t\t\t\tcoordinate_name = dim_name\n\t\t\t\t\n\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\t\t\t\n\t\t\t\t\n\t\t# Next lets see if we have a \"coordinates\" attribute we can use (CF convention)\n\t\tif self.variable.get_attribute('coordinates'):\n\t\t\t\n\t\t\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\n\t\t\t\t\t\t\n\t\t\t# Find each associated variable\n\t\t\tfor name in self.coordinates_names:\n\t\t\t\t\n\t\t\t\tif name in self.variable.group.variables.keys():\n\t\t\t\t\t\n\t\t\t\t\tcoord_variable = self.variable.group.variables[name]\n\t\t\t\t\tself.coordinates_variables.append(coord_variable)\n\n\t\t\t\t\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\n\t\t\t\t\t# See if we can find out what spatial/temporal variable this is\n\t\t\t\t\ttry:\n\t\t\t\t\t\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\n\t\t\t\t\texcept:\n\t\t\t\t\t\tcoordinate_name = name\n\n\t\t\t\t\t# Create the coordinates_mapping entry but with an empty dimensions map for now\n\t\t\t\t\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\n\t\t\t\t\t\t\n\t\t\t\t\t# Add each coordinates variable dimension to the mappable list and generate the map\n\t\t\t\t\t#print 'generating dimensions map for ', coord_variable.dimensions\n\t\t\t\t\tfor dimension in coord_variable.dimensions:\n\t\t\t\t\t\t#print dimension, coord_variable.dimensions\n\t\t\t\t\t\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\n\t\t\t\t\t\tif not dimension.name in mapped:\n\t\t\t\t\t\t\tmapped.append(dimension.name)\n\t\t\t\t\t\t\t\n\t\t# Setup shortcut to identify time coordinate variable\n\t\ttry:\n\t\t\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\n\t\t\tself.time_dim = self.coordinates_mapping['time']['map'][0]\n\t\texcept:\n\t\t\tself.time_variable = None\n\t\t\tself.time_dim = None\n\t\t\t\n\t\t# Shortcuts for latitude and longitude coordinate variables\n\t\ttry:\n\t\t\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\n\t\texcept:\n\t\t\tself.latitude_variable = None\n\n\t\ttry:\n\t\t\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\n\t\texcept:\n\t\t\tself.longitude_variable = None\n\n\t\ttry:\n\t\t\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\n\t\t\tself.level_dim = self.coordinates_mapping['level']['map'][0]\n\t\texcept:\n\t\t\tself.level_variable = None\n\t\t\tself.level_dim = None","def compute_max(self):\r\n self.x_max = self.ox + self.dx*self.nx\r\n self.y_max = self.oy + self.dy*self.ny\r\n self.z_max = self.oz + self.dz*self.nz","def replace_x_y_nominal_lat_lon(ds):\n ds = ds.copy()\n if 'x' in ds.dims and 'y' in ds.dims:\n \n nominal_y = ds.lat.mean('x')\n # extract the equatorial lat and take those lon values as nominal lon\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\n nominal_x = ds.lon.isel(y=eq_ind)\n ds.coords['x'].data = nominal_x.data\n ds.coords['y'].data = nominal_y.data\n\n ds = ds.sortby('x')\n ds = ds.sortby('y')\n \n else:\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\n return ds","def find_max_coords(self):\n all_max_bound = []\n all_min_bound = []\n shape_dict = self.shape_dict\n for zone_id in shape_dict:\n zone_shape = shape_dict[zone_id]\n max_bound_zone = zone_shape.max_bound\n min_bound_zone = zone_shape.min_bound\n all_max_bound.append(max_bound_zone)\n all_min_bound.append(min_bound_zone)\n\n map_max_bound, unused_max = Utils.calculate_boundaries(all_max_bound)\n unused_min, map_min_bound = Utils.calculate_boundaries(all_min_bound)\n\n return (map_max_bound, map_min_bound)","def get_maxdistance_landmarktoPointcloud(self):\n if len(self.subsetnodes) == 0: # Make sure tat the landmark set is already constructed.\n self.select()\n landmarktopointcloud_dist = self.getLandmark_Witness_matrix()\n self.MaxMindist = np.nanmax(np.nanmin(landmarktopointcloud_dist, axis=0)) # Compute max of the min of each column\n return self.MaxMindist","def _coordinate_flex_vocabulary(obj, latname=None, lonname=None):\n if (latname is not None) or (lonname is not None):\n try:\n lat = obj[latname]\n lon = obj[lonname]\n except KeyError:\n raise LookupError\n\n if (np.size(lat) > 1) and (np.size(lon) > 1):\n lat = np.atleast_1d(lat)\n lon = np.atleast_1d(lon)\n return lat, lon\n\n vocab = [\n {\"lat\": \"LATITUDE\", \"lon\": \"LONGITUDE\"},\n {\"lat\": \"latitude\", \"lon\": \"longitude\"},\n {\"lat\": \"lat\", \"lon\": \"lon\"},\n {\"lat\": \"LAT\", \"lon\": \"LON\"},\n ]\n for v in vocab:\n try:\n lat = obj[v[\"lat\"]]\n lon = obj[v[\"lon\"]]\n if (np.size(lat) > 1) and (np.size(lon) > 1):\n lat = np.atleast_1d(lat)\n lon = np.atleast_1d(lon)\n return lat, lon\n except KeyError:\n pass\n raise LookupError","def is_longitude_var(obj):\n if (obj.name =='longitude'):\n return True\n else:\n return False","def magnitud_momento(slip, prof, lons, lats):\n\n #mu = 3*10**10 # rigidez en N/m\n \n # calculos previos \n\n maxlat = np.max(lats) # latitud maxima\n lon_maxlat = lons[np.where(lats == maxlat)[0][0], np.where(lats == maxlat)[1][0]] # longitud correspondiente a la latitud maxima\n minlat = np.min(lats) # latitud minima\n lon_minlat = lons[np.where(lats == minlat)[0][0], np.where(lats == minlat)[1][0]] # longitud correspondiente a la latitud minima\n maxlon = np.max(lons) # longitud maxima\n lat_maxlon = lats[np.where(lons == maxlon)[0][0], np.where(lons == maxlon)[1][0]] # latitud correspondiente a la longitud maxima\n minlon = np.min(lons) # longitud minima\n lat_minlon = lats[np.where(lons == minlon)[0][0], np.where(lons == minlon)[1][0]]\n maxprof = np.max(prof) # profundidad maxima\n minprof = np.min(prof) # profundidad minima\n \n largo_falla = dist_sf_alt(lon_minlat, lon_maxlat, minlat, maxlat) # largo de la falla en metros\n ancho_falla = np.sqrt((np.max(prof)-np.min(prof))**2 + dist_sf_alt( maxlon, minlon, lat_maxlon, lat_minlon)**2) # ancho de la falla\n\n n_fils = np.shape(lons)[0] # numero de filas\n n_cols = np.shape(lons)[1] # numero de columnas\n\n # tamano subfallas\n largo_subfalla = largo_falla/n_fils \n ancho_subfalla = ancho_falla/n_cols \n area_subfalla = largo_subfalla*ancho_subfalla\n\n # se estima el tiempo que tarda la ruptura, tau, para luego estimar la rigidez\n # se utiliza beta = 2500 m/s\n tau = tau_ruptura( largo_falla )\n # se estima la rigidez de la interfaz dependiendo de la profundidad\n rigidez = estima_rigidez( largo_falla, tau )\n \n # calculo Mo\n\n Mo = rigidez*area_subfalla*slip\n Mo = np.sum(Mo)\n Mw = 2.0/3.0*np.log10(Mo)-6.06\n\n return Mw, area_subfalla","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def lon(self):\n return self['lon']","def get_location_metres(original_location, dNorth, dEast):\n earth_radius=6378137.0 #Radius of \"spherical\" earth\n #Coordinate offsets in radians\n dLat = dNorth/earth_radius\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\n\n #New position in decimal degrees\n newlat = original_location.lat + (dLat * 180/math.pi)\n newlon = original_location.lon + (dLon * 180/math.pi)\n\n return dk.LocationGlobal(newlat, newlon,original_location.alt)","def probaContagius(lat1,lon1,lat2,lon2,M):\n GAMMA = 0.02\n dlon = abs(lon2 - lon1) * 10000\n dlat = abs(lat2 - lat1) * 10000\n distance_Y = int(round(dlon, 0))\n distance_X = int(round(dlat, 0))\n proba = 0\n if ( (distance_X>=0 and distance_X<300) and (distance_Y>=0 and distance_Y<300) ):\n proba = GAMMA * M[distance_X][distance_Y]\n return proba","def get_local_maxes(self, use_full=False, strict=False, x_y=None):\n if x_y is None:\n if use_full:\n x, y = self.x_full, self.y_full\n y_offset = 0\n else:\n x, y = self.x, self.y\n y_offset = self.y_offset\n else:\n x, y = x_y\n y_offset = 0\n\n if strict:\n # take only those greater than both adjacent\n maxes = sps.argrelextrema(y, np.greater)[0]\n else:\n # take all greater/equal to both sides\n maxes = sps.argrelextrema(y, np.greater_equal)[0]\n\n # check that max_y values > 0\n maxes = maxes[y[maxes] > 0]\n\n # filter capped values on both sides\n maxes = maxes[y[maxes] != 5 - y_offset]\n\n max_x = x[maxes]\n max_y = y[maxes]\n\n return max_x, max_y","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 multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \"north\"):\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n\n mlatA = self.mlatA[inds]\n mlatB = self.mlatB[inds]\n mlatC = self.mlatC[inds]\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 \n N = int((len(NeA)/n*2) - 1) #nr of windows\n \n dx = (secondsB[1]-secondsB[0])*self.velB[0]\n \n nBAs = []\n nBCs = []\n nACs = []\n \n for i in range(N):\n startind = int(i/2*n)\n stopind = int((i/2+1)*n)\n temp_NeA = NeA[startind:stopind]\n temp_NeB = NeB[startind:stopind]\n temp_NeC = NeC[startind:stopind]\n \n temp_secondsA = secondsA[startind:stopind]\n temp_secondsB = secondsB[startind:stopind]\n temp_secondsC = secondsC[startind:stopind]\n \n \n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\n if np.sum(curr_timediff) > 2:\n continue\n \n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\n \n if np.max(gradA) < 0.9:\n continue\n \n stdA = np.std(gradA)\n stdB = np.std(gradB)\n stdC = np.std(gradC)\n \n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\n \n p0A = [1, meanA, stdA]\n p0B = [1, meanB, stdB]\n p0C = [1, meanB, stdB]\n \n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\n \n nBA = poptB[1] - poptA[1]\n nBC = poptB[1] - poptC[1]\n nAC = poptA[1] - poptC[1]\n \n nBAs.append(nBA)\n nBCs.append(nBC)\n nACs.append(nAC)\n \n \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 V = self.velA[0]\n for i in range(len(nBAs)):\n VBA = self.along_track_velo(V, sBA, nBAs[i])\n VBC = self.along_track_velo(V, sBC, nBCs[i])\n VAC = self.along_track_velo(V, sAC, nACs[i])\n \n print(VBA)\n print(VBC)\n print(VAC)\n print(\"________________________________________\")","def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\n\n\n if min_lon<0 and max_lon>0:\n splitExtract = True; Turns=2\n grdMODEL.splitExtract=splitExtract\n else:\n splitExtract = False; Turns=1\n grdMODEL.splitExtract=splitExtract\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\n \n # Array to store the results returned from the function\n res=np.zeros((Turns,4),dtype=np.float64)\n \n lats=grdMODEL.lat[:,0]\n lons=grdMODEL.lon[0,:]\n\n \n for k in range(Turns):\n\n if k==0 and splitExtract == True:\n minLon=min_lon; maxLon=0\n minLon=minLon+360\n maxLon=maxLon+360\n elif k==1 and splitExtract == True:\n minLon=0; maxLon=max_lon\n else:\n minLon=min_lon; maxLon=max_lon\n \n distances1 = []\n distances2 = []\n indices=[]\n index=1\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n \n distances1 = []\n distances2 = []\n index=1\n \n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n \n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n \n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n grdMODEL.indices=res","def _resolution(self):\n _, xres, _, _, _, yres = self.geotransform\n return xres, yres","def _calc_longitudes(self):\n assert self.tracers\n\n # zp is z unit vector at all times, shape 501 x 3\n zp = np.cross(self.p0_positions, self.p0_velocities)\n zp = zp / np.linalg.norm(zp, axis=-1)[:, None]\n\n # xp and yp are x and y unit vectors\n xp = self.p0_positions\n xp = xp / np.linalg.norm(xp, axis=-1)[:, None]\n yp = np.cross(zp, xp)\n\n # project particle positions into orbital x-y plane\n p1_xp = np.sum(self.p1_positions * xp[:, None, :], axis=-1)\n p1_yp = np.sum(self.p1_positions * yp[:, None, :], axis=-1)\n p2_xp = np.sum(self.p2_positions * xp[:, None, :], axis=-1)\n p2_yp = np.sum(self.p2_positions * yp[:, None, :], axis=-1)\n\n # get longitudes\n p1_phi = np.arctan2(p1_yp, p1_xp)\n p2_phi = np.arctan2(p2_yp, p2_xp)\n\n # add/subtract multiples of 2pi for particles on higher wraps.\n dp = np.vstack((np.zeros((1, self.N1)), np.diff(p1_phi, axis=0)))\n for j in range(self.N1):\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\n for i in range(changes.size):\n p1_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\n dp = np.vstack((np.zeros((1, self.N2)), np.diff(p2_phi, axis=0)))\n for j in range(self.N2):\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\n for i in range(changes.size):\n p2_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\n\n return p1_phi, p2_phi","def get_location_metres(original_location, dNorth, dEast):\n earth_radius = 6378137.0 #Radius of \"spherical\" earth\n #Coordinate offsets in radians\n dLat = dNorth/earth_radius\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\n\n #New position in decimal degrees\n newlat = original_location.lat + (dLat * 180/math.pi)\n newlon = original_location.lon + (dLon * 180/math.pi)\n if type(original_location) is LocationGlobal:\n targetlocation=LocationGlobal(newlat, newlon,original_location.alt)\n elif type(original_location) is LocationGlobalRelative:\n targetlocation=LocationGlobalRelative(newlat, newlon,original_location.alt)\n else:\n raise Exception(\"Invalid Location object passed\")\n \n return targetlocation;","def spatial_dimension(self):\r\n pass","def getShortestCoordinate (analyzer,startLat, startLon, endLat, endLon):\n estacionOrigen=model.getCloserStation (analyzer, startLat, startLon)\n estacionDestino=model.getCloserStation (analyzer, endLat, endLon)\n ruta,tiempo=model.getShortestCoordinate(analyzer,estacionOrigen, estacionDestino)\n return (estacionOrigen,estacionDestino,ruta,tiempo)","def Distance_orthonormique(lon1, lat1, lon2, lat2):\r\n \r\n #Convert position in radians\r\n lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\r\n #rvmT = Earth radius [km]\r\n rvmT = 6371 \r\n #Project the position on\r\n a = sin((lat2 - lat1)/2)**2 + cos(lat1) * cos(lat2) * sin((lon2 - lon1)/2)**2\r\n c = 2 * asin(sqrt(a)) \r\n \r\n d = c * rvmT\r\n return d","def _calculate_location(self, map_4d):\n\n # MARGINALISE: Determining the 3-D coalescence map\n self.coa_map = np.log(np.sum(np.exp(map_4d), axis=-1))\n\n # Normalise\n self.coa_map = self.coa_map/np.max(self.coa_map)\n\n # Fit 3-D spline function to small window around max coalescence\n # location and interpolate to determine sub-grid maximum coalescence\n # location.\n loc_spline = self._splineloc(np.copy(self.coa_map))\n\n # Apply gaussian smoothing to small window around max coalescence\n # location and fit 3-D gaussian function to determine local\n # expectation location and uncertainty\n smoothed_coa_map = self._gaufilt3d(np.copy(self.coa_map))\n loc_gau, loc_gau_err = self._gaufit3d(np.copy(smoothed_coa_map),\n thresh=0.)\n\n # Calculate global covariance expected location and uncertainty\n loc_cov, loc_cov_err = self._covfit3d(np.copy(self.coa_map))\n\n return loc_spline, loc_gau, loc_gau_err, loc_cov, loc_cov_err","def test_analysis_of_vector_data_top_N(self):\n\n for vectorname in ['test_buildings.shp',\n 'tsunami_building_exposure.shp']:\n\n filename = '%s/%s' % (TESTDATA, vectorname)\n layer = read_layer(filename)\n attributes = layer.get_data()\n\n # Check exceptions\n try:\n L = layer.get_topN(attribute='FLOOR_AREA', N=0)\n except VerificationError:\n pass\n else:\n msg = 'Exception should have been raised for N == 0'\n raise Exception(msg)\n\n # Check results\n for N in [5, 10, 11, 17]:\n if vectorname == 'test_buildings.shp':\n L = layer.get_topN(attribute='FLOOR_AREA', N=N)\n assert len(L) == N\n\n msg = ('Got projection %s, expected %s' %\n (L.projection, layer.projection))\n assert L.projection == layer.projection, msg\n #print [a['FLOOR_AREA'] for a in L.attributes]\n elif vectorname == 'tsunami_building_exposure.shp':\n L = layer.get_topN(attribute='STR_VALUE', N=N)\n assert len(L) == N\n assert L.get_projection() == layer.get_projection()\n val = [a['STR_VALUE'] for a in L.data]\n\n ref = [a['STR_VALUE'] for a in attributes]\n ref.sort()\n\n assert numpy.allclose(val, ref[-N:],\n atol=1.0e-12, rtol=1.0e-12)\n else:\n raise Exception","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def __test(inLat, inLong, inZone=False):\n e, n, z = utm_from_lonlat(inLong, inLat, inZone)\n lon, lat = lonlat_from_utm(e, n, z)\n\n return z, e, n, lon, lat","def bounds(self):\n\n if self.size == 0:\n lo, hi = np.nan, np.nan\n elif self.is_monotonic:\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\n elif self.dtype is np.datetime64:\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\n else:\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\n\n return lo, hi","def calculate_vars(data, lat, lon):\n # Keep track of running distance and time calculations\n distance_to_dest = 0.0\n time_estimate = 0.0\n\n # Calculate from starting dest to first point in data\n user_coords = (lat, lon)\n first_path_coords = (data[0][\"lat\"], data[0][\"lon\"])\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\n distance_to_dest += first_distance\n time_estimate += first_distance * 20 # 3mph walking speed\n\n # Calculate for all other points\n for i in range(1, len(data) - 1):\n this_coords = (data[i][\"lat\"], data[i][\"lon\"])\n next_coords = (data[i + 1][\"lat\"], data[i + 1][\"lon\"])\n\n distance = geopy.distance.distance(this_coords, next_coords).miles\n distance_to_dest += distance\n time_estimate += distance * 20 # 3mph walking speed\n\n # Round distance and time estimates\n distance_to_dest = round(distance_to_dest, 1)\n time_estimate = round(time_estimate)\n\n return distance_to_dest, time_estimate","def get_max_score(location_list, grid, shape):","def stageData(self,m):\n obs = Variable(filename = self.source,\n variable_name = self.variable,\n alternate_vars = self.alternate_vars)\n if obs.time is None: raise il.NotTemporalVariable()\n self.pruneRegions(obs)\n \n # Try to extract a commensurate quantity from the model\n mod = m.extractTimeSeries(self.variable,\n alt_vars = self.alternate_vars,\n expression = self.derived,\n initial_time = obs.time_bnds[ 0,0],\n final_time = obs.time_bnds[-1,1],\n lats = None if obs.spatial else obs.lat,\n lons = None if obs.spatial else obs.lon)\n obs,mod = il.MakeComparable(obs,mod,\n mask_ref = True,\n clip_ref = True,\n extents = self.extents,\n logstring = \"[%s][%s]\" % (self.longname,m.name))\n \n # Check the order of magnitude of the data and convert to help avoid roundoff errors\n def _reduceRoundoffErrors(var):\n if \"s-1\" in var.unit: return var.convert(var.unit.replace(\"s-1\",\"d-1\"))\n if \"kg\" in var.unit: return var.convert(var.unit.replace(\"kg\" ,\"g\" ))\n return var\n def _getOrder(var):\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\n order = _getOrder(obs)\n count = 0\n while order < -2 and count < 2:\n obs = _reduceRoundoffErrors(obs)\n order = _getOrder(obs)\n count += 1\n \n # convert the model data to the same unit\n mod = mod.convert(obs.unit)\n\n return obs,mod","def get_location_metres(original_location, dNorth, dEast):\n earth_radius=6378137.0 #Radius of \"spherical\" earth\n #Coordinate offsets in radians\n dLat = dNorth/earth_radius\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\n\n #New position in decimal degrees\n newlat = original_location.lat + (dLat * 180/math.pi)\n newlon = original_location.lon + (dLon * 180/math.pi)\n return LocationGlobal(newlat, newlon,original_location.alt)","def get_location_metres(original_location, dNorth, dEast):\n earth_radius = 6378137.0 #Radius of \"spherical\" earth\n #Coordinate offsets in radians\n dLat = dNorth / earth_radius\n dLon = dEast / (earth_radius * math.cos(math.pi * original_location.lat /\n 180))\n\n #New position in decimal degrees\n newlat = original_location.lat + (dLat * 180 / math.pi)\n newlon = original_location.lon + (dLon * 180 / math.pi)\n return LocationGlobal(newlat, newlon, original_location.alt)","def M(latitude):\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);","def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\n\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\n # Get Value\n vrow = invar[kpt,:]\n \n # Place into variable\n mappt = np.zeros(nlat5*nlon5)*np.nan\n mappt[okpts] = vrow\n mappt = mappt.reshape(nlat5,nlon5)\n return mappt","def MercatorBounds(lat, lng, lod):\n\n num_tiles = 1 << lod\n\n (west, east) = LongitudinalBounds(lng, num_tiles)\n\n # Normalize to between -90 and 90 degrees latitude.\n while lat < -90.0:\n lat += 180.0\n while lat >= 90.0:\n lat -= 180.0\n\n y = int(ToMercPosition(lat, num_tiles))\n south = ToMercDegrees(y, num_tiles)\n north = ToMercDegrees(y + 1, num_tiles)\n\n return {\n \"south\": south,\n \"north\": north,\n \"west\": west,\n \"east\": east\n }","def msl_nn_srtm_interp(self, lon_lat):\n tiles = self.find_srtm_tiles(lon_lat)\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\n lon_lat_msl[:, 0:2] = lon_lat\n for tile in set(tiles):\n otile = rasterio.open(tile, 'r')\n oimg = otile.read(1)\n idx = np.where(np.array(tiles) == tile)[0]\n pix = feat.geo_to_pix(\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\n pix = np.round(pix).astype(np.int)\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\n otile.close()\n nan_mask = lon_lat_msl[:, 2] == -32768\n lon_lat_msl[nan_mask, 2] = np.NaN\n return lon_lat_msl","def a_test2_mh():\n model = ARIMAX(formula=\"y ~ x1 + x2\", data=data, ar=1, ma=1, family=Exponential())\n x = model.fit('M-H',nsims=300)\n assert(len(model.latent_variables.z_list) == 5)\n lvs = np.array([i.value for i in model.latent_variables.z_list])\n assert(len(lvs[np.isnan(lvs)]) == 0)","def safeProj(proj, lon, lat):\n x, y = proj(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_nodes(self, latlon=False):\n ids = np.where(np.isnan(self.data[:,:,:]))\n i_nan = ids[0][0] ; j_nan = ids[1][0]\n \n def area_neighbours(Area, i_nan, j_nan):\n rows = np.array(Area)[:,0]\n cols = np.array(Area)[:,1]\n rows_m = rows-1\n cols_m = cols-1\n rows_p = rows+1\n cols_p = cols+1\n \n p1 = np.array([rows_m,cols]).ravel().reshape(len(rows),2,order='F')\n p2 = np.array([rows_p,cols]).ravel().reshape(len(rows),2,order='F')\n p3 = np.array([rows,cols_m]).ravel().reshape(len(rows),2,order='F')\n p4 = np.array([rows,cols_p]).ravel().reshape(len(rows),2,order='F')\n cond1 = p1[:,0]<0\n cond2 = p2[:,0]>self.dimX-1\n cond3 = p3[:,1]<0\n cond4 = p4[:,1]>self.dimY-1\n if latlon:\n p3[:,1][cond3] = self.dimY-1\n p4[:,1][cond4] = 0\n else:\n p3[:,0][cond3] = i_nan\n p3[:,1][cond3] = j_nan\n p4[:,0][cond4] = i_nan\n p4[:,1][cond4] = j_nan\n p1[:,0][cond1] = i_nan\n p1[:,1][cond1] = j_nan\n p2[:,0][cond2] = i_nan\n p2[:,1][cond2] = j_nan\n p = np.concatenate((p1,p2,p3,p4)).tolist()\n return [i for i in p if i not in self.unavail]\n\n def area_max_correlation(Area, neighbours):\n Rmean = [] ; X = []\n for cell in neighbours:\n R = []\n new_cell = cell[0]*self.dimY + cell[1]\n if new_cell in self.gridcells:\n X.append(cell)\n IDm = np.where(self.gridcells==new_cell)\n Rmean.append(np.nanmean(self.corrs[cells_in_k,IDm]))\n try:\n Rmax = np.nanmax(Rmean)\n except ValueError:\n Rmax = np.nan\n return np.array(X), Rmean, Rmax\n \n def diag_indices(a, k):\n rows, cols = np.diag_indices_from(a)\n if k < 0:\n return rows[-k:], cols[:k]\n elif k > 0:\n return rows[:-k], cols[k:]\n else:\n return rows, cols\n\n #S T E P 1 (C R E A T E N O D E S)\n\n self.nodes = {}\n self.unavail = []\n if latlon:\n neighbour_corrs1 = self.corrs.diagonal(offset=1)\n neighbour_corrs2 = self.corrs.diagonal(offset=self.dimY-1)\n subset = np.arange(0,len(neighbour_corrs2),self.dimY)\n neighbour_corrs2 = neighbour_corrs2[subset]\n neighbour_corrs = np.concatenate((neighbour_corrs1,neighbour_corrs2))\n\n cellIDs1 = diag_indices(self.corrs,1)\n cellIDs2 = diag_indices(self.corrs,self.dimY-1)\n\n cellIDs = (np.concatenate((cellIDs1[0],cellIDs2[0][subset])),\\\n np.concatenate((cellIDs1[1],cellIDs2[1][subset])))\n else:\n neighbour_corrs = self.corrs.diagonal(offset=1)\n cellIDs = diag_indices(self.corrs,1)\n \n cellIDs = (self.gridcells[cellIDs[0]],self.gridcells[cellIDs[1]])\n k = 0\n neighbour_corrs,cellIDs1,cellIDs2 = list(zip(*sorted(zip(neighbour_corrs,cellIDs[0],cellIDs[1]),reverse=True)))\n cell_IDs = (cellIDs1,cellIDs2)\n np.random.seed(2)\n for it in range(len(neighbour_corrs)):\n cells_in_k = []\n i = cell_IDs[0][it]\n j = cell_IDs[1][it]\n r = neighbour_corrs[it]\n \n row_i = int(np.floor(i/self.dimY)) ; col_i = int(i % self.dimY)\n row_j = int(np.floor(j/self.dimY)) ; col_j = int(j % self.dimY)\n \n if ([row_i,col_i] not in self.unavail) & ([row_j,col_j] not in self.unavail):\n if r>self.tau:\n self.nodes.setdefault(k, []).append([row_i,col_i])\n self.nodes.setdefault(k, []).append([row_j,col_j])\n self.unavail.append([row_i,col_i])\n self.unavail.append([row_j,col_j])\n cells_in_k.extend(np.where(self.gridcells==i)[0])\n cells_in_k.extend(np.where(self.gridcells==j)[0])\n\n while True: #expand\n neighbours = area_neighbours(self.nodes[k], i_nan, j_nan)\n X, Rmean, Rmax = area_max_correlation(Area=self.nodes[k], neighbours=neighbours)\n if Rmax > self.tau:\n m = X[Rmean==Rmax].tolist()\n if len(m)>1:\n m = m[np.random.randint(low=0,high=len(m))]\n else:\n m = m[0]\n self.nodes.setdefault(k, []).append(m)\n self.unavail.append(m)\n cells_in_k.extend(np.where(self.gridcells==m[0]*self.dimY+m[1])[0])\n else:\n break\n if len(self.nodes[k]) <= 2:\n del self.nodes[k]\n k += 1\n else:\n break\n \n #S T E P 2 (M E R G E N O D E S)\n \n self.unavail = []\n while True:\n Rs = {}\n unavail_neighbours = {}\n num_cells = dict([(area,len(self.nodes[area])) if self.nodes[area] not in self.unavail else (area,np.inf) for area in self.nodes.keys()])\n maxID = min(num_cells.items(), key=operator.itemgetter(1))[0]\n if num_cells[maxID] > 175: #arbitrary choice?\n break\n else:\n cells_in_k = [np.where(self.gridcells==cell[0]*self.dimY+cell[1])[0] for cell in self.nodes[maxID]]\n neighbours = area_neighbours(self.nodes[maxID], i_nan, j_nan)\n for cell in neighbours:\n gcell = cell[0]*self.dimY + cell[1]\n Rmean = []\n cond1 = gcell in self.gridcells\n cond2 = cell not in self.nodes[maxID]\n cond3 = cell not in [k for k, g in itertools.groupby(sorted(itertools.chain(*unavail_neighbours.values())))]\n cond4 = len([area for area, cells in self.nodes.items() if cell in cells]) > 0\n if (cond1) & (cond2) & (cond3) & (cond4):\n nID = [area for area, cells in self.nodes.items() if cell in cells][0]\n unavail_neighbours[nID] = self.nodes[nID]\n X, Rmean, Rmax = area_max_correlation(Area=self.nodes[nID]+self.nodes[maxID], neighbours=self.nodes[nID]+self.nodes[maxID])\n if nID not in Rs: \n Rs[nID] = np.nanmean(Rmean)\n try:\n Rs_maxID = max(Rs.items(), key=operator.itemgetter(1))[0]\n if Rs[Rs_maxID] > self.tau:\n for cell in self.nodes.pop(Rs_maxID, None):\n self.nodes.setdefault(maxID, []).append([cell[0],cell[1]])\n else:\n self.unavail.append(self.nodes[maxID])\n except ValueError:\n self.unavail.append(self.nodes[maxID])","def decide_resolution(vec):\n if N >= NOld and M >= MOld:\n ovec = increase_resolution(vec)\n\n elif N <= NOld and M <= MOld:\n ovec = decrease_resolution(vec)\n\n return ovec","def get_map_sphere_variance(self, i_seq):\n return self._map_variances[i_seq]","def test_coord_preceding_fs(self):","def check_location_confidence(self):\n\t\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\n\t\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\n\t\tepsilon_meters = .08\n\t\tpixel_distances = []\n\t\tactual_distances = []\n\t\tnum_observed = 0\n\t\tfor ti in self.targs:\n\t\t\tif ti.props_are_set:\n\t\t\t\tfor tj in self.targs:\n\t\t\t\t\tif tj.props_are_set: \n\t\t\t\t\t\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\n\t\t\t\t\t\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\n\t\t\t\t\t\tif pixel_dist == 0:\n\t\t\t\t\t\t\tpixel_dist = 10000 #ignore two of the same points\n\t\t\t\t\t\t\tactual_dist = 10000\n\t\t\t\t\t\tpixel_distances.append(pixel_dist)\t\n\t\t\t\t\t\tactual_distances.append(actual_dist)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\t\tactual_distances.append(10000)\n\t\t\telse:\n\t\t\t\tfor _ in self.targs:\n\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\tactual_distances.append(10000)\n\t\tmin_ind_pixel = np.argmin(pixel_distances)\n\t\tmin_ind_actual = np.argmin(actual_distances)\n\t\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\n\t\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\n\t\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\n\t\t\t#measurements are not trustworthy, return nothing\n\t\t\treturn None\n\n\t\treturn best_guys","def mag2(self) -> numbers.Number:\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\n return mv_val[0]","def calcPosition (lat, lon):\n nauticalMilePerLat = 60.00721\n nauticalMilePerLongitude = 60.10793\n rad = math.pi / 180.0\n milesPerNauticalMile = 1.15078\n \n y = lat * nauticalMilePerLat\n x = math.cos(lat * rad) * lon * nauticalMilePerLongitude\n\n return x * milesPerNauticalMile * 1609.344, y * milesPerNauticalMile * 1609.344","def get_distance_metres(aLocation1, aLocation2):\n dlat = aLocation2.lat - aLocation1.lat\n dlong = aLocation2.lon - aLocation1.lon\n dlong *= math.cos( aLocation2.lat * math.pi / 180.0 )\n return math.sqrt((dlat*dlat) + (dlong*dlong)) * 1.113195e5","def get_min_max(self) -> tuple:\r\n\r\n minimum = float(\"inf\")\r\n maximum = float(\"-inf\")\r\n\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n for name, data in self.trees_data.items():\r\n if self.trees[name][\"point_helper\"] is None:\r\n mapping = self.trees[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n return minimum, maximum","def get_dimensional_measurements():\n return Global_Module.global_dimensional_measurements","def get_data(n):\n data = pd.read_csv('map_data/lior_results_2.csv')\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\n data = data[data.binomial != 'Sus bucculentus'] # EX\n data = data[data.binomial != 'Melomys rubicola'] # EX\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\n total_mass_density=data.AdultBodyMassG * data.pop_density)\n data = data.sort_values(by='total_mass_density', ascending=False)\n data = data.iloc[0:n - 1]\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\"EPSG:6933\")\n geo_data = geo_data[geo_data.category != 'EX']\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\n (geo_data['legend'] == 'Extant (non breeding)') |\n (geo_data['legend'] == 'Extant (resident)') |\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Probably Extant (resident)') |\n (geo_data['legend'] == 'Reintroduced')]\n range_polygons = range_polygons.merge(data, on='binomial')\n range_polygons = range_polygons.to_crs(\"EPSG:6933\")\n return range_polygons","def extractvalues( locs: torch.tensor,\n x_os: torch.tensor,\n y_os: torch.tensor,\n z_os: torch.tensor,\n ints:torch.tensor, dim: int=3):\n\n dim = tuple([1 for i in range(dim)])\n coord = tuple(locs.nonzero().transpose(1,0))\n x_os_val = x_os[coord].reshape(-1, *dim)\n y_os_val = y_os[coord].reshape(-1, *dim)\n z_os_val = z_os[coord].reshape(-1, *dim)\n ints_val = ints[coord].reshape(-1, *dim)\n return x_os_val, y_os_val, z_os_val, ints_val","def testLengthsOfLocalization(self):\n\t\tloc_len = len(self.d3.loc_terms)\n\t\tself.assertEqual(14, loc_len)","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 dist_sf_alt( lon1, lon2, lat1, lat2 ):\n\n dist = Geodesic.WGS84.Inverse( lat1, lon1, lat2, lon2 )[ \"s12\" ]\n \n return dist","def dist_sf( lon1, lon2, lat1, lat2 ):\n\n subfalla_i = (lon1, lat1)\n subfalla_j = (lon2, lat2)\n distancia = distance.distance( subfalla_i, subfalla_j ).meters\n\n return distancia","def _multiple_values_max(self, maps, threshold):\r\n max_val = np.zeros((maps.shape[0], maps.shape[1]), dtype=np.float)\r\n for i in range(maps.shape[1]):\r\n cmin = np.min(maps[:,i])\r\n cmax = np.max(maps[:,i])\r\n limit = cmax - (cmax - cmin) * threshold[i]\r\n min_mask = maps[:,i] <= limit\r\n max_mask = maps[:,i] > limit\r\n # for an abundance map the delta is around [-1..1],\r\n # but it can be outside this interval, it's something\r\n # to test\r\n # a guard with a -10 value maybe ok.\r\n rmin = min_mask * -10\r\n max_val[:,i] = max_mask * maps[:,i] + rmin\r\n max_vec = np.max(max_val, axis=1)\r\n max_mask = max_vec > -10\r\n argmax = np.argmax(max_val, axis=1)\r\n return (argmax + 1) * max_mask","def calcMetresDistance(lat1, long1, lat2, long2):\n return (abs(lat1 - lat2) + abs(long1 - long2)) * 100\n # no, like, really badly","def merc(lat, lon):\n\tr_major = 6378137.000\n\tx = r_major * math.radians(lon)\n\tscale = x/lon\n\ty = 180.0/math.pi * math.log(math.tan(math.pi/4.0 + lat * (math.pi/180.0)/2.0)) * scale\n\treturn (x, y)","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 _get_dlon_dlat_km(self):\n self.dlon_km=np.array([])\n self.dlat_km=np.array([])\n for lat in self.lat:\n dist_lon, az, baz = obspy.geodetics.gps2dist_azimuth(lat, 0., lat, self.dlon)\n dist_lat, az, baz = obspy.geodetics.gps2dist_azimuth(lat, 0., lat+self.dlat, 0.)\n self.dlon_km=np.append(self.dlon_km, dist_lon/1000.)\n self.dlat_km=np.append(self.dlat_km, dist_lat/1000.)\n self.dlon_kmArr=(np.tile(self.dlon_km, self.Nlon).reshape(self.Nlon, self.Nlat)).T\n self.dlat_kmArr=(np.tile(self.dlat_km, self.Nlon).reshape(self.Nlon, self.Nlat)).T\n return","def spatial_expval(map_):\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * x), np.sum(map_ * y)","def CreateTargetGeoField(nbtimestep,latlen,lonlen):\n\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\n\n return pres_grid,u_grid,v_grid","def find_max_score_location(grid, shape):"],"string":"[\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def find_longitude_var(nc,name):\\n var_obj = nc.variables[name] # Find the corresponding variable object \\n dimens = var_obj.dimensions # Find the names of the dimensions of variable\\n for i in range(len(dimens)):\\n # For each dimension find the corresponding variable\\n var_dim = nc.variables[dimens[i]]\\n if is_longitude_var(var_dim) == True:\\n return var_obj # If longitude exists, return the variable object\\n \\n return None\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def spatial_var(map_):\\n expx, expy = spatial_expval(map_)\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def find_area(self):\\n min_lat_point = self.latitude_min\\n max_lat_point = self.latitude_max\\n min_lon_point = self.longitude_min\\n max_lon_point = self.longitude_max\\n self.rename_latitude()\\n self.rename_longitude()\\n all_lat_bounds = self.cube.coord('latitude').bounds\\n all_lon_bounds = self.cube.coord('longitude').bounds\\n # print(all_lat_bounds)\\n # print(all_lon_bounds)\\n for i, lat in enumerate(all_lat_bounds):\\n for j, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= min_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= min_lon_point < lon_bounds[1]:\\n nlat_min = i\\n nlon_min = j\\n else:\\n pass\\n else:\\n pass\\n\\n for k, lat in enumerate(all_lat_bounds):\\n for l, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= max_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= max_lon_point < lon_bounds[1]:\\n nlat_max = k\\n nlon_max = l\\n else:\\n pass\\n else:\\n pass\\n\\n area_subset = self.cube[:, nlat_min:nlat_max+1, nlon_min:nlon_max+1]\\n # print(area_subset.coord('latitude').points)\\n # print(area_subset.coord('longitude').points)\\n area_mean = area_subset.collapsed(['latitude', 'longitude'],\\n iris.analysis.MEAN)\\n\\n return area_mean\",\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 lat_lons(self):\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\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 coordExtrema(a):\\n # Extreme values of longitude and latitude in the survey.\\n longiMin = sp.inf\\n latMin = sp.inf\\n longiMax = -sp.inf\\n latMax = -sp.inf\\n for t in range(len(a)):\\n if a[t].pktCount > 0:\\n arraMin = sp.amin(a[t].longi)\\n if arraMin < longiMin:\\n longiMin = sp.amin(a[t].longi)\\n arraMin = sp.amin(a[t].lat)\\n if arraMin < latMin:\\n latMin = arraMin\\n arraMax = sp.amax(a[t].longi)\\n if arraMax > longiMax:\\n longiMax = arraMax\\n arraMax = sp.amax(a[t].lat)\\n if arraMax > latMax:\\n latMax = arraMax\\n\\n ext = cs.emptyClass()\\n ext.longiMin = longiMin\\n ext.longiMax = longiMax\\n ext.latMin = latMin\\n ext.latMax = latMax\\n return ext\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def local_maxima_3D(data, order=3):\\n size = 1 + 2 * order\\n footprint = np.ones((size, size, size))\\n footprint[order, order, order] = 0\\n\\n filtered = ndi.maximum_filter(data, footprint=footprint)\\n mask_local_maxima = data > filtered\\n coords = np.asarray(np.where(mask_local_maxima)).T\\n values = data[mask_local_maxima]\\n\\n return coords, values\",\n \"def extract_loc(ref_lon, ref_lat, tlon, tlat, var):\\n\\n if var.ndim == 3: # 3D variable\\n zmax, imax, jmax = var.shape\\n threeD = True\\n elif var.ndim == 2: # 2D variable\\n imax, jmax = var.shape\\n threeD = False\\n else:\\n print 'extract_loc: check variable dimensions'\\n return\\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 # arrays to store weights and data to be averaged\\n if threeD: # 3D variable\\n wghts = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((zmax,len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var): # mask weights\\n dist_m = MA.array(N.resize(dist,var.shape),mask=var.mask)\\n else:\\n dist_m = N.array(N.resize(dist,var.shape))\\n else: # 2D variable\\n wghts = MA.zeros((len(Ilist)*len(Jlist)),float)\\n data = MA.zeros((len(Ilist)*len(Jlist)),float)\\n if MA.isMA(var):\\n dist_m = MA.array(dist,mask=var.mask) # mask weights\\n else:\\n dist_m = N.array(dist)\\n\\n # get the 4 model grid points and compute weights\\n n = 0\\n for i in Ilist:\\n for j in Jlist:\\n wghts[...,n] = 1./dist_m[...,i,j]\\n data[...,n] = var[...,i,j]\\n n += 1\\n\\n # compute weighted average\\n wavg = MA.average(data,axis=-1,weights=wghts)\\n return wavg\",\n \"def get_scale_local_maximas_vectorized(cube_coordinates, laplacian_cube):\\n x, y, z = [ cube_coordinates[:, ind] for ind in range(3) ]\\n \\n point_responses = laplacian_cube[x, y, z]\\n lowers = point_responses.copy()\\n uppers = point_responses.copy()\\n not_layer_0 = z > 0\\n lower_responses = laplacian_cube[x[not_layer_0], y[not_layer_0], z[not_layer_0]-1]\\n lowers[not_layer_0] = lower_responses \\n \\n not_max_layer = z < (laplacian_cube.shape[2] - 1)\\n upper_responses = laplacian_cube[x[not_max_layer], y[not_max_layer], z[not_max_layer]+1]\\n uppers[not_max_layer] = upper_responses\\n \\n lo_check = np.ones(z.shape, dtype=np.bool)\\n lo_check[not_layer_0] = (point_responses > lowers)[not_layer_0]\\n hi_check = np.ones(z.shape, dtype=np.bool)\\n hi_check[not_max_layer] = (point_responses > uppers)[not_max_layer]\\n \\n return cube_coordinates[lo_check & hi_check]\",\n \"def get_bounds(self):\\n\\n northing=self.f.variables['y']\\n easting=self.f.variables['x']\\n\\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\\n\\n return (lon1,lon2,lat1,lat2)\",\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 findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\\n res=np.zeros((4),dtype=np.float64)\\n minLon=min_lon; maxLon=max_lon\\n\\n distances1 = []; distances2 = []\\n indices=[]; index=1\\n\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1 = []; distances2 = []; index=1\\n\\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n\\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\\n return res\",\n \"def moonlongitude(time):\\n B0 = 481267.8809\\n C0 = 218.3162\\n # fmt: off\\n A = np.array([62888.e-4, 12740.e-4, 6583.e-4, 2136.e-4, 1851.e-4, \\\\\\n 1144.e-4, 588.e-4, 571.e-4, 533.e-4, 458.e-4, 409.e-4, \\\\\\n 347.e-4, 304.e-4, 154.e-4, 125.e-4, 110.e-4, 107.e-4, \\\\\\n 100.e-4, 85.e-4, 79.e-4, 68.e-4, 52.e-4, 50.e-4, 40.e-4, \\\\\\n 40.e-4, 40.e-4, 38.e-4, 37.e-4, 28.e-4, 27.e-4, 26.e-4, \\\\\\n 24.e-4, 23.e-4, 22.e-4, 21.e-4, 21.e-4, 21.e-4, 18.e-4, \\\\\\n 16.e-4, 12.e-4, 11.e-4, 9.e-4, 8.e-4, 7.e-4, 7.e-4, \\\\\\n 7.e-4, 7.e-4, 6.e-4, 6.e-4, 5.e-4, 5.e-4, 5.e-4, \\\\\\n 4.e-4, 4.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, 3.e-4, \\\\\\n 3.e-4, 3.e-4])\\n B = np.array([477198.868, 413335.35, 890534.22, 954397.74, \\\\\\n 35999.05, 966404.0, 63863.5, 377336.3, \\\\\\n 1367733.1, 854535.2, 441199.8, 445267.1, \\\\\\n 513197.9, 75870, 1443603, 489205, 1303870, \\\\\\n 1431597, 826671, 449334, 926533, 31932, \\\\\\n 481266, 1331734, 1844932, 133, 1781068, \\\\\\n 541062, 1934, 918399, 1379739, 99863, \\\\\\n 922466, 818536, 990397, 71998, 341337, \\\\\\n 401329, 1856938, 1267871, 1920802, 858602, \\\\\\n 1403732, 790672, 405201, 485333, 27864, \\\\\\n 111869, 2258267, 1908795, 1745069, 509131, \\\\\\n 39871, 12006, 958465, 381404, 349472, \\\\\\n 1808933, 549197, 4067, 2322131.])\\n C = np.array([44.963, 10.74, 145.70, 179.93, 87.53, 276.5, \\\\\\n 124.2, 13.2, 280.7, 148.2, 47.4, 27.9, 222.5, \\\\\\n 41, 52, 142, 246, 315, 111, 188, \\\\\\n 323, 107, 205, 283, 56, 29, 21, \\\\\\n 259, 145, 182, 17, 122, 163, 151, \\\\\\n 357, 85, 16, 274, 152, 249, 186, \\\\\\n 129, 98, 114, 50, 186, 127, 38, \\\\\\n 156, 90, 24, 242, 223, 187, 340, \\\\\\n 354, 337, 58, 220, 70, 191])\\n # fmt: on\\n RAD = 0.0174532925199433\\n tempb = (B * time + C) * RAD\\n amp = A * np.cos(tempb)\\n moonlon = np.sum(amp)\\n moonlon = (moonlon + B0 * time + C0) * RAD\\n return moonlon\",\n \"def geo_m_v2(data_array):\\n r = 6378.137 #promien ziemi w km\\n delta = np.zeros(data_array.size//7-1)\\n alo = data_array[0][1]\\n ala = data_array[0][2]\\n count = 0\\n for row in data_array[1:]:\\n dLat = (row[2] - ala) * math.pi/180.0\\n dLon = (row[1] - alo) * math.pi/180.0\\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\\\\n * math.sin(dLon/2.0)**2\\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\\n count += 1\\n alo = row[1]\\n ala = row[2]\\n return delta\",\n \"def merge_maps(self, map_2d):\\n x = map_2d.data.max(0, keepdim=True)[0]\\n y = map_2d.data.max(1, keepdim=True)[0]\\n return x, y\",\n \"def mlat_finder(self, lat1, lat0, pole = \\\"north\\\"):\\n\\n if pole == \\\"both\\\":\\n lowerA = np.abs(self.mlatA) < lat1\\n higherA = np.abs(self.mlatA) > lat0\\n is_poleA = lowerA * higherA\\n\\n elif pole == \\\"north\\\":\\n lowerA = (self.mlatA) < lat1\\n higherA = (self.mlatA) > lat0\\n is_poleA = lowerA * higherA\\n\\n elif pole == \\\"south\\\":\\n lowerA = (self.mlatA) > lat1\\n higherA = (self.mlatA) < lat0\\n is_poleA = lowerA * higherA\\n\\n high_lat_A = np.where(is_poleA == 1)\\n low_lat_A = np.where(is_poleA == 0)\\n indsA = [low_lat_A, high_lat_A]\\n\\n return indsA\",\n \"def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\\n\\n geo_extent_vars = {}\\n geo_extent_units = []\\n\\n # variables must have units\\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\\n \\n geo_extent_vars[var.name] = 0\\n # units in this set\\n if var.units in possible_units:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n # standard name\\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n # axis of \\\"X\\\"\\n if hasattr(var, 'axis') and var.axis == axis_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n if var.name == std_name or var.name == short_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n\\n if len(geo_extent_vars) == 0:\\n return\\n\\n # filter out any zero scores\\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\\n\\n # sort by criteria passed\\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\\n\\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n # Let's just pick one\\n geo_vals = nc.variables[final_geo_vars[0][:]]\\n if geo_vals.size == 1:\\n obs_res = [0.0]\\n else:\\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n geo_min = round(float(min(obs_mins)), 5)\\n geo_max = round(float(max(obs_maxs)), 5)\\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\\n geo_res = \\\"{} {}\\\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\\n\\n print('<attribute name=\\\"geospatial_{}_min\\\" value=\\\"{}\\\" />'.format(short_name, geo_min))\\n print('<attribute name=\\\"geospatial_{}_max\\\" value=\\\"{}\\\" />'.format(short_name, geo_max))\\n print('<attribute name=\\\"geospatial_{}_resolution\\\" value=\\\"{}\\\" />'.format(short_name, geo_res))\\n print('<attribute name=\\\"geospatial_{}_units\\\" value=\\\"{}\\\" />'.format(short_name, geo_extent_units))\",\n \"def get_location_metres(original_location, dNorth, dEast): \\n [r_center, r_level] = eclipse_compensate(original_location)\\n \\n # coordinate offsets in radians\\n dLat = dNorth / r_center\\n dLon = dEast / r_level\\n \\n # new position in decimal degrees\\n newlat = original_location.lat + math.degrees(dLat)\\n newlon = original_location.lon + math.degrees(dLon)\\n \\n # return according to the input coordinate Class\\n if isinstance(original_location,LocationGlobal):\\n targetlocation = LocationGlobal(newlat, newlon,original_location.alt)\\n \\n elif isinstance(original_location,LocationGlobalRelative):\\n targetlocation = LocationGlobalRelative(newlat, newlon,original_location.alt)\\n \\n else:\\n raise Exception(\\\"Invalid Location object passed\\\")\\n \\n return targetlocation\",\n \"def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_x = cls.get_var(data1_, is_population=True)\\n var_y = cls.get_var(data2_, is_population=True)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)\",\n \"def find_local_maxima(tens):\\n return tf.squeeze(tf.where(tf.equal(label_local_extrema(tens), 'P')))\",\n \"def get_min_max(self):\\n\\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\\n mr[:] = np.max(mr)\\n\\n mxmin = self.mx - mr\\n mxmax = self.mx + mr\\n mymin = self.my - mr\\n mymax = self.my + mr\\n mzmin = self.mz - mr\\n mzmax = self.mz + mr\\n\\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\\n\\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\\n\\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\\n\\n return xmin, xmax, ymin, ymax, zmin, zmax\",\n \"def mme_geo(samples, moment=1):\\n samples = samples ** moment\\n k = len(samples)\\n return ( k / np.sum(samples))\",\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 reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def spatial(self):\",\n \"def getMinMax(self,arr):\\n # not implemented for Template SED yet\\n return arr[\\\"z\\\"], arr[\\\"z\\\"]\",\n \"def getInfo(dir, minlat, maxlat, minlon, maxlon):\\n\\n data_lon = Dataset(dir+'a1979/salidas/wrfout_c15d_d01_1979-12-28_00:00:00.a1979')\\n LON = data_lon.variables['XLONG'][:]\\n LAT = data_lon.variables['XLAT'][:]\\n\\n LON = LON[0][0]\\n LAT = LAT[0]\\n\\n LONsize = len(LON)\\n LATsize = len(LAT)\\n celda = []\\n var_cut = []\\n result = ne(LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\\n\\n return result\",\n \"def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_pool = cls.get_var_pool(data1_, data2_)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)\",\n \"def build_coordinates_map(self):\\n\\t\\t# We need to keep track of which dimensions we can map\\n\\t\\tmapped = []\\n\\t\\t\\n\\t\\t# First lets check for standard 1D coordinate variables. These are variables\\n\\t\\t# that have the same name as one of the variables dimensions or 1D variables\\n\\t\\t# sharing a dimension with the variable \\n\\t\\tfor di in range (0,len(self.variable.dimensions)):\\n\\n\\t\\t\\tdimension = self.variable.dimensions[di]\\n\\t\\t\\tdim_name = dimension.name\\n\\n\\t\\t\\t# Find variables with same name as the dimension\\n\\t\\t\\tif dim_name in self.variable.group.variables.keys():\\n\\n\\t\\t\\t\\tcoord_variable = self.variable.group.variables[dim_name]\\n\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\t\\t\\t\\tmapped.append(dim_name)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# See if we can use the units to find out what spatial/temporal variable this is from \\n\\t\\t\\t\\t# the CF conventions\\n\\t\\t\\t\\tcoordinate_name = cf_units2coordinates(coord_variable.get_attribute('units'))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If we can't we just default to the dimension name\\n\\t\\t\\t\\tif not coordinate_name:\\n\\t\\t\\t\\t\\tcoordinate_name = dim_name\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':dim_name, 'map':[di]}\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t# Next lets see if we have a \\\"coordinates\\\" attribute we can use (CF convention)\\n\\t\\tif self.variable.get_attribute('coordinates'):\\n\\t\\t\\t\\n\\t\\t\\tself.coordinates_names = self.variable.get_attribute('coordinates').split()\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# Find each associated variable\\n\\t\\t\\tfor name in self.coordinates_names:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif name in self.variable.group.variables.keys():\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tcoord_variable = self.variable.group.variables[name]\\n\\t\\t\\t\\t\\tself.coordinates_variables.append(coord_variable)\\n\\n\\t\\t\\t\\t\\t#print 'got coordinate variable ', coord_variable, coord_variable.dimensions\\n\\t\\t\\t\\t\\t# See if we can find out what spatial/temporal variable this is\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = cf_dimensions[self.variable.group.variables[name].get_attribute('units')]\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tcoordinate_name = name\\n\\n\\t\\t\\t\\t\\t# Create the coordinates_mapping entry but with an empty dimensions map for now\\n\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name] = {'variable':name, 'map':[], 'coordinates': self.coordinates_names}\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Add each coordinates variable dimension to the mappable list and generate the map\\n\\t\\t\\t\\t\\t#print 'generating dimensions map for ', coord_variable.dimensions\\n\\t\\t\\t\\t\\tfor dimension in coord_variable.dimensions:\\n\\t\\t\\t\\t\\t\\t#print dimension, coord_variable.dimensions\\n\\t\\t\\t\\t\\t\\tself.coordinates_mapping[coordinate_name]['map'].append(self.variable.dimensions.index(dimension))\\n\\t\\t\\t\\t\\t\\tif not dimension.name in mapped:\\n\\t\\t\\t\\t\\t\\t\\tmapped.append(dimension.name)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t# Setup shortcut to identify time coordinate variable\\n\\t\\ttry:\\n\\t\\t\\tself.time_variable = self.variable.group.variables[self.coordinates_mapping['time']['variable']]\\n\\t\\t\\tself.time_dim = self.coordinates_mapping['time']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.time_variable = None\\n\\t\\t\\tself.time_dim = None\\n\\t\\t\\t\\n\\t\\t# Shortcuts for latitude and longitude coordinate variables\\n\\t\\ttry:\\n\\t\\t\\tself.latitude_variable = self.variable.group.variables[self.coordinates_mapping['latitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.latitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.longitude_variable = self.variable.group.variables[self.coordinates_mapping['longitude']['variable']]\\n\\t\\texcept:\\n\\t\\t\\tself.longitude_variable = None\\n\\n\\t\\ttry:\\n\\t\\t\\tself.level_variable = self.variable.group.variables[self.coordinates_mapping['level']['variable']]\\n\\t\\t\\tself.level_dim = self.coordinates_mapping['level']['map'][0]\\n\\t\\texcept:\\n\\t\\t\\tself.level_variable = None\\n\\t\\t\\tself.level_dim = None\",\n \"def compute_max(self):\\r\\n self.x_max = self.ox + self.dx*self.nx\\r\\n self.y_max = self.oy + self.dy*self.ny\\r\\n self.z_max = self.oz + self.dz*self.nz\",\n \"def replace_x_y_nominal_lat_lon(ds):\\n ds = ds.copy()\\n if 'x' in ds.dims and 'y' in ds.dims:\\n \\n nominal_y = ds.lat.mean('x')\\n # extract the equatorial lat and take those lon values as nominal lon\\n eq_ind = abs(ds.lat.mean('x')).load().argmin().data\\n nominal_x = ds.lon.isel(y=eq_ind)\\n ds.coords['x'].data = nominal_x.data\\n ds.coords['y'].data = nominal_y.data\\n\\n ds = ds.sortby('x')\\n ds = ds.sortby('y')\\n \\n else:\\n warnings.warn('No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model' %ds.attrs['source_id'])\\n return ds\",\n \"def find_max_coords(self):\\n all_max_bound = []\\n all_min_bound = []\\n shape_dict = self.shape_dict\\n for zone_id in shape_dict:\\n zone_shape = shape_dict[zone_id]\\n max_bound_zone = zone_shape.max_bound\\n min_bound_zone = zone_shape.min_bound\\n all_max_bound.append(max_bound_zone)\\n all_min_bound.append(min_bound_zone)\\n\\n map_max_bound, unused_max = Utils.calculate_boundaries(all_max_bound)\\n unused_min, map_min_bound = Utils.calculate_boundaries(all_min_bound)\\n\\n return (map_max_bound, map_min_bound)\",\n \"def get_maxdistance_landmarktoPointcloud(self):\\n if len(self.subsetnodes) == 0: # Make sure tat the landmark set is already constructed.\\n self.select()\\n landmarktopointcloud_dist = self.getLandmark_Witness_matrix()\\n self.MaxMindist = np.nanmax(np.nanmin(landmarktopointcloud_dist, axis=0)) # Compute max of the min of each column\\n return self.MaxMindist\",\n \"def _coordinate_flex_vocabulary(obj, latname=None, lonname=None):\\n if (latname is not None) or (lonname is not None):\\n try:\\n lat = obj[latname]\\n lon = obj[lonname]\\n except KeyError:\\n raise LookupError\\n\\n if (np.size(lat) > 1) and (np.size(lon) > 1):\\n lat = np.atleast_1d(lat)\\n lon = np.atleast_1d(lon)\\n return lat, lon\\n\\n vocab = [\\n {\\\"lat\\\": \\\"LATITUDE\\\", \\\"lon\\\": \\\"LONGITUDE\\\"},\\n {\\\"lat\\\": \\\"latitude\\\", \\\"lon\\\": \\\"longitude\\\"},\\n {\\\"lat\\\": \\\"lat\\\", \\\"lon\\\": \\\"lon\\\"},\\n {\\\"lat\\\": \\\"LAT\\\", \\\"lon\\\": \\\"LON\\\"},\\n ]\\n for v in vocab:\\n try:\\n lat = obj[v[\\\"lat\\\"]]\\n lon = obj[v[\\\"lon\\\"]]\\n if (np.size(lat) > 1) and (np.size(lon) > 1):\\n lat = np.atleast_1d(lat)\\n lon = np.atleast_1d(lon)\\n return lat, lon\\n except KeyError:\\n pass\\n raise LookupError\",\n \"def is_longitude_var(obj):\\n if (obj.name =='longitude'):\\n return True\\n else:\\n return False\",\n \"def magnitud_momento(slip, prof, lons, lats):\\n\\n #mu = 3*10**10 # rigidez en N/m\\n \\n # calculos previos \\n\\n maxlat = np.max(lats) # latitud maxima\\n lon_maxlat = lons[np.where(lats == maxlat)[0][0], np.where(lats == maxlat)[1][0]] # longitud correspondiente a la latitud maxima\\n minlat = np.min(lats) # latitud minima\\n lon_minlat = lons[np.where(lats == minlat)[0][0], np.where(lats == minlat)[1][0]] # longitud correspondiente a la latitud minima\\n maxlon = np.max(lons) # longitud maxima\\n lat_maxlon = lats[np.where(lons == maxlon)[0][0], np.where(lons == maxlon)[1][0]] # latitud correspondiente a la longitud maxima\\n minlon = np.min(lons) # longitud minima\\n lat_minlon = lats[np.where(lons == minlon)[0][0], np.where(lons == minlon)[1][0]]\\n maxprof = np.max(prof) # profundidad maxima\\n minprof = np.min(prof) # profundidad minima\\n \\n largo_falla = dist_sf_alt(lon_minlat, lon_maxlat, minlat, maxlat) # largo de la falla en metros\\n ancho_falla = np.sqrt((np.max(prof)-np.min(prof))**2 + dist_sf_alt( maxlon, minlon, lat_maxlon, lat_minlon)**2) # ancho de la falla\\n\\n n_fils = np.shape(lons)[0] # numero de filas\\n n_cols = np.shape(lons)[1] # numero de columnas\\n\\n # tamano subfallas\\n largo_subfalla = largo_falla/n_fils \\n ancho_subfalla = ancho_falla/n_cols \\n area_subfalla = largo_subfalla*ancho_subfalla\\n\\n # se estima el tiempo que tarda la ruptura, tau, para luego estimar la rigidez\\n # se utiliza beta = 2500 m/s\\n tau = tau_ruptura( largo_falla )\\n # se estima la rigidez de la interfaz dependiendo de la profundidad\\n rigidez = estima_rigidez( largo_falla, tau )\\n \\n # calculo Mo\\n\\n Mo = rigidez*area_subfalla*slip\\n Mo = np.sum(Mo)\\n Mw = 2.0/3.0*np.log10(Mo)-6.06\\n\\n return Mw, area_subfalla\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def lon(self):\\n return self['lon']\",\n \"def get_location_metres(original_location, dNorth, dEast):\\n earth_radius=6378137.0 #Radius of \\\"spherical\\\" earth\\n #Coordinate offsets in radians\\n dLat = dNorth/earth_radius\\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\\n\\n #New position in decimal degrees\\n newlat = original_location.lat + (dLat * 180/math.pi)\\n newlon = original_location.lon + (dLon * 180/math.pi)\\n\\n return dk.LocationGlobal(newlat, newlon,original_location.alt)\",\n \"def probaContagius(lat1,lon1,lat2,lon2,M):\\n GAMMA = 0.02\\n dlon = abs(lon2 - lon1) * 10000\\n dlat = abs(lat2 - lat1) * 10000\\n distance_Y = int(round(dlon, 0))\\n distance_X = int(round(dlat, 0))\\n proba = 0\\n if ( (distance_X>=0 and distance_X<300) and (distance_Y>=0 and distance_Y<300) ):\\n proba = GAMMA * M[distance_X][distance_Y]\\n return proba\",\n \"def get_local_maxes(self, use_full=False, strict=False, x_y=None):\\n if x_y is None:\\n if use_full:\\n x, y = self.x_full, self.y_full\\n y_offset = 0\\n else:\\n x, y = self.x, self.y\\n y_offset = self.y_offset\\n else:\\n x, y = x_y\\n y_offset = 0\\n\\n if strict:\\n # take only those greater than both adjacent\\n maxes = sps.argrelextrema(y, np.greater)[0]\\n else:\\n # take all greater/equal to both sides\\n maxes = sps.argrelextrema(y, np.greater_equal)[0]\\n\\n # check that max_y values > 0\\n maxes = maxes[y[maxes] > 0]\\n\\n # filter capped values on both sides\\n maxes = maxes[y[maxes] != 5 - y_offset]\\n\\n max_x = x[maxes]\\n max_y = y[maxes]\\n\\n return max_x, max_y\",\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 multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \\\"north\\\"):\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n\\n mlatA = self.mlatA[inds]\\n mlatB = self.mlatB[inds]\\n mlatC = self.mlatC[inds]\\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 \\n N = int((len(NeA)/n*2) - 1) #nr of windows\\n \\n dx = (secondsB[1]-secondsB[0])*self.velB[0]\\n \\n nBAs = []\\n nBCs = []\\n nACs = []\\n \\n for i in range(N):\\n startind = int(i/2*n)\\n stopind = int((i/2+1)*n)\\n temp_NeA = NeA[startind:stopind]\\n temp_NeB = NeB[startind:stopind]\\n temp_NeC = NeC[startind:stopind]\\n \\n temp_secondsA = secondsA[startind:stopind]\\n temp_secondsB = secondsB[startind:stopind]\\n temp_secondsC = secondsC[startind:stopind]\\n \\n \\n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\\n if np.sum(curr_timediff) > 2:\\n continue\\n \\n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\\n \\n if np.max(gradA) < 0.9:\\n continue\\n \\n stdA = np.std(gradA)\\n stdB = np.std(gradB)\\n stdC = np.std(gradC)\\n \\n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\\n \\n p0A = [1, meanA, stdA]\\n p0B = [1, meanB, stdB]\\n p0C = [1, meanB, stdB]\\n \\n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\\n \\n nBA = poptB[1] - poptA[1]\\n nBC = poptB[1] - poptC[1]\\n nAC = poptA[1] - poptC[1]\\n \\n nBAs.append(nBA)\\n nBCs.append(nBC)\\n nACs.append(nAC)\\n \\n \\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 V = self.velA[0]\\n for i in range(len(nBAs)):\\n VBA = self.along_track_velo(V, sBA, nBAs[i])\\n VBC = self.along_track_velo(V, sBC, nBCs[i])\\n VAC = self.along_track_velo(V, sAC, nACs[i])\\n \\n print(VBA)\\n print(VBC)\\n print(VAC)\\n print(\\\"________________________________________\\\")\",\n \"def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\\n\\n\\n if min_lon<0 and max_lon>0:\\n splitExtract = True; Turns=2\\n grdMODEL.splitExtract=splitExtract\\n else:\\n splitExtract = False; Turns=1\\n grdMODEL.splitExtract=splitExtract\\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\\n \\n # Array to store the results returned from the function\\n res=np.zeros((Turns,4),dtype=np.float64)\\n \\n lats=grdMODEL.lat[:,0]\\n lons=grdMODEL.lon[0,:]\\n\\n \\n for k in range(Turns):\\n\\n if k==0 and splitExtract == True:\\n minLon=min_lon; maxLon=0\\n minLon=minLon+360\\n maxLon=maxLon+360\\n elif k==1 and splitExtract == True:\\n minLon=0; maxLon=max_lon\\n else:\\n minLon=min_lon; maxLon=max_lon\\n \\n distances1 = []\\n distances2 = []\\n indices=[]\\n index=1\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n \\n distances1 = []\\n distances2 = []\\n index=1\\n \\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n \\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n \\n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n grdMODEL.indices=res\",\n \"def _resolution(self):\\n _, xres, _, _, _, yres = self.geotransform\\n return xres, yres\",\n \"def _calc_longitudes(self):\\n assert self.tracers\\n\\n # zp is z unit vector at all times, shape 501 x 3\\n zp = np.cross(self.p0_positions, self.p0_velocities)\\n zp = zp / np.linalg.norm(zp, axis=-1)[:, None]\\n\\n # xp and yp are x and y unit vectors\\n xp = self.p0_positions\\n xp = xp / np.linalg.norm(xp, axis=-1)[:, None]\\n yp = np.cross(zp, xp)\\n\\n # project particle positions into orbital x-y plane\\n p1_xp = np.sum(self.p1_positions * xp[:, None, :], axis=-1)\\n p1_yp = np.sum(self.p1_positions * yp[:, None, :], axis=-1)\\n p2_xp = np.sum(self.p2_positions * xp[:, None, :], axis=-1)\\n p2_yp = np.sum(self.p2_positions * yp[:, None, :], axis=-1)\\n\\n # get longitudes\\n p1_phi = np.arctan2(p1_yp, p1_xp)\\n p2_phi = np.arctan2(p2_yp, p2_xp)\\n\\n # add/subtract multiples of 2pi for particles on higher wraps.\\n dp = np.vstack((np.zeros((1, self.N1)), np.diff(p1_phi, axis=0)))\\n for j in range(self.N1):\\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\\n for i in range(changes.size):\\n p1_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\\n dp = np.vstack((np.zeros((1, self.N2)), np.diff(p2_phi, axis=0)))\\n for j in range(self.N2):\\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\\n for i in range(changes.size):\\n p2_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\\n\\n return p1_phi, p2_phi\",\n \"def get_location_metres(original_location, dNorth, dEast):\\n earth_radius = 6378137.0 #Radius of \\\"spherical\\\" earth\\n #Coordinate offsets in radians\\n dLat = dNorth/earth_radius\\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\\n\\n #New position in decimal degrees\\n newlat = original_location.lat + (dLat * 180/math.pi)\\n newlon = original_location.lon + (dLon * 180/math.pi)\\n if type(original_location) is LocationGlobal:\\n targetlocation=LocationGlobal(newlat, newlon,original_location.alt)\\n elif type(original_location) is LocationGlobalRelative:\\n targetlocation=LocationGlobalRelative(newlat, newlon,original_location.alt)\\n else:\\n raise Exception(\\\"Invalid Location object passed\\\")\\n \\n return targetlocation;\",\n \"def spatial_dimension(self):\\r\\n pass\",\n \"def getShortestCoordinate (analyzer,startLat, startLon, endLat, endLon):\\n estacionOrigen=model.getCloserStation (analyzer, startLat, startLon)\\n estacionDestino=model.getCloserStation (analyzer, endLat, endLon)\\n ruta,tiempo=model.getShortestCoordinate(analyzer,estacionOrigen, estacionDestino)\\n return (estacionOrigen,estacionDestino,ruta,tiempo)\",\n \"def Distance_orthonormique(lon1, lat1, lon2, lat2):\\r\\n \\r\\n #Convert position in radians\\r\\n lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\\r\\n #rvmT = Earth radius [km]\\r\\n rvmT = 6371 \\r\\n #Project the position on\\r\\n a = sin((lat2 - lat1)/2)**2 + cos(lat1) * cos(lat2) * sin((lon2 - lon1)/2)**2\\r\\n c = 2 * asin(sqrt(a)) \\r\\n \\r\\n d = c * rvmT\\r\\n return d\",\n \"def _calculate_location(self, map_4d):\\n\\n # MARGINALISE: Determining the 3-D coalescence map\\n self.coa_map = np.log(np.sum(np.exp(map_4d), axis=-1))\\n\\n # Normalise\\n self.coa_map = self.coa_map/np.max(self.coa_map)\\n\\n # Fit 3-D spline function to small window around max coalescence\\n # location and interpolate to determine sub-grid maximum coalescence\\n # location.\\n loc_spline = self._splineloc(np.copy(self.coa_map))\\n\\n # Apply gaussian smoothing to small window around max coalescence\\n # location and fit 3-D gaussian function to determine local\\n # expectation location and uncertainty\\n smoothed_coa_map = self._gaufilt3d(np.copy(self.coa_map))\\n loc_gau, loc_gau_err = self._gaufit3d(np.copy(smoothed_coa_map),\\n thresh=0.)\\n\\n # Calculate global covariance expected location and uncertainty\\n loc_cov, loc_cov_err = self._covfit3d(np.copy(self.coa_map))\\n\\n return loc_spline, loc_gau, loc_gau_err, loc_cov, loc_cov_err\",\n \"def test_analysis_of_vector_data_top_N(self):\\n\\n for vectorname in ['test_buildings.shp',\\n 'tsunami_building_exposure.shp']:\\n\\n filename = '%s/%s' % (TESTDATA, vectorname)\\n layer = read_layer(filename)\\n attributes = layer.get_data()\\n\\n # Check exceptions\\n try:\\n L = layer.get_topN(attribute='FLOOR_AREA', N=0)\\n except VerificationError:\\n pass\\n else:\\n msg = 'Exception should have been raised for N == 0'\\n raise Exception(msg)\\n\\n # Check results\\n for N in [5, 10, 11, 17]:\\n if vectorname == 'test_buildings.shp':\\n L = layer.get_topN(attribute='FLOOR_AREA', N=N)\\n assert len(L) == N\\n\\n msg = ('Got projection %s, expected %s' %\\n (L.projection, layer.projection))\\n assert L.projection == layer.projection, msg\\n #print [a['FLOOR_AREA'] for a in L.attributes]\\n elif vectorname == 'tsunami_building_exposure.shp':\\n L = layer.get_topN(attribute='STR_VALUE', N=N)\\n assert len(L) == N\\n assert L.get_projection() == layer.get_projection()\\n val = [a['STR_VALUE'] for a in L.data]\\n\\n ref = [a['STR_VALUE'] for a in attributes]\\n ref.sort()\\n\\n assert numpy.allclose(val, ref[-N:],\\n atol=1.0e-12, rtol=1.0e-12)\\n else:\\n raise Exception\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def __test(inLat, inLong, inZone=False):\\n e, n, z = utm_from_lonlat(inLong, inLat, inZone)\\n lon, lat = lonlat_from_utm(e, n, z)\\n\\n return z, e, n, lon, lat\",\n \"def bounds(self):\\n\\n if self.size == 0:\\n lo, hi = np.nan, np.nan\\n elif self.is_monotonic:\\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\\n elif self.dtype is np.datetime64:\\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\\n else:\\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\\n\\n return lo, hi\",\n \"def calculate_vars(data, lat, lon):\\n # Keep track of running distance and time calculations\\n distance_to_dest = 0.0\\n time_estimate = 0.0\\n\\n # Calculate from starting dest to first point in data\\n user_coords = (lat, lon)\\n first_path_coords = (data[0][\\\"lat\\\"], data[0][\\\"lon\\\"])\\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\\n distance_to_dest += first_distance\\n time_estimate += first_distance * 20 # 3mph walking speed\\n\\n # Calculate for all other points\\n for i in range(1, len(data) - 1):\\n this_coords = (data[i][\\\"lat\\\"], data[i][\\\"lon\\\"])\\n next_coords = (data[i + 1][\\\"lat\\\"], data[i + 1][\\\"lon\\\"])\\n\\n distance = geopy.distance.distance(this_coords, next_coords).miles\\n distance_to_dest += distance\\n time_estimate += distance * 20 # 3mph walking speed\\n\\n # Round distance and time estimates\\n distance_to_dest = round(distance_to_dest, 1)\\n time_estimate = round(time_estimate)\\n\\n return distance_to_dest, time_estimate\",\n \"def get_max_score(location_list, grid, shape):\",\n \"def stageData(self,m):\\n obs = Variable(filename = self.source,\\n variable_name = self.variable,\\n alternate_vars = self.alternate_vars)\\n if obs.time is None: raise il.NotTemporalVariable()\\n self.pruneRegions(obs)\\n \\n # Try to extract a commensurate quantity from the model\\n mod = m.extractTimeSeries(self.variable,\\n alt_vars = self.alternate_vars,\\n expression = self.derived,\\n initial_time = obs.time_bnds[ 0,0],\\n final_time = obs.time_bnds[-1,1],\\n lats = None if obs.spatial else obs.lat,\\n lons = None if obs.spatial else obs.lon)\\n obs,mod = il.MakeComparable(obs,mod,\\n mask_ref = True,\\n clip_ref = True,\\n extents = self.extents,\\n logstring = \\\"[%s][%s]\\\" % (self.longname,m.name))\\n \\n # Check the order of magnitude of the data and convert to help avoid roundoff errors\\n def _reduceRoundoffErrors(var):\\n if \\\"s-1\\\" in var.unit: return var.convert(var.unit.replace(\\\"s-1\\\",\\\"d-1\\\"))\\n if \\\"kg\\\" in var.unit: return var.convert(var.unit.replace(\\\"kg\\\" ,\\\"g\\\" ))\\n return var\\n def _getOrder(var):\\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\\n order = _getOrder(obs)\\n count = 0\\n while order < -2 and count < 2:\\n obs = _reduceRoundoffErrors(obs)\\n order = _getOrder(obs)\\n count += 1\\n \\n # convert the model data to the same unit\\n mod = mod.convert(obs.unit)\\n\\n return obs,mod\",\n \"def get_location_metres(original_location, dNorth, dEast):\\n earth_radius=6378137.0 #Radius of \\\"spherical\\\" earth\\n #Coordinate offsets in radians\\n dLat = dNorth/earth_radius\\n dLon = dEast/(earth_radius*math.cos(math.pi*original_location.lat/180))\\n\\n #New position in decimal degrees\\n newlat = original_location.lat + (dLat * 180/math.pi)\\n newlon = original_location.lon + (dLon * 180/math.pi)\\n return LocationGlobal(newlat, newlon,original_location.alt)\",\n \"def get_location_metres(original_location, dNorth, dEast):\\n earth_radius = 6378137.0 #Radius of \\\"spherical\\\" earth\\n #Coordinate offsets in radians\\n dLat = dNorth / earth_radius\\n dLon = dEast / (earth_radius * math.cos(math.pi * original_location.lat /\\n 180))\\n\\n #New position in decimal degrees\\n newlat = original_location.lat + (dLat * 180 / math.pi)\\n newlon = original_location.lon + (dLon * 180 / math.pi)\\n return LocationGlobal(newlat, newlon, original_location.alt)\",\n \"def M(latitude):\\n return a*(1.0-e2)/pow((1.0-e2)*pow(math.sin(latitude),2.0),3.0/2.0);\",\n \"def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\\n\\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def retrieve_point(invar,kpt,nlat5,nlon5,okpts):\\n # Get Value\\n vrow = invar[kpt,:]\\n \\n # Place into variable\\n mappt = np.zeros(nlat5*nlon5)*np.nan\\n mappt[okpts] = vrow\\n mappt = mappt.reshape(nlat5,nlon5)\\n return mappt\",\n \"def MercatorBounds(lat, lng, lod):\\n\\n num_tiles = 1 << lod\\n\\n (west, east) = LongitudinalBounds(lng, num_tiles)\\n\\n # Normalize to between -90 and 90 degrees latitude.\\n while lat < -90.0:\\n lat += 180.0\\n while lat >= 90.0:\\n lat -= 180.0\\n\\n y = int(ToMercPosition(lat, num_tiles))\\n south = ToMercDegrees(y, num_tiles)\\n north = ToMercDegrees(y + 1, num_tiles)\\n\\n return {\\n \\\"south\\\": south,\\n \\\"north\\\": north,\\n \\\"west\\\": west,\\n \\\"east\\\": east\\n }\",\n \"def msl_nn_srtm_interp(self, lon_lat):\\n tiles = self.find_srtm_tiles(lon_lat)\\n lon_lat_msl = np.zeros((lon_lat.shape[0], 3))\\n lon_lat_msl[:, 0:2] = lon_lat\\n for tile in set(tiles):\\n otile = rasterio.open(tile, 'r')\\n oimg = otile.read(1)\\n idx = np.where(np.array(tiles) == tile)[0]\\n pix = feat.geo_to_pix(\\n otile.affine, lon_lat[idx, 0], lon_lat[idx, 1])\\n pix = np.round(pix).astype(np.int)\\n lon_lat_msl[idx, 2] = oimg[pix[:, 1], pix[:, 0]]\\n otile.close()\\n nan_mask = lon_lat_msl[:, 2] == -32768\\n lon_lat_msl[nan_mask, 2] = np.NaN\\n return lon_lat_msl\",\n \"def a_test2_mh():\\n model = ARIMAX(formula=\\\"y ~ x1 + x2\\\", data=data, ar=1, ma=1, family=Exponential())\\n x = model.fit('M-H',nsims=300)\\n assert(len(model.latent_variables.z_list) == 5)\\n lvs = np.array([i.value for i in model.latent_variables.z_list])\\n assert(len(lvs[np.isnan(lvs)]) == 0)\",\n \"def safeProj(proj, lon, lat):\\n x, y = proj(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_nodes(self, latlon=False):\\n ids = np.where(np.isnan(self.data[:,:,:]))\\n i_nan = ids[0][0] ; j_nan = ids[1][0]\\n \\n def area_neighbours(Area, i_nan, j_nan):\\n rows = np.array(Area)[:,0]\\n cols = np.array(Area)[:,1]\\n rows_m = rows-1\\n cols_m = cols-1\\n rows_p = rows+1\\n cols_p = cols+1\\n \\n p1 = np.array([rows_m,cols]).ravel().reshape(len(rows),2,order='F')\\n p2 = np.array([rows_p,cols]).ravel().reshape(len(rows),2,order='F')\\n p3 = np.array([rows,cols_m]).ravel().reshape(len(rows),2,order='F')\\n p4 = np.array([rows,cols_p]).ravel().reshape(len(rows),2,order='F')\\n cond1 = p1[:,0]<0\\n cond2 = p2[:,0]>self.dimX-1\\n cond3 = p3[:,1]<0\\n cond4 = p4[:,1]>self.dimY-1\\n if latlon:\\n p3[:,1][cond3] = self.dimY-1\\n p4[:,1][cond4] = 0\\n else:\\n p3[:,0][cond3] = i_nan\\n p3[:,1][cond3] = j_nan\\n p4[:,0][cond4] = i_nan\\n p4[:,1][cond4] = j_nan\\n p1[:,0][cond1] = i_nan\\n p1[:,1][cond1] = j_nan\\n p2[:,0][cond2] = i_nan\\n p2[:,1][cond2] = j_nan\\n p = np.concatenate((p1,p2,p3,p4)).tolist()\\n return [i for i in p if i not in self.unavail]\\n\\n def area_max_correlation(Area, neighbours):\\n Rmean = [] ; X = []\\n for cell in neighbours:\\n R = []\\n new_cell = cell[0]*self.dimY + cell[1]\\n if new_cell in self.gridcells:\\n X.append(cell)\\n IDm = np.where(self.gridcells==new_cell)\\n Rmean.append(np.nanmean(self.corrs[cells_in_k,IDm]))\\n try:\\n Rmax = np.nanmax(Rmean)\\n except ValueError:\\n Rmax = np.nan\\n return np.array(X), Rmean, Rmax\\n \\n def diag_indices(a, k):\\n rows, cols = np.diag_indices_from(a)\\n if k < 0:\\n return rows[-k:], cols[:k]\\n elif k > 0:\\n return rows[:-k], cols[k:]\\n else:\\n return rows, cols\\n\\n #S T E P 1 (C R E A T E N O D E S)\\n\\n self.nodes = {}\\n self.unavail = []\\n if latlon:\\n neighbour_corrs1 = self.corrs.diagonal(offset=1)\\n neighbour_corrs2 = self.corrs.diagonal(offset=self.dimY-1)\\n subset = np.arange(0,len(neighbour_corrs2),self.dimY)\\n neighbour_corrs2 = neighbour_corrs2[subset]\\n neighbour_corrs = np.concatenate((neighbour_corrs1,neighbour_corrs2))\\n\\n cellIDs1 = diag_indices(self.corrs,1)\\n cellIDs2 = diag_indices(self.corrs,self.dimY-1)\\n\\n cellIDs = (np.concatenate((cellIDs1[0],cellIDs2[0][subset])),\\\\\\n np.concatenate((cellIDs1[1],cellIDs2[1][subset])))\\n else:\\n neighbour_corrs = self.corrs.diagonal(offset=1)\\n cellIDs = diag_indices(self.corrs,1)\\n \\n cellIDs = (self.gridcells[cellIDs[0]],self.gridcells[cellIDs[1]])\\n k = 0\\n neighbour_corrs,cellIDs1,cellIDs2 = list(zip(*sorted(zip(neighbour_corrs,cellIDs[0],cellIDs[1]),reverse=True)))\\n cell_IDs = (cellIDs1,cellIDs2)\\n np.random.seed(2)\\n for it in range(len(neighbour_corrs)):\\n cells_in_k = []\\n i = cell_IDs[0][it]\\n j = cell_IDs[1][it]\\n r = neighbour_corrs[it]\\n \\n row_i = int(np.floor(i/self.dimY)) ; col_i = int(i % self.dimY)\\n row_j = int(np.floor(j/self.dimY)) ; col_j = int(j % self.dimY)\\n \\n if ([row_i,col_i] not in self.unavail) & ([row_j,col_j] not in self.unavail):\\n if r>self.tau:\\n self.nodes.setdefault(k, []).append([row_i,col_i])\\n self.nodes.setdefault(k, []).append([row_j,col_j])\\n self.unavail.append([row_i,col_i])\\n self.unavail.append([row_j,col_j])\\n cells_in_k.extend(np.where(self.gridcells==i)[0])\\n cells_in_k.extend(np.where(self.gridcells==j)[0])\\n\\n while True: #expand\\n neighbours = area_neighbours(self.nodes[k], i_nan, j_nan)\\n X, Rmean, Rmax = area_max_correlation(Area=self.nodes[k], neighbours=neighbours)\\n if Rmax > self.tau:\\n m = X[Rmean==Rmax].tolist()\\n if len(m)>1:\\n m = m[np.random.randint(low=0,high=len(m))]\\n else:\\n m = m[0]\\n self.nodes.setdefault(k, []).append(m)\\n self.unavail.append(m)\\n cells_in_k.extend(np.where(self.gridcells==m[0]*self.dimY+m[1])[0])\\n else:\\n break\\n if len(self.nodes[k]) <= 2:\\n del self.nodes[k]\\n k += 1\\n else:\\n break\\n \\n #S T E P 2 (M E R G E N O D E S)\\n \\n self.unavail = []\\n while True:\\n Rs = {}\\n unavail_neighbours = {}\\n num_cells = dict([(area,len(self.nodes[area])) if self.nodes[area] not in self.unavail else (area,np.inf) for area in self.nodes.keys()])\\n maxID = min(num_cells.items(), key=operator.itemgetter(1))[0]\\n if num_cells[maxID] > 175: #arbitrary choice?\\n break\\n else:\\n cells_in_k = [np.where(self.gridcells==cell[0]*self.dimY+cell[1])[0] for cell in self.nodes[maxID]]\\n neighbours = area_neighbours(self.nodes[maxID], i_nan, j_nan)\\n for cell in neighbours:\\n gcell = cell[0]*self.dimY + cell[1]\\n Rmean = []\\n cond1 = gcell in self.gridcells\\n cond2 = cell not in self.nodes[maxID]\\n cond3 = cell not in [k for k, g in itertools.groupby(sorted(itertools.chain(*unavail_neighbours.values())))]\\n cond4 = len([area for area, cells in self.nodes.items() if cell in cells]) > 0\\n if (cond1) & (cond2) & (cond3) & (cond4):\\n nID = [area for area, cells in self.nodes.items() if cell in cells][0]\\n unavail_neighbours[nID] = self.nodes[nID]\\n X, Rmean, Rmax = area_max_correlation(Area=self.nodes[nID]+self.nodes[maxID], neighbours=self.nodes[nID]+self.nodes[maxID])\\n if nID not in Rs: \\n Rs[nID] = np.nanmean(Rmean)\\n try:\\n Rs_maxID = max(Rs.items(), key=operator.itemgetter(1))[0]\\n if Rs[Rs_maxID] > self.tau:\\n for cell in self.nodes.pop(Rs_maxID, None):\\n self.nodes.setdefault(maxID, []).append([cell[0],cell[1]])\\n else:\\n self.unavail.append(self.nodes[maxID])\\n except ValueError:\\n self.unavail.append(self.nodes[maxID])\",\n \"def decide_resolution(vec):\\n if N >= NOld and M >= MOld:\\n ovec = increase_resolution(vec)\\n\\n elif N <= NOld and M <= MOld:\\n ovec = decrease_resolution(vec)\\n\\n return ovec\",\n \"def get_map_sphere_variance(self, i_seq):\\n return self._map_variances[i_seq]\",\n \"def test_coord_preceding_fs(self):\",\n \"def check_location_confidence(self):\\n\\t\\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\\n\\t\\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\\n\\t\\tepsilon_meters = .08\\n\\t\\tpixel_distances = []\\n\\t\\tactual_distances = []\\n\\t\\tnum_observed = 0\\n\\t\\tfor ti in self.targs:\\n\\t\\t\\tif ti.props_are_set:\\n\\t\\t\\t\\tfor tj in self.targs:\\n\\t\\t\\t\\t\\tif tj.props_are_set: \\n\\t\\t\\t\\t\\t\\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\\n\\t\\t\\t\\t\\t\\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\\n\\t\\t\\t\\t\\t\\tif pixel_dist == 0:\\n\\t\\t\\t\\t\\t\\t\\tpixel_dist = 10000 #ignore two of the same points\\n\\t\\t\\t\\t\\t\\t\\tactual_dist = 10000\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(pixel_dist)\\t\\n\\t\\t\\t\\t\\t\\tactual_distances.append(actual_dist)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor _ in self.targs:\\n\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\tmin_ind_pixel = np.argmin(pixel_distances)\\n\\t\\tmin_ind_actual = np.argmin(actual_distances)\\n\\t\\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\\n\\t\\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\\n\\t\\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\\n\\t\\t\\t#measurements are not trustworthy, return nothing\\n\\t\\t\\treturn None\\n\\n\\t\\treturn best_guys\",\n \"def mag2(self) -> numbers.Number:\\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\\n return mv_val[0]\",\n \"def calcPosition (lat, lon):\\n nauticalMilePerLat = 60.00721\\n nauticalMilePerLongitude = 60.10793\\n rad = math.pi / 180.0\\n milesPerNauticalMile = 1.15078\\n \\n y = lat * nauticalMilePerLat\\n x = math.cos(lat * rad) * lon * nauticalMilePerLongitude\\n\\n return x * milesPerNauticalMile * 1609.344, y * milesPerNauticalMile * 1609.344\",\n \"def get_distance_metres(aLocation1, aLocation2):\\n dlat = aLocation2.lat - aLocation1.lat\\n dlong = aLocation2.lon - aLocation1.lon\\n dlong *= math.cos( aLocation2.lat * math.pi / 180.0 )\\n return math.sqrt((dlat*dlat) + (dlong*dlong)) * 1.113195e5\",\n \"def get_min_max(self) -> tuple:\\r\\n\\r\\n minimum = float(\\\"inf\\\")\\r\\n maximum = float(\\\"-inf\\\")\\r\\n\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n if self.trees[name][\\\"point_helper\\\"] is None:\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n return minimum, maximum\",\n \"def get_dimensional_measurements():\\n return Global_Module.global_dimensional_measurements\",\n \"def get_data(n):\\n data = pd.read_csv('map_data/lior_results_2.csv')\\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\\n data = data[data.binomial != 'Sus bucculentus'] # EX\\n data = data[data.binomial != 'Melomys rubicola'] # EX\\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\\n total_mass_density=data.AdultBodyMassG * data.pop_density)\\n data = data.sort_values(by='total_mass_density', ascending=False)\\n data = data.iloc[0:n - 1]\\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\\\"EPSG:6933\\\")\\n geo_data = geo_data[geo_data.category != 'EX']\\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\\n (geo_data['legend'] == 'Extant (non breeding)') |\\n (geo_data['legend'] == 'Extant (resident)') |\\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Probably Extant (resident)') |\\n (geo_data['legend'] == 'Reintroduced')]\\n range_polygons = range_polygons.merge(data, on='binomial')\\n range_polygons = range_polygons.to_crs(\\\"EPSG:6933\\\")\\n return range_polygons\",\n \"def extractvalues( locs: torch.tensor,\\n x_os: torch.tensor,\\n y_os: torch.tensor,\\n z_os: torch.tensor,\\n ints:torch.tensor, dim: int=3):\\n\\n dim = tuple([1 for i in range(dim)])\\n coord = tuple(locs.nonzero().transpose(1,0))\\n x_os_val = x_os[coord].reshape(-1, *dim)\\n y_os_val = y_os[coord].reshape(-1, *dim)\\n z_os_val = z_os[coord].reshape(-1, *dim)\\n ints_val = ints[coord].reshape(-1, *dim)\\n return x_os_val, y_os_val, z_os_val, ints_val\",\n \"def testLengthsOfLocalization(self):\\n\\t\\tloc_len = len(self.d3.loc_terms)\\n\\t\\tself.assertEqual(14, loc_len)\",\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 dist_sf_alt( lon1, lon2, lat1, lat2 ):\\n\\n dist = Geodesic.WGS84.Inverse( lat1, lon1, lat2, lon2 )[ \\\"s12\\\" ]\\n \\n return dist\",\n \"def dist_sf( lon1, lon2, lat1, lat2 ):\\n\\n subfalla_i = (lon1, lat1)\\n subfalla_j = (lon2, lat2)\\n distancia = distance.distance( subfalla_i, subfalla_j ).meters\\n\\n return distancia\",\n \"def _multiple_values_max(self, maps, threshold):\\r\\n max_val = np.zeros((maps.shape[0], maps.shape[1]), dtype=np.float)\\r\\n for i in range(maps.shape[1]):\\r\\n cmin = np.min(maps[:,i])\\r\\n cmax = np.max(maps[:,i])\\r\\n limit = cmax - (cmax - cmin) * threshold[i]\\r\\n min_mask = maps[:,i] <= limit\\r\\n max_mask = maps[:,i] > limit\\r\\n # for an abundance map the delta is around [-1..1],\\r\\n # but it can be outside this interval, it's something\\r\\n # to test\\r\\n # a guard with a -10 value maybe ok.\\r\\n rmin = min_mask * -10\\r\\n max_val[:,i] = max_mask * maps[:,i] + rmin\\r\\n max_vec = np.max(max_val, axis=1)\\r\\n max_mask = max_vec > -10\\r\\n argmax = np.argmax(max_val, axis=1)\\r\\n return (argmax + 1) * max_mask\",\n \"def calcMetresDistance(lat1, long1, lat2, long2):\\n return (abs(lat1 - lat2) + abs(long1 - long2)) * 100\\n # no, like, really badly\",\n \"def merc(lat, lon):\\n\\tr_major = 6378137.000\\n\\tx = r_major * math.radians(lon)\\n\\tscale = x/lon\\n\\ty = 180.0/math.pi * math.log(math.tan(math.pi/4.0 + lat * (math.pi/180.0)/2.0)) * scale\\n\\treturn (x, y)\",\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 _get_dlon_dlat_km(self):\\n self.dlon_km=np.array([])\\n self.dlat_km=np.array([])\\n for lat in self.lat:\\n dist_lon, az, baz = obspy.geodetics.gps2dist_azimuth(lat, 0., lat, self.dlon)\\n dist_lat, az, baz = obspy.geodetics.gps2dist_azimuth(lat, 0., lat+self.dlat, 0.)\\n self.dlon_km=np.append(self.dlon_km, dist_lon/1000.)\\n self.dlat_km=np.append(self.dlat_km, dist_lat/1000.)\\n self.dlon_kmArr=(np.tile(self.dlon_km, self.Nlon).reshape(self.Nlon, self.Nlat)).T\\n self.dlat_kmArr=(np.tile(self.dlat_km, self.Nlon).reshape(self.Nlon, self.Nlat)).T\\n return\",\n \"def spatial_expval(map_):\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * x), np.sum(map_ * y)\",\n \"def CreateTargetGeoField(nbtimestep,latlen,lonlen):\\n\\n pres_grid = np.zeros((nbtimestep, latlen, lonlen))\\n u_grid = np.zeros((nbtimestep, latlen, lonlen))\\n v_grid = np.zeros((nbtimestep, latlen, lonlen))\\n\\n return pres_grid,u_grid,v_grid\",\n \"def find_max_score_location(grid, shape):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68968886","0.66709334","0.6106323","0.59900844","0.5892058","0.57636064","0.57299185","0.5693455","0.5671543","0.56326985","0.5609396","0.5597439","0.5474902","0.5423528","0.5386049","0.53539693","0.5313379","0.5313333","0.53117704","0.53086036","0.530855","0.53082246","0.5274431","0.526225","0.5235767","0.522743","0.5209887","0.52091694","0.52030355","0.5142041","0.5140875","0.51317716","0.51285607","0.5113935","0.5096447","0.5092166","0.5091167","0.5081426","0.50782436","0.5070363","0.5063611","0.5053873","0.50455314","0.50432837","0.50417256","0.5034586","0.5029282","0.50226176","0.50120294","0.50085944","0.5004577","0.50043666","0.5000785","0.500001","0.4998804","0.49868613","0.49807063","0.49780726","0.49749213","0.49694553","0.49643236","0.49564132","0.49543366","0.49358052","0.49286675","0.49253875","0.4921005","0.49190187","0.49165922","0.49049842","0.49035105","0.49031508","0.48985663","0.4894767","0.48935196","0.48921368","0.48870304","0.48859546","0.48853117","0.48797983","0.4867577","0.48667368","0.48638368","0.48574156","0.4856665","0.4855404","0.4851924","0.48432115","0.48429334","0.4842513","0.48420894","0.4840901","0.4840112","0.48386863","0.4836885","0.48322675","0.48291692","0.48216695","0.48209384","0.48162663"],"string":"[\n \"0.68968886\",\n \"0.66709334\",\n \"0.6106323\",\n \"0.59900844\",\n \"0.5892058\",\n \"0.57636064\",\n \"0.57299185\",\n \"0.5693455\",\n \"0.5671543\",\n \"0.56326985\",\n \"0.5609396\",\n \"0.5597439\",\n \"0.5474902\",\n \"0.5423528\",\n \"0.5386049\",\n \"0.53539693\",\n \"0.5313379\",\n \"0.5313333\",\n \"0.53117704\",\n \"0.53086036\",\n \"0.530855\",\n \"0.53082246\",\n \"0.5274431\",\n \"0.526225\",\n \"0.5235767\",\n \"0.522743\",\n \"0.5209887\",\n \"0.52091694\",\n \"0.52030355\",\n \"0.5142041\",\n \"0.5140875\",\n \"0.51317716\",\n \"0.51285607\",\n \"0.5113935\",\n \"0.5096447\",\n \"0.5092166\",\n \"0.5091167\",\n \"0.5081426\",\n \"0.50782436\",\n \"0.5070363\",\n \"0.5063611\",\n \"0.5053873\",\n \"0.50455314\",\n \"0.50432837\",\n \"0.50417256\",\n \"0.5034586\",\n \"0.5029282\",\n \"0.50226176\",\n \"0.50120294\",\n \"0.50085944\",\n \"0.5004577\",\n \"0.50043666\",\n \"0.5000785\",\n \"0.500001\",\n \"0.4998804\",\n \"0.49868613\",\n \"0.49807063\",\n \"0.49780726\",\n \"0.49749213\",\n \"0.49694553\",\n \"0.49643236\",\n \"0.49564132\",\n \"0.49543366\",\n \"0.49358052\",\n \"0.49286675\",\n \"0.49253875\",\n \"0.4921005\",\n \"0.49190187\",\n \"0.49165922\",\n \"0.49049842\",\n \"0.49035105\",\n \"0.49031508\",\n \"0.48985663\",\n \"0.4894767\",\n \"0.48935196\",\n \"0.48921368\",\n \"0.48870304\",\n \"0.48859546\",\n \"0.48853117\",\n \"0.48797983\",\n \"0.4867577\",\n \"0.48667368\",\n \"0.48638368\",\n \"0.48574156\",\n \"0.4856665\",\n \"0.4855404\",\n \"0.4851924\",\n \"0.48432115\",\n \"0.48429334\",\n \"0.4842513\",\n \"0.48420894\",\n \"0.4840901\",\n \"0.4840112\",\n \"0.48386863\",\n \"0.4836885\",\n \"0.48322675\",\n \"0.48291692\",\n \"0.48216695\",\n \"0.48209384\",\n \"0.48162663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7268381"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19881,"cells":{"query":{"kind":"string","value":"returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest level points but whose values are the levels"},"document":{"kind":"string","value":"def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv"},"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 select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\n else:\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\n if ids is None or len(ids)==0:\n ig = len(levax)-1\n else:\n ig = ids[0][0]\n # Crude fist cut: don't interpolate, just return a value\n if levax == mv.getAxisList()[0]:\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\n elif levax == mv.getAxisList()[1]:\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\n else:\n print \"ERROR, select_lev() does not support level axis except as first or second dimentions\"\n return None\n return mvs","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def dim2():\n probs = (0.1, 0.2, 0.3, 0.4)\n categories = (\"asdfa\", \"2\", \"3\", \"4\")\n categories = OrderedDict(zip(categories, probs))\n dim2 = Categorical(\"yolo2\", categories, default_value=\"2\")\n return dim2","def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv","def getLevel(unique_name):","def getLevels():","def main_trees_quick(df):\n groups = df.groupby(['tree', 'scale'])\n try:\n mmp = groups.mvir.transform(np.max) == df.mvir\n except (KeyError, AttributeError):\n mmp = groups.Mvir.transform(np.max) == df.Mvir\n return mmp","def est_maxlevel(dims,bandwidth):\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\n lev=int(lev)\n return lev","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def resolution(self, level):\n return 2 ** (level - 1)","def _determine_level(levels, points):\n import operator\n level = None\n sorted_levels = sorted(levels.iteritems(), key=operator.itemgetter(1))\n for el in sorted_levels:\n if points <= el[1]:\n level = el[0]\n break\n\n max_level = max(levels.iterkeys(), key=lambda threshold: levels[threshold])\n if points >= levels[max_level]:\n level = max_level\n return level","def get_level_mag(slide, level):\n return level_mags(slide)[level]","def levshape(self) -> Shape:\n return tuple(len(x) for x in self.levels)","def max_diaphragmatic_level(levels):\n return [max(x) for x in levels]","def zoomlevels(self):\n return self._bboxes[0][1] #TODO: merge all coverages","def map_roi_levels(self, rois, num_levels):\r\n scale = torch.sqrt(\r\n (rois[:, 3] - rois[:, 1] + 1) * (rois[:, 4] - rois[:, 2] + 1))\r\n target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6))\r\n target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()\r\n return target_lvls","def get_var_level_index(sample_size, threshold):\n if sample_size <= 0:\n raise ValueError(\"Sample size cannot be non-positive:\", sample_size)\n if threshold <= 0.0:\n return 0\n if threshold >= 1.0:\n return sample_size - 1\n return int(math.floor(sample_size * threshold))","def enforce(self, wave, variables, parameters):\n return np.hstack([variables[0] - self.level])","def test_lfc_ml2():\n levels = np.array([1024.95703125, 1016.61474609, 1005.33056641, 991.08544922, 973.4163208,\n 951.3381958, 924.82836914, 898.25482178, 873.46124268, 848.69830322,\n 823.92553711, 788.49304199, 743.44580078, 700.50970459, 659.62017822,\n 620.70861816, 583.69421387, 548.49719238, 515.03826904, 483.24401855,\n 453.0418396, 424.36477661, 397.1505127, 371.33441162, 346.85922241,\n 323.66995239, 301.70935059, 280.92651367, 261.27053833, 242.69168091,\n 225.14237976, 208.57781982, 192.95333862, 178.22599792, 164.39630127,\n 151.54336548, 139.68635559, 128.74923706, 118.6588974, 109.35111237,\n 100.76405334, 92.84288025, 85.53556824, 78.79430389, 72.57549286,\n 66.83885193, 61.54678726, 56.66480637, 52.16108322]) * units.mbar\n temperatures = np.array([6.00750732, 5.14892578, 4.177948, 3.00268555, 1.55535889,\n -0.25527954, -1.93988037, -3.57766724, -4.40600586, -4.19238281,\n -3.71185303, -4.47943115, -6.81280518, -8.08685303, -8.41287231,\n -10.79302979, -14.13262939, -16.85784912, -19.51675415,\n -22.28689575, -24.99938965, -27.79664612, -30.90414429,\n -34.49435425, -38.438797, -42.27981567, -45.99230957,\n -49.75340271, -53.58230591, -57.30686951, -60.76026917,\n -63.92070007, -66.72470093, -68.97846985, -70.4264679,\n -71.16407776, -71.53797913, -71.64375305, -71.52735901,\n -71.53523254, -71.61097717, -71.92687988, -72.68682861,\n -74.129776, -76.02471924, -76.88977051, -76.26008606,\n -75.90351868, -76.15809631]) * units.celsius\n dewpoints = np.array([4.50012302, 3.42483997, 2.78102994, 2.24474645, 1.593485, -0.9440815,\n -3.8044982, -3.55629468, -9.7376976, -10.2950449, -9.67498302,\n -10.30486488, -8.70559597, -8.71669006, -12.66509628, -18.6697197,\n -23.00351334, -29.46240425, -36.82178497, -41.68824768, -44.50320816,\n -48.54426575, -52.50753403, -51.09564209, -48.92690659, -49.97380829,\n -51.57516098, -52.62096405, -54.24332809, -57.09109879, -60.5596199,\n -63.93486404, -67.07530212, -70.01263428, -72.9258728, -76.12271881,\n -79.49847412, -82.2350769, -83.91127014, -84.95665741, -85.61238861,\n -86.16391754, -86.7653656, -87.34436035, -87.87495422, -88.34281921,\n -88.74453735, -89.04680634, -89.26436615]) * units.celsius\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof, td_mixed)\n assert_almost_equal(lfc_pressure, 962.34 * units.mbar, 2)\n assert_almost_equal(lfc_temp, 0.767 * units.degC, 2)","def level(self):\n return self.init_v[2]","def dims(self):\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)","def get_map_size(level):\n if level < 5:\n return 5, 5\n if level < 70:\n return 10, 10\n if level < 150:\n return 25, 25\n return 50, 50","def estimate_var(sample, threshold):\n sample_size = len(sample)\n index_at = get_var_level_index(sample_size, threshold)\n sample.sort()\n return sample[index_at]","def _get_level_values(self, level: int, unique: bool = False) -> Index:\n lev = self.levels[level]\n level_codes = self.codes[level]\n name = self._names[level]\n if unique:\n level_codes = algos.unique(level_codes)\n filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)\n return lev._shallow_copy(filled, name=name)","def zernike_Double_Index(nlevels):\n \n\t \n if not (nlevels>=0):\n print('Input parameter nlevels must be >= 0')\n raise AssertionError()\n \n if (nlevels == 0):\n \n m = 0\n n = 0\n \n return n, m\n \n else:\n \n # ++++ Defining layout for row number n and colunmn number m ++++++++\n\n row_n = nlevels+1\n col_m = 2*nlevels +1\n x = np.arange(row_n)\n y = np.arange(-(col_m-1)//2, (col_m+1)//2,1)\n Q = [(i,j) for i in x for j in y]\n #\n\n\n nm_index = []\n \n top = (col_m + 1)/2\n leftside = row_n*col_m - col_m + 1\n rightside = row_n*col_m \n\n k1 = 0; k2 = 0\n\n for i in xrange(top,row_n*col_m+1, 2*col_m):\n\n nm_index.append(Q[i-1])\n s1 = i + col_m + 1\n s2 = i + col_m - 1 \n jj1 = k1\n jj2 = k2\n\n\n while (s2 <= leftside): \n\n nm_index.append(Q[s2-1])\n s2 +=col_m - 1\n jj1 += 1\n jj2 -= 1\n\n leftside +=2\n\n jj1 = k1\n jj2 = k2\n\n while (s1 <= rightside): \n\n # \n nm_index.append(Q[s1-1])\n s1 +=col_m + 1\n jj1 += 1\n jj2 += 1\n\n rightside -=2\n k1 = 0; k2 += 2\n\n n = np.array(nm_index)[:,0]\n m = np.array(nm_index)[:,1]\n\n return n, m","def mi(self, lhs, rhs, cond=None):\n\t\tbins = np.amax(data, axis=0) # read levels for each variable\n\t\tif len(bins) == 1:\n\t\t\thist,_ = np.histogramdd(data, bins=(bins)) # frequency counts\n\t\t\tPx = hist/hist.sum()\n\t\t\tMI = -1 * np.sum( Px * np.log( Px ) )\n\t\t\treturn round(MI, 4)\n\t\t\t\n\t\tif len(bins) == 2:\n\t\t\thist,_ = np.histogramdd(data, bins=bins[0:2]) # frequency counts\n\n\t\t\tPxy = hist / hist.sum()# joint probability distribution over X,Y,Z\n\t\t\tPx = np.sum(Pxy, axis = 1) # P(X,Z)\n\t\t\tPy = np.sum(Pxy, axis = 0) # P(Y,Z)\t\n\n\t\t\tPxPy = np.outer(Px,Py)\n\t\t\tPxy += 1e-7\n\t\t\tPxPy += 1e-7\n\t\t\tMI = np.sum(Pxy * np.log(Pxy / (PxPy)))\n\t\t\treturn round(MI,4)\n\t\telif len(bins) > 2 and conditional==True:\n\t\t\t# CHECK FOR > 3 COLUMNS -> concatenate Z into one column\n\t\t\tif len(bins) > 3:\n\t\t\t\tdata = data.astype('str')\n\t\t\t\tncols = len(bins)\n\t\t\t\tfor i in range(len(data)):\n\t\t\t\t\tdata[i,2] = ''.join(data[i,2:ncols])\n\t\t\t\tdata = data.astype('int')[:,0:3]\n\n\t\t\tbins = np.amax(data,axis=0)\n\t\t\thist,_ = np.histogramdd(data, bins=bins) # frequency counts\n\n\t\t\tPxyz = hist / hist.sum()# joint probability distribution over X,Y,Z\n\t\t\tPz = np.sum(Pxyz, axis = (0,1)) # P(Z)\n\t\t\tPxz = np.sum(Pxyz, axis = 1) # P(X,Z)\n\t\t\tPyz = np.sum(Pxyz, axis = 0) # P(Y,Z)\t\n\n\t\t\tPxy_z = Pxyz / (Pz+1e-7) # P(X,Y | Z) = P(X,Y,Z) / P(Z)\n\t\t\tPx_z = Pxz / (Pz+1e-7) # P(X | Z) = P(X,Z) / P(Z)\t\n\t\t\tPy_z = Pyz / (Pz+1e-7) # P(Y | Z) = P(Y,Z) / P(Z)\n\n\t\t\tPx_y_z = np.empty((Pxy_z.shape)) # P(X|Z)P(Y|Z)\n\t\t\tfor i in range(bins[0]):\n\t\t\t\tfor j in range(bins[1]):\n\t\t\t\t\tfor k in range(bins[2]):\n\t\t\t\t\t\tPx_y_z[i][j][k] = Px_z[i][k]*Py_z[j][k]\n\t\t\tPxyz += 1e-7\n\t\t\tPxy_z += 1e-7\n\t\t\tPx_y_z += 1e-7\n\t\t\tMI = np.sum(Pxyz * np.log(Pxy_z / (Px_y_z)))\n\t\t\t\n\t\t\treturn round(MI,4)\n\t\telif len(bins) > 2 and conditional == False:\n\t\t\tdata = data.astype('str')\n\t\t\tncols = len(bins)\n\t\t\tfor i in range(len(data)):\n\t\t\t\tdata[i,1] = ''.join(data[i,1:ncols])\n\t\t\tdata = data.astype('int')[:,0:2]\n\n\t\t\thist,_ = np.histogramdd(data, bins=bins[0:2]) # frequency counts\n\n\t\t\tPxy = hist / hist.sum()# joint probability distribution over X,Y,Z\n\t\t\tPx = np.sum(Pxy, axis = 1) # P(X,Z)\n\t\t\tPy = np.sum(Pxy, axis = 0) # P(Y,Z)\t\n\n\t\t\tPxPy = np.outer(Px,Py)\n\t\t\tPxy += 1e-7\n\t\t\tPxPy += 1e-7\n\t\t\tMI = np.sum(Pxy * np.log(Pxy / (PxPy)))\n\t\t\treturn round(MI,4)","def model_onelayer_pert(r):\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\tif (r > 6361000.0):\n\t\trho = 2.7\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 2.0 + 0.02\n\t\tvsh = vsv \n\t\teta = 1.0\n\n\telse:\n\t\trho = 3.1\n\t\tvpv = 7.8\n\t\tvph = vpv\n\t\tvsv = 3.0\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def scale_u_and_v(u, v, level, pyr):\n # TODO: Your code here\n image = pyr[level-1]\n expanded_u = ps4.expand_image(u)\n expanded_v = ps4.expand_image(v)\n scaled_u = expanded_u * 2\n scaled_v = expanded_v * 2\n if image.shape[0] == scaled_u.shape[0] - 1:\n scaled_u = scaled_u[:-1, :]\n if image.shape[1] == scaled_u.shape[1] - 1:\n scaled_u = scaled_u[:, :-1]\n if image.shape[0] == scaled_v.shape[0] - 1:\n scaled_v = scaled_v[:-1, :]\n if image.shape[1] == scaled_v.shape[1] - 1:\n scaled_v = scaled_v[:, :-1]\n return scaled_u, scaled_v","def assign_to_levels(boxes, im_size, num_levels=6, finest_stride=3):\n im_area = im_size[0] * im_size[1]\n widths = boxes[:, 2] - boxes[:, 0] + 1.0\n heights = boxes[:, 3] - boxes[:, 1] + 1.0\n areas = widths * heights\n # if e.g. the finest level has a stride of 4, we want all boxes\n # at 1/4 image resolution to map to the coarsest level (k = 0)\n k = np.round(np.log2(math.sqrt(im_area) / np.sqrt(areas)) - math.log2(finest_stride))\n k = k.astype(np.int32)\n inds = np.where(k < 0)[0]\n k[inds] = 0\n inds = np.where(k > num_levels)[0]\n k[inds] = num_levels\n return k","def read_vs_1d(vname, depth): \n with open(vname, 'r') as f:\n lines = f.readlines() \n line0=lines[0].split()\n n_col = int(line0[0])\n \n data = []\n\n for line in lines[1:]:\n data.append([float(val) for val in line.split()])\n\n data = np.concatenate(data) \n v_mod = data.reshape([n_col,6])\n \n depth_ref = 0\n for i in range(0, n_col):\n depth_ref = depth_ref+v_mod[i,0]\n #print(depth_ref)\n if(depth_ref>depth):\n vs_1d = v_mod[i-1,2]\n rho_1d = v_mod[i-1,3] \n break\n \n return vs_1d, rho_1d","def pop_var_from_subpop_var(groups):\n return np.hstack(groups).var()","def assign_level(self, minibatch_reference_proboxes):\n with tf.name_scope('assign_levels'):\n ymin, xmin, ymax, xmax = tf.unstack(minibatch_reference_proboxes, axis=2)\n\n w = tf.maximum(xmax - xmin, 0.) # avoid w is negative\n h = tf.maximum(ymax - ymin, 0.) # avoid h is negative\n\n levels = tf.round(4. + tf.log(tf.sqrt(w*h + 1e-8)/224.0) / tf.log(2.)) # 4 + log_2(***)\n\n levels = tf.maximum(levels, tf.ones_like(levels) * (np.float32(self.min_level))) # level minimum is 2\n levels = tf.minimum(levels, tf.ones_like(levels) * (np.float32(self.max_level))) # level maximum is 5\n\n return tf.cast(levels, tf.int32)","def zoomlevels(self):\n return self._bboxes[0][1] #TODO: merge all coverages","def get_level_size(slide, level):\n return slide.level_dimensions[level]","def resolve(self):\n ind = [ i for i in combinations(range(self.nplex()),2) ]\n hi,lo = self.insertLevel(ind)\n lo.sort(axis=1)\n ind = sortByColumns(lo)\n return lo[ind]","def buildMainVars(self, model, n, name=\"main_cells\"):\n import gurobipy as gb\n ASSERT_TYPE(model, gb.Model)\n lb = 0 if self.nnls else -gb.GRB.INFINITY\n # First index is cell (among non-zero), second index is child\n two_d_vars: gb.MVar = model.addMVar((int(n), int(self.childGeoLen)), vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\n return two_d_vars","def front_column_model_p_gain():","def measureUnfoldedLevel(ds, verbose = False):\n points = getIndexedTraces(ds)\n from sklearn.cluster import KMeans\n x = points[points[:,0] > 150, 1].reshape((-1,1))\n # remove outliers \n std = np.std(x)\n mean = np.mean(x)\n x = x[x > mean - 4*std].reshape((-1,1)) \n # ML clustering\n kmeans = KMeans(n_clusters=3, random_state=0).fit(x)\n x_cluster = kmeans.predict(x)\n means = [ np.mean(x[x_cluster == i]) for i in range(3)]\n means = sorted(means) \n level_one = means[1]\n if np.abs(level_one) > 0.35 or np.abs(level_one) < 0.1:\n print(\"Warning! Unfolded level detector in unexpected range: \",leven_one)\n if verbose: #feedback\n pyplot.figure()\n pyplot.hist2d(points[:,0], points[:,1], \n bins=(70*2, 50*2),\n range = [[0, 700], [-0.45, 0.05]],\n cmax = 100000/4 # clip max\n )\n pyplot.plot([0,700], [level_one]*2, 'r--')\n return level_one","def levelsets_to_vector_field(levelsets, stepsize):\r\n vector_field_shape = levelsets[0][0].shape\r\n y_comp_combined = np.ndarray(vector_field_shape)\r\n x_comp_combined = np.ndarray(vector_field_shape)\r\n y_comp_combined.fill(np.nan)\r\n x_comp_combined.fill(np.nan)\r\n\r\n for source, target in levelsets:\r\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\r\n labels_present.remove(0)#relates to background\r\n\r\n #print(labels_present)\r\n for l in labels_present:\r\n\r\n source_cluster = source == l\r\n target_cluster = target == l\r\n\r\n\r\n \"\"\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\r\n plt.show()\r\n print(\"-----------\")\"\"\"\r\n\r\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\r\n\r\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\r\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\r\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\r\n return y_comp_combined, x_comp_combined","def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_pool = cls.get_var_pool(data1_, data2_)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def take_max_level(self):\n level = 0\n for k, v in self.d.items():\n level = max(level, len(k.split(\":\")))\n return level","def create_subspace_preference_dimensionality(self):\n # For each point compute number of dimensions that have a lower variance then delta\n spd = np.count_nonzero(self.attribute_variances < self.delta, axis=1)\n return spd","def calc_base_eff_and_infl(level):\n return 2 + (level - 1)","def test_get_dimension(self):\n\n v = Vector({ 'x': 1 })\n self.assertEqual(1, v.dimensions['x'])","def decide_resolution(vec):\n if N >= NOld and M >= MOld:\n ovec = increase_resolution(vec)\n\n elif N <= NOld and M <= MOld:\n ovec = decrease_resolution(vec)\n\n return ovec","def create_flux_vector_pms_gr(self):\n soma_prod = 0\n soma_inj = 0\n lim4 = 1e-4\n store_velocity = {}\n store_flux = {}\n for primal in self.primals:\n #1\n primal_id = self.mb.tag_get_data(self.primal_id_tag, primal, flat=True)[0]\n primal_id = self.ident_primal[primal_id]\n fine_elems_in_primal = self.mb.get_entities_by_handle(primal)\n for volume in fine_elems_in_primal:\n #2\n flux = {}\n velocity = {}\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\n centroid_volume = self.mesh_topo_util.get_average_position([volume])\n z_vol = self.tz - centroid_volume[2]\n adjs_vol = self.mesh_topo_util.get_bridge_adjacencies(volume, 2, 3)\n gid_vol = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\n for adj in adjs_vol:\n #3\n gid_adj = self.mb.tag_get_data(self.global_id_tag, adj, flat=True)[0]\n if adj not in fine_elems_in_primal:\n #4\n pvol = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\n padj = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\n #3\n else:\n #4\n pvol = self.mb.tag_get_data(self.pcorr_tag, volume, flat=True)[0]\n padj = self.mb.tag_get_data(self.pcorr_tag, adj, flat=True)[0]\n #3\n kadj = self.mb.tag_get_data(self.perm_tag, adj).reshape([3, 3])\n centroid_adj = self.mesh_topo_util.get_average_position([adj])\n z_adj = self.tz - centroid_adj[2]\n direction = centroid_adj - centroid_volume\n unit = direction/np.linalg.norm(direction)\n #unit = vetor unitario na direcao de direction\n uni = self.unitary(direction)\n # uni = valor positivo do vetor unitario\n kvol = np.dot(np.dot(kvol,uni),uni)\n kadj = np.dot(np.dot(kadj,uni),uni)\n keq = self.kequiv(kvol, kadj)/(self.mi)\n keq2 = keq\n keq = keq*(np.dot(self.A, uni))\n pvol2 = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\n padj2 = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\n grad_p = (padj - pvol)/float(abs(np.dot(direction, uni)))\n grad_z = (z_adj - z_vol)/float(abs(np.dot(direction, uni)))\n grad_p2 = (padj2 - pvol2)/float(abs(np.dot(direction, uni)))\n q = (grad_p)*keq - grad_z*keq*self.gama\n print((grad_p)*keq)\n print(- grad_z*keq*self.gama)\n print(q)\n print(self.store_flux_pf_gr[volume][tuple(unit)])\n print('\\n')\n import pdb; pdb.set_trace()\n\n if gid_adj > gid_vol:\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\n else:\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\n\n flux[tuple(unit)] = q\n velocity[tuple(unit)] = v\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\n\n #2\n # print(gid_vol)\n # print(velocity)\n # print('\\n')\n # import pdb; pdb.set_trace()\n store_flux[volume] = flux\n self.mb.tag_set_data(self.flux_fine_pms_tag, volume, sum(flux.values()))\n # flt = sum(flux.values())\n # if volume not in self.wells_inj and volume not in self.wells_prod:\n # lim4 = 1e-7\n # if abs(flt) > lim4:\n # print(gid_vol)\n # print(flt)\n # import pdb; pdb.set_trace()\n # flt = sum(flux.values())\n store_velocity[volume] = velocity\n\n for volume in set(self.all_fine_vols) - set(self.wells):\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\n values = store_flux[volume].values()\n if sum(values) > lim4:\n print('fluxo multiescala nao esta dando conservativo')\n print('gid:{0}'.format(gid))\n print(sum(values))\n import pdb; pdb.set_trace()\n\n with open('fluxo_multiescala_gr.txt', 'w') as arq:\n for volume in self.wells:\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat= True)[0]\n values = store_flux[volume].values()\n if volume in self.wells_inj:\n soma_inj += sum(values)\n else:\n soma_prod += sum(values)\n arq.write('gid:{0} , fluxo:{1}\\n'.format(gid, sum(values)))\n arq.write('\\n')\n arq.write('soma_inj:{0}\\n'.format(soma_inj))\n arq.write('soma_prod:{0}\\n'.format(soma_prod))\n\n return store_flux","def get_no_strat_levels(no_vert_levels_atmos):\n try:\n if float(no_vert_levels_atmos) > 60:\n no_strat_levels = '20'\n else:\n no_strat_levels = '10'\n except:\n no_strat_levels = '10'\n\n return no_strat_levels","def model_onelayer(r):\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\tif (r > 6361000.0):\n\t\trho = 2.7\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 2.0\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\telse:\n\t\trho = 3.1\n\t\tvpv = 7.8\n\t\tvph = vpv\n\t\tvsv = 3.0\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def get_levels(std0, slope, nsigma):\n nslope = nsigma * slope\n levels = [0]\n while levels[-1] <= 1:\n levels.append((levels[-1] * (1 + nslope) + 2 * nsigma * std0) / (1 - nslope))\n levels.pop()\n return levels","def _get_ndim(self):\n return len(self.level_shapes[0])","def heightvar( mv ):\n if mv is None: return None\n lev_axis = levAxis(mv)\n heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km\n heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,\n attributes={'units':\"km\"} )\n return heightmv","def _level_info(entity):\n if entity.is_max_level():\n return 'Maxed'\n if entity.max_level is not None:\n return '{entity.level}/{entity.max_level}'.format(entity=entity)\n return entity.level","def support(self, level=1):\n if level == 1:\n sup = (2 * self.pivot_point) - self.last_high\n elif level == 2:\n sup = self.pivot_point - (self.last_high - self.last_low)\n elif level == 3:\n sup = self.last_low - 2*(self.last_high - self.pivot_point)\n else:\n raise ValueError('Not a valid level. Must be 1, 2, or 3')\n return sup","def levels(ohlc_day):\r\n high = round(ohlc_day[\"high\"][-1],2)\r\n low = round(ohlc_day[\"low\"][-1],2)\r\n close = round(ohlc_day[\"close\"][-1],2)\r\n pivot = round((high + low + close)/3,2)\r\n r1 = round((2*pivot - low),2)\r\n r2 = round((pivot + (high - low)),2)\r\n r3 = round((high + 2*(pivot - low)),2)\r\n s1 = round((2*pivot - high),2)\r\n s2 = round((pivot - (high - low)),2)\r\n s3 = round((low - 2*(high - pivot)),2)\r\n return (pivot,r1,r2,r3,s1,s2,s3)","def multiple_intersections():\n levels = np.array([966., 937.2, 925., 904.6, 872.6, 853., 850., 836., 821., 811.6, 782.3,\n 754.2, 726.9, 700., 648.9, 624.6, 601.1, 595., 587., 576., 555.7,\n 534.2, 524., 500., 473.3, 400., 384.5, 358., 343., 308.3, 300., 276.,\n 273., 268.5, 250., 244.2, 233., 200.]) * units.mbar\n temperatures = np.array([18.2, 16.8, 16.2, 15.1, 13.3, 12.2, 12.4, 14., 14.4,\n 13.7, 11.4, 9.1, 6.8, 4.4, -1.4, -4.4, -7.3, -8.1,\n -7.9, -7.7, -8.7, -9.8, -10.3, -13.5, -17.1, -28.1, -30.7,\n -35.3, -37.1, -43.5, -45.1, -49.9, -50.4, -51.1, -54.1, -55.,\n -56.7, -57.5]) * units.degC\n dewpoints = np.array([16.9, 15.9, 15.5, 14.2, 12.1, 10.8, 8.6, 0., -3.6, -4.4,\n -6.9, -9.5, -12., -14.6, -15.8, -16.4, -16.9, -17.1, -27.9, -42.7,\n -44.1, -45.6, -46.3, -45.5, -47.1, -52.1, -50.4, -47.3, -57.1,\n -57.9, -58.1, -60.9, -61.4, -62.1, -65.1, -65.6,\n -66.7, -70.5]) * units.degC\n return levels, temperatures, dewpoints","def estimate_maxm_neutral_axis_depth(self):\r\n\t\txu_d = abs(self.concrete.max_compresive_strain)/\\\r\n\t\t\t(abs(self.concrete.max_compresive_strain) + self.steel.max_tensile_strain)\r\n\t\tself.max_positive_na = xu_d*self.positive_effective_depth\r\n\t\tself.max_negative_na = xu_d*self.negative_effective_depth","def find_fermi_level(self):\n all_max_val = self.gather_qpt_function('get_max_val')\n all_min_cond = self.gather_qpt_function('get_min_cond')\n if i_am_master:\n max_val = np.max(all_max_val)\n min_cond = np.min(all_min_cond)\n mu = (max_val + min_cond) / 2.0\n mu = np.array(mu, dtype=np.float64)\n else:\n mu = np.empty(1, dtype=np.float64)\n\n comm.Bcast([mu, MPI.DOUBLE])\n\n self.set_fermi_level(mu)","def test_cube_multi_level(self):\n temperature = self._make_multi_level(self.temperature, time_promote=True)\n relative_humidity = self._make_multi_level(\n self.relative_humidity, time_promote=True\n )\n pressure = self._make_multi_level(self.pressure, time_promote=True)\n result = WetBulbTemperature().process(\n CubeList([temperature, relative_humidity, pressure])\n )\n self.assertEqual(result.coord_dims(\"time\")[0], 0)\n self.assertEqual(result.coord_dims(\"height\")[0], 1)","def nvar(self):\n return self.h.shape[0]","def get_min_depth(l_k):\n return max(l_k.values())","def n_levels(self):\n return len(self.scales)","def getMtVariant(data, depth_min = 10, depth_ratio_min = 0.0):\n\tvar = {}\n\tn = 0\n\tfor family in data:\n\t\tvar[family] = {}\n\t\tfor sample in data[family]:\n\t\t\tvar[family][sample] = {}\n\t\t\tfor variant in data[family][sample].values():\n\t\t\t\tif (variant.ref == \"N\"):\n\t\t\t\t\tcontinue\n\t\t\t\tif (variant.depth_qc >= depth_min and variant.depth_ratio >= depth_ratio_min):\n\t\t\t\t\tvar[family][sample][variant.pos] = variant\n\t\t\t\t\tn += 1\n\t\t\t\telse:\n\t\t\t\t\tvar[family][sample][variant.pos] = None\n\tprint \"Read %d mitochondrial DNA variants\" % n\n\treturn var","def load_variable_profile(\n self,\n varname,\n ):\n if self.depth is None:\n raise LookupError('Profile variables not available in this dataset')\n var = self.dataset.data_vars[varname]\n if 'nVertLevelsLES' in var.dims:\n # LES variables with different vertical levels\n with xr.open_dataset(self._filepath_mesh) as fmesh:\n z = fmesh.data_vars['zLES'].values[0,0,:]\n depth = xr.DataArray(\n z,\n dims=('nVertLevelsLES'),\n coords={'nVertLevelsLES': z},\n attrs={'units': 'm', 'long_name': 'depth'},\n )\n var = var.assign_coords({'nVertLevelsLES': depth})\n elif 'nVertLevelsP1' in var.dims:\n var = var.assign_coords({'nVertLevelsP1': self.depth_iface})\n elif 'nVertLevels' in var.dims:\n var = var.assign_coords({'nVertLevels': self.depth})\n # mask topography\n if 'nCells' in var.dims:\n with xr.open_dataset(self._filepath_mesh) as fmesh:\n maxlevelcell = fmesh.data_vars['maxLevelCell']\n var = var.where(var.nVertLevels>=var.nVertLevels[maxlevelcell-1])\n else:\n raise LookupError('\\'{}\\' is not a profile variables'.format(varname))\n return var.transpose()","def getLevel(self):\n return self.level","def get_var_pool(cls, data1: tuple, data2: tuple) -> float:\n cls._data_validation(data1)\n cls._data_validation(data2)\n n1 = cls.get_n(data1)\n var1 = cls.get_var(data1)\n n2 = cls.get_n(data2)\n var2 = cls.get_var(data2)\n return ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2)","def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_x = cls.get_var(data1_, is_population=True)\n var_y = cls.get_var(data2_, is_population=True)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)","def maximum_level(self, question_type):\n\t\treturn 2","def discretize(self, x):\n encoded = self.est.forward(x)\n # encoded will be (A,B,C ... K)\n # take argmax along dim k, and take that from levels\n indices = np.argmax(encoded, axis=-1)\n return np.take(self.levels, indices)","def basisVar(bases):\n \n var = [] # The ordered list of active coordinates \n k = 0\n for b in bases:\n if np.isscalar(b):\n # A singleton, inactive coordinate\n k += 1\n else:\n # An active basis\n for i in range(b.nd):\n var.append(k)\n k += 1 \n return var","def defineSigmaLevels():\r\n # A and B values for the definition of sigma levelist\r\n # Since there are 72 model levels, there are 73 half levels, so it is for A and B values\r\n # the unit of A is hPa!!!!!!!!!!!!\r\n # from surface to TOA\r\n A = np.array([\r\n 0.000000e+00, 4.804826e-02, 6.593752e+00, 1.313480e+01, 1.961311e+01, 2.609201e+01,\r\n 3.257081e+01, 3.898201e+01, 4.533901e+01, 5.169611e+01, 5.805321e+01, 6.436264e+01,\r\n 7.062198e+01, 7.883422e+01, 8.909992e+01, 9.936521e+01, 1.091817e+02, 1.189586e+02,\r\n 1.286959e+02, 1.429100e+02, 1.562600e+02, 1.696090e+02, 1.816190e+02, 1.930970e+02,\r\n 2.032590e+02, 2.121500e+02, 2.187760e+02, 2.238980e+02, 2.243630e+02, 2.168650e+02,\r\n 2.011920e+02, 1.769300e+02, 1.503930e+02, 1.278370e+02, 1.086630e+02, 9.236572e+01,\r\n 7.851231e+01, 6.660341e+01, 5.638791e+01, 4.764391e+01, 4.017541e+01, 3.381001e+01,\r\n 2.836781e+01, 2.373041e+01, 1.979160e+01, 1.645710e+01, 1.364340e+01, 1.127690e+01,\r\n 9.292942e+00, 7.619842e+00, 6.216801e+00, 5.046801e+00, 4.076571e+00, 3.276431e+00,\r\n 2.620211e+00, 2.084970e+00, 1.650790e+00, 1.300510e+00, 1.019440e+00, 7.951341e-01,\r\n 6.167791e-01, 4.758061e-01, 3.650411e-01, 2.785261e-01, 2.113490e-01, 1.594950e-01,\r\n 1.197030e-01, 8.934502e-02, 6.600001e-02, 4.758501e-02, 3.270000e-02, 2.000000e-02,\r\n 1.000000e-02,],dtype=float)\r\n # reverse A\r\n A = A[::-1] * 100 # change unit to Pa\r\n # the unit of B is 1!!!!!!!!!!!!\r\n # from surfac eto TOA\r\n B = np.array([\r\n 1.000000e+00, 9.849520e-01, 9.634060e-01, 9.418650e-01, 9.203870e-01, 8.989080e-01,\r\n 8.774290e-01, 8.560180e-01, 8.346609e-01, 8.133039e-01, 7.919469e-01, 7.706375e-01,\r\n 7.493782e-01, 7.211660e-01, 6.858999e-01, 6.506349e-01, 6.158184e-01, 5.810415e-01,\r\n 5.463042e-01, 4.945902e-01, 4.437402e-01, 3.928911e-01, 3.433811e-01, 2.944031e-01,\r\n 2.467411e-01, 2.003501e-01, 1.562241e-01, 1.136021e-01, 6.372006e-02, 2.801004e-02,\r\n 6.960025e-03, 8.175413e-09, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\r\n 0.000000e+00,],dtype=float)\r\n # reverse B\r\n B = B[::-1]\r\n\r\n return (A, B)","def level_sets(self):\n in_degrees = self.in_degree(labels=True)\n level = [x for x in in_degrees if in_degrees[x]==0]\n Levels = []\n while len(level) != 0:\n Levels.append(level)\n new_level = []\n for x in level:\n for y in self.neighbors_out(x):\n in_degrees[y] -= 1\n if in_degrees[y] == 0:\n new_level.append(y)\n level = new_level\n return Levels","def dim3():\n return Integer(\"yolo3\", \"uniform\", 3, 7, shape=(1,))","def levels(ohlc_day):\n high = round(ohlc_day[\"high\"][-1],2)\n low = round(ohlc_day[\"low\"][-1],2)\n close = round(ohlc_day[\"close\"][-1],2)\n pivot = round((high + low + close)/3,2)\n r1 = round((2*pivot - low),2)\n r2 = round((pivot + (high - low)),2)\n r3 = round((high + 2*(pivot - low)),2)\n s1 = round((2*pivot - high),2)\n s2 = round((pivot - (high - low)),2)\n s3 = round((low - 2*(high - pivot)),2)\n return (pivot,r1,r2,r3,s1,s2,s3)","def create_sub_mdps(self, level):\n\n mdps_copy = set(self.mdps[level-1].copy())\n mdps = set()\n upper_level_exits = {}\n\n # Full depth-first search to group MDPs into MERs\n while len(mdps_copy) > 0:\n curr_mdp = random.choice(tuple(mdps_copy))\n mer, exits = set(), set()\n # Group curr_mdp with neighbors to form a MER and find exits\n self.dfs(mdps_copy, curr_mdp, level, mer, exits)\n # Choose a state var that is representative of the new MER\n state_var = next(iter(mer)).state_var[1:]\n # Create a new upper level MDP and set its properties\n mdp = MDP(level=level, state_var=state_var)\n mdp.mer = frozenset(mer)\n\n upper_level_exits[mdp] = exits\n for _mdp in mer:\n mdp.primitive_states.update(_mdp.primitive_states)\n mdps.add(mdp)\n\n self.mdps[level] = mdps\n\n # Add MDP Exits/Actions\n for mdp in self.mdps[level]:\n mdp.exits = set()\n # Generate new exits (mdp at level, Exit at level-1, target mdp at level)\n for s_mdp, exit, n_mdp in upper_level_exits[mdp]:\n neighbor_mdp = n_mdp.get_upper_mdp(self.mdps) \n mdp.exits.add(Exit(mdp, Exit(s_mdp, exit, n_mdp), neighbor_mdp))","def max_level(data: np.ndarray) -> int:\n shape = data.shape[1:] # exclude channel dimension\n return min(shape).bit_length() - 1","def top_k_betweenness_centrality(self):\n d={}\n l=[]\n for v in vertices:\n a=self.betweenness_centrality(v)\n d[v]=a\n l.append(a)\n m=max(l)\n l1=[]\n for key in d:\n if d[key]==m:\n l1.append(key)\n\n return l1","def _G_to_km_on_basis_single_level(self, w, m):\n kB = self._sym.kBoundedSubspace(self.k,t=1)\n g = kB.K_kschur()\n mon = self.km()\n if m < w.length():\n return 0\n ans = self.zero()\n for la in Partitions(m, max_part = self.k):\n ans += g.homogeneous_basis_noncommutative_variables_zero_Hecke((la)).coefficient(w)*mon(la)\n return ans","def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\n y_transformed, _ = Y.median(1)\n y_transformed = y_transformed.reshape(-1, 1)\n levels = y_transformed.repeat(1, Y.shape[1])\n seasonalities = None\n\n return levels, None","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def add_extra_level(self, variable, xlevel):\n \n if variable not in [\"geopotential\", \"temperature\"]:\n raise Exception(\"variable should be one of [geopotential,temperature]\")\n \n if variable == \"geopotential\":\n # geopotential \n A = self.z.z[:, -1, :, :].to_dataset() # copy lowest pressure level\n A[\"level\"] = xlevel\n self.z = (xarray.concat([self.z, A], dim=\"level\"))\n \n # convert pressure to geopotential\n self.z.z[0, -1, :, :] = pres2alt(xlevel * 100) * g\n \n else: \n # temperature\n A = self.t.t[:, -1, :, :].to_dataset() # copy lowest pressure level\n A[\"level\"] = xlevel\n self.t = (xarray.concat([self.t, A], dim=\"level\"))","def __init__(self, level):\n self.level = level\n self.my_map = {}\n self.my_level = []\n self.my_grid = []","def test_mixed_layer():\n pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa\n temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC\n mixed_layer_temperature = mixed_layer(pressure, temperature, depth=250 * units.hPa)[0]\n assert_almost_equal(mixed_layer_temperature, 16.4024930 * units.degC, 6)","def get_plevels(\n filepath: Union[os.PathLike, str] = \"/data/cees/zespinos/netcdf_data/MiMA-topo-v1.1-40-level\",\n) -> None:\n with netcdf.netcdf_file(os.path.join(filepath, \"atmos_1day_d12240_plevel.nc\")) as year_four_qbo:\n plevels = year_four_qbo.variables[\"level\"][:]#[LOWEST_PLEVEL:LAST_PLEVEL]\n return plevels","def compare_select(self, x: torch.Tensor) -> [torch.Tensor, torch.LongTensor]:\n reshaped_x = x.reshape(-1, self.n_states, 2)\n max_values, absolute_max_ind = torch.max(reshaped_x, 2)\n return max_values, absolute_max_ind","def level_calc_manager(natal_tab, control_tab, esolevel, planets12):\n planet_control = { k: control_tab[natal_tab[k]][esolevel] \n for k in natal_tab } \n planet_level, used_planets = calc_level(planet_control)\n planets = [item for item in planets12 if item in used_planets]\n return (planets, planet_control, planet_level)","def mult_var_by_prior(self, x_scaled):\n model_var = self.likelihood(x_scaled)[1]\n tensor_log_prior = self.log_prior(x_scaled)\n return tf.reshape(model_var, shape=tensor_log_prior.shape) * tf.math.exp(tensor_log_prior)","def calc_level(xp, dominion):\n if xp < 3:\n xp_potential = 1\n if xp >= 3 and xp < 6:\n xp_potential = 2\n if xp >= 6 and xp < 12:\n xp_potential = 3\n if xp >= 12 and xp < 24:\n xp_potential = 4\n if xp >= 24 and xp < 48:\n xp_potential = 5\n if xp >= 48 and xp < 72:\n xp_potential = 6\n if xp >= 72 and xp < 96:\n xp_potential = 7\n if xp >= 96 and xp < 130:\n xp_potential = 8\n if xp >= 130 and xp < 170:\n xp_potential = 9\n if xp >= 170:\n xp_potential = 10\n if dominion < 2:\n dom_potential = 1\n if dominion >= 2 and dominion < 4:\n dom_potential = 2\n if dominion >= 4 and dominion < 10:\n dom_potential = 3\n if dominion >= 10 and dominion < 22:\n dom_potential = 4\n if dominion >= 22 and dominion < 38:\n dom_potential = 5\n if dominion >= 38 and dominion < 57:\n dom_potential = 6\n if dominion >= 57 and dominion < 76:\n dom_potential = 7\n if dominion >= 76 and dominion < 95:\n dom_potential = 8\n if dominion >= 95 and dominion < 124:\n dom_potential = 9\n if dominion >= 124:\n dom_potential = 10\n return min(xp_potential, dom_potential)","def define_variables(m):\r\n\r\n # Non-negative candidate capacity\r\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Solar build limits\r\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Wind build limits\r\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage build limits\r\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Min power output (all generators excluding storage units)\r\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing thermal\r\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate thermal\r\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing wind\r\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate wind\r\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing solar\r\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate solar\r\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - hydro\r\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min charging power - storage units\r\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min discharging power - storage_units\r\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - existing storage\r\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - candidate storage\r\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - existing storage\r\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - candidate storage\r\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - storage units\r\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - existing storage units\r\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - candidate storage\r\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - interval end\r\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - interval end\r\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate up (thermal and hydro generators)\r\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate down (thermal and hydro generators)\r\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Non-negative lost load power\r\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min powerflow\r\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max powerflow\r\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage energy transition\r\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\r\n\r\n # Power balance (locational marginal price)\r\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\r\n\r\n return m","def lvl_algo(next_level):\n total_xp_needed = (next_level * next_level)\n return total_xp_needed","def _get_static_level2(self):\n return self.__static_level2","def get_pedigree_variance(pm, version=\"original\"):\n assert all(isinstance(obj, int) for obj in pm.values())\n return sum(PEDIGREE_MATRIX_VALUES[version][k][v - 1] for k, v in pm.items())","def z(self):\n data = np.ma.array(np.zeros(self.n_levels()), mask=True)\n for i in range(self.n_levels()):\n if self.profile_data[i]['Missing']: continue\n data[i] = self.profile_data[i]['Depth']\n return data","def get_level(k):\r\n return int(log2(k))","def get_depths(self, variables):\n\n return [0.]","def metis(W, levels, rid=None):\n # Function written by M. Defferrard, taken verbatim, from \n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L34\n\n N, N = W.shape\n if rid is None:\n rid = np.random.permutation(range(N))\n parents = []\n degree = W.sum(axis=0) - W.diagonal()\n graphs = []\n graphs.append(W)\n #supernode_size = np.ones(N)\n #nd_sz = [supernode_size]\n #count = 0\n\n #while N > maxsize:\n for _ in range(levels):\n\n #count += 1\n\n # CHOOSE THE WEIGHTS FOR THE PAIRING\n # weights = ones(N,1) # metis weights\n weights = degree # graclus weights\n # weights = supernode_size # other possibility\n weights = np.array(weights).squeeze()\n\n # PAIR THE VERTICES AND CONSTRUCT THE ROOT VECTOR\n idx_row, idx_col, val = scipy.sparse.find(W)\n perm = np.argsort(idx_row)\n rr = idx_row[perm]\n cc = idx_col[perm]\n vv = val[perm]\n cluster_id = metis_one_level(rr,cc,vv,rid,weights) # rr is ordered\n parents.append(cluster_id)\n\n # TO DO\n # COMPUTE THE SIZE OF THE SUPERNODES AND THEIR DEGREE \n #supernode_size = full( sparse(cluster_id, ones(N,1) ,\n #\tsupernode_size ) )\n #print(cluster_id)\n #print(supernode_size)\n #nd_sz{count+1}=supernode_size;\n\n # COMPUTE THE EDGES WEIGHTS FOR THE NEW GRAPH\n nrr = cluster_id[rr]\n ncc = cluster_id[cc]\n nvv = vv\n Nnew = cluster_id.max() + 1\n # CSR is more appropriate: row,val pairs appear multiple times\n W = scipy.sparse.csr_matrix((nvv,(nrr,ncc)), shape=(Nnew,Nnew))\n W.eliminate_zeros()\n # Add new graph to the list of all coarsened graphs\n graphs.append(W)\n N, N = W.shape\n\n # COMPUTE THE DEGREE (OMIT OR NOT SELF LOOPS)\n degree = W.sum(axis=0)\n #degree = W.sum(axis=0) - W.diagonal()\n\n # CHOOSE THE ORDER IN WHICH VERTICES WILL BE VISTED AT THE NEXT PASS\n #[~, rid]=sort(ss); # arthur strategy\n #[~, rid]=sort(supernode_size); # thomas strategy\n #rid=randperm(N); # metis/graclus strategy\n ss = np.array(W.sum(axis=0)).squeeze()\n rid = np.argsort(ss)\n\n return graphs, parents","def identifier(self, sub, obj, t):\n\n # use the trained model q(r,v|x) = q(r|x)q(v|x,r)\n # to compute probabilities for the latent variables\n # and then get the most probable relation and predicate from the posterior\n prob_pred, prob_rel, z_loc, z_scale = self.encoder(sub, obj, t)\n _, r_map = torch.topk(prob_rel, 1)\n r_map = torch.squeeze(r_map)\n _, v_map = torch.topk(prob_pred, 1)\n\n return r_map, v_map","def getStatesDim(self):\n return 2","def psis(self, num_levels=-1):\n if not self.solved: self.solve()\n return self.ev[:num_levels]","def levels(self):\n return np.array(self._levels()).T"],"string":"[\n \"def select_lev( mv, slev ):\\n levax = levAxis(mv)\\n # Get ig, the first index for which levax[ig]>slev\\n # Assume that levax values are monotonic.\\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\\n if levax[0]<=levax[-1]:\\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\\n else:\\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\\n if ids is None or len(ids)==0:\\n ig = len(levax)-1\\n else:\\n ig = ids[0][0]\\n # Crude fist cut: don't interpolate, just return a value\\n if levax == mv.getAxisList()[0]:\\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\\n elif levax == mv.getAxisList()[1]:\\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\\n else:\\n print \\\"ERROR, select_lev() does not support level axis except as first or second dimentions\\\"\\n return None\\n return mvs\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def dim2():\\n probs = (0.1, 0.2, 0.3, 0.4)\\n categories = (\\\"asdfa\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n categories = OrderedDict(zip(categories, probs))\\n dim2 = Categorical(\\\"yolo2\\\", categories, default_value=\\\"2\\\")\\n return dim2\",\n \"def levvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n #levmv = mv.clone() # good if mv has only a lev axis\\n #levmv[:] = lev_axis[:]\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\\n attributes={'units':lev_axis.units},\\n copy=True )\\n return levmv\",\n \"def getLevel(unique_name):\",\n \"def getLevels():\",\n \"def main_trees_quick(df):\\n groups = df.groupby(['tree', 'scale'])\\n try:\\n mmp = groups.mvir.transform(np.max) == df.mvir\\n except (KeyError, AttributeError):\\n mmp = groups.Mvir.transform(np.max) == df.Mvir\\n return mmp\",\n \"def est_maxlevel(dims,bandwidth):\\n lev = math.floor((math.log(min(dims))/math.log(2)-2)/bandwidth)\\n lev=int(lev)\\n return lev\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def resolution(self, level):\\n return 2 ** (level - 1)\",\n \"def _determine_level(levels, points):\\n import operator\\n level = None\\n sorted_levels = sorted(levels.iteritems(), key=operator.itemgetter(1))\\n for el in sorted_levels:\\n if points <= el[1]:\\n level = el[0]\\n break\\n\\n max_level = max(levels.iterkeys(), key=lambda threshold: levels[threshold])\\n if points >= levels[max_level]:\\n level = max_level\\n return level\",\n \"def get_level_mag(slide, level):\\n return level_mags(slide)[level]\",\n \"def levshape(self) -> Shape:\\n return tuple(len(x) for x in self.levels)\",\n \"def max_diaphragmatic_level(levels):\\n return [max(x) for x in levels]\",\n \"def zoomlevels(self):\\n return self._bboxes[0][1] #TODO: merge all coverages\",\n \"def map_roi_levels(self, rois, num_levels):\\r\\n scale = torch.sqrt(\\r\\n (rois[:, 3] - rois[:, 1] + 1) * (rois[:, 4] - rois[:, 2] + 1))\\r\\n target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6))\\r\\n target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()\\r\\n return target_lvls\",\n \"def get_var_level_index(sample_size, threshold):\\n if sample_size <= 0:\\n raise ValueError(\\\"Sample size cannot be non-positive:\\\", sample_size)\\n if threshold <= 0.0:\\n return 0\\n if threshold >= 1.0:\\n return sample_size - 1\\n return int(math.floor(sample_size * threshold))\",\n \"def enforce(self, wave, variables, parameters):\\n return np.hstack([variables[0] - self.level])\",\n \"def test_lfc_ml2():\\n levels = np.array([1024.95703125, 1016.61474609, 1005.33056641, 991.08544922, 973.4163208,\\n 951.3381958, 924.82836914, 898.25482178, 873.46124268, 848.69830322,\\n 823.92553711, 788.49304199, 743.44580078, 700.50970459, 659.62017822,\\n 620.70861816, 583.69421387, 548.49719238, 515.03826904, 483.24401855,\\n 453.0418396, 424.36477661, 397.1505127, 371.33441162, 346.85922241,\\n 323.66995239, 301.70935059, 280.92651367, 261.27053833, 242.69168091,\\n 225.14237976, 208.57781982, 192.95333862, 178.22599792, 164.39630127,\\n 151.54336548, 139.68635559, 128.74923706, 118.6588974, 109.35111237,\\n 100.76405334, 92.84288025, 85.53556824, 78.79430389, 72.57549286,\\n 66.83885193, 61.54678726, 56.66480637, 52.16108322]) * units.mbar\\n temperatures = np.array([6.00750732, 5.14892578, 4.177948, 3.00268555, 1.55535889,\\n -0.25527954, -1.93988037, -3.57766724, -4.40600586, -4.19238281,\\n -3.71185303, -4.47943115, -6.81280518, -8.08685303, -8.41287231,\\n -10.79302979, -14.13262939, -16.85784912, -19.51675415,\\n -22.28689575, -24.99938965, -27.79664612, -30.90414429,\\n -34.49435425, -38.438797, -42.27981567, -45.99230957,\\n -49.75340271, -53.58230591, -57.30686951, -60.76026917,\\n -63.92070007, -66.72470093, -68.97846985, -70.4264679,\\n -71.16407776, -71.53797913, -71.64375305, -71.52735901,\\n -71.53523254, -71.61097717, -71.92687988, -72.68682861,\\n -74.129776, -76.02471924, -76.88977051, -76.26008606,\\n -75.90351868, -76.15809631]) * units.celsius\\n dewpoints = np.array([4.50012302, 3.42483997, 2.78102994, 2.24474645, 1.593485, -0.9440815,\\n -3.8044982, -3.55629468, -9.7376976, -10.2950449, -9.67498302,\\n -10.30486488, -8.70559597, -8.71669006, -12.66509628, -18.6697197,\\n -23.00351334, -29.46240425, -36.82178497, -41.68824768, -44.50320816,\\n -48.54426575, -52.50753403, -51.09564209, -48.92690659, -49.97380829,\\n -51.57516098, -52.62096405, -54.24332809, -57.09109879, -60.5596199,\\n -63.93486404, -67.07530212, -70.01263428, -72.9258728, -76.12271881,\\n -79.49847412, -82.2350769, -83.91127014, -84.95665741, -85.61238861,\\n -86.16391754, -86.7653656, -87.34436035, -87.87495422, -88.34281921,\\n -88.74453735, -89.04680634, -89.26436615]) * units.celsius\\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof, td_mixed)\\n assert_almost_equal(lfc_pressure, 962.34 * units.mbar, 2)\\n assert_almost_equal(lfc_temp, 0.767 * units.degC, 2)\",\n \"def level(self):\\n return self.init_v[2]\",\n \"def dims(self):\\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)\",\n \"def get_map_size(level):\\n if level < 5:\\n return 5, 5\\n if level < 70:\\n return 10, 10\\n if level < 150:\\n return 25, 25\\n return 50, 50\",\n \"def estimate_var(sample, threshold):\\n sample_size = len(sample)\\n index_at = get_var_level_index(sample_size, threshold)\\n sample.sort()\\n return sample[index_at]\",\n \"def _get_level_values(self, level: int, unique: bool = False) -> Index:\\n lev = self.levels[level]\\n level_codes = self.codes[level]\\n name = self._names[level]\\n if unique:\\n level_codes = algos.unique(level_codes)\\n filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)\\n return lev._shallow_copy(filled, name=name)\",\n \"def zernike_Double_Index(nlevels):\\n \\n\\t \\n if not (nlevels>=0):\\n print('Input parameter nlevels must be >= 0')\\n raise AssertionError()\\n \\n if (nlevels == 0):\\n \\n m = 0\\n n = 0\\n \\n return n, m\\n \\n else:\\n \\n # ++++ Defining layout for row number n and colunmn number m ++++++++\\n\\n row_n = nlevels+1\\n col_m = 2*nlevels +1\\n x = np.arange(row_n)\\n y = np.arange(-(col_m-1)//2, (col_m+1)//2,1)\\n Q = [(i,j) for i in x for j in y]\\n #\\n\\n\\n nm_index = []\\n \\n top = (col_m + 1)/2\\n leftside = row_n*col_m - col_m + 1\\n rightside = row_n*col_m \\n\\n k1 = 0; k2 = 0\\n\\n for i in xrange(top,row_n*col_m+1, 2*col_m):\\n\\n nm_index.append(Q[i-1])\\n s1 = i + col_m + 1\\n s2 = i + col_m - 1 \\n jj1 = k1\\n jj2 = k2\\n\\n\\n while (s2 <= leftside): \\n\\n nm_index.append(Q[s2-1])\\n s2 +=col_m - 1\\n jj1 += 1\\n jj2 -= 1\\n\\n leftside +=2\\n\\n jj1 = k1\\n jj2 = k2\\n\\n while (s1 <= rightside): \\n\\n # \\n nm_index.append(Q[s1-1])\\n s1 +=col_m + 1\\n jj1 += 1\\n jj2 += 1\\n\\n rightside -=2\\n k1 = 0; k2 += 2\\n\\n n = np.array(nm_index)[:,0]\\n m = np.array(nm_index)[:,1]\\n\\n return n, m\",\n \"def mi(self, lhs, rhs, cond=None):\\n\\t\\tbins = np.amax(data, axis=0) # read levels for each variable\\n\\t\\tif len(bins) == 1:\\n\\t\\t\\thist,_ = np.histogramdd(data, bins=(bins)) # frequency counts\\n\\t\\t\\tPx = hist/hist.sum()\\n\\t\\t\\tMI = -1 * np.sum( Px * np.log( Px ) )\\n\\t\\t\\treturn round(MI, 4)\\n\\t\\t\\t\\n\\t\\tif len(bins) == 2:\\n\\t\\t\\thist,_ = np.histogramdd(data, bins=bins[0:2]) # frequency counts\\n\\n\\t\\t\\tPxy = hist / hist.sum()# joint probability distribution over X,Y,Z\\n\\t\\t\\tPx = np.sum(Pxy, axis = 1) # P(X,Z)\\n\\t\\t\\tPy = np.sum(Pxy, axis = 0) # P(Y,Z)\\t\\n\\n\\t\\t\\tPxPy = np.outer(Px,Py)\\n\\t\\t\\tPxy += 1e-7\\n\\t\\t\\tPxPy += 1e-7\\n\\t\\t\\tMI = np.sum(Pxy * np.log(Pxy / (PxPy)))\\n\\t\\t\\treturn round(MI,4)\\n\\t\\telif len(bins) > 2 and conditional==True:\\n\\t\\t\\t# CHECK FOR > 3 COLUMNS -> concatenate Z into one column\\n\\t\\t\\tif len(bins) > 3:\\n\\t\\t\\t\\tdata = data.astype('str')\\n\\t\\t\\t\\tncols = len(bins)\\n\\t\\t\\t\\tfor i in range(len(data)):\\n\\t\\t\\t\\t\\tdata[i,2] = ''.join(data[i,2:ncols])\\n\\t\\t\\t\\tdata = data.astype('int')[:,0:3]\\n\\n\\t\\t\\tbins = np.amax(data,axis=0)\\n\\t\\t\\thist,_ = np.histogramdd(data, bins=bins) # frequency counts\\n\\n\\t\\t\\tPxyz = hist / hist.sum()# joint probability distribution over X,Y,Z\\n\\t\\t\\tPz = np.sum(Pxyz, axis = (0,1)) # P(Z)\\n\\t\\t\\tPxz = np.sum(Pxyz, axis = 1) # P(X,Z)\\n\\t\\t\\tPyz = np.sum(Pxyz, axis = 0) # P(Y,Z)\\t\\n\\n\\t\\t\\tPxy_z = Pxyz / (Pz+1e-7) # P(X,Y | Z) = P(X,Y,Z) / P(Z)\\n\\t\\t\\tPx_z = Pxz / (Pz+1e-7) # P(X | Z) = P(X,Z) / P(Z)\\t\\n\\t\\t\\tPy_z = Pyz / (Pz+1e-7) # P(Y | Z) = P(Y,Z) / P(Z)\\n\\n\\t\\t\\tPx_y_z = np.empty((Pxy_z.shape)) # P(X|Z)P(Y|Z)\\n\\t\\t\\tfor i in range(bins[0]):\\n\\t\\t\\t\\tfor j in range(bins[1]):\\n\\t\\t\\t\\t\\tfor k in range(bins[2]):\\n\\t\\t\\t\\t\\t\\tPx_y_z[i][j][k] = Px_z[i][k]*Py_z[j][k]\\n\\t\\t\\tPxyz += 1e-7\\n\\t\\t\\tPxy_z += 1e-7\\n\\t\\t\\tPx_y_z += 1e-7\\n\\t\\t\\tMI = np.sum(Pxyz * np.log(Pxy_z / (Px_y_z)))\\n\\t\\t\\t\\n\\t\\t\\treturn round(MI,4)\\n\\t\\telif len(bins) > 2 and conditional == False:\\n\\t\\t\\tdata = data.astype('str')\\n\\t\\t\\tncols = len(bins)\\n\\t\\t\\tfor i in range(len(data)):\\n\\t\\t\\t\\tdata[i,1] = ''.join(data[i,1:ncols])\\n\\t\\t\\tdata = data.astype('int')[:,0:2]\\n\\n\\t\\t\\thist,_ = np.histogramdd(data, bins=bins[0:2]) # frequency counts\\n\\n\\t\\t\\tPxy = hist / hist.sum()# joint probability distribution over X,Y,Z\\n\\t\\t\\tPx = np.sum(Pxy, axis = 1) # P(X,Z)\\n\\t\\t\\tPy = np.sum(Pxy, axis = 0) # P(Y,Z)\\t\\n\\n\\t\\t\\tPxPy = np.outer(Px,Py)\\n\\t\\t\\tPxy += 1e-7\\n\\t\\t\\tPxPy += 1e-7\\n\\t\\t\\tMI = np.sum(Pxy * np.log(Pxy / (PxPy)))\\n\\t\\t\\treturn round(MI,4)\",\n \"def model_onelayer_pert(r):\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\tif (r > 6361000.0):\\n\\t\\trho = 2.7\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.0 + 0.02\\n\\t\\tvsh = vsv \\n\\t\\teta = 1.0\\n\\n\\telse:\\n\\t\\trho = 3.1\\n\\t\\tvpv = 7.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.0\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def scale_u_and_v(u, v, level, pyr):\\n # TODO: Your code here\\n image = pyr[level-1]\\n expanded_u = ps4.expand_image(u)\\n expanded_v = ps4.expand_image(v)\\n scaled_u = expanded_u * 2\\n scaled_v = expanded_v * 2\\n if image.shape[0] == scaled_u.shape[0] - 1:\\n scaled_u = scaled_u[:-1, :]\\n if image.shape[1] == scaled_u.shape[1] - 1:\\n scaled_u = scaled_u[:, :-1]\\n if image.shape[0] == scaled_v.shape[0] - 1:\\n scaled_v = scaled_v[:-1, :]\\n if image.shape[1] == scaled_v.shape[1] - 1:\\n scaled_v = scaled_v[:, :-1]\\n return scaled_u, scaled_v\",\n \"def assign_to_levels(boxes, im_size, num_levels=6, finest_stride=3):\\n im_area = im_size[0] * im_size[1]\\n widths = boxes[:, 2] - boxes[:, 0] + 1.0\\n heights = boxes[:, 3] - boxes[:, 1] + 1.0\\n areas = widths * heights\\n # if e.g. the finest level has a stride of 4, we want all boxes\\n # at 1/4 image resolution to map to the coarsest level (k = 0)\\n k = np.round(np.log2(math.sqrt(im_area) / np.sqrt(areas)) - math.log2(finest_stride))\\n k = k.astype(np.int32)\\n inds = np.where(k < 0)[0]\\n k[inds] = 0\\n inds = np.where(k > num_levels)[0]\\n k[inds] = num_levels\\n return k\",\n \"def read_vs_1d(vname, depth): \\n with open(vname, 'r') as f:\\n lines = f.readlines() \\n line0=lines[0].split()\\n n_col = int(line0[0])\\n \\n data = []\\n\\n for line in lines[1:]:\\n data.append([float(val) for val in line.split()])\\n\\n data = np.concatenate(data) \\n v_mod = data.reshape([n_col,6])\\n \\n depth_ref = 0\\n for i in range(0, n_col):\\n depth_ref = depth_ref+v_mod[i,0]\\n #print(depth_ref)\\n if(depth_ref>depth):\\n vs_1d = v_mod[i-1,2]\\n rho_1d = v_mod[i-1,3] \\n break\\n \\n return vs_1d, rho_1d\",\n \"def pop_var_from_subpop_var(groups):\\n return np.hstack(groups).var()\",\n \"def assign_level(self, minibatch_reference_proboxes):\\n with tf.name_scope('assign_levels'):\\n ymin, xmin, ymax, xmax = tf.unstack(minibatch_reference_proboxes, axis=2)\\n\\n w = tf.maximum(xmax - xmin, 0.) # avoid w is negative\\n h = tf.maximum(ymax - ymin, 0.) # avoid h is negative\\n\\n levels = tf.round(4. + tf.log(tf.sqrt(w*h + 1e-8)/224.0) / tf.log(2.)) # 4 + log_2(***)\\n\\n levels = tf.maximum(levels, tf.ones_like(levels) * (np.float32(self.min_level))) # level minimum is 2\\n levels = tf.minimum(levels, tf.ones_like(levels) * (np.float32(self.max_level))) # level maximum is 5\\n\\n return tf.cast(levels, tf.int32)\",\n \"def zoomlevels(self):\\n return self._bboxes[0][1] #TODO: merge all coverages\",\n \"def get_level_size(slide, level):\\n return slide.level_dimensions[level]\",\n \"def resolve(self):\\n ind = [ i for i in combinations(range(self.nplex()),2) ]\\n hi,lo = self.insertLevel(ind)\\n lo.sort(axis=1)\\n ind = sortByColumns(lo)\\n return lo[ind]\",\n \"def buildMainVars(self, model, n, name=\\\"main_cells\\\"):\\n import gurobipy as gb\\n ASSERT_TYPE(model, gb.Model)\\n lb = 0 if self.nnls else -gb.GRB.INFINITY\\n # First index is cell (among non-zero), second index is child\\n two_d_vars: gb.MVar = model.addMVar((int(n), int(self.childGeoLen)), vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\\n return two_d_vars\",\n \"def front_column_model_p_gain():\",\n \"def measureUnfoldedLevel(ds, verbose = False):\\n points = getIndexedTraces(ds)\\n from sklearn.cluster import KMeans\\n x = points[points[:,0] > 150, 1].reshape((-1,1))\\n # remove outliers \\n std = np.std(x)\\n mean = np.mean(x)\\n x = x[x > mean - 4*std].reshape((-1,1)) \\n # ML clustering\\n kmeans = KMeans(n_clusters=3, random_state=0).fit(x)\\n x_cluster = kmeans.predict(x)\\n means = [ np.mean(x[x_cluster == i]) for i in range(3)]\\n means = sorted(means) \\n level_one = means[1]\\n if np.abs(level_one) > 0.35 or np.abs(level_one) < 0.1:\\n print(\\\"Warning! Unfolded level detector in unexpected range: \\\",leven_one)\\n if verbose: #feedback\\n pyplot.figure()\\n pyplot.hist2d(points[:,0], points[:,1], \\n bins=(70*2, 50*2),\\n range = [[0, 700], [-0.45, 0.05]],\\n cmax = 100000/4 # clip max\\n )\\n pyplot.plot([0,700], [level_one]*2, 'r--')\\n return level_one\",\n \"def levelsets_to_vector_field(levelsets, stepsize):\\r\\n vector_field_shape = levelsets[0][0].shape\\r\\n y_comp_combined = np.ndarray(vector_field_shape)\\r\\n x_comp_combined = np.ndarray(vector_field_shape)\\r\\n y_comp_combined.fill(np.nan)\\r\\n x_comp_combined.fill(np.nan)\\r\\n\\r\\n for source, target in levelsets:\\r\\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\\r\\n labels_present.remove(0)#relates to background\\r\\n\\r\\n #print(labels_present)\\r\\n for l in labels_present:\\r\\n\\r\\n source_cluster = source == l\\r\\n target_cluster = target == l\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\\r\\n plt.show()\\r\\n print(\\\"-----------\\\")\\\"\\\"\\\"\\r\\n\\r\\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\\r\\n\\r\\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\\r\\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\\r\\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\\r\\n return y_comp_combined, x_comp_combined\",\n \"def test_two_pop_unknown_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_pool = cls.get_var_pool(data1_, data2_)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_pool / n_x + var_pool / n_y)\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def take_max_level(self):\\n level = 0\\n for k, v in self.d.items():\\n level = max(level, len(k.split(\\\":\\\")))\\n return level\",\n \"def create_subspace_preference_dimensionality(self):\\n # For each point compute number of dimensions that have a lower variance then delta\\n spd = np.count_nonzero(self.attribute_variances < self.delta, axis=1)\\n return spd\",\n \"def calc_base_eff_and_infl(level):\\n return 2 + (level - 1)\",\n \"def test_get_dimension(self):\\n\\n v = Vector({ 'x': 1 })\\n self.assertEqual(1, v.dimensions['x'])\",\n \"def decide_resolution(vec):\\n if N >= NOld and M >= MOld:\\n ovec = increase_resolution(vec)\\n\\n elif N <= NOld and M <= MOld:\\n ovec = decrease_resolution(vec)\\n\\n return ovec\",\n \"def create_flux_vector_pms_gr(self):\\n soma_prod = 0\\n soma_inj = 0\\n lim4 = 1e-4\\n store_velocity = {}\\n store_flux = {}\\n for primal in self.primals:\\n #1\\n primal_id = self.mb.tag_get_data(self.primal_id_tag, primal, flat=True)[0]\\n primal_id = self.ident_primal[primal_id]\\n fine_elems_in_primal = self.mb.get_entities_by_handle(primal)\\n for volume in fine_elems_in_primal:\\n #2\\n flux = {}\\n velocity = {}\\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\\n centroid_volume = self.mesh_topo_util.get_average_position([volume])\\n z_vol = self.tz - centroid_volume[2]\\n adjs_vol = self.mesh_topo_util.get_bridge_adjacencies(volume, 2, 3)\\n gid_vol = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\\n for adj in adjs_vol:\\n #3\\n gid_adj = self.mb.tag_get_data(self.global_id_tag, adj, flat=True)[0]\\n if adj not in fine_elems_in_primal:\\n #4\\n pvol = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\\n padj = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\\n #3\\n else:\\n #4\\n pvol = self.mb.tag_get_data(self.pcorr_tag, volume, flat=True)[0]\\n padj = self.mb.tag_get_data(self.pcorr_tag, adj, flat=True)[0]\\n #3\\n kadj = self.mb.tag_get_data(self.perm_tag, adj).reshape([3, 3])\\n centroid_adj = self.mesh_topo_util.get_average_position([adj])\\n z_adj = self.tz - centroid_adj[2]\\n direction = centroid_adj - centroid_volume\\n unit = direction/np.linalg.norm(direction)\\n #unit = vetor unitario na direcao de direction\\n uni = self.unitary(direction)\\n # uni = valor positivo do vetor unitario\\n kvol = np.dot(np.dot(kvol,uni),uni)\\n kadj = np.dot(np.dot(kadj,uni),uni)\\n keq = self.kequiv(kvol, kadj)/(self.mi)\\n keq2 = keq\\n keq = keq*(np.dot(self.A, uni))\\n pvol2 = self.mb.tag_get_data(self.pms_tag, volume, flat=True)[0]\\n padj2 = self.mb.tag_get_data(self.pms_tag, adj, flat=True)[0]\\n grad_p = (padj - pvol)/float(abs(np.dot(direction, uni)))\\n grad_z = (z_adj - z_vol)/float(abs(np.dot(direction, uni)))\\n grad_p2 = (padj2 - pvol2)/float(abs(np.dot(direction, uni)))\\n q = (grad_p)*keq - grad_z*keq*self.gama\\n print((grad_p)*keq)\\n print(- grad_z*keq*self.gama)\\n print(q)\\n print(self.store_flux_pf_gr[volume][tuple(unit)])\\n print('\\\\n')\\n import pdb; pdb.set_trace()\\n\\n if gid_adj > gid_vol:\\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\\n else:\\n v = -((grad_p2)*keq2 - grad_z*self.gama*keq2)\\n\\n flux[tuple(unit)] = q\\n velocity[tuple(unit)] = v\\n kvol = self.mb.tag_get_data(self.perm_tag, volume).reshape([3, 3])\\n\\n #2\\n # print(gid_vol)\\n # print(velocity)\\n # print('\\\\n')\\n # import pdb; pdb.set_trace()\\n store_flux[volume] = flux\\n self.mb.tag_set_data(self.flux_fine_pms_tag, volume, sum(flux.values()))\\n # flt = sum(flux.values())\\n # if volume not in self.wells_inj and volume not in self.wells_prod:\\n # lim4 = 1e-7\\n # if abs(flt) > lim4:\\n # print(gid_vol)\\n # print(flt)\\n # import pdb; pdb.set_trace()\\n # flt = sum(flux.values())\\n store_velocity[volume] = velocity\\n\\n for volume in set(self.all_fine_vols) - set(self.wells):\\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat=True)[0]\\n values = store_flux[volume].values()\\n if sum(values) > lim4:\\n print('fluxo multiescala nao esta dando conservativo')\\n print('gid:{0}'.format(gid))\\n print(sum(values))\\n import pdb; pdb.set_trace()\\n\\n with open('fluxo_multiescala_gr.txt', 'w') as arq:\\n for volume in self.wells:\\n gid = self.mb.tag_get_data(self.global_id_tag, volume, flat= True)[0]\\n values = store_flux[volume].values()\\n if volume in self.wells_inj:\\n soma_inj += sum(values)\\n else:\\n soma_prod += sum(values)\\n arq.write('gid:{0} , fluxo:{1}\\\\n'.format(gid, sum(values)))\\n arq.write('\\\\n')\\n arq.write('soma_inj:{0}\\\\n'.format(soma_inj))\\n arq.write('soma_prod:{0}\\\\n'.format(soma_prod))\\n\\n return store_flux\",\n \"def get_no_strat_levels(no_vert_levels_atmos):\\n try:\\n if float(no_vert_levels_atmos) > 60:\\n no_strat_levels = '20'\\n else:\\n no_strat_levels = '10'\\n except:\\n no_strat_levels = '10'\\n\\n return no_strat_levels\",\n \"def model_onelayer(r):\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\tif (r > 6361000.0):\\n\\t\\trho = 2.7\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.0\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\telse:\\n\\t\\trho = 3.1\\n\\t\\tvpv = 7.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.0\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def get_levels(std0, slope, nsigma):\\n nslope = nsigma * slope\\n levels = [0]\\n while levels[-1] <= 1:\\n levels.append((levels[-1] * (1 + nslope) + 2 * nsigma * std0) / (1 - nslope))\\n levels.pop()\\n return levels\",\n \"def _get_ndim(self):\\n return len(self.level_shapes[0])\",\n \"def heightvar( mv ):\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km\\n heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,\\n attributes={'units':\\\"km\\\"} )\\n return heightmv\",\n \"def _level_info(entity):\\n if entity.is_max_level():\\n return 'Maxed'\\n if entity.max_level is not None:\\n return '{entity.level}/{entity.max_level}'.format(entity=entity)\\n return entity.level\",\n \"def support(self, level=1):\\n if level == 1:\\n sup = (2 * self.pivot_point) - self.last_high\\n elif level == 2:\\n sup = self.pivot_point - (self.last_high - self.last_low)\\n elif level == 3:\\n sup = self.last_low - 2*(self.last_high - self.pivot_point)\\n else:\\n raise ValueError('Not a valid level. Must be 1, 2, or 3')\\n return sup\",\n \"def levels(ohlc_day):\\r\\n high = round(ohlc_day[\\\"high\\\"][-1],2)\\r\\n low = round(ohlc_day[\\\"low\\\"][-1],2)\\r\\n close = round(ohlc_day[\\\"close\\\"][-1],2)\\r\\n pivot = round((high + low + close)/3,2)\\r\\n r1 = round((2*pivot - low),2)\\r\\n r2 = round((pivot + (high - low)),2)\\r\\n r3 = round((high + 2*(pivot - low)),2)\\r\\n s1 = round((2*pivot - high),2)\\r\\n s2 = round((pivot - (high - low)),2)\\r\\n s3 = round((low - 2*(high - pivot)),2)\\r\\n return (pivot,r1,r2,r3,s1,s2,s3)\",\n \"def multiple_intersections():\\n levels = np.array([966., 937.2, 925., 904.6, 872.6, 853., 850., 836., 821., 811.6, 782.3,\\n 754.2, 726.9, 700., 648.9, 624.6, 601.1, 595., 587., 576., 555.7,\\n 534.2, 524., 500., 473.3, 400., 384.5, 358., 343., 308.3, 300., 276.,\\n 273., 268.5, 250., 244.2, 233., 200.]) * units.mbar\\n temperatures = np.array([18.2, 16.8, 16.2, 15.1, 13.3, 12.2, 12.4, 14., 14.4,\\n 13.7, 11.4, 9.1, 6.8, 4.4, -1.4, -4.4, -7.3, -8.1,\\n -7.9, -7.7, -8.7, -9.8, -10.3, -13.5, -17.1, -28.1, -30.7,\\n -35.3, -37.1, -43.5, -45.1, -49.9, -50.4, -51.1, -54.1, -55.,\\n -56.7, -57.5]) * units.degC\\n dewpoints = np.array([16.9, 15.9, 15.5, 14.2, 12.1, 10.8, 8.6, 0., -3.6, -4.4,\\n -6.9, -9.5, -12., -14.6, -15.8, -16.4, -16.9, -17.1, -27.9, -42.7,\\n -44.1, -45.6, -46.3, -45.5, -47.1, -52.1, -50.4, -47.3, -57.1,\\n -57.9, -58.1, -60.9, -61.4, -62.1, -65.1, -65.6,\\n -66.7, -70.5]) * units.degC\\n return levels, temperatures, dewpoints\",\n \"def estimate_maxm_neutral_axis_depth(self):\\r\\n\\t\\txu_d = abs(self.concrete.max_compresive_strain)/\\\\\\r\\n\\t\\t\\t(abs(self.concrete.max_compresive_strain) + self.steel.max_tensile_strain)\\r\\n\\t\\tself.max_positive_na = xu_d*self.positive_effective_depth\\r\\n\\t\\tself.max_negative_na = xu_d*self.negative_effective_depth\",\n \"def find_fermi_level(self):\\n all_max_val = self.gather_qpt_function('get_max_val')\\n all_min_cond = self.gather_qpt_function('get_min_cond')\\n if i_am_master:\\n max_val = np.max(all_max_val)\\n min_cond = np.min(all_min_cond)\\n mu = (max_val + min_cond) / 2.0\\n mu = np.array(mu, dtype=np.float64)\\n else:\\n mu = np.empty(1, dtype=np.float64)\\n\\n comm.Bcast([mu, MPI.DOUBLE])\\n\\n self.set_fermi_level(mu)\",\n \"def test_cube_multi_level(self):\\n temperature = self._make_multi_level(self.temperature, time_promote=True)\\n relative_humidity = self._make_multi_level(\\n self.relative_humidity, time_promote=True\\n )\\n pressure = self._make_multi_level(self.pressure, time_promote=True)\\n result = WetBulbTemperature().process(\\n CubeList([temperature, relative_humidity, pressure])\\n )\\n self.assertEqual(result.coord_dims(\\\"time\\\")[0], 0)\\n self.assertEqual(result.coord_dims(\\\"height\\\")[0], 1)\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def get_min_depth(l_k):\\n return max(l_k.values())\",\n \"def n_levels(self):\\n return len(self.scales)\",\n \"def getMtVariant(data, depth_min = 10, depth_ratio_min = 0.0):\\n\\tvar = {}\\n\\tn = 0\\n\\tfor family in data:\\n\\t\\tvar[family] = {}\\n\\t\\tfor sample in data[family]:\\n\\t\\t\\tvar[family][sample] = {}\\n\\t\\t\\tfor variant in data[family][sample].values():\\n\\t\\t\\t\\tif (variant.ref == \\\"N\\\"):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif (variant.depth_qc >= depth_min and variant.depth_ratio >= depth_ratio_min):\\n\\t\\t\\t\\t\\tvar[family][sample][variant.pos] = variant\\n\\t\\t\\t\\t\\tn += 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tvar[family][sample][variant.pos] = None\\n\\tprint \\\"Read %d mitochondrial DNA variants\\\" % n\\n\\treturn var\",\n \"def load_variable_profile(\\n self,\\n varname,\\n ):\\n if self.depth is None:\\n raise LookupError('Profile variables not available in this dataset')\\n var = self.dataset.data_vars[varname]\\n if 'nVertLevelsLES' in var.dims:\\n # LES variables with different vertical levels\\n with xr.open_dataset(self._filepath_mesh) as fmesh:\\n z = fmesh.data_vars['zLES'].values[0,0,:]\\n depth = xr.DataArray(\\n z,\\n dims=('nVertLevelsLES'),\\n coords={'nVertLevelsLES': z},\\n attrs={'units': 'm', 'long_name': 'depth'},\\n )\\n var = var.assign_coords({'nVertLevelsLES': depth})\\n elif 'nVertLevelsP1' in var.dims:\\n var = var.assign_coords({'nVertLevelsP1': self.depth_iface})\\n elif 'nVertLevels' in var.dims:\\n var = var.assign_coords({'nVertLevels': self.depth})\\n # mask topography\\n if 'nCells' in var.dims:\\n with xr.open_dataset(self._filepath_mesh) as fmesh:\\n maxlevelcell = fmesh.data_vars['maxLevelCell']\\n var = var.where(var.nVertLevels>=var.nVertLevels[maxlevelcell-1])\\n else:\\n raise LookupError('\\\\'{}\\\\' is not a profile variables'.format(varname))\\n return var.transpose()\",\n \"def getLevel(self):\\n return self.level\",\n \"def get_var_pool(cls, data1: tuple, data2: tuple) -> float:\\n cls._data_validation(data1)\\n cls._data_validation(data2)\\n n1 = cls.get_n(data1)\\n var1 = cls.get_var(data1)\\n n2 = cls.get_n(data2)\\n var2 = cls.get_var(data2)\\n return ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2)\",\n \"def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_x = cls.get_var(data1_, is_population=True)\\n var_y = cls.get_var(data2_, is_population=True)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)\",\n \"def maximum_level(self, question_type):\\n\\t\\treturn 2\",\n \"def discretize(self, x):\\n encoded = self.est.forward(x)\\n # encoded will be (A,B,C ... K)\\n # take argmax along dim k, and take that from levels\\n indices = np.argmax(encoded, axis=-1)\\n return np.take(self.levels, indices)\",\n \"def basisVar(bases):\\n \\n var = [] # The ordered list of active coordinates \\n k = 0\\n for b in bases:\\n if np.isscalar(b):\\n # A singleton, inactive coordinate\\n k += 1\\n else:\\n # An active basis\\n for i in range(b.nd):\\n var.append(k)\\n k += 1 \\n return var\",\n \"def defineSigmaLevels():\\r\\n # A and B values for the definition of sigma levelist\\r\\n # Since there are 72 model levels, there are 73 half levels, so it is for A and B values\\r\\n # the unit of A is hPa!!!!!!!!!!!!\\r\\n # from surface to TOA\\r\\n A = np.array([\\r\\n 0.000000e+00, 4.804826e-02, 6.593752e+00, 1.313480e+01, 1.961311e+01, 2.609201e+01,\\r\\n 3.257081e+01, 3.898201e+01, 4.533901e+01, 5.169611e+01, 5.805321e+01, 6.436264e+01,\\r\\n 7.062198e+01, 7.883422e+01, 8.909992e+01, 9.936521e+01, 1.091817e+02, 1.189586e+02,\\r\\n 1.286959e+02, 1.429100e+02, 1.562600e+02, 1.696090e+02, 1.816190e+02, 1.930970e+02,\\r\\n 2.032590e+02, 2.121500e+02, 2.187760e+02, 2.238980e+02, 2.243630e+02, 2.168650e+02,\\r\\n 2.011920e+02, 1.769300e+02, 1.503930e+02, 1.278370e+02, 1.086630e+02, 9.236572e+01,\\r\\n 7.851231e+01, 6.660341e+01, 5.638791e+01, 4.764391e+01, 4.017541e+01, 3.381001e+01,\\r\\n 2.836781e+01, 2.373041e+01, 1.979160e+01, 1.645710e+01, 1.364340e+01, 1.127690e+01,\\r\\n 9.292942e+00, 7.619842e+00, 6.216801e+00, 5.046801e+00, 4.076571e+00, 3.276431e+00,\\r\\n 2.620211e+00, 2.084970e+00, 1.650790e+00, 1.300510e+00, 1.019440e+00, 7.951341e-01,\\r\\n 6.167791e-01, 4.758061e-01, 3.650411e-01, 2.785261e-01, 2.113490e-01, 1.594950e-01,\\r\\n 1.197030e-01, 8.934502e-02, 6.600001e-02, 4.758501e-02, 3.270000e-02, 2.000000e-02,\\r\\n 1.000000e-02,],dtype=float)\\r\\n # reverse A\\r\\n A = A[::-1] * 100 # change unit to Pa\\r\\n # the unit of B is 1!!!!!!!!!!!!\\r\\n # from surfac eto TOA\\r\\n B = np.array([\\r\\n 1.000000e+00, 9.849520e-01, 9.634060e-01, 9.418650e-01, 9.203870e-01, 8.989080e-01,\\r\\n 8.774290e-01, 8.560180e-01, 8.346609e-01, 8.133039e-01, 7.919469e-01, 7.706375e-01,\\r\\n 7.493782e-01, 7.211660e-01, 6.858999e-01, 6.506349e-01, 6.158184e-01, 5.810415e-01,\\r\\n 5.463042e-01, 4.945902e-01, 4.437402e-01, 3.928911e-01, 3.433811e-01, 2.944031e-01,\\r\\n 2.467411e-01, 2.003501e-01, 1.562241e-01, 1.136021e-01, 6.372006e-02, 2.801004e-02,\\r\\n 6.960025e-03, 8.175413e-09, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\\r\\n 0.000000e+00,],dtype=float)\\r\\n # reverse B\\r\\n B = B[::-1]\\r\\n\\r\\n return (A, B)\",\n \"def level_sets(self):\\n in_degrees = self.in_degree(labels=True)\\n level = [x for x in in_degrees if in_degrees[x]==0]\\n Levels = []\\n while len(level) != 0:\\n Levels.append(level)\\n new_level = []\\n for x in level:\\n for y in self.neighbors_out(x):\\n in_degrees[y] -= 1\\n if in_degrees[y] == 0:\\n new_level.append(y)\\n level = new_level\\n return Levels\",\n \"def dim3():\\n return Integer(\\\"yolo3\\\", \\\"uniform\\\", 3, 7, shape=(1,))\",\n \"def levels(ohlc_day):\\n high = round(ohlc_day[\\\"high\\\"][-1],2)\\n low = round(ohlc_day[\\\"low\\\"][-1],2)\\n close = round(ohlc_day[\\\"close\\\"][-1],2)\\n pivot = round((high + low + close)/3,2)\\n r1 = round((2*pivot - low),2)\\n r2 = round((pivot + (high - low)),2)\\n r3 = round((high + 2*(pivot - low)),2)\\n s1 = round((2*pivot - high),2)\\n s2 = round((pivot - (high - low)),2)\\n s3 = round((low - 2*(high - pivot)),2)\\n return (pivot,r1,r2,r3,s1,s2,s3)\",\n \"def create_sub_mdps(self, level):\\n\\n mdps_copy = set(self.mdps[level-1].copy())\\n mdps = set()\\n upper_level_exits = {}\\n\\n # Full depth-first search to group MDPs into MERs\\n while len(mdps_copy) > 0:\\n curr_mdp = random.choice(tuple(mdps_copy))\\n mer, exits = set(), set()\\n # Group curr_mdp with neighbors to form a MER and find exits\\n self.dfs(mdps_copy, curr_mdp, level, mer, exits)\\n # Choose a state var that is representative of the new MER\\n state_var = next(iter(mer)).state_var[1:]\\n # Create a new upper level MDP and set its properties\\n mdp = MDP(level=level, state_var=state_var)\\n mdp.mer = frozenset(mer)\\n\\n upper_level_exits[mdp] = exits\\n for _mdp in mer:\\n mdp.primitive_states.update(_mdp.primitive_states)\\n mdps.add(mdp)\\n\\n self.mdps[level] = mdps\\n\\n # Add MDP Exits/Actions\\n for mdp in self.mdps[level]:\\n mdp.exits = set()\\n # Generate new exits (mdp at level, Exit at level-1, target mdp at level)\\n for s_mdp, exit, n_mdp in upper_level_exits[mdp]:\\n neighbor_mdp = n_mdp.get_upper_mdp(self.mdps) \\n mdp.exits.add(Exit(mdp, Exit(s_mdp, exit, n_mdp), neighbor_mdp))\",\n \"def max_level(data: np.ndarray) -> int:\\n shape = data.shape[1:] # exclude channel dimension\\n return min(shape).bit_length() - 1\",\n \"def top_k_betweenness_centrality(self):\\n d={}\\n l=[]\\n for v in vertices:\\n a=self.betweenness_centrality(v)\\n d[v]=a\\n l.append(a)\\n m=max(l)\\n l1=[]\\n for key in d:\\n if d[key]==m:\\n l1.append(key)\\n\\n return l1\",\n \"def _G_to_km_on_basis_single_level(self, w, m):\\n kB = self._sym.kBoundedSubspace(self.k,t=1)\\n g = kB.K_kschur()\\n mon = self.km()\\n if m < w.length():\\n return 0\\n ans = self.zero()\\n for la in Partitions(m, max_part = self.k):\\n ans += g.homogeneous_basis_noncommutative_variables_zero_Hecke((la)).coefficient(w)*mon(la)\\n return ans\",\n \"def compute_levels_seasons(self, Y: t.Tensor, idxs: t.Tensor):\\n y_transformed, _ = Y.median(1)\\n y_transformed = y_transformed.reshape(-1, 1)\\n levels = y_transformed.repeat(1, Y.shape[1])\\n seasonalities = None\\n\\n return levels, None\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def add_extra_level(self, variable, xlevel):\\n \\n if variable not in [\\\"geopotential\\\", \\\"temperature\\\"]:\\n raise Exception(\\\"variable should be one of [geopotential,temperature]\\\")\\n \\n if variable == \\\"geopotential\\\":\\n # geopotential \\n A = self.z.z[:, -1, :, :].to_dataset() # copy lowest pressure level\\n A[\\\"level\\\"] = xlevel\\n self.z = (xarray.concat([self.z, A], dim=\\\"level\\\"))\\n \\n # convert pressure to geopotential\\n self.z.z[0, -1, :, :] = pres2alt(xlevel * 100) * g\\n \\n else: \\n # temperature\\n A = self.t.t[:, -1, :, :].to_dataset() # copy lowest pressure level\\n A[\\\"level\\\"] = xlevel\\n self.t = (xarray.concat([self.t, A], dim=\\\"level\\\"))\",\n \"def __init__(self, level):\\n self.level = level\\n self.my_map = {}\\n self.my_level = []\\n self.my_grid = []\",\n \"def test_mixed_layer():\\n pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa\\n temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC\\n mixed_layer_temperature = mixed_layer(pressure, temperature, depth=250 * units.hPa)[0]\\n assert_almost_equal(mixed_layer_temperature, 16.4024930 * units.degC, 6)\",\n \"def get_plevels(\\n filepath: Union[os.PathLike, str] = \\\"/data/cees/zespinos/netcdf_data/MiMA-topo-v1.1-40-level\\\",\\n) -> None:\\n with netcdf.netcdf_file(os.path.join(filepath, \\\"atmos_1day_d12240_plevel.nc\\\")) as year_four_qbo:\\n plevels = year_four_qbo.variables[\\\"level\\\"][:]#[LOWEST_PLEVEL:LAST_PLEVEL]\\n return plevels\",\n \"def compare_select(self, x: torch.Tensor) -> [torch.Tensor, torch.LongTensor]:\\n reshaped_x = x.reshape(-1, self.n_states, 2)\\n max_values, absolute_max_ind = torch.max(reshaped_x, 2)\\n return max_values, absolute_max_ind\",\n \"def level_calc_manager(natal_tab, control_tab, esolevel, planets12):\\n planet_control = { k: control_tab[natal_tab[k]][esolevel] \\n for k in natal_tab } \\n planet_level, used_planets = calc_level(planet_control)\\n planets = [item for item in planets12 if item in used_planets]\\n return (planets, planet_control, planet_level)\",\n \"def mult_var_by_prior(self, x_scaled):\\n model_var = self.likelihood(x_scaled)[1]\\n tensor_log_prior = self.log_prior(x_scaled)\\n return tf.reshape(model_var, shape=tensor_log_prior.shape) * tf.math.exp(tensor_log_prior)\",\n \"def calc_level(xp, dominion):\\n if xp < 3:\\n xp_potential = 1\\n if xp >= 3 and xp < 6:\\n xp_potential = 2\\n if xp >= 6 and xp < 12:\\n xp_potential = 3\\n if xp >= 12 and xp < 24:\\n xp_potential = 4\\n if xp >= 24 and xp < 48:\\n xp_potential = 5\\n if xp >= 48 and xp < 72:\\n xp_potential = 6\\n if xp >= 72 and xp < 96:\\n xp_potential = 7\\n if xp >= 96 and xp < 130:\\n xp_potential = 8\\n if xp >= 130 and xp < 170:\\n xp_potential = 9\\n if xp >= 170:\\n xp_potential = 10\\n if dominion < 2:\\n dom_potential = 1\\n if dominion >= 2 and dominion < 4:\\n dom_potential = 2\\n if dominion >= 4 and dominion < 10:\\n dom_potential = 3\\n if dominion >= 10 and dominion < 22:\\n dom_potential = 4\\n if dominion >= 22 and dominion < 38:\\n dom_potential = 5\\n if dominion >= 38 and dominion < 57:\\n dom_potential = 6\\n if dominion >= 57 and dominion < 76:\\n dom_potential = 7\\n if dominion >= 76 and dominion < 95:\\n dom_potential = 8\\n if dominion >= 95 and dominion < 124:\\n dom_potential = 9\\n if dominion >= 124:\\n dom_potential = 10\\n return min(xp_potential, dom_potential)\",\n \"def define_variables(m):\\r\\n\\r\\n # Non-negative candidate capacity\\r\\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Solar build limits\\r\\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Wind build limits\\r\\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage build limits\\r\\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min power output (all generators excluding storage units)\\r\\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing thermal\\r\\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate thermal\\r\\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing wind\\r\\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate wind\\r\\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing solar\\r\\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate solar\\r\\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - hydro\\r\\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min charging power - storage units\\r\\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min discharging power - storage_units\\r\\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - existing storage\\r\\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - candidate storage\\r\\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - existing storage\\r\\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - candidate storage\\r\\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - storage units\\r\\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - existing storage units\\r\\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - candidate storage\\r\\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - interval end\\r\\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - interval end\\r\\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate up (thermal and hydro generators)\\r\\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate down (thermal and hydro generators)\\r\\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Non-negative lost load power\\r\\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min powerflow\\r\\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max powerflow\\r\\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage energy transition\\r\\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n # Power balance (locational marginal price)\\r\\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n return m\",\n \"def lvl_algo(next_level):\\n total_xp_needed = (next_level * next_level)\\n return total_xp_needed\",\n \"def _get_static_level2(self):\\n return self.__static_level2\",\n \"def get_pedigree_variance(pm, version=\\\"original\\\"):\\n assert all(isinstance(obj, int) for obj in pm.values())\\n return sum(PEDIGREE_MATRIX_VALUES[version][k][v - 1] for k, v in pm.items())\",\n \"def z(self):\\n data = np.ma.array(np.zeros(self.n_levels()), mask=True)\\n for i in range(self.n_levels()):\\n if self.profile_data[i]['Missing']: continue\\n data[i] = self.profile_data[i]['Depth']\\n return data\",\n \"def get_level(k):\\r\\n return int(log2(k))\",\n \"def get_depths(self, variables):\\n\\n return [0.]\",\n \"def metis(W, levels, rid=None):\\n # Function written by M. Defferrard, taken verbatim, from \\n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L34\\n\\n N, N = W.shape\\n if rid is None:\\n rid = np.random.permutation(range(N))\\n parents = []\\n degree = W.sum(axis=0) - W.diagonal()\\n graphs = []\\n graphs.append(W)\\n #supernode_size = np.ones(N)\\n #nd_sz = [supernode_size]\\n #count = 0\\n\\n #while N > maxsize:\\n for _ in range(levels):\\n\\n #count += 1\\n\\n # CHOOSE THE WEIGHTS FOR THE PAIRING\\n # weights = ones(N,1) # metis weights\\n weights = degree # graclus weights\\n # weights = supernode_size # other possibility\\n weights = np.array(weights).squeeze()\\n\\n # PAIR THE VERTICES AND CONSTRUCT THE ROOT VECTOR\\n idx_row, idx_col, val = scipy.sparse.find(W)\\n perm = np.argsort(idx_row)\\n rr = idx_row[perm]\\n cc = idx_col[perm]\\n vv = val[perm]\\n cluster_id = metis_one_level(rr,cc,vv,rid,weights) # rr is ordered\\n parents.append(cluster_id)\\n\\n # TO DO\\n # COMPUTE THE SIZE OF THE SUPERNODES AND THEIR DEGREE \\n #supernode_size = full( sparse(cluster_id, ones(N,1) ,\\n #\\tsupernode_size ) )\\n #print(cluster_id)\\n #print(supernode_size)\\n #nd_sz{count+1}=supernode_size;\\n\\n # COMPUTE THE EDGES WEIGHTS FOR THE NEW GRAPH\\n nrr = cluster_id[rr]\\n ncc = cluster_id[cc]\\n nvv = vv\\n Nnew = cluster_id.max() + 1\\n # CSR is more appropriate: row,val pairs appear multiple times\\n W = scipy.sparse.csr_matrix((nvv,(nrr,ncc)), shape=(Nnew,Nnew))\\n W.eliminate_zeros()\\n # Add new graph to the list of all coarsened graphs\\n graphs.append(W)\\n N, N = W.shape\\n\\n # COMPUTE THE DEGREE (OMIT OR NOT SELF LOOPS)\\n degree = W.sum(axis=0)\\n #degree = W.sum(axis=0) - W.diagonal()\\n\\n # CHOOSE THE ORDER IN WHICH VERTICES WILL BE VISTED AT THE NEXT PASS\\n #[~, rid]=sort(ss); # arthur strategy\\n #[~, rid]=sort(supernode_size); # thomas strategy\\n #rid=randperm(N); # metis/graclus strategy\\n ss = np.array(W.sum(axis=0)).squeeze()\\n rid = np.argsort(ss)\\n\\n return graphs, parents\",\n \"def identifier(self, sub, obj, t):\\n\\n # use the trained model q(r,v|x) = q(r|x)q(v|x,r)\\n # to compute probabilities for the latent variables\\n # and then get the most probable relation and predicate from the posterior\\n prob_pred, prob_rel, z_loc, z_scale = self.encoder(sub, obj, t)\\n _, r_map = torch.topk(prob_rel, 1)\\n r_map = torch.squeeze(r_map)\\n _, v_map = torch.topk(prob_pred, 1)\\n\\n return r_map, v_map\",\n \"def getStatesDim(self):\\n return 2\",\n \"def psis(self, num_levels=-1):\\n if not self.solved: self.solve()\\n return self.ev[:num_levels]\",\n \"def levels(self):\\n return np.array(self._levels()).T\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60400754","0.5711261","0.53916866","0.5316189","0.5314503","0.5262245","0.5258733","0.5256473","0.52382195","0.5228566","0.5206168","0.51694137","0.51330495","0.51280445","0.51269424","0.5126678","0.5115695","0.51080126","0.50934094","0.5042593","0.50391614","0.5038767","0.50226116","0.49956325","0.49911064","0.49690497","0.4966342","0.49567708","0.49533004","0.4944632","0.49383703","0.49376366","0.49313936","0.49125668","0.49114293","0.4893533","0.4872974","0.48553115","0.48487657","0.48459122","0.483954","0.4829582","0.48096913","0.48042995","0.4790929","0.47755614","0.4767597","0.4763214","0.47566357","0.47528723","0.47470182","0.47448587","0.4723244","0.47180113","0.47165838","0.47139952","0.47100252","0.47091338","0.47006354","0.4696489","0.4691442","0.46839562","0.46790603","0.46712154","0.46710423","0.46698707","0.4669859","0.4653382","0.46516356","0.46489817","0.46447906","0.4638773","0.4635006","0.4631281","0.4631103","0.46306074","0.4627217","0.46259665","0.46255353","0.46223587","0.46218282","0.46178567","0.4616746","0.46144277","0.46094924","0.4607464","0.46055168","0.46041825","0.46025947","0.45873046","0.45867425","0.45860443","0.45850974","0.45753944","0.45729628","0.4571161","0.45708987","0.45688984","0.456708","0.4564083"],"string":"[\n \"0.60400754\",\n \"0.5711261\",\n \"0.53916866\",\n \"0.5316189\",\n \"0.5314503\",\n \"0.5262245\",\n \"0.5258733\",\n \"0.5256473\",\n \"0.52382195\",\n \"0.5228566\",\n \"0.5206168\",\n \"0.51694137\",\n \"0.51330495\",\n \"0.51280445\",\n \"0.51269424\",\n \"0.5126678\",\n \"0.5115695\",\n \"0.51080126\",\n \"0.50934094\",\n \"0.5042593\",\n \"0.50391614\",\n \"0.5038767\",\n \"0.50226116\",\n \"0.49956325\",\n \"0.49911064\",\n \"0.49690497\",\n \"0.4966342\",\n \"0.49567708\",\n \"0.49533004\",\n \"0.4944632\",\n \"0.49383703\",\n \"0.49376366\",\n \"0.49313936\",\n \"0.49125668\",\n \"0.49114293\",\n \"0.4893533\",\n \"0.4872974\",\n \"0.48553115\",\n \"0.48487657\",\n \"0.48459122\",\n \"0.483954\",\n \"0.4829582\",\n \"0.48096913\",\n \"0.48042995\",\n \"0.4790929\",\n \"0.47755614\",\n \"0.4767597\",\n \"0.4763214\",\n \"0.47566357\",\n \"0.47528723\",\n \"0.47470182\",\n \"0.47448587\",\n \"0.4723244\",\n \"0.47180113\",\n \"0.47165838\",\n \"0.47139952\",\n \"0.47100252\",\n \"0.47091338\",\n \"0.47006354\",\n \"0.4696489\",\n \"0.4691442\",\n \"0.46839562\",\n \"0.46790603\",\n \"0.46712154\",\n \"0.46710423\",\n \"0.46698707\",\n \"0.4669859\",\n \"0.4653382\",\n \"0.46516356\",\n \"0.46489817\",\n \"0.46447906\",\n \"0.4638773\",\n \"0.4635006\",\n \"0.4631281\",\n \"0.4631103\",\n \"0.46306074\",\n \"0.4627217\",\n \"0.46259665\",\n \"0.46255353\",\n \"0.46223587\",\n \"0.46218282\",\n \"0.46178567\",\n \"0.4616746\",\n \"0.46144277\",\n \"0.46094924\",\n \"0.4607464\",\n \"0.46055168\",\n \"0.46041825\",\n \"0.46025947\",\n \"0.45873046\",\n \"0.45867425\",\n \"0.45860443\",\n \"0.45850974\",\n \"0.45753944\",\n \"0.45729628\",\n \"0.4571161\",\n \"0.45708987\",\n \"0.45688984\",\n \"0.456708\",\n \"0.4564083\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65224934"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19882,"cells":{"query":{"kind":"string","value":"interpolates a variable mv along its second axis, normally latitude, so as to match the new axis (which should be coarser, i.e. fewer points), and returns a numpy array of the interpolated values. The first axis is normally levels, and isn't expected to be very large (usually <20; surely <50) There shall be no more than two axes."},"document":{"kind":"string","value":"def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals"},"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 reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def interpolate(m):\n \n x1 = m[0]\n x2 = m[1]\n x3 = m[2]\n y1 = m[3]\n y2 = m[4]\n y3 = m[5]\n denom = (x1 - x2)*(x1 - x3)*(x2 - x3)\n A = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom\n B = (x3**2 * (y1 - y2) + x2**2 * (y3 - y1) + x1**2 * (y2 - y3)) / denom\n C = (x2 * x3 * (x2 - x3) * y1 + x3 * x1 * (x3 - x1) * y2 + x1 * x2 * (x1 - x2) * y3) / denom\n xext = -B/(2*A)\n yext = A*xext**2 + B*xext + C\n \n return(np.array([xext,yext]))","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def interpolation_matrix(m):\n return np.nanmean(m,axis=1)","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def myinterp2d(x, y, z, xnew, ynew, method='linear'):\n x = np.ravel(x)\n y = np.ravel(y)\n z = np.ravel(z)\n znew = griddata((x, y), z, (xnew, ynew), method=method, fill_value=0.)\n return znew","def interpolate_matrix(matrix):","def loc_massmet(mass):\n return np.interp(mass, massmet[:, 0], massmet[:, 1])","def interpolate_vertical(ml_file, inter_file, new_vertical_axis):\n with xr.load_dataset(inter_file) as interpolated:\n reference = [variable for variable in interpolated.variables if len(interpolated[variable].shape) == 4][0]\n with xr.open_dataset(ml_file) as ml:\n for variable in [variable for variable in ml.variables if variable not in interpolated.variables\n and len(ml[variable].dims) == 4\n and \"lev_2\" in ml[variable].dims]:\n try:\n x = np.array(ml[new_vertical_axis].data)\n y = np.array(ml[variable].data)\n interpolated_data = interpolate_1d(interpolated[\"lev\"].data, x, y, axis=1)\n attributes = ml[variable].attrs\n\n interpolated[variable] = interpolated[reference].copy(data=interpolated_data)\n interpolated[variable].attrs = ml[variable].attrs\n except Exception as e:\n print(variable, e)\n interpolated.to_netcdf(inter_file)","def coord_interp(parameter, interval):\r\n epoch = _np.linspace(1800, 12600 , int(10800/interval)+1) # 3h validity interval within 4h\r\n time = _np.array([epoch**deg for deg in range(len(parameter)-1,-1,-1)])\r\n return _np.matmul(parameter,time)","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def interpolation(self, arr, factor):\n\t x = arr[:, 0]\n\t y = arr[:, 1]\n\t z = arr[:, 2]\n\t t = np.linspace(0,x.shape[0],num=x.shape[0])\n\t to_expand = [x, y, z]\n\t for i in range(len(to_expand)):\n\t spl = interp1d(t, np.ravel(to_expand[i]))\n\t to_expand[i] = spl(np.linspace(0,len(t), len(t)*factor))\n\t new_matrix = np.matrix(np.r_[0:len(t):1.0/factor])\n\t for i in to_expand:\n\t new_matrix = np.concatenate((new_matrix, np.matrix(i)), axis = 0)\n\t return new_matrix.T[:,1:]","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def frechet_var_approx(dist_proj):\n return torch.mean(dist_proj ** 2).item()","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def interpolate2D(uv, img):\n\n x, y = uv.T\n\n # Get closest points\n x1, y1 = np.floor(uv).T.astype(np.int)\n x2, y2 = np.ceil(uv).T.astype(np.int)\n\n # Evaluate color function at closest points\n Q11 = img[y1, x1]\n Q12 = img[y1, x2]\n Q21 = img[y2, x1]\n Q22 = img[y2, x2]\n\n # Interpolate on x\n\n n = x2-x1\n alpha, beta = ((x2-x)/n)[:, None], ((x-x1)/n)[:, None]\n\n fxy1 = alpha*Q11 + beta*Q21\n fxy2 = alpha*Q12 + beta*Q22\n\n # Interpolate on y\n\n n = y2-y1\n alpha, beta = ((y2-y)/n)[:, None], ((y-y1)/n)[:, None]\n\n return alpha*fxy1 + beta*fxy2","def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def interpolate_meridional(self, *interp1d_args, **interp1d_kwargs):\n return self.interp1d_meridional(*interp1d_args, **interp1d_kwargs)(self.lat)","def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def focal_projection(m, dx=.02, return_grid=False):\n dy = dx # grid loop\n x = np.arange(-1, 1, dx)[None, ...]\n y = np.arange(-1, 1, dy)[..., None]\n\n nx = len(x)\n ny = len(y) # vectorization of previous code begins here\n\n x2 = x.repeat(ny, axis=0)\n y2 = y.repeat(ny, axis=1)\n\n r2 = x2 * x2 + y2 * y2\n trend = np.arctan2(y2, x2)\n plunge = np.pi / 2 - 2 * np.arcsin(np.sqrt(r2 / 2)) # equal area projection\n\n vij1 = np.cos(trend) * np.cos(plunge) # set up local vector grids\n vij2 = np.sin(trend) * np.cos(plunge)\n vij3 = np.sin(plunge)\n\n m = np.array(m)\n if len(m.ravel()) == 9:\n m = moment_convert(m)\n\n u1 = (vij1 * m[0] + vij2 * m[5] + vij3 * m[4]) * vij1\n u2 = (vij1 * m[5] + vij2 * m[1] + vij3 * m[3]) * vij2\n u3 = (vij1 * m[4] + vij2 * m[3] + vij3 * m[2]) * vij3\n u = u1 + u2 + u3\n u[r2 > 1] = np.nan\n if return_grid:\n return u, vij1, vij2, vij3\n return u","def interpolate_2d(x, y, z, x_new, y_new):\n fun = RectBivariateSpline(x, y, z, kx=1, ky=1) # linear interpolation\n return fun(x_new, y_new)","def vp_from_ke(m):\n return (m[0, 0]/m[2,0], m[1,0]/m[2,0])","def reduce2scalar( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def dmsp_map_interpolate_NN_smooth(X_dmsp, Y_dmsp, X_map, Y_map, Obs_map, k = 5, tol = 3):\n #reshape to N by 2 array where each row is (X, Y)\n dmsp_points = np.hstack((X_dmsp.flatten().reshape(-1,1),Y_dmsp.flatten().reshape(-1,1)))\n map_points = np.hstack((X_map.flatten().reshape(-1,1), Y_map.flatten().reshape(-1,1)))\n N_points = dmsp_points.shape[0]\n obs_val = Obs_map.flatten()\n model = sklearn.neighbors.BallTree(map_points,leaf_size = 40 )\n dists, inds = model.query(dmsp_points, k=k) \n\n obs_interp = np.empty(N_points)\n for i in range(N_points):\n norm = LA.norm(dists[i])\n if (norm > tol):\n obs_interp[i] = np.nan\n else:\n# weights = dists[i]/norm\n\n weights = dists[i]/np.nansum(dists[i])\n obs_interp[i] = np.nansum( obs_val[inds[i]] * weights )\n\n return obs_interp","def linear_interp2d(z, map_lower, map_higher, comoving_dist=False, NewProjected=False):\n with h5py.File(map_lower, \"r\") as ds1, h5py.File(map_higher, \"r\") as ds2:\n if NewProjected:\n dm_name = \"map\"\n header_name = \"Header\"\n else:\n dm_name = \"DM\"\n header_name = \"HEADER\"\n\n y2 = ds2[dm_name][:]\n y1 = ds1[dm_name][:]\n\n if comoving_dist:\n x2 = z_to_mpc(ds2[header_name].attrs[\"Redshift\"])\n x1 = z_to_mpc(ds1[header_name].attrs[\"Redshift\"])\n dist = z_to_mpc(z) - x1\n else:\n x2 = ds2[header_name].attrs[\"Redshift\"]\n x1 = ds1[header_name].attrs[\"Redshift\"]\n dist = z - x1\n\n grad = (y2 - y1)/ (x2 - x1)\n\n return grad * dist + y1","def select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\n else:\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\n if ids is None or len(ids)==0:\n ig = len(levax)-1\n else:\n ig = ids[0][0]\n # Crude fist cut: don't interpolate, just return a value\n if levax == mv.getAxisList()[0]:\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\n elif levax == mv.getAxisList()[1]:\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\n else:\n print \"ERROR, select_lev() does not support level axis except as first or second dimentions\"\n return None\n return mvs","def Interpolate(self, ind, results):\n return _gmat_py.Interpolator_Interpolate(self, ind, results)","def interpolate(x1, x2, u, N):\n \n # finding the magnitude of each component\n a1 = np.matmul(x1, u)\n a2 = np.matmul(x2, u)\n\n ims = [np.matmul(u, t * a1 + (1 - t) * a2) \\\n for t in np.linspace(0, 1, N)]\n\n return np.stack(ims, 0)","def interp_n2(t, x, y):\n\n return y[:, 0] + (t - x[0]) * (y[:, 1] - y[:, 0]) / (x[1] - x[0])","def estimate_variance(ds,vert_step,horiz_step):\n obs_map = zeros([ds.shape[0]/vert_step,ds.shape[1]/horiz_step])\n print 'observed map has shape ' + str(obs_map.shape)\n for row in range(obs_map.shape[0]):\n for col in range(obs_map.shape[1]):\n #print 'calculating for %d %d (%d:%d,%d:%d)' % (row,col,row*vert_step,(row+1)*vert_step,\n # col*horiz_step,(col+1)*horiz_step)\n obs_var,rep_var = calc_variances(ds[row*vert_step:(row+1)*vert_step,\n col*horiz_step:(col+1)*horiz_step])\n obs_map[row,col] = sqrt(obs_var/rep_var)\n # Annotate appropriately\n obs_map.axes[0] = Array(range(obs_map.shape[0]))*vert_step\n obs_map.axes[1] = Array(range(obs_map.shape[1]))*horiz_step\n return obs_map","def linear_interpolate_release(mvi, j):\n set_system_state(mvi, 1)\n lam1 = mvi.system.lambda_()[j]\n set_system_state(mvi, 2)\n lam2 = mvi.system.lambda_()[j]\n\n # If either of the following loops are entered, there are likely going to\n # be problems.\n if (lam1 < 0) and (lam2 < 0):\n #add_constraints(mvi, mvi._state1_releases)\n #print mvi.lambda1c[j]\n #print mvi\n #raise Exception(\"Bad release interpolation.\")\n print 'WARNING: BAD INTERPOLANT'\n return mvi.t1, mvi.q1\n\n if lam1 < 0:\n return mvi.t1, mvi.q1\n\n tr = mvi.t1 - (lam1/(lam2-lam1))*(mvi.t2-mvi.t1)\n frac = (tr-mvi.t1)/(mvi.t2-mvi.t1)\n qr = frac*(mvi.q2-mvi.q1)+mvi.q1\n\n return tr, qr","def interpolate_2d(x, y, z):\n X = np.linspace(min(x), max(x))\n Y = np.linspace(min(y), max(y))\n X, Y = np.meshgrid(X, Y)\n #f = interpolate.interp2d(x, y, z)\n #Z = f(X[0, :], Y[:, 0])\n f = interpolate.LinearNDInterpolator(zip(x, y), z)\n Z = f(X, Y)\n return X, Y, Z","def interpolator(mat, distance):\n\n# calculate the place of each meassurement relative to the whole yourney of the\n# ship\n gesdistance = np.zeros(len(distance)+1)\n gesdis = distance[0]\n for i in range(1, len(distance)+1):\n gesdistance[i] = gesdistance[i-1] + distance[i-1]\n if i < len(distance):\n gesdis = gesdis + distance[i]\n\n# calculates the minimum distance for number of points of the interpolation\n mini = distance[0]\n for i in range(len(distance)):\n if distance[i] < mini:\n mini = distance[i]\n\n# interpolates linear over every depth\n newmat = np.zeros((len(mat), int(gesdis/mini)))\n\n wth = 0\n for leng in range(len(newmat)):\n newveloc = interp1d(gesdistance, mat[leng, :], kind=\"linear\")\n for wth in range(int(gesdis/mini)):\n newmat[leng, wth] = newveloc(wth*mini)\n for wdth in range(int(gesdis/mini)):\n newvelocdepth = interp1d(np.append(np.arange(0, 458, 20), 458), np.append(newmat[::20, wdth], newmat[457, wdth]), kind=\"linear\")\n for le in range(len(newmat)):\n newmat[le, wdth] = newvelocdepth(le)\n\n return np.flip(newmat), gesdis","def timeave_old( mv ):\n # I haven't thought yet about how missing values would work with this...\n # If time intervals be unequal, this will have to be changed...\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\n n = sh[0]\n # BTW, this is the size of everything else:\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\n mvta = numpy.sum( mv.__array__(), axis=0 )\n mvta /= n\n return mvta","def _interpolate_cube(self, lon, lat, egy=None, interp_log=True):\n\n shape = np.broadcast(lon, lat, egy).shape\n lon = lon * np.ones(shape)\n lat = lat * np.ones(shape)\n theta = np.pi / 2. - np.radians(lat)\n phi = np.radians(lon)\n vals = []\n for i, _ in enumerate(self.hpx.evals):\n v = hp.pixelfunc.get_interp_val(self.counts[i], theta,\n phi, nest=self.hpx.nest)\n vals += [np.expand_dims(np.array(v, ndmin=1), -1)]\n\n vals = np.concatenate(vals, axis=-1)\n\n if egy is None:\n return vals.T\n\n egy = egy * np.ones(shape)\n\n if interp_log:\n xvals = utils.val_to_pix(np.log(self.hpx.evals), np.log(egy))\n else:\n xvals = utils.val_to_pix(self.hpx.evals, egy)\n\n vals = vals.reshape((-1, vals.shape[-1]))\n xvals = np.ravel(xvals)\n v = map_coordinates(vals, [np.arange(vals.shape[0]), xvals],\n order=1)\n return v.reshape(shape)","def _proj(u,v):\n return (np.einsum('i...,i...->...',u,v)/np.einsum('i...,i...->...',u,u))*u","def dmsp_map_interpolate_NN_smooth_great_circle(lat_dmsp, lon_dmsp, lat_map, lon_map, Obs_map, k = 5, tol = 1.5):\n tol = np.deg2rad(tol)\n #reshape to N by 2 array where each row is (lat, lon)\n dmsp_points = np.deg2rad(np.hstack((lat_dmsp.flatten().reshape(-1,1),lon_dmsp.flatten().reshape(-1,1))))\n map_points = np.deg2rad(np.hstack((lat_map.flatten().reshape(-1,1), lon_map.flatten().reshape(-1,1))))\n N_points = dmsp_points.shape[0]\n obs_val = Obs_map.flatten()\n \n model = sklearn.neighbors.NearestNeighbors(n_neighbors = k, radius = tol, metric = 'haversine')\n\n model.fit(map_points)\n neighbors = model.kneighbors(dmsp_points, return_distance = True)\n \n #indices\n obs_interp = np.empty(N_points)\n for i in range(N_points):\n distances = neighbors[0][i]\n inds = neighbors[1][i]\n \n weights = distances/np.nansum(distances)\n obs_interp[i] = np.nansum( obs_val[inds] * weights)\n \n return obs_interp","def extrapolate_nans(x, y, v):\n if numpy.ma.is_masked(v):\n nans = v.mask\n else:\n nans = numpy.isnan(v)\n notnans = numpy.logical_not(nans)\n v[nans] = scipy.interpolate.griddata((x[notnans], y[notnans]), v[notnans],\n (x[nans], y[nans]),\n method='nearest').ravel()\n return v","def proj3d(v):\n v = normalize(v)\n x, y, z, w = v\n return np.array([x, y, z]) / (1 + 1e-8 - w) # avoid divide by zero","def dmsp_map_interpolate_NN_smooth_great_circle(lat_dmsp, lon_dmsp, lat_map, lon_map, Obs_map, k = 5, tol = 1.5):\n \n tol = np.deg2rad(tol)\n #reshape to N by 2 array where each row is (lat, lon)\n dmsp_points = np.deg2rad(np.hstack((lat_dmsp.flatten().reshape(-1,1),lon_dmsp.flatten().reshape(-1,1))))\n map_points = np.deg2rad(np.hstack((lat_map.flatten().reshape(-1,1), lon_map.flatten().reshape(-1,1))))\n N_points = dmsp_points.shape[0]\n obs_val = Obs_map.flatten()\n model = sklearn.neighbors.NearestNeighbors(n_neighbors = k, radius = tol, metric = 'haversine')\n\n model.fit(map_points)\n neighbors = model.kneighbors(dmsp_points, return_distance = True)\n \n #indices\n obs_interp = np.empty(N_points)\n for i in range(N_points):\n distances = neighbors[0][i]\n inds = neighbors[1][i]\n \n weights = distances/np.nansum(distances)\n obs_interp[i] = np.nansum( obs_val[inds] * weights)\n \n \n return obs_interp","def test_cubic_interp_to_densepred_is_same_for_one_gridlevel(mock_amg):\n\n # obtain the reference solution\n coarse_grid = mock_amg.grids[0]\n ny, nx = coarse_grid.ny, coarse_grid.nx\n u_ref, v_ref = np.random.rand(ny, nx), np.random.rand(ny, nx)\n\n # set the values of the windows to these values\n for ii in range(ny):\n for jj in range(nx):\n mock_amg.grids[0]._array[ii][jj].u = u_ref[ii][jj]\n mock_amg.grids[0]._array[ii][jj].v = v_ref[ii][jj]\n\n # get the expected interpolations\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\n f_u = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\n u_ref, kind='cubic')\n u_exp = f_u(xe, ye)\n f_v = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\n v_ref, kind='cubic')\n v_exp = f_v(xe, ye)\n dp_soln = mock_amg.interp_to_densepred()\n\n assert np.allclose(u_exp, dp_soln.u)\n assert np.allclose(v_exp, dp_soln.v)","def linear_interpolate_value_change(t0, v0, t1, v1, dt):\n return (v1 - v0)/float(t1-t0) * dt","def _interpolation(matrix):\n try:\n\tok = ~np.isnan(matrix)\n \txp = ok.ravel().nonzero()[0]\n \tfp = matrix[~np.isnan(matrix)]\n \tx = np.isnan(matrix).ravel().nonzero()[0]\n \tmatrix[np.isnan(matrix)] = np.interp(x, xp, fp)\n \treturn matrix\n except:\n return matrix","def linear_interpolator(moving):\n \n if isinstance(moving, medipy.base.Image) :\n MovingImageType = medipy.itk.itk_image_type(moving)\n else :\n MovingImageType = moving\n \n return itk.LinearInterpolateImageFunction[MovingImageType, itk.D].New()","def interp_spherical_data(x1, y1, x2, y2, lon, lat, J, m1, great_circle = False):\n\n background_x, background_y = m1(lon, lat)\n\n if great_circle == False:\n interp_lons = np.linspace(x1, x2, 100)\n interp_lats = np.linspace(y1, y2, 100)\n interp_x, interp_y = m1(interp_lons, interp_lats)\n\n else:\n great_circle = m1.drawgreatcircle(x1, y1, x2, y2, del_s = 50., alpha = 1.0, color = \"w\", zorder = 102)\n interp_x = great_circle[0].get_data()[0] \n interp_y = great_circle[0].get_data()[1]\n\n output_data = scipy.interpolate.griddata(list(zip(background_x, background_y)), jr1, list(zip(interp_x, interp_y)), method = 'cubic')\n\n output_lon, output_lat = m1(interp_x, interp_y, inverse = True)\n return output_data, output_lon, output_lat","def npinterpx(x, xp, fp):\n y = np.interp(x, xp, fp)\n # extrapolate left\n left = x < xp[0]\n xleft = x[left]\n yleft = fp[0] + (xleft - xp[0]) / (xp[1] - xp[0]) * (fp[1] - fp[0])\n y[left] = yleft\n # extrapolate right\n right = x > xp[-1]\n xright = x[right]\n yright = fp[-1] + (xright - xp[-1]) / (xp[-2] - xp[-1]) * (fp[-2] - fp[-1])\n y[right] = yright\n return y","def _interpolation(self, video):\n self.F_int = []\n self.mgrid_0 = []\n self.mgrid_1 = []\n for p in range(video.points.shape[0]):\n _m_0, _m_1 = np.meshgrid(self.extended_points_0[p], self.extended_points_1[p])\n _F_int = interp2d(self.extended_points_0[p], self.extended_points_1[p], video.mraw[0, _m_0, _m_1], kind='cubic')\n self.F_int.append(_F_int)\n\n m_0, m_1 = np.meshgrid(self.extended_points_0[p, self.pad:-self.pad], self.extended_points_1[p, self.pad:-self.pad])\n self.mgrid_0.append(m_0)\n self.mgrid_1.append(m_1)","def cr_spline(A, mu):\n mu, mu2 = mu, mu ** 2\n\n return A[0] * mu * mu2 + A[1] * mu2 + A[2] * mu + A[3]","def interpolate_linear(self, known_coords, known_values, interp_coords, groupname):\n\t\t#First need to reshape known_coords and known_values\n\t\tn_params = self.signal[groupname]['dimension']\n\t\tknown_coords = np.reshape( known_coords, (-1,n_params) )\n\t\tknown_values = np.reshape( known_values, (-1) )\t\t\n\t\treturn griddata(known_coords, known_values, interp_coords, method='linear')","def bilinear_interpolate(xv, yv, im, xout, yout, fill_value=0):\n ny, nx = np.shape(im)\n if (nx, ny) != (xv.size, yv.size):\n raise ValueError(\"Input arrays dimensions do not match\")\n\n xi = (nx-1.)/(xv[-1] - xv[0]) * (xout - xv[0])\n yi = (ny-1.)/(yv[-1] - yv[0]) * (yout - yv[0])\n\n return ndimage.map_coordinates(im.T, [xi, yi], cval=fill_value, order=1)","def bilinear_interpolate(xv, yv, im, xout, yout, fill_value=0):\n ny, nx = np.shape(im)\n if (nx, ny) != (xv.size, yv.size):\n raise ValueError(\"Input arrays dimensions do not match\")\n\n xi = (nx-1.)/(xv[-1] - xv[0]) * (xout - xv[0])\n yi = (ny-1.)/(yv[-1] - yv[0]) * (yout - yv[0])\n\n return ndimage.map_coordinates(im.T, [xi, yi], cval=fill_value, order=1)","def observation(self, obs):\n\n# import pdb;pdb.set_trace()\n return np.moveaxis(obs, 2, 0)","def loginterpolate(x_vector, y_vector, xout, replace_nan=np.nan):\n interpolant = interpolate.interp1d(np.log10(x_vector), np.log10(y_vector),\n bounds_error=False,\n fill_value=np.nan)\n yout = 10. ** interpolant(np.log10(xout))\n if replace_nan != np.nan:\n yout[np.isnan(yout)] = replace_nan\n return yout","def derive(params):\n x, y, dx, dy = params\n r = (x ** 2 + y ** 2) ** 0.5\n return np.array([dx, dy, -G * M * x / (r ** 3), -G * M * y / (r ** 3)])","def interpolate(self, _val1h) :\n\n\t\tval1h = _val1h.reshape(reduce(operator.mul, _val1h.shape))\t# Convert to 1-D\n\t\tv1h = np.copy(val1h)\n\t\tv1h[np.isnan(val1h)] = 0\t# Prepare for multiply\n\t\tval2 = self.M.transpose() * v1h\n\t\tval2[np.logical_not(self.mask2)] = np.nan\n\t\treturn val2","def interp_upsampling(V):\n V = tf.reshape(V, [-1] + V.get_shape().as_list()[1:])\n grid = volshape_to_ndgrid([f*2 for f in V.get_shape().as_list()[1:-1]])\n grid = [tf.cast(f, 'float32') for f in grid]\n grid = [tf.expand_dims(f/2 - f, 0) for f in grid]\n offset = tf.stack(grid, len(grid) + 1)\n\n V = SpatialTransformer(interp_method='linear')([V, offset])\n return V","def rescale(params):\n theta_mean = np.mean(params, axis=0)\n theta_mult = np.max(params - theta_mean, axis=0)\n return (params - theta_mean) * theta_mult**-1, theta_mean, theta_mult","def splineint(a, b, y, mu1, munp1):\n n = len(y) - 1\n h = (b - a)/float(n)\n c, d = ones(n - 2), 4*ones(n - 1)\n l ,u = trifactor(c, d, c)\n b1 = (6/h**2)*(y[2:(n + 1)] - 2*y[1:n] + y[:(n - 1)])\n b1[0] -= mu1\n b1[n - 2] -= munp1\n trisolve(l, u, c, b1)\n mu2ton = b1\n mu = zeros(n + 1)\n mu[0] = mu1\n mu[1:n] = mu2ton\n mu[n] = munp1\n \n C = array(zeros((n, 4))) # Apply lemma 1.3 to obtain the coefficient matrix\n C[:, 0] = y[:n]\n C[:, 1] = (y[1:(n+1)] - y[:n])/h - h*mu[:n]/3-h*mu[1:(n+1)]/6\n C[:, 2] = mu[:n]/2\n C[:, 3] = (mu[1:(n + 1)] - mu[0:n])/(6*h)\n C = matrix(C)\n return linspace(a, b - h, n), C","def get_proj(self):\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\n\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\n\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \n worldM = proj3d.world_transformation(xmin, xmax,\n ymin, ymax,\n zmin, zmax)\n\n # look into the middle of the new coordinates \n R = np.array([0.5, 0.5, 0.5])\n\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\n zp = R[2] + np.sin(relev) * self.dist\n E = np.array((xp, yp, zp))\n\n self.eye = E\n self.vvec = R - E\n self.vvec = self.vvec / proj3d.mod(self.vvec)\n\n if abs(relev) > np.pi/2:\n # upside down \n V = np.array((0, 0, -1))\n else:\n V = np.array((0, 0, 1))\n\n zfront, zback = -self.dist, self.dist\n\n viewM = proj3d.view_transformation(E, R, V)\n perspM = proj3d.persp_transformation(zfront, zback)\n M0 = np.dot(viewM, worldM)\n M = np.dot(perspM, M0)\n return M","def proj_linf(v, radius=1):\n vmod = np.abs(v)\n projmult = np.minimum(radius/vmod, 1)\n return projmult*v","def my_mvn(mu_x, mu_y, r):\n return multivariate_normal([mu_x, mu_y], [[r, 0], [0, r]])","def extrap1d(x,y,kind=\"linear\"):\n interpolator = interp1d(x,y,kind=kind)\n xs = interpolator.x\n ys = interpolator.y\n def pointwise(x):\n if x < xs[0]: return ys[0]+(x-xs[0])*(ys[1]-ys[0])/(xs[1]-xs[0])\n elif x > xs[-1]: return ys[-1]+(x-xs[-1])*(ys[-1]-ys[-2])/(xs[-1]-xs[-2])\n else: return interpolator(x)\n def ufunclike(xs):\n return array(list(map(pointwise, array(xs))))\n return ufunclike","def reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string)>2:\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n avmv = averager( mv, axis=axes_string )\n else:\n avmv = mv\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def read_velocities(filename, return_grid=True, return_proj=False):\n ds = gdal.Open(filename)\n #Get dimensions\n nc = ds.RasterXSize\n nr = ds.RasterYSize\n \n geotransform = ds.GetGeoTransform()\n xOrigin = geotransform[0]\n xPix = geotransform[1] #pixel width in x-direction\n yOrigin = geotransform[3]\n yPix = geotransform[5] #pixel height in y-direction\n \n lons = xOrigin + np.arange(0, nc)*xPix\n lats = yOrigin + np.arange(0, nr)*yPix\n \n x, y = np.meshgrid(lons, lats)\n \n vband = ds.GetRasterBand(1)\n varr = vband.ReadAsArray()\n \n if return_grid and return_proj:\n return x, y, varr, ds.GetProjection()\n elif return_grid:\n return x, y, varr\n else: \n return varr","def coord_vec(self, key):\n i = self.axis_index(key)\n return np.linspace(self.mins[i], self.maxs[i], self.shape[i])","def interpolate_to_pixel(U, imshape, kind=\"linear\") -> np.ndarray:\n # Velocity components\n u, v = U\n nr, nc = u.shape\n\n ws_x = int(np.round(imshape[0] / nr))\n ws_y = int(np.round(imshape[1] / nc))\n\n x, y = np.arange(nr) * ws_x + ws_x // 2, np.arange(nc) * ws_y + ws_y // 2\n xi, yi = np.arange(imshape[0]), np.arange(imshape[1])\n\n # Interpolate to pixel level\n u_px = scipy.interpolate.interp2d(y, x, u, kind=kind)(yi, xi)\n v_px = scipy.interpolate.interp2d(y, x, v, kind=kind)(yi, xi)\n\n return np.stack((u_px, v_px))","def lmap(v: float, x: Interval, y: Interval) -> float:\n return y[0] + (v - x[0]) * (y[1] - y[0]) / (x[1] - x[0])","def profile_interp(var,z_orig,z_interp,method='linear',out_of_bounds='NaN'):\n z_orig = z_orig[~isnan(z_orig)]\n var= var[~isnan(var)]\n #assert(all(diff(z_orig) > 0))\n if len(z_orig) > len(var) or len(var) > len(z_orig): return NaN\n if len(z_orig) <= 2 or len(var) <= 2: return NaN\n \n if out_of_bounds == 'NaN':\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value=NaN)\n elif out_of_bounds == 'nearest':\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value=(var[0],var[-1]))\n elif out_of_bounds == 'extrap':\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value='extrapolate')\n else:\n raise ValueError('Extrapolation method must be NaN, nearest, or cubic.')\n result = interpolant(z_interp)\n\n if result.size == 1: return result.item()\n else: return result","def test_linear_interp_to_densepred_is_same_for_one_gridlevel(mock_amg):\n\n # obtain the reference solution\n coarse_grid = mock_amg.grids[0]\n ny, nx = coarse_grid.ny, coarse_grid.nx\n u_ref, v_ref = np.random.rand(ny, nx), np.random.rand(ny, nx)\n\n # set the values of the windows to these values\n for ii in range(ny):\n for jj in range(nx):\n mock_amg.grids[0]._array[ii][jj].u = u_ref[ii][jj]\n mock_amg.grids[0]._array[ii][jj].v = v_ref[ii][jj]\n\n # get the expected interpolations\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\n f_u = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\n u_ref, kind='linear')\n u_exp = f_u(xe, ye)\n f_v = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\n v_ref, kind='linear')\n v_exp = f_v(xe, ye)\n dp_soln = mock_amg.interp_to_densepred(method='linear')\n\n assert np.allclose(u_exp, dp_soln.u)\n assert np.allclose(v_exp, dp_soln.v)","def _extrapolate(self):\n maxrho = self.maxrho\n x = np.linspace(1.001, maxrho, int(self.nrho/5))\n rho1 = self.rho # rho up to 1\n dec_l = 0.01\n ni_ov = np.zeros((self.nion, len(x)), dtype=float)\n ninew = np.zeros((self.nion, self.nrho+len(x)),dtype=float)\n ne_ov1 = self.ne[self.nrho-1]*np.exp(-((x-1.)/dec_l))\n te_ov1 = self.te[self.nrho-1]*np.exp(-(x-1.)/dec_l)\n ti_ov1 = self.ti[self.nrho-1]*np.exp(-(x-1.)/dec_l)\n vt_ov1 = self.vt[self.nrho-1]*np.exp(-(x-1.)/dec_l)\n for i in range(self.nion):\n ni_ov[i,:] = self.ni[i,self.nrho-1]*np.exp(-(x-1.)/dec_l)\n ninew[i,:] = np.concatenate([self.ni[i,:], ni_ov[i,:]])\n self.ni = ninew\n self.rho = np.concatenate([rho1, x])\n self.nrho = len(rho1)+len(x)\n self.ne = np.concatenate([self.ne, ne_ov1])\n self.te = np.concatenate([self.te, te_ov1])\n self.ti = np.concatenate([self.ti, ti_ov1])\n self.vt = np.concatenate([self.vt, vt_ov1])","def pvi(inp, scale: int = 10):\n\n if len(inp.data.shape) == 1:\n data = inp.data[:, np.newaxis]\n else:\n data = inp.data\n\n delta_inp = np.abs((data[scale:, :] - data[:-scale, :]))\n delta_inp2 = np.sum(delta_inp ** 2, axis=1)\n sigma = np.mean(delta_inp2)\n result = np.array(delta_inp2 / sigma)\n\n time = inp.coords[inp.dims[0]].data\n\n result = xr.DataArray(result, coords=[time[0:len(delta_inp)]],\n dims=[inp.dims[0]], attrs=inp.attrs)\n\n result.attrs[\"units\"] = \"dimensionless\"\n\n return result","def mse_converter( fname ):\n lines = []\n with open( fname ) as fh:\n for line in fh.readlines():\n if len(line) > 1: # avoid empty lines\n if line.startswith('m'):\n continue\n # strip off \\n and split on tabs\n line = line.strip().split( '\\t' )\n lines.append( ( float(line[0]), float(line[1]) ) )\n return numpy.array( lines )","def transform_contour(contour: np.ndarray, M):\n return cv2.transform(contour[:, np.newaxis], m=M)[:, 0, :2]","def interpolate_eleMean(model):\n # Get mean of columns (data at the same elevation) without taking int account NaNs\n el_mean = nanmean(model,axis=0)\n #print(el_mean) \n # Find indices for NaNs, and replace them by the column mean\n ind_nan = np.where(np.isnan(model))\n model[ind_nan] = np.take(el_mean,ind_nan[1])\n\n return model","def get_variance_maps_models(variable=\"pr\",models=None,cmip_dir = None,period=12):\n if models is None:\n f = cdms.open(\"/work/marvel1/SEASONAL/MMA/cmip5.ZONALMMA.historical-rcp85.rip.mo.atm.Amon.pr.ver-1.AmpPhase.nc\")\n phase = f(\"phase\")\n models = eval(phase.getAxis(0).models)\n f.close()\n if cmip_dir is None:\n cmip_dir = \"/work/cmip5/historical-rcp85/atm/mo/\"+variable+\"/\"\n fobs = cdms.open(\"/work/marvel1/SEASONAL/OBS/GPCP.precip.mon.mean.nc\")\n the_grid = fobs(\"precip\").getGrid()\n nlat,nlon=the_grid.shape\n fobs.close()\n VarianceMaps = np.zeros((len(models),nlat))+1.e20\n counter=0\n for model in models:\n print model\n try:\n fname = sorted(glob.glob(cmip_dir+\"*.\"+model+\".*\"))[0]\n fp = cdms.open(fname)\n prtest = fp(variable,time=(\"1979-1-1\",\"2014-12-31\")).regrid(the_grid,regridTool='regrid2')\n przonal = cdutil.averager(prtest,axis='x')\n dom = variance_map(przonal,period=period)\n VarianceMaps[counter]=dom\n fp.close()\n counter+=1\n except:\n continue\n \n modax = cdms.createAxis(range(len(models)))\n modax.id = \"model\"\n modax.models = str(models)\n VarianceMaps = MV.array(VarianceMaps)\n VarianceMaps.setAxis(0,modax)\n VarianceMaps.setAxis(1,the_grid.getLatitude())\n return MV.masked_where(VarianceMaps>1.e10,VarianceMaps)","def _interpolate_cumulative_mass(self, r):\n \n # interpolate\n #spline = interpolate.UnivariateSpline(self._cumulative_mass_r,\n # self._cumulative_mass_m)\n \n # linear interpolation is more reliable, assuming number of points\n # is large enough\n spline = interpolate.interp1d(self._cumulative_mass_r, self._cumulative_mass_m)\n \n return 10.0**spline(np.log10(r))","def get_vertical_gridline_values(self, x):\n indices = numpy.where(numpy.abs(self.x - x) <= 1.0E-06)[0]\n # if no station matches the given value, we interpolate\n if indices.size == 0:\n i = numpy.where(self.x > x)[0][0]\n return (self.y, (abs(self.x[i] - x) * self.values[:, i - 1]\n + abs(self.x[i - 1] - x) * self.values[:, i])\n / abs(self.x[i] - self.x[i - 1]))\n else:\n i = indices[0]\n return self.y, self.values[:, i]","def dcm_to_mrp(dcm):\n c = np.sqrt(np.trace(dcm) + 1)\n return (1/(c*(c + 2))) * np.array([dcm[1, 2] - dcm[2, 1], dcm[2, 0] - dcm[0, 2], dcm[0, 1] - dcm[1, 0]])","def test_cubic_interp_to_densepred_is_similar_for_two_levels(mock_amg):\n\n # split all the cells so that we have two tiers\n mock_amg.split_all_cells()\n coarse_grid, fine_grid = mock_amg.grids[0], mock_amg.grids[1]\n\n # obtain the reference solution for the whole domain\n nyf, nxf = fine_grid.ny, fine_grid.nx\n u_ref, v_ref = np.random.rand(nyf, nxf), np.random.rand(nyf, nxf)\n\n # set all the window values\n for ii in range(nyf):\n # determine if the value should go onto the coarse or fine tier\n # coarse tiers are 0, 2, 4, etc and so will return 0 (False) when\n # modded with 2\n coarse_i = False if ii % 2 else True\n for jj in range(nxf):\n # determine if the value should go onto the coarse or fine tier\n coarse_j = False if jj % 2 else True\n # if both coarse_i, coarse_j are True, then we are on the coarse\n # grid, else we are on the fine grid\n if coarse_i and coarse_j:\n mock_amg.grids[0]._array[ii//2][jj//2].u = u_ref[ii][jj]\n mock_amg.grids[0]._array[ii//2][jj//2].v = v_ref[ii][jj]\n else:\n mock_amg.grids[1]._array[ii][jj].u = u_ref[ii][jj]\n mock_amg.grids[1]._array[ii][jj].v = v_ref[ii][jj]\n\n # get the expected interpolations\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\n f_u = interp.interp2d(fine_grid.x_vec, fine_grid.y_vec,\n u_ref, kind='cubic')\n u_exp = f_u(xe, ye)\n f_v = interp.interp2d(fine_grid.x_vec, fine_grid.y_vec,\n v_ref, kind='cubic')\n v_exp = f_v(xe, ye)\n\n dp_soln = mock_amg.interp_to_densepred()\n\n assert np.allclose(u_exp, dp_soln.u)\n assert np.allclose(v_exp, dp_soln.v)","def velocity_interpolation(a, axis=-1):\n nd = len(a.shape)\n\n # adding one extra dimension to field at the lower boundary with\n # zeros.\n a_shape = list(a.shape)\n a_shape[axis] = a.shape[axis] + 1\n a_shape = tuple(a_shape)\n slice0 = [slice(None)] * nd\n slice0[axis] = slice(1, None)\n slice0 = tuple(slice0)\n a_prim = np.zeros(a_shape)\n a_prim[slice0] = a\n\n # doing the interpolation\n slice1 = [slice(None)] * nd\n slice2 = [slice(None)] * nd\n slice1[axis] = slice(None, -1)\n slice2[axis] = slice(1, None)\n slice1 = tuple(slice1)\n slice2 = tuple(slice2)\n\n a_interp = (a_prim[slice1] + a_prim[slice2])/2\n return a_interp","def _interp_2d(grid1,grid2,value,xi1,xi2,j1,j2):\r\n\r\n # a. left/right\r\n nom_1_left = grid1[j1+1]-xi1\r\n nom_1_right = xi1-grid1[j1]\r\n\r\n nom_2_left = grid2[j2+1]-xi2\r\n nom_2_right = xi2-grid2[j2]\r\n\r\n # b. interpolation\r\n denom = (grid1[j1+1]-grid1[j1])*(grid2[j2+1]-grid2[j2])\r\n nom = 0\r\n for k1 in range(2):\r\n nom_1 = nom_1_left if k1 == 0 else nom_1_right\r\n for k2 in range(2):\r\n nom_2 = nom_2_left if k2 == 0 else nom_2_right \r\n nom += nom_1*nom_2*value[j1+k1,j2+k2]\r\n\r\n return nom/denom","def interpolation_1D(rawdata, squint_vec, angle_vec):\n rawdata_corr = rawdata * 1\n for idx_freq in range(rawdata.shape[0]):\n az_new = angle_vec - squint_vec[idx_freq]\n current_data = rawdata[idx_freq, :]\n interpolator = _interp.interp1d(angle_vec, current_data, kind='linear', bounds_error=False, fill_value=0, assume_sorted=True)\n rawdata_corr[idx_freq, :] = interpolator(az_new)\n # rawdata_corr[idx_freq, :] = _np.interp(az_new, angle_vec, current_data, left=0.0, right=0.0)\n if idx_freq % 500 == 0:\n print_str = \"interp sample: {idx}, ,shift: {sh} samples\".format(idx=idx_freq, sh=az_new[0] - angle_vec[0])\n print(print_str)\n rawdata_corr = rawdata_corr.__array_wrap__(rawdata)\n return rawdata_corr","def restrict_lat( mv, latmin, latmax ):\n if latmin==-90: latmin = -91 # just to make sure\n if latmax==90: latmax = 91\n\n # axes\n latax,idx = latAxis2(mv)\n if latax is None: return None\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\n newlatax = latax.subaxis( imin, imax+1 )\n # TO DO: use latax.bounds (if present) for newlatax.bounds\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\n # At the moment, we don't need bounds. This would get us through if necessary:\n # newlatax.bounds = newlatax.genGenericBounds()\n newaxes = list( allAxes(mv) ) # shallow copy\n newaxes[idx] = newlatax\n\n # shrink the data to match the shrunk lat axis\n newmv_shape = list( mv.shape )\n newmv_shape[idx] = imax+1 - imin\n if imin>0:\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\n else:\n nd = mv\n lenidx = nd.shape[idx]\n if lenidx > newmv_shape[idx]:\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\n else:\n newdata = nd\n\n # new variable\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\n newmv.units = mv.units\n return newmv","def scale_massmet(mass):\n upper_84 = np.interp(mass, massmet[:, 0], massmet[:, 3])\n lower_16 = np.interp(mass, massmet[:, 0], massmet[:, 2])\n return (upper_84-lower_16)","def multi_sds_to_XYZ_integration(\n msds,\n cmfs=STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']\n .copy().trim(DEFAULT_SPECTRAL_SHAPE),\n illuminant=sd_ones(),\n k=None,\n shape=DEFAULT_SPECTRAL_SHAPE):\n\n if isinstance(msds, MultiSpectralDistributions):\n return as_float_array([\n sd_to_XYZ_integration(sd, cmfs, illuminant, k)\n for sd in msds.to_sds()\n ])\n else:\n msds = as_float_array(msds)\n\n msd_shape_m_1, shape_wl_count = msds.shape[-1], len(shape.range())\n assert msd_shape_m_1 == shape_wl_count, (\n 'Multi-spectral distributions array with {0} wavelengths '\n 'is not compatible with spectral shape with {1} wavelengths!'.\n format(msd_shape_m_1, shape_wl_count))\n\n if cmfs.shape != shape:\n runtime_warning('Aligning \"{0}\" cmfs shape to \"{1}\".'.format(\n cmfs.name, shape))\n cmfs = cmfs.copy().align(shape)\n\n if illuminant.shape != shape:\n runtime_warning('Aligning \"{0}\" illuminant shape to \"{1}\".'.format(\n illuminant.name, shape))\n illuminant = illuminant.copy().align(shape)\n\n S = illuminant.values\n x_bar, y_bar, z_bar = tsplit(cmfs.values)\n dw = cmfs.shape.interval\n\n k = 100 / (np.sum(y_bar * S) * dw) if k is None else k\n\n X_p = msds * x_bar * S * dw\n Y_p = msds * y_bar * S * dw\n Z_p = msds * z_bar * S * dw\n\n XYZ = k * np.sum(np.array([X_p, Y_p, Z_p]), axis=-1)\n\n return from_range_100(np.rollaxis(XYZ, 0, msds.ndim))","def func_vl2_pressure_curve(nc, index):\n loc = {\"lat\": 47.6680, \"lon\": 134.0430, \"height\": -4505.0}\n return func_pressure_curve(nc, index, loc)","def _splineloc(self, coa_map, win=5, upscale=10):\n\n # Get shape of 3-D coalescence map\n nx, ny, nz = coa_map.shape\n n = np.array([nx, ny, nz])\n\n # Find maximum coalescence location in grid\n mx, my, mz = np.unravel_index(np.nanargmax(coa_map), coa_map.shape)\n i = np.array([mx, my, mz])\n\n # Determining window about maximum value and trimming coa grid\n w2 = (win - 1)//2\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\n\n # If subgrid is not close to the edge\n if (x2 - x1) == (y2 - y1) == (z2 - z1):\n coa_map_trim = coa_map[x1:x2, y1:y2, z1:z2]\n\n # Defining the original interpolation function\n xo = np.linspace(0, coa_map_trim.shape[0] - 1,\n coa_map_trim.shape[0])\n yo = np.linspace(0, coa_map_trim.shape[1] - 1,\n coa_map_trim.shape[1])\n zo = np.linspace(0, coa_map_trim.shape[2] - 1,\n coa_map_trim.shape[2])\n xog, yog, zog = np.meshgrid(xo, yo, zo)\n interpgrid = Rbf(xog.flatten(), yog.flatten(), zog.flatten(),\n coa_map_trim.flatten(),\n function=\"cubic\")\n\n # Creating the new interpolated grid\n xx = np.linspace(0, coa_map_trim.shape[0] - 1,\n (coa_map_trim.shape[0] - 1) * upscale + 1)\n yy = np.linspace(0, coa_map_trim.shape[1] - 1,\n (coa_map_trim.shape[1] - 1) * upscale + 1)\n zz = np.linspace(0, coa_map_trim.shape[2] - 1,\n (coa_map_trim.shape[2] - 1) * upscale + 1)\n xxg, yyg, zzg = np.meshgrid(xx, yy, zz)\n\n # Interpolate spline function on new grid\n coa_map_int = interpgrid(xxg.flatten(), yyg.flatten(),\n zzg.flatten()).reshape(xxg.shape)\n\n # Calculate max coalescence location on interpolated grid\n mxi, myi, mzi = np.unravel_index(np.nanargmax(coa_map_int),\n coa_map_int.shape)\n mxi = mxi/upscale + x1\n myi = myi/upscale + y1\n mzi = mzi/upscale + z1\n self.output.log(\"\\t\\tGridded loc: {} {} {}\".format(mx, my, mz), self.log)\n self.output.log(\"\\t\\tSpline loc: {} {} {}\".format(mxi, myi, mzi), self.log)\n\n # Run check that spline location is within grid-cell\n if (abs(mx - mxi) > 1) or (abs(my - myi) > 1) or \\\n (abs(mz - mzi) > 1):\n msg = \"\\tSpline warning: spline location outside grid cell\"\n msg += \"with maximum coalescence value\"\n self.output.log(msg, self.log)\n\n xyz = self.lut.xyz2loc(np.array([[mxi, myi, mzi]]), inverse=True)\n loc_spline = self.lut.xyz2coord(xyz)[0]\n\n # Run check that spline location is within window\n if (abs(mx - mxi) > w2) or (abs(my - myi) > w2) or \\\n (abs(mz - mzi) > w2):\n msg = \"\\t !!!! Spline error: location outside interpolation \"\n msg += \"window !!!!\\n\\t\\t\\tGridded Location returned\"\n self.output.log(msg, self.log)\n\n xyz = self.lut.xyz2loc(np.array([[mx, my, mz]]), inverse=True)\n loc_spline = self.lut.xyz2coord(xyz)[0]\n\n else:\n msg = \"\\t !!!! Spline error: interpolation window crosses edge of \"\n msg += \"grid !!!!\\n\\t\\t\\tGridded Location returned\"\n self.output.log(msg, self.log)\n\n xyz = self.lut.xyz2loc(np.array([[mx, my, mz]]), inverse=True)\n loc_spline = self.lut.xyz2coord(xyz)[0]\n\n return loc_spline","def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv","def geo_m_v2(data_array):\n r = 6378.137 #promien ziemi w km\n delta = np.zeros(data_array.size//7-1)\n alo = data_array[0][1]\n ala = data_array[0][2]\n count = 0\n for row in data_array[1:]:\n dLat = (row[2] - ala) * math.pi/180.0\n dLon = (row[1] - alo) * math.pi/180.0\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\n * math.sin(dLon/2.0)**2\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\n count += 1\n alo = row[1]\n ala = row[2]\n return delta","def linearize(self, params, unknowns, resids):\n\n m = self.slope\n J = {}\n\n J['y', 'x'] = m\n return J","def line_ratio_map(quant1='L_[NII]122', quant2='L_[NII]205', ContourFunct='ne_mw', res=0.5, plane='xy', units='Jy', **kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n GR = glo.global_results()\n location = aux.moment0_map_location(res=res,plane=plane,gal_index=p.gal_index)\n\n try:\n momentmap = np.load(location, allow_pickle=True)\n print('Found stored momentmap data')\n except:\n print('Did not find stored momentmap data - creating')\n aux.convert_cell_data_to_regular_grid(res=res, plane=plane, gal_index=p.gal_index)\n momentmap = np.load(location, allow_pickle=True)\n\n indexes = momentmap[-1]\n index1, index2 = int(indexes[1]), int(indexes[2])\n \n momentmap = momentmap[:-1] \n \n dictionary = p.moment0_dict\n \n num1=dictionary[quant1]\n num2=dictionary[quant2]\n num =dictionary[ContourFunct]\n x = momentmap[:,1]\n y = momentmap[:,2]\n lumus = np.array(momentmap[:,3])\n \n line1=[]\n line2=[]\n Contour_Function=[]\n m=[]\n for row in lumus:\n \n line1.append(row[num1])\n line2.append(row[num2])\n \n \n if ContourFunct == 'ne_mw':\n if row[dictionary['m']] == 0:\n \n Contour_Function.append(0)\n else:\n Contour_Function.append(row[num]/row[dictionary['m']])\n else:\n Contour_Function.append(row[num]) \n \n line1 = np.array(line1)\n line2 = np.array(line2)\n Contour_Function = np.array(Contour_Function)\n \n ratio = np.divide(line1, line2, out=np.zeros_like(line1), where=line2!=0)\n \n ratio = ratio.reshape(index1, index2)\n x = x.reshape(index1, index2)\n y = y.reshape(index1, index2)\n line1 = line1.reshape(index1, index2)\n line2 = line2.reshape(index1, index2)\n #pdb.set_trace()\n Contour_Function=Contour_Function.reshape(index1,index2)\n \n ratio[ratio==0] = np.min(ratio[ratio>0])\n Contour_Function[Contour_Function==0] = 1e-30\n\n\n if p.add:\n fig,ax = plt.gcf(),p.ax #plot already available \n else:\n fig, ax = plt.subplots(figsize=(10,8))\n plt.subplots_adjust(left=0.1,bottom=0.2,right=0.8)\n \n if p.log: cs = ax.pcolormesh(x, y, np.log10(ratio), cmap=plt.cm.viridis, vmin=np.log10(ratio).max()-1.5, shading='auto')\n if not p.log: cs = ax.pcolormesh(x, y, ratio, cmap=plt.cm.viridis, vmin=ratio.max()/100, shading='auto')\n\n if not p.add:\n\n ax.set_title('Line Ratio map of ' + quant1.replace('L_','') + \"/\" + quant2.replace('L_',''))\n ax.set_xlabel('x [kpc]')\n ax.set_ylabel('y [kpc]')\n levels = np.arange(np.min(np.log10(Contour_Function[Contour_Function > 1e-30])).round(), np.max(np.log10(Contour_Function)).round(), 1)\n cr=ax.contour(x,y,np.log10(Contour_Function),cmap=plt.cm.plasma, levels=levels)\n\n if p.add:labels:''\n cbaxes=fig.add_axes([.15, 0.09, 0.6, 0.027])\n cbar=fig.colorbar(cr,cax=cbaxes,orientation='horizontal', label= 'log '+ getlabel(ContourFunct))\n cbaxes2 = fig.add_axes([0.82, 0.24, 0.027, 0.6])\n if p.log: fig.colorbar(cs, cax=cbaxes2, label= 'log ' + quant1.replace('L_','') + \" / \" + quant2.replace('L_','') )\n if not p.log: fig.colorbar(cs, cax=cbaxes2, label= quant1.replace('L_','') + \" / \" + quant2.replace('L_','') )\n if p.R_max:\n ax.set_xlim([-p.R_max,p.R_max])\n ax.set_ylim([-p.R_max,p.R_max])\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'lineratios/'): os.mkdir(p.d_plot + 'lineratios/') \n plt.savefig(p.d_plot+'lineratios/map_%s%s_%i_%s_%s' % (p.sim_name,p.sim_run,p.gal_index,quant1.replace('L_',''),quant2.replace('L_',''))+ '_' + plane + '_res' + str(res) +'.png', facecolor='w', dpi=500)","def interp_zt(array, heights, goal):\n\n print('Coffee time :-)')\n nt = array.shape[0]\n out = np.empty((nt,goal.size), dtype=np.float)\n for i in range(nt):\n out[i,:] = np.interp(goal, heights[i,:], array[i,:])\n return out","def ret2dva(xret, yret):\n return xret / 280.0, yret / 280.0","def spatial_var(map_):\n expx, expy = spatial_expval(map_)\n map_ = map_ / np.sum(map_)\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\n\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))","def convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )"],"string":"[\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def interpolate(m):\\n \\n x1 = m[0]\\n x2 = m[1]\\n x3 = m[2]\\n y1 = m[3]\\n y2 = m[4]\\n y3 = m[5]\\n denom = (x1 - x2)*(x1 - x3)*(x2 - x3)\\n A = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom\\n B = (x3**2 * (y1 - y2) + x2**2 * (y3 - y1) + x1**2 * (y2 - y3)) / denom\\n C = (x2 * x3 * (x2 - x3) * y1 + x3 * x1 * (x3 - x1) * y2 + x1 * x2 * (x1 - x2) * y3) / denom\\n xext = -B/(2*A)\\n yext = A*xext**2 + B*xext + C\\n \\n return(np.array([xext,yext]))\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def interpolation_matrix(m):\\n return np.nanmean(m,axis=1)\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def myinterp2d(x, y, z, xnew, ynew, method='linear'):\\n x = np.ravel(x)\\n y = np.ravel(y)\\n z = np.ravel(z)\\n znew = griddata((x, y), z, (xnew, ynew), method=method, fill_value=0.)\\n return znew\",\n \"def interpolate_matrix(matrix):\",\n \"def loc_massmet(mass):\\n return np.interp(mass, massmet[:, 0], massmet[:, 1])\",\n \"def interpolate_vertical(ml_file, inter_file, new_vertical_axis):\\n with xr.load_dataset(inter_file) as interpolated:\\n reference = [variable for variable in interpolated.variables if len(interpolated[variable].shape) == 4][0]\\n with xr.open_dataset(ml_file) as ml:\\n for variable in [variable for variable in ml.variables if variable not in interpolated.variables\\n and len(ml[variable].dims) == 4\\n and \\\"lev_2\\\" in ml[variable].dims]:\\n try:\\n x = np.array(ml[new_vertical_axis].data)\\n y = np.array(ml[variable].data)\\n interpolated_data = interpolate_1d(interpolated[\\\"lev\\\"].data, x, y, axis=1)\\n attributes = ml[variable].attrs\\n\\n interpolated[variable] = interpolated[reference].copy(data=interpolated_data)\\n interpolated[variable].attrs = ml[variable].attrs\\n except Exception as e:\\n print(variable, e)\\n interpolated.to_netcdf(inter_file)\",\n \"def coord_interp(parameter, interval):\\r\\n epoch = _np.linspace(1800, 12600 , int(10800/interval)+1) # 3h validity interval within 4h\\r\\n time = _np.array([epoch**deg for deg in range(len(parameter)-1,-1,-1)])\\r\\n return _np.matmul(parameter,time)\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def interpolation(self, arr, factor):\\n\\t x = arr[:, 0]\\n\\t y = arr[:, 1]\\n\\t z = arr[:, 2]\\n\\t t = np.linspace(0,x.shape[0],num=x.shape[0])\\n\\t to_expand = [x, y, z]\\n\\t for i in range(len(to_expand)):\\n\\t spl = interp1d(t, np.ravel(to_expand[i]))\\n\\t to_expand[i] = spl(np.linspace(0,len(t), len(t)*factor))\\n\\t new_matrix = np.matrix(np.r_[0:len(t):1.0/factor])\\n\\t for i in to_expand:\\n\\t new_matrix = np.concatenate((new_matrix, np.matrix(i)), axis = 0)\\n\\t return new_matrix.T[:,1:]\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def frechet_var_approx(dist_proj):\\n return torch.mean(dist_proj ** 2).item()\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def interpolate2D(uv, img):\\n\\n x, y = uv.T\\n\\n # Get closest points\\n x1, y1 = np.floor(uv).T.astype(np.int)\\n x2, y2 = np.ceil(uv).T.astype(np.int)\\n\\n # Evaluate color function at closest points\\n Q11 = img[y1, x1]\\n Q12 = img[y1, x2]\\n Q21 = img[y2, x1]\\n Q22 = img[y2, x2]\\n\\n # Interpolate on x\\n\\n n = x2-x1\\n alpha, beta = ((x2-x)/n)[:, None], ((x-x1)/n)[:, None]\\n\\n fxy1 = alpha*Q11 + beta*Q21\\n fxy2 = alpha*Q12 + beta*Q22\\n\\n # Interpolate on y\\n\\n n = y2-y1\\n alpha, beta = ((y2-y)/n)[:, None], ((y-y1)/n)[:, None]\\n\\n return alpha*fxy1 + beta*fxy2\",\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def interpolate_meridional(self, *interp1d_args, **interp1d_kwargs):\\n return self.interp1d_meridional(*interp1d_args, **interp1d_kwargs)(self.lat)\",\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def focal_projection(m, dx=.02, return_grid=False):\\n dy = dx # grid loop\\n x = np.arange(-1, 1, dx)[None, ...]\\n y = np.arange(-1, 1, dy)[..., None]\\n\\n nx = len(x)\\n ny = len(y) # vectorization of previous code begins here\\n\\n x2 = x.repeat(ny, axis=0)\\n y2 = y.repeat(ny, axis=1)\\n\\n r2 = x2 * x2 + y2 * y2\\n trend = np.arctan2(y2, x2)\\n plunge = np.pi / 2 - 2 * np.arcsin(np.sqrt(r2 / 2)) # equal area projection\\n\\n vij1 = np.cos(trend) * np.cos(plunge) # set up local vector grids\\n vij2 = np.sin(trend) * np.cos(plunge)\\n vij3 = np.sin(plunge)\\n\\n m = np.array(m)\\n if len(m.ravel()) == 9:\\n m = moment_convert(m)\\n\\n u1 = (vij1 * m[0] + vij2 * m[5] + vij3 * m[4]) * vij1\\n u2 = (vij1 * m[5] + vij2 * m[1] + vij3 * m[3]) * vij2\\n u3 = (vij1 * m[4] + vij2 * m[3] + vij3 * m[2]) * vij3\\n u = u1 + u2 + u3\\n u[r2 > 1] = np.nan\\n if return_grid:\\n return u, vij1, vij2, vij3\\n return u\",\n \"def interpolate_2d(x, y, z, x_new, y_new):\\n fun = RectBivariateSpline(x, y, z, kx=1, ky=1) # linear interpolation\\n return fun(x_new, y_new)\",\n \"def vp_from_ke(m):\\n return (m[0, 0]/m[2,0], m[1,0]/m[2,0])\",\n \"def reduce2scalar( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def dmsp_map_interpolate_NN_smooth(X_dmsp, Y_dmsp, X_map, Y_map, Obs_map, k = 5, tol = 3):\\n #reshape to N by 2 array where each row is (X, Y)\\n dmsp_points = np.hstack((X_dmsp.flatten().reshape(-1,1),Y_dmsp.flatten().reshape(-1,1)))\\n map_points = np.hstack((X_map.flatten().reshape(-1,1), Y_map.flatten().reshape(-1,1)))\\n N_points = dmsp_points.shape[0]\\n obs_val = Obs_map.flatten()\\n model = sklearn.neighbors.BallTree(map_points,leaf_size = 40 )\\n dists, inds = model.query(dmsp_points, k=k) \\n\\n obs_interp = np.empty(N_points)\\n for i in range(N_points):\\n norm = LA.norm(dists[i])\\n if (norm > tol):\\n obs_interp[i] = np.nan\\n else:\\n# weights = dists[i]/norm\\n\\n weights = dists[i]/np.nansum(dists[i])\\n obs_interp[i] = np.nansum( obs_val[inds[i]] * weights )\\n\\n return obs_interp\",\n \"def linear_interp2d(z, map_lower, map_higher, comoving_dist=False, NewProjected=False):\\n with h5py.File(map_lower, \\\"r\\\") as ds1, h5py.File(map_higher, \\\"r\\\") as ds2:\\n if NewProjected:\\n dm_name = \\\"map\\\"\\n header_name = \\\"Header\\\"\\n else:\\n dm_name = \\\"DM\\\"\\n header_name = \\\"HEADER\\\"\\n\\n y2 = ds2[dm_name][:]\\n y1 = ds1[dm_name][:]\\n\\n if comoving_dist:\\n x2 = z_to_mpc(ds2[header_name].attrs[\\\"Redshift\\\"])\\n x1 = z_to_mpc(ds1[header_name].attrs[\\\"Redshift\\\"])\\n dist = z_to_mpc(z) - x1\\n else:\\n x2 = ds2[header_name].attrs[\\\"Redshift\\\"]\\n x1 = ds1[header_name].attrs[\\\"Redshift\\\"]\\n dist = z - x1\\n\\n grad = (y2 - y1)/ (x2 - x1)\\n\\n return grad * dist + y1\",\n \"def select_lev( mv, slev ):\\n levax = levAxis(mv)\\n # Get ig, the first index for which levax[ig]>slev\\n # Assume that levax values are monotonic.\\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\\n if levax[0]<=levax[-1]:\\n ids = numpy.where( levax[:]>=slev.value ) # assumes levax values are monotonic increasing\\n else:\\n ids = numpy.where( levax[:]<=slev.value ) # assumes levax values are monotonic decreasing\\n if ids is None or len(ids)==0:\\n ig = len(levax)-1\\n else:\\n ig = ids[0][0]\\n # Crude fist cut: don't interpolate, just return a value\\n if levax == mv.getAxisList()[0]:\\n mvs = cdms2.createVariable( mv[ig:ig+1,...], copy=1 ) # why ig:ig+1 rather than ig? bug workaround.\\n elif levax == mv.getAxisList()[1]:\\n mvs = cdms2.createVariable( mv[:,ig:ig+1,...], copy=1 )\\n else:\\n print \\\"ERROR, select_lev() does not support level axis except as first or second dimentions\\\"\\n return None\\n return mvs\",\n \"def Interpolate(self, ind, results):\\n return _gmat_py.Interpolator_Interpolate(self, ind, results)\",\n \"def interpolate(x1, x2, u, N):\\n \\n # finding the magnitude of each component\\n a1 = np.matmul(x1, u)\\n a2 = np.matmul(x2, u)\\n\\n ims = [np.matmul(u, t * a1 + (1 - t) * a2) \\\\\\n for t in np.linspace(0, 1, N)]\\n\\n return np.stack(ims, 0)\",\n \"def interp_n2(t, x, y):\\n\\n return y[:, 0] + (t - x[0]) * (y[:, 1] - y[:, 0]) / (x[1] - x[0])\",\n \"def estimate_variance(ds,vert_step,horiz_step):\\n obs_map = zeros([ds.shape[0]/vert_step,ds.shape[1]/horiz_step])\\n print 'observed map has shape ' + str(obs_map.shape)\\n for row in range(obs_map.shape[0]):\\n for col in range(obs_map.shape[1]):\\n #print 'calculating for %d %d (%d:%d,%d:%d)' % (row,col,row*vert_step,(row+1)*vert_step,\\n # col*horiz_step,(col+1)*horiz_step)\\n obs_var,rep_var = calc_variances(ds[row*vert_step:(row+1)*vert_step,\\n col*horiz_step:(col+1)*horiz_step])\\n obs_map[row,col] = sqrt(obs_var/rep_var)\\n # Annotate appropriately\\n obs_map.axes[0] = Array(range(obs_map.shape[0]))*vert_step\\n obs_map.axes[1] = Array(range(obs_map.shape[1]))*horiz_step\\n return obs_map\",\n \"def linear_interpolate_release(mvi, j):\\n set_system_state(mvi, 1)\\n lam1 = mvi.system.lambda_()[j]\\n set_system_state(mvi, 2)\\n lam2 = mvi.system.lambda_()[j]\\n\\n # If either of the following loops are entered, there are likely going to\\n # be problems.\\n if (lam1 < 0) and (lam2 < 0):\\n #add_constraints(mvi, mvi._state1_releases)\\n #print mvi.lambda1c[j]\\n #print mvi\\n #raise Exception(\\\"Bad release interpolation.\\\")\\n print 'WARNING: BAD INTERPOLANT'\\n return mvi.t1, mvi.q1\\n\\n if lam1 < 0:\\n return mvi.t1, mvi.q1\\n\\n tr = mvi.t1 - (lam1/(lam2-lam1))*(mvi.t2-mvi.t1)\\n frac = (tr-mvi.t1)/(mvi.t2-mvi.t1)\\n qr = frac*(mvi.q2-mvi.q1)+mvi.q1\\n\\n return tr, qr\",\n \"def interpolate_2d(x, y, z):\\n X = np.linspace(min(x), max(x))\\n Y = np.linspace(min(y), max(y))\\n X, Y = np.meshgrid(X, Y)\\n #f = interpolate.interp2d(x, y, z)\\n #Z = f(X[0, :], Y[:, 0])\\n f = interpolate.LinearNDInterpolator(zip(x, y), z)\\n Z = f(X, Y)\\n return X, Y, Z\",\n \"def interpolator(mat, distance):\\n\\n# calculate the place of each meassurement relative to the whole yourney of the\\n# ship\\n gesdistance = np.zeros(len(distance)+1)\\n gesdis = distance[0]\\n for i in range(1, len(distance)+1):\\n gesdistance[i] = gesdistance[i-1] + distance[i-1]\\n if i < len(distance):\\n gesdis = gesdis + distance[i]\\n\\n# calculates the minimum distance for number of points of the interpolation\\n mini = distance[0]\\n for i in range(len(distance)):\\n if distance[i] < mini:\\n mini = distance[i]\\n\\n# interpolates linear over every depth\\n newmat = np.zeros((len(mat), int(gesdis/mini)))\\n\\n wth = 0\\n for leng in range(len(newmat)):\\n newveloc = interp1d(gesdistance, mat[leng, :], kind=\\\"linear\\\")\\n for wth in range(int(gesdis/mini)):\\n newmat[leng, wth] = newveloc(wth*mini)\\n for wdth in range(int(gesdis/mini)):\\n newvelocdepth = interp1d(np.append(np.arange(0, 458, 20), 458), np.append(newmat[::20, wdth], newmat[457, wdth]), kind=\\\"linear\\\")\\n for le in range(len(newmat)):\\n newmat[le, wdth] = newvelocdepth(le)\\n\\n return np.flip(newmat), gesdis\",\n \"def timeave_old( mv ):\\n # I haven't thought yet about how missing values would work with this...\\n # If time intervals be unequal, this will have to be changed...\\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\\n n = sh[0]\\n # BTW, this is the size of everything else:\\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\\n mvta = numpy.sum( mv.__array__(), axis=0 )\\n mvta /= n\\n return mvta\",\n \"def _interpolate_cube(self, lon, lat, egy=None, interp_log=True):\\n\\n shape = np.broadcast(lon, lat, egy).shape\\n lon = lon * np.ones(shape)\\n lat = lat * np.ones(shape)\\n theta = np.pi / 2. - np.radians(lat)\\n phi = np.radians(lon)\\n vals = []\\n for i, _ in enumerate(self.hpx.evals):\\n v = hp.pixelfunc.get_interp_val(self.counts[i], theta,\\n phi, nest=self.hpx.nest)\\n vals += [np.expand_dims(np.array(v, ndmin=1), -1)]\\n\\n vals = np.concatenate(vals, axis=-1)\\n\\n if egy is None:\\n return vals.T\\n\\n egy = egy * np.ones(shape)\\n\\n if interp_log:\\n xvals = utils.val_to_pix(np.log(self.hpx.evals), np.log(egy))\\n else:\\n xvals = utils.val_to_pix(self.hpx.evals, egy)\\n\\n vals = vals.reshape((-1, vals.shape[-1]))\\n xvals = np.ravel(xvals)\\n v = map_coordinates(vals, [np.arange(vals.shape[0]), xvals],\\n order=1)\\n return v.reshape(shape)\",\n \"def _proj(u,v):\\n return (np.einsum('i...,i...->...',u,v)/np.einsum('i...,i...->...',u,u))*u\",\n \"def dmsp_map_interpolate_NN_smooth_great_circle(lat_dmsp, lon_dmsp, lat_map, lon_map, Obs_map, k = 5, tol = 1.5):\\n tol = np.deg2rad(tol)\\n #reshape to N by 2 array where each row is (lat, lon)\\n dmsp_points = np.deg2rad(np.hstack((lat_dmsp.flatten().reshape(-1,1),lon_dmsp.flatten().reshape(-1,1))))\\n map_points = np.deg2rad(np.hstack((lat_map.flatten().reshape(-1,1), lon_map.flatten().reshape(-1,1))))\\n N_points = dmsp_points.shape[0]\\n obs_val = Obs_map.flatten()\\n \\n model = sklearn.neighbors.NearestNeighbors(n_neighbors = k, radius = tol, metric = 'haversine')\\n\\n model.fit(map_points)\\n neighbors = model.kneighbors(dmsp_points, return_distance = True)\\n \\n #indices\\n obs_interp = np.empty(N_points)\\n for i in range(N_points):\\n distances = neighbors[0][i]\\n inds = neighbors[1][i]\\n \\n weights = distances/np.nansum(distances)\\n obs_interp[i] = np.nansum( obs_val[inds] * weights)\\n \\n return obs_interp\",\n \"def extrapolate_nans(x, y, v):\\n if numpy.ma.is_masked(v):\\n nans = v.mask\\n else:\\n nans = numpy.isnan(v)\\n notnans = numpy.logical_not(nans)\\n v[nans] = scipy.interpolate.griddata((x[notnans], y[notnans]), v[notnans],\\n (x[nans], y[nans]),\\n method='nearest').ravel()\\n return v\",\n \"def proj3d(v):\\n v = normalize(v)\\n x, y, z, w = v\\n return np.array([x, y, z]) / (1 + 1e-8 - w) # avoid divide by zero\",\n \"def dmsp_map_interpolate_NN_smooth_great_circle(lat_dmsp, lon_dmsp, lat_map, lon_map, Obs_map, k = 5, tol = 1.5):\\n \\n tol = np.deg2rad(tol)\\n #reshape to N by 2 array where each row is (lat, lon)\\n dmsp_points = np.deg2rad(np.hstack((lat_dmsp.flatten().reshape(-1,1),lon_dmsp.flatten().reshape(-1,1))))\\n map_points = np.deg2rad(np.hstack((lat_map.flatten().reshape(-1,1), lon_map.flatten().reshape(-1,1))))\\n N_points = dmsp_points.shape[0]\\n obs_val = Obs_map.flatten()\\n model = sklearn.neighbors.NearestNeighbors(n_neighbors = k, radius = tol, metric = 'haversine')\\n\\n model.fit(map_points)\\n neighbors = model.kneighbors(dmsp_points, return_distance = True)\\n \\n #indices\\n obs_interp = np.empty(N_points)\\n for i in range(N_points):\\n distances = neighbors[0][i]\\n inds = neighbors[1][i]\\n \\n weights = distances/np.nansum(distances)\\n obs_interp[i] = np.nansum( obs_val[inds] * weights)\\n \\n \\n return obs_interp\",\n \"def test_cubic_interp_to_densepred_is_same_for_one_gridlevel(mock_amg):\\n\\n # obtain the reference solution\\n coarse_grid = mock_amg.grids[0]\\n ny, nx = coarse_grid.ny, coarse_grid.nx\\n u_ref, v_ref = np.random.rand(ny, nx), np.random.rand(ny, nx)\\n\\n # set the values of the windows to these values\\n for ii in range(ny):\\n for jj in range(nx):\\n mock_amg.grids[0]._array[ii][jj].u = u_ref[ii][jj]\\n mock_amg.grids[0]._array[ii][jj].v = v_ref[ii][jj]\\n\\n # get the expected interpolations\\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\\n f_u = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\\n u_ref, kind='cubic')\\n u_exp = f_u(xe, ye)\\n f_v = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\\n v_ref, kind='cubic')\\n v_exp = f_v(xe, ye)\\n dp_soln = mock_amg.interp_to_densepred()\\n\\n assert np.allclose(u_exp, dp_soln.u)\\n assert np.allclose(v_exp, dp_soln.v)\",\n \"def linear_interpolate_value_change(t0, v0, t1, v1, dt):\\n return (v1 - v0)/float(t1-t0) * dt\",\n \"def _interpolation(matrix):\\n try:\\n\\tok = ~np.isnan(matrix)\\n \\txp = ok.ravel().nonzero()[0]\\n \\tfp = matrix[~np.isnan(matrix)]\\n \\tx = np.isnan(matrix).ravel().nonzero()[0]\\n \\tmatrix[np.isnan(matrix)] = np.interp(x, xp, fp)\\n \\treturn matrix\\n except:\\n return matrix\",\n \"def linear_interpolator(moving):\\n \\n if isinstance(moving, medipy.base.Image) :\\n MovingImageType = medipy.itk.itk_image_type(moving)\\n else :\\n MovingImageType = moving\\n \\n return itk.LinearInterpolateImageFunction[MovingImageType, itk.D].New()\",\n \"def interp_spherical_data(x1, y1, x2, y2, lon, lat, J, m1, great_circle = False):\\n\\n background_x, background_y = m1(lon, lat)\\n\\n if great_circle == False:\\n interp_lons = np.linspace(x1, x2, 100)\\n interp_lats = np.linspace(y1, y2, 100)\\n interp_x, interp_y = m1(interp_lons, interp_lats)\\n\\n else:\\n great_circle = m1.drawgreatcircle(x1, y1, x2, y2, del_s = 50., alpha = 1.0, color = \\\"w\\\", zorder = 102)\\n interp_x = great_circle[0].get_data()[0] \\n interp_y = great_circle[0].get_data()[1]\\n\\n output_data = scipy.interpolate.griddata(list(zip(background_x, background_y)), jr1, list(zip(interp_x, interp_y)), method = 'cubic')\\n\\n output_lon, output_lat = m1(interp_x, interp_y, inverse = True)\\n return output_data, output_lon, output_lat\",\n \"def npinterpx(x, xp, fp):\\n y = np.interp(x, xp, fp)\\n # extrapolate left\\n left = x < xp[0]\\n xleft = x[left]\\n yleft = fp[0] + (xleft - xp[0]) / (xp[1] - xp[0]) * (fp[1] - fp[0])\\n y[left] = yleft\\n # extrapolate right\\n right = x > xp[-1]\\n xright = x[right]\\n yright = fp[-1] + (xright - xp[-1]) / (xp[-2] - xp[-1]) * (fp[-2] - fp[-1])\\n y[right] = yright\\n return y\",\n \"def _interpolation(self, video):\\n self.F_int = []\\n self.mgrid_0 = []\\n self.mgrid_1 = []\\n for p in range(video.points.shape[0]):\\n _m_0, _m_1 = np.meshgrid(self.extended_points_0[p], self.extended_points_1[p])\\n _F_int = interp2d(self.extended_points_0[p], self.extended_points_1[p], video.mraw[0, _m_0, _m_1], kind='cubic')\\n self.F_int.append(_F_int)\\n\\n m_0, m_1 = np.meshgrid(self.extended_points_0[p, self.pad:-self.pad], self.extended_points_1[p, self.pad:-self.pad])\\n self.mgrid_0.append(m_0)\\n self.mgrid_1.append(m_1)\",\n \"def cr_spline(A, mu):\\n mu, mu2 = mu, mu ** 2\\n\\n return A[0] * mu * mu2 + A[1] * mu2 + A[2] * mu + A[3]\",\n \"def interpolate_linear(self, known_coords, known_values, interp_coords, groupname):\\n\\t\\t#First need to reshape known_coords and known_values\\n\\t\\tn_params = self.signal[groupname]['dimension']\\n\\t\\tknown_coords = np.reshape( known_coords, (-1,n_params) )\\n\\t\\tknown_values = np.reshape( known_values, (-1) )\\t\\t\\n\\t\\treturn griddata(known_coords, known_values, interp_coords, method='linear')\",\n \"def bilinear_interpolate(xv, yv, im, xout, yout, fill_value=0):\\n ny, nx = np.shape(im)\\n if (nx, ny) != (xv.size, yv.size):\\n raise ValueError(\\\"Input arrays dimensions do not match\\\")\\n\\n xi = (nx-1.)/(xv[-1] - xv[0]) * (xout - xv[0])\\n yi = (ny-1.)/(yv[-1] - yv[0]) * (yout - yv[0])\\n\\n return ndimage.map_coordinates(im.T, [xi, yi], cval=fill_value, order=1)\",\n \"def bilinear_interpolate(xv, yv, im, xout, yout, fill_value=0):\\n ny, nx = np.shape(im)\\n if (nx, ny) != (xv.size, yv.size):\\n raise ValueError(\\\"Input arrays dimensions do not match\\\")\\n\\n xi = (nx-1.)/(xv[-1] - xv[0]) * (xout - xv[0])\\n yi = (ny-1.)/(yv[-1] - yv[0]) * (yout - yv[0])\\n\\n return ndimage.map_coordinates(im.T, [xi, yi], cval=fill_value, order=1)\",\n \"def observation(self, obs):\\n\\n# import pdb;pdb.set_trace()\\n return np.moveaxis(obs, 2, 0)\",\n \"def loginterpolate(x_vector, y_vector, xout, replace_nan=np.nan):\\n interpolant = interpolate.interp1d(np.log10(x_vector), np.log10(y_vector),\\n bounds_error=False,\\n fill_value=np.nan)\\n yout = 10. ** interpolant(np.log10(xout))\\n if replace_nan != np.nan:\\n yout[np.isnan(yout)] = replace_nan\\n return yout\",\n \"def derive(params):\\n x, y, dx, dy = params\\n r = (x ** 2 + y ** 2) ** 0.5\\n return np.array([dx, dy, -G * M * x / (r ** 3), -G * M * y / (r ** 3)])\",\n \"def interpolate(self, _val1h) :\\n\\n\\t\\tval1h = _val1h.reshape(reduce(operator.mul, _val1h.shape))\\t# Convert to 1-D\\n\\t\\tv1h = np.copy(val1h)\\n\\t\\tv1h[np.isnan(val1h)] = 0\\t# Prepare for multiply\\n\\t\\tval2 = self.M.transpose() * v1h\\n\\t\\tval2[np.logical_not(self.mask2)] = np.nan\\n\\t\\treturn val2\",\n \"def interp_upsampling(V):\\n V = tf.reshape(V, [-1] + V.get_shape().as_list()[1:])\\n grid = volshape_to_ndgrid([f*2 for f in V.get_shape().as_list()[1:-1]])\\n grid = [tf.cast(f, 'float32') for f in grid]\\n grid = [tf.expand_dims(f/2 - f, 0) for f in grid]\\n offset = tf.stack(grid, len(grid) + 1)\\n\\n V = SpatialTransformer(interp_method='linear')([V, offset])\\n return V\",\n \"def rescale(params):\\n theta_mean = np.mean(params, axis=0)\\n theta_mult = np.max(params - theta_mean, axis=0)\\n return (params - theta_mean) * theta_mult**-1, theta_mean, theta_mult\",\n \"def splineint(a, b, y, mu1, munp1):\\n n = len(y) - 1\\n h = (b - a)/float(n)\\n c, d = ones(n - 2), 4*ones(n - 1)\\n l ,u = trifactor(c, d, c)\\n b1 = (6/h**2)*(y[2:(n + 1)] - 2*y[1:n] + y[:(n - 1)])\\n b1[0] -= mu1\\n b1[n - 2] -= munp1\\n trisolve(l, u, c, b1)\\n mu2ton = b1\\n mu = zeros(n + 1)\\n mu[0] = mu1\\n mu[1:n] = mu2ton\\n mu[n] = munp1\\n \\n C = array(zeros((n, 4))) # Apply lemma 1.3 to obtain the coefficient matrix\\n C[:, 0] = y[:n]\\n C[:, 1] = (y[1:(n+1)] - y[:n])/h - h*mu[:n]/3-h*mu[1:(n+1)]/6\\n C[:, 2] = mu[:n]/2\\n C[:, 3] = (mu[1:(n + 1)] - mu[0:n])/(6*h)\\n C = matrix(C)\\n return linspace(a, b - h, n), C\",\n \"def get_proj(self):\\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\\n\\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\\n\\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \\n worldM = proj3d.world_transformation(xmin, xmax,\\n ymin, ymax,\\n zmin, zmax)\\n\\n # look into the middle of the new coordinates \\n R = np.array([0.5, 0.5, 0.5])\\n\\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\\n zp = R[2] + np.sin(relev) * self.dist\\n E = np.array((xp, yp, zp))\\n\\n self.eye = E\\n self.vvec = R - E\\n self.vvec = self.vvec / proj3d.mod(self.vvec)\\n\\n if abs(relev) > np.pi/2:\\n # upside down \\n V = np.array((0, 0, -1))\\n else:\\n V = np.array((0, 0, 1))\\n\\n zfront, zback = -self.dist, self.dist\\n\\n viewM = proj3d.view_transformation(E, R, V)\\n perspM = proj3d.persp_transformation(zfront, zback)\\n M0 = np.dot(viewM, worldM)\\n M = np.dot(perspM, M0)\\n return M\",\n \"def proj_linf(v, radius=1):\\n vmod = np.abs(v)\\n projmult = np.minimum(radius/vmod, 1)\\n return projmult*v\",\n \"def my_mvn(mu_x, mu_y, r):\\n return multivariate_normal([mu_x, mu_y], [[r, 0], [0, r]])\",\n \"def extrap1d(x,y,kind=\\\"linear\\\"):\\n interpolator = interp1d(x,y,kind=kind)\\n xs = interpolator.x\\n ys = interpolator.y\\n def pointwise(x):\\n if x < xs[0]: return ys[0]+(x-xs[0])*(ys[1]-ys[0])/(xs[1]-xs[0])\\n elif x > xs[-1]: return ys[-1]+(x-xs[-1])*(ys[-1]-ys[-2])/(xs[-1]-xs[-2])\\n else: return interpolator(x)\\n def ufunclike(xs):\\n return array(list(map(pointwise, array(xs))))\\n return ufunclike\",\n \"def reduce_time( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id=='time' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n if len(axes_string)>2:\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n avmv = averager( mv, axis=axes_string )\\n else:\\n avmv = mv\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def read_velocities(filename, return_grid=True, return_proj=False):\\n ds = gdal.Open(filename)\\n #Get dimensions\\n nc = ds.RasterXSize\\n nr = ds.RasterYSize\\n \\n geotransform = ds.GetGeoTransform()\\n xOrigin = geotransform[0]\\n xPix = geotransform[1] #pixel width in x-direction\\n yOrigin = geotransform[3]\\n yPix = geotransform[5] #pixel height in y-direction\\n \\n lons = xOrigin + np.arange(0, nc)*xPix\\n lats = yOrigin + np.arange(0, nr)*yPix\\n \\n x, y = np.meshgrid(lons, lats)\\n \\n vband = ds.GetRasterBand(1)\\n varr = vband.ReadAsArray()\\n \\n if return_grid and return_proj:\\n return x, y, varr, ds.GetProjection()\\n elif return_grid:\\n return x, y, varr\\n else: \\n return varr\",\n \"def coord_vec(self, key):\\n i = self.axis_index(key)\\n return np.linspace(self.mins[i], self.maxs[i], self.shape[i])\",\n \"def interpolate_to_pixel(U, imshape, kind=\\\"linear\\\") -> np.ndarray:\\n # Velocity components\\n u, v = U\\n nr, nc = u.shape\\n\\n ws_x = int(np.round(imshape[0] / nr))\\n ws_y = int(np.round(imshape[1] / nc))\\n\\n x, y = np.arange(nr) * ws_x + ws_x // 2, np.arange(nc) * ws_y + ws_y // 2\\n xi, yi = np.arange(imshape[0]), np.arange(imshape[1])\\n\\n # Interpolate to pixel level\\n u_px = scipy.interpolate.interp2d(y, x, u, kind=kind)(yi, xi)\\n v_px = scipy.interpolate.interp2d(y, x, v, kind=kind)(yi, xi)\\n\\n return np.stack((u_px, v_px))\",\n \"def lmap(v: float, x: Interval, y: Interval) -> float:\\n return y[0] + (v - x[0]) * (y[1] - y[0]) / (x[1] - x[0])\",\n \"def profile_interp(var,z_orig,z_interp,method='linear',out_of_bounds='NaN'):\\n z_orig = z_orig[~isnan(z_orig)]\\n var= var[~isnan(var)]\\n #assert(all(diff(z_orig) > 0))\\n if len(z_orig) > len(var) or len(var) > len(z_orig): return NaN\\n if len(z_orig) <= 2 or len(var) <= 2: return NaN\\n \\n if out_of_bounds == 'NaN':\\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value=NaN)\\n elif out_of_bounds == 'nearest':\\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value=(var[0],var[-1]))\\n elif out_of_bounds == 'extrap':\\n interpolant = interpolate.interp1d(z_orig,var,kind=method,bounds_error=False,fill_value='extrapolate')\\n else:\\n raise ValueError('Extrapolation method must be NaN, nearest, or cubic.')\\n result = interpolant(z_interp)\\n\\n if result.size == 1: return result.item()\\n else: return result\",\n \"def test_linear_interp_to_densepred_is_same_for_one_gridlevel(mock_amg):\\n\\n # obtain the reference solution\\n coarse_grid = mock_amg.grids[0]\\n ny, nx = coarse_grid.ny, coarse_grid.nx\\n u_ref, v_ref = np.random.rand(ny, nx), np.random.rand(ny, nx)\\n\\n # set the values of the windows to these values\\n for ii in range(ny):\\n for jj in range(nx):\\n mock_amg.grids[0]._array[ii][jj].u = u_ref[ii][jj]\\n mock_amg.grids[0]._array[ii][jj].v = v_ref[ii][jj]\\n\\n # get the expected interpolations\\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\\n f_u = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\\n u_ref, kind='linear')\\n u_exp = f_u(xe, ye)\\n f_v = interp.interp2d(coarse_grid.x_vec, coarse_grid.y_vec,\\n v_ref, kind='linear')\\n v_exp = f_v(xe, ye)\\n dp_soln = mock_amg.interp_to_densepred(method='linear')\\n\\n assert np.allclose(u_exp, dp_soln.u)\\n assert np.allclose(v_exp, dp_soln.v)\",\n \"def _extrapolate(self):\\n maxrho = self.maxrho\\n x = np.linspace(1.001, maxrho, int(self.nrho/5))\\n rho1 = self.rho # rho up to 1\\n dec_l = 0.01\\n ni_ov = np.zeros((self.nion, len(x)), dtype=float)\\n ninew = np.zeros((self.nion, self.nrho+len(x)),dtype=float)\\n ne_ov1 = self.ne[self.nrho-1]*np.exp(-((x-1.)/dec_l))\\n te_ov1 = self.te[self.nrho-1]*np.exp(-(x-1.)/dec_l)\\n ti_ov1 = self.ti[self.nrho-1]*np.exp(-(x-1.)/dec_l)\\n vt_ov1 = self.vt[self.nrho-1]*np.exp(-(x-1.)/dec_l)\\n for i in range(self.nion):\\n ni_ov[i,:] = self.ni[i,self.nrho-1]*np.exp(-(x-1.)/dec_l)\\n ninew[i,:] = np.concatenate([self.ni[i,:], ni_ov[i,:]])\\n self.ni = ninew\\n self.rho = np.concatenate([rho1, x])\\n self.nrho = len(rho1)+len(x)\\n self.ne = np.concatenate([self.ne, ne_ov1])\\n self.te = np.concatenate([self.te, te_ov1])\\n self.ti = np.concatenate([self.ti, ti_ov1])\\n self.vt = np.concatenate([self.vt, vt_ov1])\",\n \"def pvi(inp, scale: int = 10):\\n\\n if len(inp.data.shape) == 1:\\n data = inp.data[:, np.newaxis]\\n else:\\n data = inp.data\\n\\n delta_inp = np.abs((data[scale:, :] - data[:-scale, :]))\\n delta_inp2 = np.sum(delta_inp ** 2, axis=1)\\n sigma = np.mean(delta_inp2)\\n result = np.array(delta_inp2 / sigma)\\n\\n time = inp.coords[inp.dims[0]].data\\n\\n result = xr.DataArray(result, coords=[time[0:len(delta_inp)]],\\n dims=[inp.dims[0]], attrs=inp.attrs)\\n\\n result.attrs[\\\"units\\\"] = \\\"dimensionless\\\"\\n\\n return result\",\n \"def mse_converter( fname ):\\n lines = []\\n with open( fname ) as fh:\\n for line in fh.readlines():\\n if len(line) > 1: # avoid empty lines\\n if line.startswith('m'):\\n continue\\n # strip off \\\\n and split on tabs\\n line = line.strip().split( '\\\\t' )\\n lines.append( ( float(line[0]), float(line[1]) ) )\\n return numpy.array( lines )\",\n \"def transform_contour(contour: np.ndarray, M):\\n return cv2.transform(contour[:, np.newaxis], m=M)[:, 0, :2]\",\n \"def interpolate_eleMean(model):\\n # Get mean of columns (data at the same elevation) without taking int account NaNs\\n el_mean = nanmean(model,axis=0)\\n #print(el_mean) \\n # Find indices for NaNs, and replace them by the column mean\\n ind_nan = np.where(np.isnan(model))\\n model[ind_nan] = np.take(el_mean,ind_nan[1])\\n\\n return model\",\n \"def get_variance_maps_models(variable=\\\"pr\\\",models=None,cmip_dir = None,period=12):\\n if models is None:\\n f = cdms.open(\\\"/work/marvel1/SEASONAL/MMA/cmip5.ZONALMMA.historical-rcp85.rip.mo.atm.Amon.pr.ver-1.AmpPhase.nc\\\")\\n phase = f(\\\"phase\\\")\\n models = eval(phase.getAxis(0).models)\\n f.close()\\n if cmip_dir is None:\\n cmip_dir = \\\"/work/cmip5/historical-rcp85/atm/mo/\\\"+variable+\\\"/\\\"\\n fobs = cdms.open(\\\"/work/marvel1/SEASONAL/OBS/GPCP.precip.mon.mean.nc\\\")\\n the_grid = fobs(\\\"precip\\\").getGrid()\\n nlat,nlon=the_grid.shape\\n fobs.close()\\n VarianceMaps = np.zeros((len(models),nlat))+1.e20\\n counter=0\\n for model in models:\\n print model\\n try:\\n fname = sorted(glob.glob(cmip_dir+\\\"*.\\\"+model+\\\".*\\\"))[0]\\n fp = cdms.open(fname)\\n prtest = fp(variable,time=(\\\"1979-1-1\\\",\\\"2014-12-31\\\")).regrid(the_grid,regridTool='regrid2')\\n przonal = cdutil.averager(prtest,axis='x')\\n dom = variance_map(przonal,period=period)\\n VarianceMaps[counter]=dom\\n fp.close()\\n counter+=1\\n except:\\n continue\\n \\n modax = cdms.createAxis(range(len(models)))\\n modax.id = \\\"model\\\"\\n modax.models = str(models)\\n VarianceMaps = MV.array(VarianceMaps)\\n VarianceMaps.setAxis(0,modax)\\n VarianceMaps.setAxis(1,the_grid.getLatitude())\\n return MV.masked_where(VarianceMaps>1.e10,VarianceMaps)\",\n \"def _interpolate_cumulative_mass(self, r):\\n \\n # interpolate\\n #spline = interpolate.UnivariateSpline(self._cumulative_mass_r,\\n # self._cumulative_mass_m)\\n \\n # linear interpolation is more reliable, assuming number of points\\n # is large enough\\n spline = interpolate.interp1d(self._cumulative_mass_r, self._cumulative_mass_m)\\n \\n return 10.0**spline(np.log10(r))\",\n \"def get_vertical_gridline_values(self, x):\\n indices = numpy.where(numpy.abs(self.x - x) <= 1.0E-06)[0]\\n # if no station matches the given value, we interpolate\\n if indices.size == 0:\\n i = numpy.where(self.x > x)[0][0]\\n return (self.y, (abs(self.x[i] - x) * self.values[:, i - 1]\\n + abs(self.x[i - 1] - x) * self.values[:, i])\\n / abs(self.x[i] - self.x[i - 1]))\\n else:\\n i = indices[0]\\n return self.y, self.values[:, i]\",\n \"def dcm_to_mrp(dcm):\\n c = np.sqrt(np.trace(dcm) + 1)\\n return (1/(c*(c + 2))) * np.array([dcm[1, 2] - dcm[2, 1], dcm[2, 0] - dcm[0, 2], dcm[0, 1] - dcm[1, 0]])\",\n \"def test_cubic_interp_to_densepred_is_similar_for_two_levels(mock_amg):\\n\\n # split all the cells so that we have two tiers\\n mock_amg.split_all_cells()\\n coarse_grid, fine_grid = mock_amg.grids[0], mock_amg.grids[1]\\n\\n # obtain the reference solution for the whole domain\\n nyf, nxf = fine_grid.ny, fine_grid.nx\\n u_ref, v_ref = np.random.rand(nyf, nxf), np.random.rand(nyf, nxf)\\n\\n # set all the window values\\n for ii in range(nyf):\\n # determine if the value should go onto the coarse or fine tier\\n # coarse tiers are 0, 2, 4, etc and so will return 0 (False) when\\n # modded with 2\\n coarse_i = False if ii % 2 else True\\n for jj in range(nxf):\\n # determine if the value should go onto the coarse or fine tier\\n coarse_j = False if jj % 2 else True\\n # if both coarse_i, coarse_j are True, then we are on the coarse\\n # grid, else we are on the fine grid\\n if coarse_i and coarse_j:\\n mock_amg.grids[0]._array[ii//2][jj//2].u = u_ref[ii][jj]\\n mock_amg.grids[0]._array[ii//2][jj//2].v = v_ref[ii][jj]\\n else:\\n mock_amg.grids[1]._array[ii][jj].u = u_ref[ii][jj]\\n mock_amg.grids[1]._array[ii][jj].v = v_ref[ii][jj]\\n\\n # get the expected interpolations\\n xe, ye = np.arange(mock_amg.img_dim[1]), np.arange(mock_amg.img_dim[0])\\n f_u = interp.interp2d(fine_grid.x_vec, fine_grid.y_vec,\\n u_ref, kind='cubic')\\n u_exp = f_u(xe, ye)\\n f_v = interp.interp2d(fine_grid.x_vec, fine_grid.y_vec,\\n v_ref, kind='cubic')\\n v_exp = f_v(xe, ye)\\n\\n dp_soln = mock_amg.interp_to_densepred()\\n\\n assert np.allclose(u_exp, dp_soln.u)\\n assert np.allclose(v_exp, dp_soln.v)\",\n \"def velocity_interpolation(a, axis=-1):\\n nd = len(a.shape)\\n\\n # adding one extra dimension to field at the lower boundary with\\n # zeros.\\n a_shape = list(a.shape)\\n a_shape[axis] = a.shape[axis] + 1\\n a_shape = tuple(a_shape)\\n slice0 = [slice(None)] * nd\\n slice0[axis] = slice(1, None)\\n slice0 = tuple(slice0)\\n a_prim = np.zeros(a_shape)\\n a_prim[slice0] = a\\n\\n # doing the interpolation\\n slice1 = [slice(None)] * nd\\n slice2 = [slice(None)] * nd\\n slice1[axis] = slice(None, -1)\\n slice2[axis] = slice(1, None)\\n slice1 = tuple(slice1)\\n slice2 = tuple(slice2)\\n\\n a_interp = (a_prim[slice1] + a_prim[slice2])/2\\n return a_interp\",\n \"def _interp_2d(grid1,grid2,value,xi1,xi2,j1,j2):\\r\\n\\r\\n # a. left/right\\r\\n nom_1_left = grid1[j1+1]-xi1\\r\\n nom_1_right = xi1-grid1[j1]\\r\\n\\r\\n nom_2_left = grid2[j2+1]-xi2\\r\\n nom_2_right = xi2-grid2[j2]\\r\\n\\r\\n # b. interpolation\\r\\n denom = (grid1[j1+1]-grid1[j1])*(grid2[j2+1]-grid2[j2])\\r\\n nom = 0\\r\\n for k1 in range(2):\\r\\n nom_1 = nom_1_left if k1 == 0 else nom_1_right\\r\\n for k2 in range(2):\\r\\n nom_2 = nom_2_left if k2 == 0 else nom_2_right \\r\\n nom += nom_1*nom_2*value[j1+k1,j2+k2]\\r\\n\\r\\n return nom/denom\",\n \"def interpolation_1D(rawdata, squint_vec, angle_vec):\\n rawdata_corr = rawdata * 1\\n for idx_freq in range(rawdata.shape[0]):\\n az_new = angle_vec - squint_vec[idx_freq]\\n current_data = rawdata[idx_freq, :]\\n interpolator = _interp.interp1d(angle_vec, current_data, kind='linear', bounds_error=False, fill_value=0, assume_sorted=True)\\n rawdata_corr[idx_freq, :] = interpolator(az_new)\\n # rawdata_corr[idx_freq, :] = _np.interp(az_new, angle_vec, current_data, left=0.0, right=0.0)\\n if idx_freq % 500 == 0:\\n print_str = \\\"interp sample: {idx}, ,shift: {sh} samples\\\".format(idx=idx_freq, sh=az_new[0] - angle_vec[0])\\n print(print_str)\\n rawdata_corr = rawdata_corr.__array_wrap__(rawdata)\\n return rawdata_corr\",\n \"def restrict_lat( mv, latmin, latmax ):\\n if latmin==-90: latmin = -91 # just to make sure\\n if latmax==90: latmax = 91\\n\\n # axes\\n latax,idx = latAxis2(mv)\\n if latax is None: return None\\n imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n imax = max( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )\\n newlatax = latax.subaxis( imin, imax+1 )\\n # TO DO: use latax.bounds (if present) for newlatax.bounds\\n # At the moment, I'm working with data for which latax.bounds doesn't exist.\\n # At the moment, we don't need bounds. This would get us through if necessary:\\n # newlatax.bounds = newlatax.genGenericBounds()\\n newaxes = list( allAxes(mv) ) # shallow copy\\n newaxes[idx] = newlatax\\n\\n # shrink the data to match the shrunk lat axis\\n newmv_shape = list( mv.shape )\\n newmv_shape[idx] = imax+1 - imin\\n if imin>0:\\n nd = numpy.delete( mv.data, slice(0,imin), idx ) # doesn't change mv\\n else:\\n nd = mv\\n lenidx = nd.shape[idx]\\n if lenidx > newmv_shape[idx]:\\n newdata = numpy.delete( nd.data, slice(imax+1-imin,lenidx), idx )\\n else:\\n newdata = nd\\n\\n # new variable\\n newmv = cdms2.createVariable( newdata, copy=True, axes=newaxes, id=mv.id )\\n newmv.units = mv.units\\n return newmv\",\n \"def scale_massmet(mass):\\n upper_84 = np.interp(mass, massmet[:, 0], massmet[:, 3])\\n lower_16 = np.interp(mass, massmet[:, 0], massmet[:, 2])\\n return (upper_84-lower_16)\",\n \"def multi_sds_to_XYZ_integration(\\n msds,\\n cmfs=STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']\\n .copy().trim(DEFAULT_SPECTRAL_SHAPE),\\n illuminant=sd_ones(),\\n k=None,\\n shape=DEFAULT_SPECTRAL_SHAPE):\\n\\n if isinstance(msds, MultiSpectralDistributions):\\n return as_float_array([\\n sd_to_XYZ_integration(sd, cmfs, illuminant, k)\\n for sd in msds.to_sds()\\n ])\\n else:\\n msds = as_float_array(msds)\\n\\n msd_shape_m_1, shape_wl_count = msds.shape[-1], len(shape.range())\\n assert msd_shape_m_1 == shape_wl_count, (\\n 'Multi-spectral distributions array with {0} wavelengths '\\n 'is not compatible with spectral shape with {1} wavelengths!'.\\n format(msd_shape_m_1, shape_wl_count))\\n\\n if cmfs.shape != shape:\\n runtime_warning('Aligning \\\"{0}\\\" cmfs shape to \\\"{1}\\\".'.format(\\n cmfs.name, shape))\\n cmfs = cmfs.copy().align(shape)\\n\\n if illuminant.shape != shape:\\n runtime_warning('Aligning \\\"{0}\\\" illuminant shape to \\\"{1}\\\".'.format(\\n illuminant.name, shape))\\n illuminant = illuminant.copy().align(shape)\\n\\n S = illuminant.values\\n x_bar, y_bar, z_bar = tsplit(cmfs.values)\\n dw = cmfs.shape.interval\\n\\n k = 100 / (np.sum(y_bar * S) * dw) if k is None else k\\n\\n X_p = msds * x_bar * S * dw\\n Y_p = msds * y_bar * S * dw\\n Z_p = msds * z_bar * S * dw\\n\\n XYZ = k * np.sum(np.array([X_p, Y_p, Z_p]), axis=-1)\\n\\n return from_range_100(np.rollaxis(XYZ, 0, msds.ndim))\",\n \"def func_vl2_pressure_curve(nc, index):\\n loc = {\\\"lat\\\": 47.6680, \\\"lon\\\": 134.0430, \\\"height\\\": -4505.0}\\n return func_pressure_curve(nc, index, loc)\",\n \"def _splineloc(self, coa_map, win=5, upscale=10):\\n\\n # Get shape of 3-D coalescence map\\n nx, ny, nz = coa_map.shape\\n n = np.array([nx, ny, nz])\\n\\n # Find maximum coalescence location in grid\\n mx, my, mz = np.unravel_index(np.nanargmax(coa_map), coa_map.shape)\\n i = np.array([mx, my, mz])\\n\\n # Determining window about maximum value and trimming coa grid\\n w2 = (win - 1)//2\\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\\n\\n # If subgrid is not close to the edge\\n if (x2 - x1) == (y2 - y1) == (z2 - z1):\\n coa_map_trim = coa_map[x1:x2, y1:y2, z1:z2]\\n\\n # Defining the original interpolation function\\n xo = np.linspace(0, coa_map_trim.shape[0] - 1,\\n coa_map_trim.shape[0])\\n yo = np.linspace(0, coa_map_trim.shape[1] - 1,\\n coa_map_trim.shape[1])\\n zo = np.linspace(0, coa_map_trim.shape[2] - 1,\\n coa_map_trim.shape[2])\\n xog, yog, zog = np.meshgrid(xo, yo, zo)\\n interpgrid = Rbf(xog.flatten(), yog.flatten(), zog.flatten(),\\n coa_map_trim.flatten(),\\n function=\\\"cubic\\\")\\n\\n # Creating the new interpolated grid\\n xx = np.linspace(0, coa_map_trim.shape[0] - 1,\\n (coa_map_trim.shape[0] - 1) * upscale + 1)\\n yy = np.linspace(0, coa_map_trim.shape[1] - 1,\\n (coa_map_trim.shape[1] - 1) * upscale + 1)\\n zz = np.linspace(0, coa_map_trim.shape[2] - 1,\\n (coa_map_trim.shape[2] - 1) * upscale + 1)\\n xxg, yyg, zzg = np.meshgrid(xx, yy, zz)\\n\\n # Interpolate spline function on new grid\\n coa_map_int = interpgrid(xxg.flatten(), yyg.flatten(),\\n zzg.flatten()).reshape(xxg.shape)\\n\\n # Calculate max coalescence location on interpolated grid\\n mxi, myi, mzi = np.unravel_index(np.nanargmax(coa_map_int),\\n coa_map_int.shape)\\n mxi = mxi/upscale + x1\\n myi = myi/upscale + y1\\n mzi = mzi/upscale + z1\\n self.output.log(\\\"\\\\t\\\\tGridded loc: {} {} {}\\\".format(mx, my, mz), self.log)\\n self.output.log(\\\"\\\\t\\\\tSpline loc: {} {} {}\\\".format(mxi, myi, mzi), self.log)\\n\\n # Run check that spline location is within grid-cell\\n if (abs(mx - mxi) > 1) or (abs(my - myi) > 1) or \\\\\\n (abs(mz - mzi) > 1):\\n msg = \\\"\\\\tSpline warning: spline location outside grid cell\\\"\\n msg += \\\"with maximum coalescence value\\\"\\n self.output.log(msg, self.log)\\n\\n xyz = self.lut.xyz2loc(np.array([[mxi, myi, mzi]]), inverse=True)\\n loc_spline = self.lut.xyz2coord(xyz)[0]\\n\\n # Run check that spline location is within window\\n if (abs(mx - mxi) > w2) or (abs(my - myi) > w2) or \\\\\\n (abs(mz - mzi) > w2):\\n msg = \\\"\\\\t !!!! Spline error: location outside interpolation \\\"\\n msg += \\\"window !!!!\\\\n\\\\t\\\\t\\\\tGridded Location returned\\\"\\n self.output.log(msg, self.log)\\n\\n xyz = self.lut.xyz2loc(np.array([[mx, my, mz]]), inverse=True)\\n loc_spline = self.lut.xyz2coord(xyz)[0]\\n\\n else:\\n msg = \\\"\\\\t !!!! Spline error: interpolation window crosses edge of \\\"\\n msg += \\\"grid !!!!\\\\n\\\\t\\\\t\\\\tGridded Location returned\\\"\\n self.output.log(msg, self.log)\\n\\n xyz = self.lut.xyz2loc(np.array([[mx, my, mz]]), inverse=True)\\n loc_spline = self.lut.xyz2coord(xyz)[0]\\n\\n return loc_spline\",\n \"def levvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n #levmv = mv.clone() # good if mv has only a lev axis\\n #levmv[:] = lev_axis[:]\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\\n attributes={'units':lev_axis.units},\\n copy=True )\\n return levmv\",\n \"def geo_m_v2(data_array):\\n r = 6378.137 #promien ziemi w km\\n delta = np.zeros(data_array.size//7-1)\\n alo = data_array[0][1]\\n ala = data_array[0][2]\\n count = 0\\n for row in data_array[1:]:\\n dLat = (row[2] - ala) * math.pi/180.0\\n dLon = (row[1] - alo) * math.pi/180.0\\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\\\\n * math.sin(dLon/2.0)**2\\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\\n count += 1\\n alo = row[1]\\n ala = row[2]\\n return delta\",\n \"def linearize(self, params, unknowns, resids):\\n\\n m = self.slope\\n J = {}\\n\\n J['y', 'x'] = m\\n return J\",\n \"def line_ratio_map(quant1='L_[NII]122', quant2='L_[NII]205', ContourFunct='ne_mw', res=0.5, plane='xy', units='Jy', **kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n GR = glo.global_results()\\n location = aux.moment0_map_location(res=res,plane=plane,gal_index=p.gal_index)\\n\\n try:\\n momentmap = np.load(location, allow_pickle=True)\\n print('Found stored momentmap data')\\n except:\\n print('Did not find stored momentmap data - creating')\\n aux.convert_cell_data_to_regular_grid(res=res, plane=plane, gal_index=p.gal_index)\\n momentmap = np.load(location, allow_pickle=True)\\n\\n indexes = momentmap[-1]\\n index1, index2 = int(indexes[1]), int(indexes[2])\\n \\n momentmap = momentmap[:-1] \\n \\n dictionary = p.moment0_dict\\n \\n num1=dictionary[quant1]\\n num2=dictionary[quant2]\\n num =dictionary[ContourFunct]\\n x = momentmap[:,1]\\n y = momentmap[:,2]\\n lumus = np.array(momentmap[:,3])\\n \\n line1=[]\\n line2=[]\\n Contour_Function=[]\\n m=[]\\n for row in lumus:\\n \\n line1.append(row[num1])\\n line2.append(row[num2])\\n \\n \\n if ContourFunct == 'ne_mw':\\n if row[dictionary['m']] == 0:\\n \\n Contour_Function.append(0)\\n else:\\n Contour_Function.append(row[num]/row[dictionary['m']])\\n else:\\n Contour_Function.append(row[num]) \\n \\n line1 = np.array(line1)\\n line2 = np.array(line2)\\n Contour_Function = np.array(Contour_Function)\\n \\n ratio = np.divide(line1, line2, out=np.zeros_like(line1), where=line2!=0)\\n \\n ratio = ratio.reshape(index1, index2)\\n x = x.reshape(index1, index2)\\n y = y.reshape(index1, index2)\\n line1 = line1.reshape(index1, index2)\\n line2 = line2.reshape(index1, index2)\\n #pdb.set_trace()\\n Contour_Function=Contour_Function.reshape(index1,index2)\\n \\n ratio[ratio==0] = np.min(ratio[ratio>0])\\n Contour_Function[Contour_Function==0] = 1e-30\\n\\n\\n if p.add:\\n fig,ax = plt.gcf(),p.ax #plot already available \\n else:\\n fig, ax = plt.subplots(figsize=(10,8))\\n plt.subplots_adjust(left=0.1,bottom=0.2,right=0.8)\\n \\n if p.log: cs = ax.pcolormesh(x, y, np.log10(ratio), cmap=plt.cm.viridis, vmin=np.log10(ratio).max()-1.5, shading='auto')\\n if not p.log: cs = ax.pcolormesh(x, y, ratio, cmap=plt.cm.viridis, vmin=ratio.max()/100, shading='auto')\\n\\n if not p.add:\\n\\n ax.set_title('Line Ratio map of ' + quant1.replace('L_','') + \\\"/\\\" + quant2.replace('L_',''))\\n ax.set_xlabel('x [kpc]')\\n ax.set_ylabel('y [kpc]')\\n levels = np.arange(np.min(np.log10(Contour_Function[Contour_Function > 1e-30])).round(), np.max(np.log10(Contour_Function)).round(), 1)\\n cr=ax.contour(x,y,np.log10(Contour_Function),cmap=plt.cm.plasma, levels=levels)\\n\\n if p.add:labels:''\\n cbaxes=fig.add_axes([.15, 0.09, 0.6, 0.027])\\n cbar=fig.colorbar(cr,cax=cbaxes,orientation='horizontal', label= 'log '+ getlabel(ContourFunct))\\n cbaxes2 = fig.add_axes([0.82, 0.24, 0.027, 0.6])\\n if p.log: fig.colorbar(cs, cax=cbaxes2, label= 'log ' + quant1.replace('L_','') + \\\" / \\\" + quant2.replace('L_','') )\\n if not p.log: fig.colorbar(cs, cax=cbaxes2, label= quant1.replace('L_','') + \\\" / \\\" + quant2.replace('L_','') )\\n if p.R_max:\\n ax.set_xlim([-p.R_max,p.R_max])\\n ax.set_ylim([-p.R_max,p.R_max])\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'lineratios/'): os.mkdir(p.d_plot + 'lineratios/') \\n plt.savefig(p.d_plot+'lineratios/map_%s%s_%i_%s_%s' % (p.sim_name,p.sim_run,p.gal_index,quant1.replace('L_',''),quant2.replace('L_',''))+ '_' + plane + '_res' + str(res) +'.png', facecolor='w', dpi=500)\",\n \"def interp_zt(array, heights, goal):\\n\\n print('Coffee time :-)')\\n nt = array.shape[0]\\n out = np.empty((nt,goal.size), dtype=np.float)\\n for i in range(nt):\\n out[i,:] = np.interp(goal, heights[i,:], array[i,:])\\n return out\",\n \"def ret2dva(xret, yret):\\n return xret / 280.0, yret / 280.0\",\n \"def spatial_var(map_):\\n expx, expy = spatial_expval(map_)\\n map_ = map_ / np.sum(map_)\\n x, y = np.meshgrid(np.arange(map_.shape[1]), np.arange(map_.shape[0]))\\n\\n return np.sum(map_ * ((x - expx) ** 2 + (y - expy) ** 2))\",\n \"def convert_axis( mv, axisold, axisindnew ):\\n (axisnew, indexina3) = axisindnew\\n axes = allAxes(mv)\\n kold = None\\n for k in range(len(axes)):\\n if axes[k]==axisold: kold=k\\n if kold==None:\\n print \\\"ERROR. convert_axis cannot find axis\\\",axisold,\\\" in variable\\\",mv\\n if len(axisold)==len(axisnew):\\n mv.setAxis( kold, axisnew )\\n return\\n # Here's what we would do in 1-D:\\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # for i in range(len(axisold)):\\n # newdata[ indexina3[i] ] = ma[i]\\n # newmv = cdms2.createVariable( newdata, id=mv.id )\\n # >1-D is the same idea, but more dimensions are coming along for the ride,\\n # making it more complicated...\\n shape0 = mv.shape\\n shape0[kold] = len(axisnew)\\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\\n # There seems to be nothing in numpy for treating one axis differently from the rest\\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\\n # The following will do the job. It would be very slow for an array with many big dimensions,\\n # but the arrays here have already been reduced for graphics; the index sets will be small or\\n # empty...\\n ranges = map( range, shape0[0:kold] )\\n for i in range(len(axisold)):\\n for idx in apply(itertools.product,ranges):\\n idx = idx + [indexina3(i)] + [Ellipsis]\\n idxo = idx + [i] + [Ellipsis]\\n newdata[ tuple(idx) ] = mv[idxo]\\n newmv = cdms2.createVariable( newdata, id=mv.id )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6127793","0.61027855","0.6082101","0.59283215","0.5838112","0.57578194","0.5623196","0.5599504","0.55420876","0.54633516","0.5410154","0.5350282","0.5312561","0.52844816","0.52626956","0.5179751","0.5162937","0.5137714","0.5093342","0.5058199","0.5038663","0.50160366","0.50040245","0.49906573","0.49896732","0.49162564","0.49052754","0.49019223","0.48935536","0.48931697","0.48727843","0.48642796","0.48018897","0.47898814","0.47834474","0.4782332","0.47617364","0.47612852","0.47470072","0.4739341","0.47281387","0.4721971","0.47150603","0.47138777","0.4702968","0.46882844","0.46822202","0.46421072","0.4634084","0.46203968","0.461944","0.46060053","0.45792937","0.4571715","0.4571639","0.4571639","0.45469528","0.45454726","0.45404917","0.45351717","0.451245","0.45101288","0.4509398","0.44906962","0.4490482","0.44838572","0.4476807","0.4471594","0.4453592","0.44518858","0.44411528","0.4438467","0.4426418","0.442584","0.44257012","0.442402","0.4422271","0.44137225","0.44090497","0.44069698","0.44056538","0.4403256","0.44030204","0.44026834","0.44008622","0.43942708","0.43901485","0.43889314","0.43814692","0.43805602","0.43785024","0.43758053","0.43679386","0.43656138","0.43655872","0.43652698","0.4364545","0.43617874","0.43614548","0.43576837"],"string":"[\n \"0.6127793\",\n \"0.61027855\",\n \"0.6082101\",\n \"0.59283215\",\n \"0.5838112\",\n \"0.57578194\",\n \"0.5623196\",\n \"0.5599504\",\n \"0.55420876\",\n \"0.54633516\",\n \"0.5410154\",\n \"0.5350282\",\n \"0.5312561\",\n \"0.52844816\",\n \"0.52626956\",\n \"0.5179751\",\n \"0.5162937\",\n \"0.5137714\",\n \"0.5093342\",\n \"0.5058199\",\n \"0.5038663\",\n \"0.50160366\",\n \"0.50040245\",\n \"0.49906573\",\n \"0.49896732\",\n \"0.49162564\",\n \"0.49052754\",\n \"0.49019223\",\n \"0.48935536\",\n \"0.48931697\",\n \"0.48727843\",\n \"0.48642796\",\n \"0.48018897\",\n \"0.47898814\",\n \"0.47834474\",\n \"0.4782332\",\n \"0.47617364\",\n \"0.47612852\",\n \"0.47470072\",\n \"0.4739341\",\n \"0.47281387\",\n \"0.4721971\",\n \"0.47150603\",\n \"0.47138777\",\n \"0.4702968\",\n \"0.46882844\",\n \"0.46822202\",\n \"0.46421072\",\n \"0.4634084\",\n \"0.46203968\",\n \"0.461944\",\n \"0.46060053\",\n \"0.45792937\",\n \"0.4571715\",\n \"0.4571639\",\n \"0.4571639\",\n \"0.45469528\",\n \"0.45454726\",\n \"0.45404917\",\n \"0.45351717\",\n \"0.451245\",\n \"0.45101288\",\n \"0.4509398\",\n \"0.44906962\",\n \"0.4490482\",\n \"0.44838572\",\n \"0.4476807\",\n \"0.4471594\",\n \"0.4453592\",\n \"0.44518858\",\n \"0.44411528\",\n \"0.4438467\",\n \"0.4426418\",\n \"0.442584\",\n \"0.44257012\",\n \"0.442402\",\n \"0.4422271\",\n \"0.44137225\",\n \"0.44090497\",\n \"0.44069698\",\n \"0.44056538\",\n \"0.4403256\",\n \"0.44030204\",\n \"0.44026834\",\n \"0.44008622\",\n \"0.43942708\",\n \"0.43901485\",\n \"0.43889314\",\n \"0.43814692\",\n \"0.43805602\",\n \"0.43785024\",\n \"0.43758053\",\n \"0.43679386\",\n \"0.43656138\",\n \"0.43655872\",\n \"0.43652698\",\n \"0.4364545\",\n \"0.43617874\",\n \"0.43614548\",\n \"0.43576837\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62990654"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19883,"cells":{"query":{"kind":"string","value":"returns mv1[0,]mv2[0,]; they should be dimensioned alike. Attributes will be fixed up where I know how."},"document":{"kind":"string","value":"def aminusb0( mv1, mv2 ):\n mv = mv1[0,] - mv2[0,]\n if hasattr(mv,'long_name'):\n if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name\n mv.long_name = ''\n return mv"},"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 _gu_matvec(x1, x2):\n return (x1 @ x2[..., np.newaxis])[..., 0]","def get_molecular_matrix_and_vector(single_body, two_body):\n x, y = single_body.shape\n func = np.vectorize(round_custom)\n _new_dim = x * y\n single_one_dim = func(single_body.reshape(_new_dim, 1))\n two_body_two_dim = func(two_body.reshape(_new_dim, _new_dim))\n\n return single_one_dim, two_body_two_dim","def _match_dims(poly1, poly2, copy=None):\r\n if copy is None:\r\n copy = True\r\n\r\n if copy:\r\n p1 = deepcopy(poly1)\r\n p2 = deepcopy(poly2)\r\n else:\r\n p1 = poly1\r\n p2 = poly2\r\n\r\n dim1 = poly1.multi_index.spatial_dimension\r\n dim2 = poly2.multi_index.spatial_dimension\r\n if dim1 >= dim2:\r\n poly2.expand_dim(dim1)\r\n else:\r\n poly1.expand_dim(dim2)\r\n return poly1, poly2","def match_dimension(p0, p1):\n\n\tif p0.shape != p1.shape:\n\t\tnxmax = max(p0.shape[0], p1.shape[0])\n\t\tnymax = max(p0.shape[1], p1.shape[1])\n\n\t\tp0 = pad_edge_to_shape(p0, int(nxmax), int(nymax))\n\t\tp1 = pad_edge_to_shape(p1, int(nxmax), int(nymax))\n\n\treturn p0, p1","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def Mxform(x1,y1,x2,y2):\n return Jones.toMueller([[np.dot(x2,x1), np.dot(x2, y1)], [np.dot(y2,x1), np.dot(y2,y1)]])","def get_m2(self):\n pass","def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb","def Rt(X):\n return X[:2,:2], X[:2, 2]","def computemeta(src, dst):\n srcy, srcx = src\n canvasx, canvasy = srcx.start, srcy.start\n width, height = srcx.stop - srcx.start, srcy.stop - srcy.start\n posy, posx = dst\n return [posx, posy, width, height, canvasx, canvasy]","def reshape(self):\n qx = self.tunx[1:].reshape(self.nsigma, self.nangles)\n qy = self.tuny[1:].reshape(self.nsigma, self.nangles)\n return qx, qy","def _mps_AA(self, A1, A2):\n Dl, d1, _ = A1.shape\n _, d2, Dr = A2.shape\n return np.reshape(np.tensordot(A1, A2, axes=(2, 0)), [Dl, d1 * d2, Dr])","def v1Mv2(v1, M, v2):\r\n return v1[:, None] * M * v2[None, :]","def getDist(ind1,ind2,distMat):\n return distMat[ind1,ind2]","def pd(self, other):\n return Matriz([self]).T() * Matriz([other])","def mate(self, p1, p2):\n return (p1, p2)","def attributes_picker(index1, index2):\r\n # Adds indexes and + 1 for data types\r\n positions = {-1}\r\n positions.add(2 * index1)\r\n positions.add((2 * index1) + 1)\r\n positions.add(2 * index2)\r\n positions.add((2 * index2) + 1)\r\n return positions","def mult(m1, m2):\n assert np.shape(m1) == (2, 3)\n assert np.shape(m2) == (2, 3)\n\n m1_temp = np.vstack((m1, [0, 0, 1]))\n m2_temp = np.vstack((m2, [0, 0, 1]))\n result = m1_temp * m2_temp\n\n return result[:2, :]","def common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n axes3.append(common_axis( axes1[i], axes2[i] ))\n return axes3","def position(self):\n return self.atoms.reshape((1,-1))","def mainIndices(self):\n return self.i1, self.i2","def _addMats(X1,X2):\n _checkSize(X1,X2)\n return [ _addVectors(X1[i],X2[i]) for i in range(len(X1))]","def combine_M_X1_X2(M, X1, X2):\n Nm = M.shape[0]\n Nx1 = X1.shape[0]\n Nx2 = X2.shape[0]\n Nt = Nm + Nx1 + Nx2\n logging.debug(\"combine_M_X1_X2: The total number of agents in the network are:\" + str(Nt))\n W = np.zeros([Nt, Nt], dtype=int)\n\n for i in range(0, Nm):\n for j in range(0, Nm):\n W[i][j] = M[i][j]\n\n x_x1 = 0\n y_x1 = 0\n for x in range(Nm, Nm + Nx1):\n for y in range(Nm, Nm + Nx1):\n W[x][y] = X1[x_x1][y_x1]\n y_x1 = y_x1 + 1\n y_x1 = 0\n x_x1 = x_x1 + 1\n\n x_x2 = 0\n y_x2 = 0\n for x in range(Nm + Nx1, Nt):\n for y in range(Nm + Nx1, Nt):\n W[x][y] = X2[x_x2][y_x2]\n y_x2 = y_x2 + 1\n y_x2 = 0\n x_x2 = x_x2 + 1\n\n return W","def _broadcast(self, v1, v2):\n v1, v2 = np.array(v1), np.array(v2)\n if len(v1.shape) < len(v2.shape):\n idx = tuple(slice(None) for i in range(len(v1.shape)))\n idx = idx + (None,) * (len(v2.shape) - len(v1.shape))\n return v1[idx], v2\n elif len(v1.shape) > len(v2.shape):\n idx = tuple(slice(None) for i in range(len(v2.shape)))\n idx = idx + (None,) * (len(v1.shape) - len(v2.shape))\n return v1, v2[idx]\n else:\n return v1, v2","def cross_link_attribute(self, attribute_name, node_list1, node_list2):\n W = self.link_attribute(attribute_name)\n return W[node_list1, :][:, node_list2]","def test_populator_alternate_attribute():\n o1, o2 = MediaBag(iid=1), MediaBag(iid=2)\n with build_multi_get(2) as multi_get:\n media.build_populator('iid', multi_get)([o1, o2])\n assert (o1.media, o2.media) == (1, 2)","def classical(m1,m2):\n \n n = m1.shape\n result = np.zeros(n, dtype = int)\n\n for i in range(n[0]):\n for j in range(n[0]):\n for k in range(n[0]):\n result[i][j] += m1[i][k] * m2[k][j]\n return result","def _reverse_numeric_op(self, other, attr_name):\n l = reshape_append_ones(self, other)\n return getattr(numpy.ndarray, attr_name)(l[0], l[1])","def single_crossover(self, original1, original2):\n point=self.r.uniform(0.1,0.6)\n cut1=int(point*len(original1))\n cut2=int(point*len(original2))\n child1=original1[:cut1]+original2[cut2:]\n child2=original2[:cut2]+original1[cut1:]\n return child1, child2","def nm2m(self):\n return self._nm2m","def getattrs(self, attrlist):\n\t\treturn np.array([getattr(self, attr) for attr in attrlist])","def basic_sub(mv1, mv2):\n obj = expand(mv1.obj - mv2.obj)\n return MV(obj)","def adjoint(self) -> 'MultiVector':\n # The multivector created by reversing all multiplications\n return self._newMV(self.layout.adjoint_func(self.value))","def _numeric_op(self, other, attr_name):\n l = reshape_append_ones(self, other)\n return getattr(numpy.ndarray, attr_name)(l[0], l[1])","def mult(diagram1, diagram2):\n raise NotImplementedError","def __mul__(self, other):\n if hasattr(other, 'as_homogenous_transformation'):\n return basis(homogenous_transformation = self.as_homogenous_transformation() * other.as_homogenous_transformation())\n elif hasattr(other, 'n'):\n if other.n == (3,1):\n b = matrix.col((other[0], other[1], other[2], 1))\n elif other.n == (4,1):\n b = other\n else:\n raise TypeError(b, \"Incompatible matrices\")\n p = self.as_homogenous_transformation() * b\n if other.n == (3,1):\n return matrix.col(p[0:3])\n else:\n return p\n else:\n raise TypeError(b)","def merge_mps_tensor_pair(A0: np.ndarray, A1: np.ndarray) -> np.ndarray:\n A = np.einsum(A0, (0, 2, 3), A1, (1, 3, 4), (0, 1, 2, 4), optimize=True)\n # combine original physical dimensions\n A = A.reshape((A.shape[0]*A.shape[1], A.shape[2], A.shape[3]))\n return A","def __getitem__(self, index):\n img, target = self.data[index], self.targets[index]\n\n return img, target","def numpy_IoU_xyctrs(bb1, bb2):\n\n # There should be at least one anchor, but maybe more. \n # If the number of dimensions is only 1 (so it's just\n # one anchor), reshape the array to allow the slicing\n # to work properly:\n \n if bb1.ndim == 1:\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\n if bb2.ndim == 1:\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\n\n # Now, n1 and n2 can represent the number of anchors:\n n_1 = bb1.shape[0]\n n_2 = bb2.shape[0]\n\n # Want the IoU for every bb1 to every bb2, so tile them into\n # long 1D arrays to allow slicing:\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\n bb2_arr = np.tile(bb2, [n_1, 1])\n\n\n x1 = np.max((bb1_arr[:,0] - 0.5*bb1_arr[:,2], \n bb2_arr[:,0] - 0.5*bb2_arr[:,2]),\n axis=0)\n y1 = np.max((bb1_arr[:,1] - 0.5*bb1_arr[:,3], \n bb2_arr[:,1] - 0.5*bb2_arr[:,3]),\n axis=0)\n x2 = np.min((bb1_arr[:,0] + 0.5*bb1_arr[:,2], \n bb2_arr[:,0] + 0.5*bb2_arr[:,2]),\n axis=0)\n y2 = np.min((bb1_arr[:,1] + 0.5*bb1_arr[:,3], \n bb2_arr[:,1] + 0.5*bb2_arr[:,3]),\n axis=0)\n\n w = x2 - x1\n h = y2 - y1\n\n inter = w*h\n\n aarea = (bb1_arr[:,3])* (bb1_arr[:,2])\n barea = (bb2_arr[:,3])* (bb2_arr[:,2])\n\n denom = aarea + barea - inter\n mask = (denom == 0)\n denom[mask] = 0.1\n\n IoU = inter / (denom)\n IoU[mask] = 0\n IoU[w <= 0] = 0\n IoU[h <= 0] = 0\n \n return np.squeeze(np.reshape(IoU, (n_1,n_2)))","def match_dimensions(A, B, dims):\n dsa = A.datashape.copy()\n dsb = B.datashape.copy()\n dsa.dim_low = list(dsa.dim_low)\n dsb.dim_low = list(dsb.dim_low)\n dsa.dim_high = list(dsa.dim_high)\n dsb.dim_high = list(dsb.dim_high)\n\n for i, j in dims:\n low = min(dsa.dim_low[i], dsb.dim_low[j])\n high = max(dsa.dim_high[i], dsb.dim_high[j])\n\n dsa.dim_low[i] = low\n dsa.dim_high[i] = high\n dsb.dim_low[j] = low\n dsb.dim_high[j] = high\n\n if dsa != A.datashape:\n A = A.redimension(dsa.schema)\n if dsb != B.datashape:\n B = B.redimension(dsb.schema)\n\n return A, B","def reflect(self, other):\n x1, y1 = self\n x2, y2 = other\n L = (x2 * x2 + y2 * y2)\n if L > pygonal.EPSILON2:\n temp = 2 * (x1 * x2 + y1 * y2) / L\n return tuple.__new__(Vec2, (x2 * temp - x1, y2 * temp - y1))\n else:\n return null","def _get_matrix(self, source_points, destination_points):\n return [\n [self.measure_between_two_points(point_a, point_b) for point_b in destination_points]\n for point_a in source_points\n ]","def test_mueller_product(self, ):\n mdims = ('mueller_v', 'mueller_h')\n mm_1 = xr.DataArray(np.random.rand(4, 4, ), dims=mdims, )\n mm_2 = xr.DataArray(np.identity(4, ), dims=mdims, )\n sv_1 = xr.DataArray(np.random.rand(4, ), dims=('stokes', ), )\n\n assert_almost_equal(mm_1.values, mueller_product(mm_1, mm_2).values, )\n assert_almost_equal(mm_1.values, mueller_product(mm_2, mm_1).values, )\n assert_almost_equal(sv_1.values, mueller_product(mm_2, sv_1).data, )","def transform(tvec1, rvec1, tvec2, rvec2):\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\n tvec3 = []\n for tvec in tvec1:\n #tvec = tvec.squeeze()\n tvec3.append(np.matmul(op, tvec))\n tvec3 = np.array(tvec3)\n return tvec3","def getTwoNodes(self):\n\t\tnode0 = self\n\t\tif(self.trMtrxNode_ind > 0):\n\t\t\tnode0 = self.trMatricesController.getNode(0)\n\t\tnode1 = self.trMatricesController.getNode(self.trMtrxNode_ind)\n\t\treturn (node0,node1)","def indices ( self, x1, y1, z1, x2, y2, z2 ):\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]","def test_separate_ims():\n\n df1, df2 = setup()\n\n # Test 1\n im = separate_ims(df1)\n size = df1['imdims'][0]\n assert im.size == (size[0]*2, size[1])\n\n # Test 2\n im = separate_ims(df2)\n size = df2['imdims'][0]\n assert im.size == (size[0], size[1])","def matrix(self, v1, v2, lengths):\n M = [[self.covariance(i, j, lengths) for j in v2] for i in v1]\n return array(M)","def __getitem__(self, index):\n x = self._input_data[index]\n if self._output_data is None:\n return x, x\n else:\n y = self._output_data[index]\n return x, y","def __mul__(self, other):\n return Vec2d(self.v[0] * other, self.v[1] * other)","def two_dim(a: cython.double[:,:]):\n a[0,0] *= 3\n return a[0,0], a[0,1], a.ndim","def Mxy(self):\n return self.Mx.My","def cross_over(ind1, ind2):\n \n network1 = ind1.network\n network2 = ind2.network\n \n size = min(len(network1.index), len(network2.index))\n cx = random.randint(1, size - 1)\n \n temp = network1.copy()\n temp.iloc[:cx,:cx] = network2.iloc[:cx,:cx]\n network2.iloc[:cx,:cx] = network1.iloc[:cx,:cx]\n network1 = temp \n \n ind1.network = network1\n ind2.network = network2\n ind1.age = 1\n ind2.age = 1\n \n return ind1, ind2","def _attributes(self, ext1, ext2):\n errorlist = []\n for attr in ['data', 'mask', 'variance', 'OBJMASK', 'OBJCAT']:\n attr1 = getattr(ext1, attr, None)\n attr2 = getattr(ext2, attr, None)\n if (attr1 is None) ^ (attr2 is None):\n errorlist.append(f'Attribute error for {attr}: '\n f'{attr1 is not None} v {attr2 is not None}')\n elif attr1 is not None:\n if isinstance(attr1, Table):\n if len(attr1) != len(attr2):\n errorlist.append(f'attr lengths differ: '\n f'{len(attr1)} v {len(attr2)}')\n else: # everything else is pixel-like\n if attr1.dtype.name != attr2.dtype.name:\n errorlist.append(f'Datatype mismatch for {attr}: '\n f'{attr1.dtype} v {attr2.dtype}')\n if attr1.shape != attr2.shape:\n errorlist.append(f'Shape mismatch for {attr}: '\n f'{attr1.shape} v {attr2.shape}')\n if 'int' in attr1.dtype.name:\n try:\n assert_most_equal(attr1, attr2, max_miss=self.max_miss)\n except AssertionError as e:\n errorlist.append(f'Inequality for {attr}: '+str(e))\n else:\n try:\n assert_most_close(attr1, attr2, max_miss=self.max_miss,\n rtol=self.rtol, atol=self.atol)\n except AssertionError as e:\n errorlist.append(f'Mismatch for {attr}: '+str(e))\n return errorlist","def alignPairShapes(s1,s2,weights):\n\n\n s1=np.asarray(s1)\n s2=np.asarray(s2)\n \n x1k=s1[:,0]\n y1k=s1[:,1]\n x2k=s2[:,0]\n y2k=s2[:,1]\n\n X1=sum(x1k*weights) \n X2=sum(x2k*weights)\n\n Y1=sum(y1k*weights)\n Y2=sum(y2k*weights)\n\n Z=sum(weights*(pow(x2k,2)+pow(y2k,2)))\n\n W=sum(weights)\n\n C1=sum(weights*(x1k*x2k+y1k*y2k))\n\n C2=sum(weights*(y1k*x2k-x1k*y2k))\n \n a=np.asarray([[X2,-Y2,W,0],[Y2,X2,0,W],[Z,0,X2,Y2],[0,Z,-Y2,X2]])\n b=np.asarray([X1,Y1,C1,C2])\n\n x=np.linalg.solve(a,b)\n\n ax=x[0]\n ay=x[1]\n tx=x[2]\n ty=x[3]\n return ax,ay,tx,ty","def __sub__(self, m):\n nv=Matrice()\n if self.__mm_type(m):\n ls=len(self)\n nv.generate(ls,self.desc())\n for i in self.desc():\n for j in range(len(self)):\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\n return nv","def np_elementwise(matx1, matx2):\n return matx1 + matx2, matx1 - matx2, matx1 * matx2, matx1 / matx2","def distance_mentions(m_i, m_j):\n return abs(m_i.id - m_j.id)","def associate(x, y):\n x = torch.cat([x[1:], x])\n xx, yy = x.reshape(1,1,-1), y.flip(0).reshape(1,1,-1)\n zz = torch.nn.functional.conv1d(xx, yy)\n z = zz.reshape(-1)\n return normalize(z)","def rdims2(tdim2):\n transformations = {}\n for index in itertools.product(*map(range, tdim2.shape)):\n key = f'{tdim2.name}[{\",\".join(map(str, index))}]'\n transformations[key] = ReshapedDimension(\n transformer=View(tdim2.shape, index, tdim2.type),\n original_dimension=tdim2,\n name=key,\n index=1,\n )\n\n return transformations","def get_params2D(ima, xform = \"xform.align2d\"):\n\tt = ima.get_attr(xform)\n\td = t.get_params(\"2D\")\n\treturn d[\"alpha\"],d[\"tx\"],d[\"ty\"],d[\"mirror\"],d[\"scale\"]","def morphPointSet(v_1, v_2, warp_frac):\n v = []\n for y in range(len(v_1)):\n v.append([(v_1[y][0] * (1 - warp_frac) + v_2[y][0] * warp_frac) , (v_1[y][1] * (1 - warp_frac) + v_2[y][1] * warp_frac)])\n return ginput_to_array(v)","def twod_shape_2_homogeneous_matrix(twod_shape): \n homogenous_4d_array =[] \n for i in range(0, len(twod_shape), 2): \n new_x = twod_shape[ i] \n new_y = twod_shape[ i + 1] \n new_z = 0.0 \n new_w = 1 \n new_vertex = [new_x, new_y, new_z, new_w] \n homogenous_4d_array.append(new_vertex) \n homogenous_4d_mat = numpy.matrix(homogenous_4d_array) \n return homogenous_4d_mat","def anticommutator(self, other) -> 'MultiVector':\n\n return ((self * other) + (other * self)) / 2","def m2(self):\n return self.mass[1]","def reflection ((x,y),(w,z)):\n twodot = 2*dotprod((x,y),(w,z))\n a, b = x - twodot* w, y - twodot*z\n return (a,b)","def element(pepx, occ):\n if not isinstance(occ,np.ndarray): occ = np.array(occ) \n L1, L2 = occ.shape\n\n mats = np.array( occ.shape )\n \n if len(occ[0]==2):\n for ind in np.ndindex(occ):\n mats[ind] = pepx[ind][:,:,:,:,occ[ind][0],occ[ind][1]]\n else:\n for ind in np.ndindex(occ):\n mats[ind] = pepx[ind][:,:,:,:,occ[ind]]\n \n return penv0.contract(mats)","def getAttributes(self):\n spacing = self.getGridSpacing()\n pan_x = self.pan_pos.x()\n pan_y = self.pan_pos.y()\n\n num_columns = int((self.zoom_factor / spacing) * self.aspect_ratio) + 2\n num_rows = int((self.zoom_factor / spacing)) + 2\n\n # get camera offset (returns pan pos to integer)\n x_offset = pan_x % spacing\n y_offset = pan_y % spacing\n\n return num_columns, num_rows, pan_x, pan_y, x_offset, y_offset, spacing","def __sub__(self, other):\n # \n # TODO - your code here\n #\n result = [];\n for i in range(self.h):\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\n \n return Matrix(result);","def __getitem__(self, idx):\n return self.transform(self.X[idx]), self.y[idx]","def subsystem(self, rows, columns):\n x = self.__s2m__(rows,0)\n y = self.__s2m__(columns,1)\n target = numpy.ix_(x,y)\n return self.foreach(\n lambda k,v: (k, v[target]),\n dimensions = self.dims,\n shape = (len(x), len(y)),\n )","def combine_params2(alpha1, sx1, sy1, mirror1, alpha2, sx2, sy2, mirror2):\n\n\tt1 = Transform({\"type\":\"2D\",\"alpha\":alpha1,\"tx\":sx1,\"ty\":sy1,\"mirror\":mirror1,\"scale\":1.0})\n\tt2 = Transform({\"type\":\"2D\",\"alpha\":alpha2,\"tx\":sx2,\"ty\":sy2,\"mirror\":mirror2,\"scale\":1.0})\n\ttt = t2*t1\n\td = tt.get_params(\"2D\")\n\treturn d[ \"alpha\" ], d[ \"tx\" ], d[ \"ty\" ], d[ \"mirror\" ]","def origins_and_displacements(self):\n origin0 = self.nodes[0]\n disp0 = self.nodes[1] - self.nodes[0]\n origin1 = self.nodes[1]\n disp1 = self.nodes[0] - self.nodes[0]\n return origin0, disp0, origin1, disp1","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 get_dim_attribute(self,attr):\n return [getattr(getattr(self,name),attr) for name in self._dimensions]","def transform2h(self, x, y, m):\n A = torch.matmul(m, torch.stack([x, y, torch.ones(len(x))]))\n xt = A[0, :] / A[2, :]\n yt = A[1, :] / A[2, :]\n return xt, yt","def get_molecular_matrix(single_body, two_body):\n x, y = single_body.shape\n func = np.vectorize(round_custom)\n _new_dim = x * y\n single_one_dim = single_body.reshape(_new_dim, 1)\n two_body_two_dim = func(two_body.reshape(_new_dim, _new_dim))\n idx = 0\n x, _ = two_body_two_dim.shape\n while idx < x:\n two_body_two_dim[idx][idx] = round_custom(single_one_dim[idx][0])\n idx += 1\n return two_body_two_dim","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def get_bar_vector(model, elem, node1, node2, xyz1):\n cd1 = node1.Cd()\n cd2 = node2.Cd()\n if model is None:\n cd1_ref = node1.cd_ref\n cd2_ref = node2.cd_ref\n\n # get the vector v, which defines the projection on to the elemental\n # coordinate frame\n if elem.g0:\n #msg = 'which is required by %s eid=%s\\n%s' % (elem.type, elem.g0, str(elem))\n g0_ref = elem.g0_ref\n n0 = g0_ref.get_position()\n v = n0 - xyz1\n else:\n v = cd1_ref.transform_node_to_global(elem.x)\n\n else:\n msg = ', which is required by %s=%s' % (elem.type, elem.eid)\n cd1_ref = model.Coord(cd1)\n cd2_ref = model.Coord(cd2)\n\n # get the vector v, which defines the projection on to the elemental\n # coordinate frame\n if elem.g0:\n #msg = 'which is required by %s eid=%s\\n%s' % (elem.type, elem.g0, str(elem))\n g0_ref = model.Node(elem.g0, msg=msg)\n n0 = g0_ref.get_position()\n v = n0 - xyz1\n else:\n v = cd1_ref.transform_node_to_global(elem.x)\n cd1_ref = model.Coord(cd1)\n cd2_ref = model.Coord(cd2)\n\n return v, cd1, cd1_ref, cd2, cd2_ref","def match_attribute_names(*arrays):\n rep = arrays[0].sdbtype.full_rep\n result = [arrays[0]]\n for a in arrays[1:]:\n renames = []\n reserved = list(a.att_names) # reserved att names\n for r in a.sdbtype.full_rep:\n nm = r[0]\n if _att_match(rep, r):\n reserved.append(nm)\n continue\n newname = _find_rename(rep, r, reserved)\n if newname is None:\n raise ValueError(\"Cannot rename %s in %s\" % (nm, a))\n renames.extend((nm, newname))\n reserved.append(newname)\n if renames:\n a = a.attribute_rename(a, *renames)\n result.append(a)\n return tuple(result)","def multiplicities(self):\n return self.nk, self.zk","def __init__(self, emb1, emb2, normalize=False):\r\n self.dim = emb1.dim\r\n \r\n vocab1 = emb1.wi.viewkeys()\r\n vocab2 = emb2.wi.viewkeys()\r\n joint_vocab = list(vocab1 & vocab2)\r\n only_vocab1 = list(vocab1 - vocab2)\r\n only_vocab2 = list(vocab2 - vocab1)\r\n self.iw = joint_vocab + only_vocab1 + only_vocab2\r\n self.wi = dict([(w, i) for i, w in enumerate(self.iw)])\r\n\r\n m_joint = emb1.m[[emb1.wi[w] for w in joint_vocab]] + emb2.m[[emb2.wi[w] for w in joint_vocab]]\r\n m_only1 = emb1.m[[emb1.wi[w] for w in only_vocab1]]\r\n m_only2 = emb2.m[[emb2.wi[w] for w in only_vocab2]]\r\n self.m = np.vstack([m_joint, m_only1, m_only2])\r\n \r\n if normalize:\r\n self.normalize()","def p2(self):\n return tuple(self.rect[2:])","def _get_compose_dims(self, other, qargs, front):\n if front:\n output_dims = self._output_dims\n if qargs is None:\n if other._output_dim != self._input_dim:\n raise QiskitError(\n \"Other operator combined output dimension ({}) does not\"\n \" match current combined input dimension ({}).\".format(\n other._output_dim, self._input_dim))\n input_dims = other._input_dims\n else:\n if other._output_dims != self.input_dims(qargs):\n raise QiskitError(\n \"Other operator output dimensions ({}) does not\"\n \" match current subsystem input dimensions ({}).\".format(\n other._output_dims, self.input_dims(qargs)))\n input_dims = list(self._input_dims)\n for i, qubit in enumerate(qargs):\n input_dims[qubit] = other._input_dims[i]\n else:\n input_dims = self._input_dims\n if qargs is None:\n if self._output_dim != other._input_dim:\n raise QiskitError(\n \"Other operator combined input dimension ({}) does not\"\n \" match current combined output dimension ({}).\".format(\n other._input_dim, self._output_dim))\n output_dims = other._output_dims\n else:\n if self.output_dims(qargs) != other._input_dims:\n raise QiskitError(\n \"Other operator input dimensions ({}) does not\"\n \" match current subsystem output dimension ({}).\".format(\n other._input_dims, self.output_dims(qargs)))\n output_dims = list(self._output_dims)\n for i, qubit in enumerate(qargs):\n output_dims[qubit] = other._output_dims[i]\n return input_dims, output_dims","def dist_matrix(self, group1, group2):\n \n tmps = []\n for i in group2:\n tmps.append([])\n for j in group1:\n mi, label = self.distance(i, j)\n tmps[-1].append(mi)\n return tmps","def __getitem__(self, idx):\n x = self.all_transforms(self.data[idx])\n y = self.labels[idx]\n return x, y","def _create_input_grid(self, x1, x2):\n return x1.unsqueeze(-2), x2.unsqueeze(-3)","def get_M2(M1, num_sys=1):\n return M1*uniform(size=num_sys)","def __getitem__(self, index):\n\n source = self.data[\"noisy_images\"][index,:,:]\n target = self.data[\"clean_images\"][index,:,:]\n\n source = torch.from_numpy(source.reshape(1,source.shape[0],source.shape[1])).cuda()\n target = torch.from_numpy(target.reshape(1,target.shape[0],target.shape[1])).cuda()\n \n if self.args.loss_function == 'MSE_Affine' or self.args.loss_function == 'N2V':\n target = torch.cat([source,target], dim = 0)\n\n return source, target","def align(self):\n features = np.load(self.cur_dir+'/'+'spec.npy', allow_pickle=True)\n targets = np.load(self.cur_dir+'/'+'target.npy', allow_pickle=True)\n \n feat_num_frames = features.shape[0]\n targ_num_frames = targets.shape[0]\n \n if feat_num_frames != targ_num_frames:\n diff = feat_num_frames - targ_num_frames\n if diff < 0:\n targets = targets[:feat_num_frames, :]\n else:\n features = features[:targ_num_frames:, :]\n \n return features.shape, targets.shape","def __getitem__(self, item):\n if item not in self.complex_mols:\n complex_mol = rdkit.Chem.rdmolops.CombineMols(self.protein_mols[item],self.ligand_mols[item] )\n self.complex_mols[item]=complex_mol\n\n return item, self.protein_mols[item], self.ligand_mols[item], \\\n self.complex_mols[item], self.labels[item]","def add_matrices(m1, m2):\n\t\n\t\n\treturn [[a+b for a, b in izip(m1, m2)] for m1, m2 in izip(m1, m2)]","def map(self, other: \"Vector\") -> \"Vector\":\n return self.__class__(*(self[i] * other[i] for i in range(len(self))))","def displacement(cls, v1, v2):\n return np.array([v2 - v1])","def __rmul__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.gmt_func(other.value, self.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other*obj\n newValue = other*self.value\n\n return self._newMV(newValue)","def _preprocessing_(self, x: np.array, m: np.array) -> (np.array, np.array):\n #normalization\n x = _normalize_(x)\n\n if not self.testing:\n x, m = self._rotate_(x, m)\n x, m = self._width_shift_(x, m)\n x, m = self._height_shift_(x, m)\n\n x = _expand_dims_(x)\n return x, m","def get_m1(self):\n\n pass","def __mul__(self,other):\n if type(other) is Vector:\n return(self.x*other.x + self.y*other.y + self.z*other.z)\n else:\n return(Vector(self.x*other,self.y*other,self.z*other))","def copy_dim(nc1, nc2, name, direction):\n if (name == direction):\n return\n dim1 = nc1.dimensions[name]\n dim2 = nc2.createDimension(name, len(dim1))"],"string":"[\n \"def _gu_matvec(x1, x2):\\n return (x1 @ x2[..., np.newaxis])[..., 0]\",\n \"def get_molecular_matrix_and_vector(single_body, two_body):\\n x, y = single_body.shape\\n func = np.vectorize(round_custom)\\n _new_dim = x * y\\n single_one_dim = func(single_body.reshape(_new_dim, 1))\\n two_body_two_dim = func(two_body.reshape(_new_dim, _new_dim))\\n\\n return single_one_dim, two_body_two_dim\",\n \"def _match_dims(poly1, poly2, copy=None):\\r\\n if copy is None:\\r\\n copy = True\\r\\n\\r\\n if copy:\\r\\n p1 = deepcopy(poly1)\\r\\n p2 = deepcopy(poly2)\\r\\n else:\\r\\n p1 = poly1\\r\\n p2 = poly2\\r\\n\\r\\n dim1 = poly1.multi_index.spatial_dimension\\r\\n dim2 = poly2.multi_index.spatial_dimension\\r\\n if dim1 >= dim2:\\r\\n poly2.expand_dim(dim1)\\r\\n else:\\r\\n poly1.expand_dim(dim2)\\r\\n return poly1, poly2\",\n \"def match_dimension(p0, p1):\\n\\n\\tif p0.shape != p1.shape:\\n\\t\\tnxmax = max(p0.shape[0], p1.shape[0])\\n\\t\\tnymax = max(p0.shape[1], p1.shape[1])\\n\\n\\t\\tp0 = pad_edge_to_shape(p0, int(nxmax), int(nymax))\\n\\t\\tp1 = pad_edge_to_shape(p1, int(nxmax), int(nymax))\\n\\n\\treturn p0, p1\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def Mxform(x1,y1,x2,y2):\\n return Jones.toMueller([[np.dot(x2,x1), np.dot(x2, y1)], [np.dot(y2,x1), np.dot(y2,y1)]])\",\n \"def get_m2(self):\\n pass\",\n \"def aminusb_1ax( mv1, mv2 ):\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARNING: aminusb_1ax1 is subtracting variables with different units!\\\",mv1,mv1\\n if mv1 is None or mv2 is None: return None\\n missing = mv1.get_fill_value()\\n axis1 = allAxes(mv1)[0]\\n axis2 = allAxes(mv2)[0]\\n if len(axis1)<=len(axis2):\\n a = mv1\\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\\n else:\\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\\n b = mv2\\n aminusb = a - b\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def Rt(X):\\n return X[:2,:2], X[:2, 2]\",\n \"def computemeta(src, dst):\\n srcy, srcx = src\\n canvasx, canvasy = srcx.start, srcy.start\\n width, height = srcx.stop - srcx.start, srcy.stop - srcy.start\\n posy, posx = dst\\n return [posx, posy, width, height, canvasx, canvasy]\",\n \"def reshape(self):\\n qx = self.tunx[1:].reshape(self.nsigma, self.nangles)\\n qy = self.tuny[1:].reshape(self.nsigma, self.nangles)\\n return qx, qy\",\n \"def _mps_AA(self, A1, A2):\\n Dl, d1, _ = A1.shape\\n _, d2, Dr = A2.shape\\n return np.reshape(np.tensordot(A1, A2, axes=(2, 0)), [Dl, d1 * d2, Dr])\",\n \"def v1Mv2(v1, M, v2):\\r\\n return v1[:, None] * M * v2[None, :]\",\n \"def getDist(ind1,ind2,distMat):\\n return distMat[ind1,ind2]\",\n \"def pd(self, other):\\n return Matriz([self]).T() * Matriz([other])\",\n \"def mate(self, p1, p2):\\n return (p1, p2)\",\n \"def attributes_picker(index1, index2):\\r\\n # Adds indexes and + 1 for data types\\r\\n positions = {-1}\\r\\n positions.add(2 * index1)\\r\\n positions.add((2 * index1) + 1)\\r\\n positions.add(2 * index2)\\r\\n positions.add((2 * index2) + 1)\\r\\n return positions\",\n \"def mult(m1, m2):\\n assert np.shape(m1) == (2, 3)\\n assert np.shape(m2) == (2, 3)\\n\\n m1_temp = np.vstack((m1, [0, 0, 1]))\\n m2_temp = np.vstack((m2, [0, 0, 1]))\\n result = m1_temp * m2_temp\\n\\n return result[:2, :]\",\n \"def common_axes( mv1, mv2 ):\\n axes1 = [a[0] for a in mv1.getDomain()]\\n axes2 = [a[0] for a in mv2.getDomain()]\\n if len(axes1)!=len(axes2):\\n print \\\"ERROR. common_axes requires same number of axes in\\\",mv1,\\\" and\\\",mv2\\n return None\\n axes3 = []\\n for i in range(len(axes1)):\\n axes3.append(common_axis( axes1[i], axes2[i] ))\\n return axes3\",\n \"def position(self):\\n return self.atoms.reshape((1,-1))\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def _addMats(X1,X2):\\n _checkSize(X1,X2)\\n return [ _addVectors(X1[i],X2[i]) for i in range(len(X1))]\",\n \"def combine_M_X1_X2(M, X1, X2):\\n Nm = M.shape[0]\\n Nx1 = X1.shape[0]\\n Nx2 = X2.shape[0]\\n Nt = Nm + Nx1 + Nx2\\n logging.debug(\\\"combine_M_X1_X2: The total number of agents in the network are:\\\" + str(Nt))\\n W = np.zeros([Nt, Nt], dtype=int)\\n\\n for i in range(0, Nm):\\n for j in range(0, Nm):\\n W[i][j] = M[i][j]\\n\\n x_x1 = 0\\n y_x1 = 0\\n for x in range(Nm, Nm + Nx1):\\n for y in range(Nm, Nm + Nx1):\\n W[x][y] = X1[x_x1][y_x1]\\n y_x1 = y_x1 + 1\\n y_x1 = 0\\n x_x1 = x_x1 + 1\\n\\n x_x2 = 0\\n y_x2 = 0\\n for x in range(Nm + Nx1, Nt):\\n for y in range(Nm + Nx1, Nt):\\n W[x][y] = X2[x_x2][y_x2]\\n y_x2 = y_x2 + 1\\n y_x2 = 0\\n x_x2 = x_x2 + 1\\n\\n return W\",\n \"def _broadcast(self, v1, v2):\\n v1, v2 = np.array(v1), np.array(v2)\\n if len(v1.shape) < len(v2.shape):\\n idx = tuple(slice(None) for i in range(len(v1.shape)))\\n idx = idx + (None,) * (len(v2.shape) - len(v1.shape))\\n return v1[idx], v2\\n elif len(v1.shape) > len(v2.shape):\\n idx = tuple(slice(None) for i in range(len(v2.shape)))\\n idx = idx + (None,) * (len(v1.shape) - len(v2.shape))\\n return v1, v2[idx]\\n else:\\n return v1, v2\",\n \"def cross_link_attribute(self, attribute_name, node_list1, node_list2):\\n W = self.link_attribute(attribute_name)\\n return W[node_list1, :][:, node_list2]\",\n \"def test_populator_alternate_attribute():\\n o1, o2 = MediaBag(iid=1), MediaBag(iid=2)\\n with build_multi_get(2) as multi_get:\\n media.build_populator('iid', multi_get)([o1, o2])\\n assert (o1.media, o2.media) == (1, 2)\",\n \"def classical(m1,m2):\\n \\n n = m1.shape\\n result = np.zeros(n, dtype = int)\\n\\n for i in range(n[0]):\\n for j in range(n[0]):\\n for k in range(n[0]):\\n result[i][j] += m1[i][k] * m2[k][j]\\n return result\",\n \"def _reverse_numeric_op(self, other, attr_name):\\n l = reshape_append_ones(self, other)\\n return getattr(numpy.ndarray, attr_name)(l[0], l[1])\",\n \"def single_crossover(self, original1, original2):\\n point=self.r.uniform(0.1,0.6)\\n cut1=int(point*len(original1))\\n cut2=int(point*len(original2))\\n child1=original1[:cut1]+original2[cut2:]\\n child2=original2[:cut2]+original1[cut1:]\\n return child1, child2\",\n \"def nm2m(self):\\n return self._nm2m\",\n \"def getattrs(self, attrlist):\\n\\t\\treturn np.array([getattr(self, attr) for attr in attrlist])\",\n \"def basic_sub(mv1, mv2):\\n obj = expand(mv1.obj - mv2.obj)\\n return MV(obj)\",\n \"def adjoint(self) -> 'MultiVector':\\n # The multivector created by reversing all multiplications\\n return self._newMV(self.layout.adjoint_func(self.value))\",\n \"def _numeric_op(self, other, attr_name):\\n l = reshape_append_ones(self, other)\\n return getattr(numpy.ndarray, attr_name)(l[0], l[1])\",\n \"def mult(diagram1, diagram2):\\n raise NotImplementedError\",\n \"def __mul__(self, other):\\n if hasattr(other, 'as_homogenous_transformation'):\\n return basis(homogenous_transformation = self.as_homogenous_transformation() * other.as_homogenous_transformation())\\n elif hasattr(other, 'n'):\\n if other.n == (3,1):\\n b = matrix.col((other[0], other[1], other[2], 1))\\n elif other.n == (4,1):\\n b = other\\n else:\\n raise TypeError(b, \\\"Incompatible matrices\\\")\\n p = self.as_homogenous_transformation() * b\\n if other.n == (3,1):\\n return matrix.col(p[0:3])\\n else:\\n return p\\n else:\\n raise TypeError(b)\",\n \"def merge_mps_tensor_pair(A0: np.ndarray, A1: np.ndarray) -> np.ndarray:\\n A = np.einsum(A0, (0, 2, 3), A1, (1, 3, 4), (0, 1, 2, 4), optimize=True)\\n # combine original physical dimensions\\n A = A.reshape((A.shape[0]*A.shape[1], A.shape[2], A.shape[3]))\\n return A\",\n \"def __getitem__(self, index):\\n img, target = self.data[index], self.targets[index]\\n\\n return img, target\",\n \"def numpy_IoU_xyctrs(bb1, bb2):\\n\\n # There should be at least one anchor, but maybe more. \\n # If the number of dimensions is only 1 (so it's just\\n # one anchor), reshape the array to allow the slicing\\n # to work properly:\\n \\n if bb1.ndim == 1:\\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\\n if bb2.ndim == 1:\\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\\n\\n # Now, n1 and n2 can represent the number of anchors:\\n n_1 = bb1.shape[0]\\n n_2 = bb2.shape[0]\\n\\n # Want the IoU for every bb1 to every bb2, so tile them into\\n # long 1D arrays to allow slicing:\\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\\n bb2_arr = np.tile(bb2, [n_1, 1])\\n\\n\\n x1 = np.max((bb1_arr[:,0] - 0.5*bb1_arr[:,2], \\n bb2_arr[:,0] - 0.5*bb2_arr[:,2]),\\n axis=0)\\n y1 = np.max((bb1_arr[:,1] - 0.5*bb1_arr[:,3], \\n bb2_arr[:,1] - 0.5*bb2_arr[:,3]),\\n axis=0)\\n x2 = np.min((bb1_arr[:,0] + 0.5*bb1_arr[:,2], \\n bb2_arr[:,0] + 0.5*bb2_arr[:,2]),\\n axis=0)\\n y2 = np.min((bb1_arr[:,1] + 0.5*bb1_arr[:,3], \\n bb2_arr[:,1] + 0.5*bb2_arr[:,3]),\\n axis=0)\\n\\n w = x2 - x1\\n h = y2 - y1\\n\\n inter = w*h\\n\\n aarea = (bb1_arr[:,3])* (bb1_arr[:,2])\\n barea = (bb2_arr[:,3])* (bb2_arr[:,2])\\n\\n denom = aarea + barea - inter\\n mask = (denom == 0)\\n denom[mask] = 0.1\\n\\n IoU = inter / (denom)\\n IoU[mask] = 0\\n IoU[w <= 0] = 0\\n IoU[h <= 0] = 0\\n \\n return np.squeeze(np.reshape(IoU, (n_1,n_2)))\",\n \"def match_dimensions(A, B, dims):\\n dsa = A.datashape.copy()\\n dsb = B.datashape.copy()\\n dsa.dim_low = list(dsa.dim_low)\\n dsb.dim_low = list(dsb.dim_low)\\n dsa.dim_high = list(dsa.dim_high)\\n dsb.dim_high = list(dsb.dim_high)\\n\\n for i, j in dims:\\n low = min(dsa.dim_low[i], dsb.dim_low[j])\\n high = max(dsa.dim_high[i], dsb.dim_high[j])\\n\\n dsa.dim_low[i] = low\\n dsa.dim_high[i] = high\\n dsb.dim_low[j] = low\\n dsb.dim_high[j] = high\\n\\n if dsa != A.datashape:\\n A = A.redimension(dsa.schema)\\n if dsb != B.datashape:\\n B = B.redimension(dsb.schema)\\n\\n return A, B\",\n \"def reflect(self, other):\\n x1, y1 = self\\n x2, y2 = other\\n L = (x2 * x2 + y2 * y2)\\n if L > pygonal.EPSILON2:\\n temp = 2 * (x1 * x2 + y1 * y2) / L\\n return tuple.__new__(Vec2, (x2 * temp - x1, y2 * temp - y1))\\n else:\\n return null\",\n \"def _get_matrix(self, source_points, destination_points):\\n return [\\n [self.measure_between_two_points(point_a, point_b) for point_b in destination_points]\\n for point_a in source_points\\n ]\",\n \"def test_mueller_product(self, ):\\n mdims = ('mueller_v', 'mueller_h')\\n mm_1 = xr.DataArray(np.random.rand(4, 4, ), dims=mdims, )\\n mm_2 = xr.DataArray(np.identity(4, ), dims=mdims, )\\n sv_1 = xr.DataArray(np.random.rand(4, ), dims=('stokes', ), )\\n\\n assert_almost_equal(mm_1.values, mueller_product(mm_1, mm_2).values, )\\n assert_almost_equal(mm_1.values, mueller_product(mm_2, mm_1).values, )\\n assert_almost_equal(sv_1.values, mueller_product(mm_2, sv_1).data, )\",\n \"def transform(tvec1, rvec1, tvec2, rvec2):\\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\\n tvec3 = []\\n for tvec in tvec1:\\n #tvec = tvec.squeeze()\\n tvec3.append(np.matmul(op, tvec))\\n tvec3 = np.array(tvec3)\\n return tvec3\",\n \"def getTwoNodes(self):\\n\\t\\tnode0 = self\\n\\t\\tif(self.trMtrxNode_ind > 0):\\n\\t\\t\\tnode0 = self.trMatricesController.getNode(0)\\n\\t\\tnode1 = self.trMatricesController.getNode(self.trMtrxNode_ind)\\n\\t\\treturn (node0,node1)\",\n \"def indices ( self, x1, y1, z1, x2, y2, z2 ):\\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]\",\n \"def test_separate_ims():\\n\\n df1, df2 = setup()\\n\\n # Test 1\\n im = separate_ims(df1)\\n size = df1['imdims'][0]\\n assert im.size == (size[0]*2, size[1])\\n\\n # Test 2\\n im = separate_ims(df2)\\n size = df2['imdims'][0]\\n assert im.size == (size[0], size[1])\",\n \"def matrix(self, v1, v2, lengths):\\n M = [[self.covariance(i, j, lengths) for j in v2] for i in v1]\\n return array(M)\",\n \"def __getitem__(self, index):\\n x = self._input_data[index]\\n if self._output_data is None:\\n return x, x\\n else:\\n y = self._output_data[index]\\n return x, y\",\n \"def __mul__(self, other):\\n return Vec2d(self.v[0] * other, self.v[1] * other)\",\n \"def two_dim(a: cython.double[:,:]):\\n a[0,0] *= 3\\n return a[0,0], a[0,1], a.ndim\",\n \"def Mxy(self):\\n return self.Mx.My\",\n \"def cross_over(ind1, ind2):\\n \\n network1 = ind1.network\\n network2 = ind2.network\\n \\n size = min(len(network1.index), len(network2.index))\\n cx = random.randint(1, size - 1)\\n \\n temp = network1.copy()\\n temp.iloc[:cx,:cx] = network2.iloc[:cx,:cx]\\n network2.iloc[:cx,:cx] = network1.iloc[:cx,:cx]\\n network1 = temp \\n \\n ind1.network = network1\\n ind2.network = network2\\n ind1.age = 1\\n ind2.age = 1\\n \\n return ind1, ind2\",\n \"def _attributes(self, ext1, ext2):\\n errorlist = []\\n for attr in ['data', 'mask', 'variance', 'OBJMASK', 'OBJCAT']:\\n attr1 = getattr(ext1, attr, None)\\n attr2 = getattr(ext2, attr, None)\\n if (attr1 is None) ^ (attr2 is None):\\n errorlist.append(f'Attribute error for {attr}: '\\n f'{attr1 is not None} v {attr2 is not None}')\\n elif attr1 is not None:\\n if isinstance(attr1, Table):\\n if len(attr1) != len(attr2):\\n errorlist.append(f'attr lengths differ: '\\n f'{len(attr1)} v {len(attr2)}')\\n else: # everything else is pixel-like\\n if attr1.dtype.name != attr2.dtype.name:\\n errorlist.append(f'Datatype mismatch for {attr}: '\\n f'{attr1.dtype} v {attr2.dtype}')\\n if attr1.shape != attr2.shape:\\n errorlist.append(f'Shape mismatch for {attr}: '\\n f'{attr1.shape} v {attr2.shape}')\\n if 'int' in attr1.dtype.name:\\n try:\\n assert_most_equal(attr1, attr2, max_miss=self.max_miss)\\n except AssertionError as e:\\n errorlist.append(f'Inequality for {attr}: '+str(e))\\n else:\\n try:\\n assert_most_close(attr1, attr2, max_miss=self.max_miss,\\n rtol=self.rtol, atol=self.atol)\\n except AssertionError as e:\\n errorlist.append(f'Mismatch for {attr}: '+str(e))\\n return errorlist\",\n \"def alignPairShapes(s1,s2,weights):\\n\\n\\n s1=np.asarray(s1)\\n s2=np.asarray(s2)\\n \\n x1k=s1[:,0]\\n y1k=s1[:,1]\\n x2k=s2[:,0]\\n y2k=s2[:,1]\\n\\n X1=sum(x1k*weights) \\n X2=sum(x2k*weights)\\n\\n Y1=sum(y1k*weights)\\n Y2=sum(y2k*weights)\\n\\n Z=sum(weights*(pow(x2k,2)+pow(y2k,2)))\\n\\n W=sum(weights)\\n\\n C1=sum(weights*(x1k*x2k+y1k*y2k))\\n\\n C2=sum(weights*(y1k*x2k-x1k*y2k))\\n \\n a=np.asarray([[X2,-Y2,W,0],[Y2,X2,0,W],[Z,0,X2,Y2],[0,Z,-Y2,X2]])\\n b=np.asarray([X1,Y1,C1,C2])\\n\\n x=np.linalg.solve(a,b)\\n\\n ax=x[0]\\n ay=x[1]\\n tx=x[2]\\n ty=x[3]\\n return ax,ay,tx,ty\",\n \"def __sub__(self, m):\\n nv=Matrice()\\n if self.__mm_type(m):\\n ls=len(self)\\n nv.generate(ls,self.desc())\\n for i in self.desc():\\n for j in range(len(self)):\\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\\n return nv\",\n \"def np_elementwise(matx1, matx2):\\n return matx1 + matx2, matx1 - matx2, matx1 * matx2, matx1 / matx2\",\n \"def distance_mentions(m_i, m_j):\\n return abs(m_i.id - m_j.id)\",\n \"def associate(x, y):\\n x = torch.cat([x[1:], x])\\n xx, yy = x.reshape(1,1,-1), y.flip(0).reshape(1,1,-1)\\n zz = torch.nn.functional.conv1d(xx, yy)\\n z = zz.reshape(-1)\\n return normalize(z)\",\n \"def rdims2(tdim2):\\n transformations = {}\\n for index in itertools.product(*map(range, tdim2.shape)):\\n key = f'{tdim2.name}[{\\\",\\\".join(map(str, index))}]'\\n transformations[key] = ReshapedDimension(\\n transformer=View(tdim2.shape, index, tdim2.type),\\n original_dimension=tdim2,\\n name=key,\\n index=1,\\n )\\n\\n return transformations\",\n \"def get_params2D(ima, xform = \\\"xform.align2d\\\"):\\n\\tt = ima.get_attr(xform)\\n\\td = t.get_params(\\\"2D\\\")\\n\\treturn d[\\\"alpha\\\"],d[\\\"tx\\\"],d[\\\"ty\\\"],d[\\\"mirror\\\"],d[\\\"scale\\\"]\",\n \"def morphPointSet(v_1, v_2, warp_frac):\\n v = []\\n for y in range(len(v_1)):\\n v.append([(v_1[y][0] * (1 - warp_frac) + v_2[y][0] * warp_frac) , (v_1[y][1] * (1 - warp_frac) + v_2[y][1] * warp_frac)])\\n return ginput_to_array(v)\",\n \"def twod_shape_2_homogeneous_matrix(twod_shape): \\n homogenous_4d_array =[] \\n for i in range(0, len(twod_shape), 2): \\n new_x = twod_shape[ i] \\n new_y = twod_shape[ i + 1] \\n new_z = 0.0 \\n new_w = 1 \\n new_vertex = [new_x, new_y, new_z, new_w] \\n homogenous_4d_array.append(new_vertex) \\n homogenous_4d_mat = numpy.matrix(homogenous_4d_array) \\n return homogenous_4d_mat\",\n \"def anticommutator(self, other) -> 'MultiVector':\\n\\n return ((self * other) + (other * self)) / 2\",\n \"def m2(self):\\n return self.mass[1]\",\n \"def reflection ((x,y),(w,z)):\\n twodot = 2*dotprod((x,y),(w,z))\\n a, b = x - twodot* w, y - twodot*z\\n return (a,b)\",\n \"def element(pepx, occ):\\n if not isinstance(occ,np.ndarray): occ = np.array(occ) \\n L1, L2 = occ.shape\\n\\n mats = np.array( occ.shape )\\n \\n if len(occ[0]==2):\\n for ind in np.ndindex(occ):\\n mats[ind] = pepx[ind][:,:,:,:,occ[ind][0],occ[ind][1]]\\n else:\\n for ind in np.ndindex(occ):\\n mats[ind] = pepx[ind][:,:,:,:,occ[ind]]\\n \\n return penv0.contract(mats)\",\n \"def getAttributes(self):\\n spacing = self.getGridSpacing()\\n pan_x = self.pan_pos.x()\\n pan_y = self.pan_pos.y()\\n\\n num_columns = int((self.zoom_factor / spacing) * self.aspect_ratio) + 2\\n num_rows = int((self.zoom_factor / spacing)) + 2\\n\\n # get camera offset (returns pan pos to integer)\\n x_offset = pan_x % spacing\\n y_offset = pan_y % spacing\\n\\n return num_columns, num_rows, pan_x, pan_y, x_offset, y_offset, spacing\",\n \"def __sub__(self, other):\\n # \\n # TODO - your code here\\n #\\n result = [];\\n for i in range(self.h):\\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\\n \\n return Matrix(result);\",\n \"def __getitem__(self, idx):\\n return self.transform(self.X[idx]), self.y[idx]\",\n \"def subsystem(self, rows, columns):\\n x = self.__s2m__(rows,0)\\n y = self.__s2m__(columns,1)\\n target = numpy.ix_(x,y)\\n return self.foreach(\\n lambda k,v: (k, v[target]),\\n dimensions = self.dims,\\n shape = (len(x), len(y)),\\n )\",\n \"def combine_params2(alpha1, sx1, sy1, mirror1, alpha2, sx2, sy2, mirror2):\\n\\n\\tt1 = Transform({\\\"type\\\":\\\"2D\\\",\\\"alpha\\\":alpha1,\\\"tx\\\":sx1,\\\"ty\\\":sy1,\\\"mirror\\\":mirror1,\\\"scale\\\":1.0})\\n\\tt2 = Transform({\\\"type\\\":\\\"2D\\\",\\\"alpha\\\":alpha2,\\\"tx\\\":sx2,\\\"ty\\\":sy2,\\\"mirror\\\":mirror2,\\\"scale\\\":1.0})\\n\\ttt = t2*t1\\n\\td = tt.get_params(\\\"2D\\\")\\n\\treturn d[ \\\"alpha\\\" ], d[ \\\"tx\\\" ], d[ \\\"ty\\\" ], d[ \\\"mirror\\\" ]\",\n \"def origins_and_displacements(self):\\n origin0 = self.nodes[0]\\n disp0 = self.nodes[1] - self.nodes[0]\\n origin1 = self.nodes[1]\\n disp1 = self.nodes[0] - self.nodes[0]\\n return origin0, disp0, origin1, disp1\",\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 get_dim_attribute(self,attr):\\n return [getattr(getattr(self,name),attr) for name in self._dimensions]\",\n \"def transform2h(self, x, y, m):\\n A = torch.matmul(m, torch.stack([x, y, torch.ones(len(x))]))\\n xt = A[0, :] / A[2, :]\\n yt = A[1, :] / A[2, :]\\n return xt, yt\",\n \"def get_molecular_matrix(single_body, two_body):\\n x, y = single_body.shape\\n func = np.vectorize(round_custom)\\n _new_dim = x * y\\n single_one_dim = single_body.reshape(_new_dim, 1)\\n two_body_two_dim = func(two_body.reshape(_new_dim, _new_dim))\\n idx = 0\\n x, _ = two_body_two_dim.shape\\n while idx < x:\\n two_body_two_dim[idx][idx] = round_custom(single_one_dim[idx][0])\\n idx += 1\\n return two_body_two_dim\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def get_bar_vector(model, elem, node1, node2, xyz1):\\n cd1 = node1.Cd()\\n cd2 = node2.Cd()\\n if model is None:\\n cd1_ref = node1.cd_ref\\n cd2_ref = node2.cd_ref\\n\\n # get the vector v, which defines the projection on to the elemental\\n # coordinate frame\\n if elem.g0:\\n #msg = 'which is required by %s eid=%s\\\\n%s' % (elem.type, elem.g0, str(elem))\\n g0_ref = elem.g0_ref\\n n0 = g0_ref.get_position()\\n v = n0 - xyz1\\n else:\\n v = cd1_ref.transform_node_to_global(elem.x)\\n\\n else:\\n msg = ', which is required by %s=%s' % (elem.type, elem.eid)\\n cd1_ref = model.Coord(cd1)\\n cd2_ref = model.Coord(cd2)\\n\\n # get the vector v, which defines the projection on to the elemental\\n # coordinate frame\\n if elem.g0:\\n #msg = 'which is required by %s eid=%s\\\\n%s' % (elem.type, elem.g0, str(elem))\\n g0_ref = model.Node(elem.g0, msg=msg)\\n n0 = g0_ref.get_position()\\n v = n0 - xyz1\\n else:\\n v = cd1_ref.transform_node_to_global(elem.x)\\n cd1_ref = model.Coord(cd1)\\n cd2_ref = model.Coord(cd2)\\n\\n return v, cd1, cd1_ref, cd2, cd2_ref\",\n \"def match_attribute_names(*arrays):\\n rep = arrays[0].sdbtype.full_rep\\n result = [arrays[0]]\\n for a in arrays[1:]:\\n renames = []\\n reserved = list(a.att_names) # reserved att names\\n for r in a.sdbtype.full_rep:\\n nm = r[0]\\n if _att_match(rep, r):\\n reserved.append(nm)\\n continue\\n newname = _find_rename(rep, r, reserved)\\n if newname is None:\\n raise ValueError(\\\"Cannot rename %s in %s\\\" % (nm, a))\\n renames.extend((nm, newname))\\n reserved.append(newname)\\n if renames:\\n a = a.attribute_rename(a, *renames)\\n result.append(a)\\n return tuple(result)\",\n \"def multiplicities(self):\\n return self.nk, self.zk\",\n \"def __init__(self, emb1, emb2, normalize=False):\\r\\n self.dim = emb1.dim\\r\\n \\r\\n vocab1 = emb1.wi.viewkeys()\\r\\n vocab2 = emb2.wi.viewkeys()\\r\\n joint_vocab = list(vocab1 & vocab2)\\r\\n only_vocab1 = list(vocab1 - vocab2)\\r\\n only_vocab2 = list(vocab2 - vocab1)\\r\\n self.iw = joint_vocab + only_vocab1 + only_vocab2\\r\\n self.wi = dict([(w, i) for i, w in enumerate(self.iw)])\\r\\n\\r\\n m_joint = emb1.m[[emb1.wi[w] for w in joint_vocab]] + emb2.m[[emb2.wi[w] for w in joint_vocab]]\\r\\n m_only1 = emb1.m[[emb1.wi[w] for w in only_vocab1]]\\r\\n m_only2 = emb2.m[[emb2.wi[w] for w in only_vocab2]]\\r\\n self.m = np.vstack([m_joint, m_only1, m_only2])\\r\\n \\r\\n if normalize:\\r\\n self.normalize()\",\n \"def p2(self):\\n return tuple(self.rect[2:])\",\n \"def _get_compose_dims(self, other, qargs, front):\\n if front:\\n output_dims = self._output_dims\\n if qargs is None:\\n if other._output_dim != self._input_dim:\\n raise QiskitError(\\n \\\"Other operator combined output dimension ({}) does not\\\"\\n \\\" match current combined input dimension ({}).\\\".format(\\n other._output_dim, self._input_dim))\\n input_dims = other._input_dims\\n else:\\n if other._output_dims != self.input_dims(qargs):\\n raise QiskitError(\\n \\\"Other operator output dimensions ({}) does not\\\"\\n \\\" match current subsystem input dimensions ({}).\\\".format(\\n other._output_dims, self.input_dims(qargs)))\\n input_dims = list(self._input_dims)\\n for i, qubit in enumerate(qargs):\\n input_dims[qubit] = other._input_dims[i]\\n else:\\n input_dims = self._input_dims\\n if qargs is None:\\n if self._output_dim != other._input_dim:\\n raise QiskitError(\\n \\\"Other operator combined input dimension ({}) does not\\\"\\n \\\" match current combined output dimension ({}).\\\".format(\\n other._input_dim, self._output_dim))\\n output_dims = other._output_dims\\n else:\\n if self.output_dims(qargs) != other._input_dims:\\n raise QiskitError(\\n \\\"Other operator input dimensions ({}) does not\\\"\\n \\\" match current subsystem output dimension ({}).\\\".format(\\n other._input_dims, self.output_dims(qargs)))\\n output_dims = list(self._output_dims)\\n for i, qubit in enumerate(qargs):\\n output_dims[qubit] = other._output_dims[i]\\n return input_dims, output_dims\",\n \"def dist_matrix(self, group1, group2):\\n \\n tmps = []\\n for i in group2:\\n tmps.append([])\\n for j in group1:\\n mi, label = self.distance(i, j)\\n tmps[-1].append(mi)\\n return tmps\",\n \"def __getitem__(self, idx):\\n x = self.all_transforms(self.data[idx])\\n y = self.labels[idx]\\n return x, y\",\n \"def _create_input_grid(self, x1, x2):\\n return x1.unsqueeze(-2), x2.unsqueeze(-3)\",\n \"def get_M2(M1, num_sys=1):\\n return M1*uniform(size=num_sys)\",\n \"def __getitem__(self, index):\\n\\n source = self.data[\\\"noisy_images\\\"][index,:,:]\\n target = self.data[\\\"clean_images\\\"][index,:,:]\\n\\n source = torch.from_numpy(source.reshape(1,source.shape[0],source.shape[1])).cuda()\\n target = torch.from_numpy(target.reshape(1,target.shape[0],target.shape[1])).cuda()\\n \\n if self.args.loss_function == 'MSE_Affine' or self.args.loss_function == 'N2V':\\n target = torch.cat([source,target], dim = 0)\\n\\n return source, target\",\n \"def align(self):\\n features = np.load(self.cur_dir+'/'+'spec.npy', allow_pickle=True)\\n targets = np.load(self.cur_dir+'/'+'target.npy', allow_pickle=True)\\n \\n feat_num_frames = features.shape[0]\\n targ_num_frames = targets.shape[0]\\n \\n if feat_num_frames != targ_num_frames:\\n diff = feat_num_frames - targ_num_frames\\n if diff < 0:\\n targets = targets[:feat_num_frames, :]\\n else:\\n features = features[:targ_num_frames:, :]\\n \\n return features.shape, targets.shape\",\n \"def __getitem__(self, item):\\n if item not in self.complex_mols:\\n complex_mol = rdkit.Chem.rdmolops.CombineMols(self.protein_mols[item],self.ligand_mols[item] )\\n self.complex_mols[item]=complex_mol\\n\\n return item, self.protein_mols[item], self.ligand_mols[item], \\\\\\n self.complex_mols[item], self.labels[item]\",\n \"def add_matrices(m1, m2):\\n\\t\\n\\t\\n\\treturn [[a+b for a, b in izip(m1, m2)] for m1, m2 in izip(m1, m2)]\",\n \"def map(self, other: \\\"Vector\\\") -> \\\"Vector\\\":\\n return self.__class__(*(self[i] * other[i] for i in range(len(self))))\",\n \"def displacement(cls, v1, v2):\\n return np.array([v2 - v1])\",\n \"def __rmul__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.gmt_func(other.value, self.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other*obj\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def _preprocessing_(self, x: np.array, m: np.array) -> (np.array, np.array):\\n #normalization\\n x = _normalize_(x)\\n\\n if not self.testing:\\n x, m = self._rotate_(x, m)\\n x, m = self._width_shift_(x, m)\\n x, m = self._height_shift_(x, m)\\n\\n x = _expand_dims_(x)\\n return x, m\",\n \"def get_m1(self):\\n\\n pass\",\n \"def __mul__(self,other):\\n if type(other) is Vector:\\n return(self.x*other.x + self.y*other.y + self.z*other.z)\\n else:\\n return(Vector(self.x*other,self.y*other,self.z*other))\",\n \"def copy_dim(nc1, nc2, name, direction):\\n if (name == direction):\\n return\\n dim1 = nc1.dimensions[name]\\n dim2 = nc2.createDimension(name, len(dim1))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5995994","0.5515784","0.5483453","0.5478269","0.5441555","0.5402159","0.5384988","0.5359179","0.52837175","0.5270582","0.5260968","0.5260383","0.525911","0.5228595","0.5210489","0.5195151","0.5183675","0.51530695","0.51313037","0.51037055","0.5097388","0.5086019","0.50781524","0.5074742","0.5043666","0.50326777","0.5027884","0.5015499","0.50100946","0.50042593","0.4995618","0.49954617","0.49944994","0.4994181","0.49833715","0.49788588","0.49730784","0.49707288","0.4966894","0.49531296","0.49486297","0.4939814","0.49372375","0.49285567","0.4907343","0.4907217","0.4904796","0.49047545","0.49003106","0.48924553","0.4890495","0.48882118","0.4886045","0.487843","0.48736042","0.48674574","0.4864235","0.48640138","0.4854536","0.4833194","0.48318887","0.48316205","0.48275554","0.48131287","0.48052672","0.4802415","0.48016778","0.4800366","0.47992256","0.47973415","0.47887823","0.47886485","0.47884807","0.47809395","0.477886","0.4777239","0.47730964","0.47724068","0.47724068","0.47717568","0.4771619","0.47714323","0.4764985","0.4763533","0.47624135","0.4761967","0.47581148","0.47562858","0.47557732","0.47542167","0.4750992","0.47498125","0.4746681","0.47463328","0.47325945","0.47306857","0.47299495","0.47282922","0.4723064","0.47175756"],"string":"[\n \"0.5995994\",\n \"0.5515784\",\n \"0.5483453\",\n \"0.5478269\",\n \"0.5441555\",\n \"0.5402159\",\n \"0.5384988\",\n \"0.5359179\",\n \"0.52837175\",\n \"0.5270582\",\n \"0.5260968\",\n \"0.5260383\",\n \"0.525911\",\n \"0.5228595\",\n \"0.5210489\",\n \"0.5195151\",\n \"0.5183675\",\n \"0.51530695\",\n \"0.51313037\",\n \"0.51037055\",\n \"0.5097388\",\n \"0.5086019\",\n \"0.50781524\",\n \"0.5074742\",\n \"0.5043666\",\n \"0.50326777\",\n \"0.5027884\",\n \"0.5015499\",\n \"0.50100946\",\n \"0.50042593\",\n \"0.4995618\",\n \"0.49954617\",\n \"0.49944994\",\n \"0.4994181\",\n \"0.49833715\",\n \"0.49788588\",\n \"0.49730784\",\n \"0.49707288\",\n \"0.4966894\",\n \"0.49531296\",\n \"0.49486297\",\n \"0.4939814\",\n \"0.49372375\",\n \"0.49285567\",\n \"0.4907343\",\n \"0.4907217\",\n \"0.4904796\",\n \"0.49047545\",\n \"0.49003106\",\n \"0.48924553\",\n \"0.4890495\",\n \"0.48882118\",\n \"0.4886045\",\n \"0.487843\",\n \"0.48736042\",\n \"0.48674574\",\n \"0.4864235\",\n \"0.48640138\",\n \"0.4854536\",\n \"0.4833194\",\n \"0.48318887\",\n \"0.48316205\",\n \"0.48275554\",\n \"0.48131287\",\n \"0.48052672\",\n \"0.4802415\",\n \"0.48016778\",\n \"0.4800366\",\n \"0.47992256\",\n \"0.47973415\",\n \"0.47887823\",\n \"0.47886485\",\n \"0.47884807\",\n \"0.47809395\",\n \"0.477886\",\n \"0.4777239\",\n \"0.47730964\",\n \"0.47724068\",\n \"0.47724068\",\n \"0.47717568\",\n \"0.4771619\",\n \"0.47714323\",\n \"0.4764985\",\n \"0.4763533\",\n \"0.47624135\",\n \"0.4761967\",\n \"0.47581148\",\n \"0.47562858\",\n \"0.47557732\",\n \"0.47542167\",\n \"0.4750992\",\n \"0.47498125\",\n \"0.4746681\",\n \"0.47463328\",\n \"0.47325945\",\n \"0.47306857\",\n \"0.47299495\",\n \"0.47282922\",\n \"0.4723064\",\n \"0.47175756\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56507003"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":19884,"cells":{"query":{"kind":"string","value":"returns a transient variable representing mv1mv2, where mv1 and mv2 are variables with exactly two axes, with the first axis the same for each (but it's ok to differ only in units, which could be converted). To perform the subtraction, one of the variables is linearly interpolated in its second dimension to the second axis of the other. The axis used will be the coarsest (fewest points) of the two axes."},"document":{"kind":"string","value":"def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb"},"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 aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb","def subm(f1, f2):\n from numpy import array, clip\n\n if type(f2) is array:\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\n bottom,top=limits(f1)\n y = clip(f1.astype('d') - f2, bottom, top)\n y = y.astype(f1.dtype)\n return y","def basic_sub(mv1, mv2):\n obj = expand(mv1.obj - mv2.obj)\n return MV(obj)","def displacement(cls, v1, v2):\n return np.array([v2 - v1])","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def vector_sub(v1,v2):\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)","def displacement(cls, v1, v2):\n return (v2 - v1).copy()","def v1Mv2(v1, M, v2):\r\n return v1[:, None] * M * v2[None, :]","def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\n\n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n ##\n res = float ( var1 ) - float ( var2 )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## \n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return var1 ## SHORTCUT\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n\n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def __rsub__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if not mv:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other - obj\n newValue = other.value - self.value\n\n return self._newMV(newValue)","def __sub__(self, other: TranslationType):\n return Translation(\n self.x - other.x,\n self.y - other.y,\n self.z - other.z)","def sub(first, other):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)","def __sub__(self, other):\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])","def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals","def __sub__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\n return self","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def __sub__(self, other):\n tmp = VectorHeat1D(self.size)\n tmp.set_values(self.get_values() - other.get_values())\n return tmp","def measurement(params1, params2):\n s0 = state(params1)\n s1 = state(params2)\n val = (np.absolute(np.conj(s0)@s1))**2\n return val","def vd(v2,v1):\n return v2-v1","def get_cross2d(v1, v2):\n return v1[0]*v2[1] - v1[1]*v2[0]","def subtract_vectors(vector_1, vector_2):\n new_coordinates = []\n index = 0\n while index < vector_1.dimension:\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\n new_coordinates.append(new_value)\n index += 1\n new_vector = Vector(new_coordinates)\n return new_vector","def vector_subtract(v1, v2):\n return v1[0] - v2[0], v1[1] - v2[1]","def df(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\n out = -y1\n div = y1 * y2\n div.exp_().add_(1)\n out.div_(div)\n return out","def diff_v_x2(x1, x2, t=0.):\n return (omega) ** 2 * x2","def calc_difference(ndvi_tile1, ndvi_tile2, output):\n \n #open dataset and get Affine transformation and bounding properties \n with rio.open(ndvi1) as src1:\n meta = src1.meta.copy()\n transform = src1.meta[\"transform\"]\n x = meta['width']\n y = meta['height']\n band1 = src1.read()\n \n #open dataset \n with rio.open(ndvi2) as src2:\n #read the band as ndarray with the same dimension of src1\n band2 = src2.read(out_shape=(src1.height, src1.width), \n resampling=rio.enums.Resampling.bilinear)\n #create destination for reprojection of src2\n dst_crs = {'init': 'EPSG:32632'}\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\n #reproject the src2 to match src1\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \n dst_transform=transform, dst_crs=dst_crs) \n \n #calculate difference between reprojected band2 and band1\n difference = np.subtract(proj_band2, band1)\n #create outfile\n outfile = output\n #write outfile with the properties and resolution of src1\n with rio.open(outfile, 'w', **meta) as dst:\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\n\n return outfile","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def __sub__(self, other):\r\n if isinstance(other, vec4):\r\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def diff_v_x1(x1, x2, t=0.):\n return (omega) ** 2 * x1","def __sub__(self,other):\n return np.linalg.norm(self.ngdv-other.ngdv)","def subtract(x, y):\n return Shape(x.wallTime, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk)","def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\n return np.linalg.norm(t1 - t2)","def d2(x0,y0,x1,y1):\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)","def __rtruediv__(self, other):\n value = -1 / (self.val * self.val)\n total = {self.var: other * value}\n return AutoDiffReverse(other / self.val, None, total)","def __sub__(self,other):\n return Vector(self.x - other.x, self.y-other.y)\n pass","def __rmul__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.gmt_func(other.value, self.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other*obj\n newValue = other*self.value\n\n return self._newMV(newValue)","def diff(self, x0, x1):\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\n q0 = x0[:nq]\n q1 = x1[:nq]\n v0 = x0[-nv:]\n v1 = x1[-nv:]\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\n return np.concatenate([dq.flat, v1 - v0])","def _canonical_sub(poly1, poly2):\r\n return _canonical_add(poly1, -poly2)","def from_pts(one, two):\n\t\treturn Vec2(two[0] - one[0], two[1] - one[1])","def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb","def mag2(self) -> numbers.Number:\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\n return mv_val[0]","def diffMat(t1,t2):\n if len(t1.shape) > 1:\n T = multVarDiffMat(t1,t2)\n else:\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\n return T","def __sub__(self, other):\r\n if isinstance(other, mat4):\r\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def __rsub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: -1})","def quaternion_subtraction(self, q1, q2):\n\n # Unpack these quaternions\n a_scalar, a_vecx, a_vecy, a_vecz = torch.unbind(q1,\n dim=-1)\n b_scalar, b_vecx, b_vecy, b_vecz = torch.unbind(q2,\n dim=-1)\n\n r_scalar = a_scalar - b_scalar\n r_vecx = a_vecx - b_vecx\n r_vecy = a_vecy - b_vecy\n r_vecz = a_vecz - b_vecz\n\n return torch.stack(\n [r_scalar, r_vecx, r_vecy, r_vecz],\n dim=-1\n )","def TVD(p1, p2):\n assert p1.shape == p2.shape\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))","def m1(el1, daz1, el2, daz2):\n x1=math.cos(el1 * math.pi/180.0)\n x2=math.cos(el2 * math.pi/180.0)\n b = (daz2-daz1)/(x2-x1)\n a = b*x1-daz1\n return (a,b)","def subtract(raster1, raster2):\n valid_mask = (\n (raster1 != nodata) &\n (raster2 != nodata))\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\n result[:] = nodata\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\n return result","def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)","def testCalculateTranslationDiff(self):\n # Test Identity\n transform1 = numpy.eye(4)\n transform2 = numpy.eye(4)\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertEqual(result, 0.0)\n # Test nonzero\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\n transform1[0:3, 3] = vector1\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\n transform2[0:3, 3] = vector2\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertAlmostEqual(result, 26.9130545, 6)\n # Order shouldn't matter\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\n self.assertAlmostEqual(result, 26.9130545, 6)","def subtract(self, other, label=None, atol=1.0E-12):\n # check the two solutions share the same grid\n assert numpy.allclose(self.x, other.x, atol=atol)\n assert numpy.allclose(self.y, other.y, atol=atol)\n assert self.values.shape == other.values.shape\n if not label:\n label = self.label + '-subtracted'\n return Field(label=label,\n time_step=self.time_step,\n x=self.x, y=self.y,\n values=self.values - other.values)","def __sub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: 1})","def cross(self, other):\n if isinstance(other, float):\n return Vector(other*self.y, -other*self.x)\n\n if isinstance(other, Vector):\n return self.x*other.y - self.y*other.x","def __rmul__(self, el2):\n if type(el2) is float or type(el2) is int:\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\n elif type(el2) is vector:\n return vector(el2.y * self.z - el2.z * self.y,\n el2.z * self.x - el2.x * self.z,\n el2.x * self.y - el2.y * self.x)\n else:\n raise TypeError('Cannot multiply a vector with something'\n 'that is neither a vector, a float or an int')","def inverse_linear ( a , b ) :\n \n x0 , f0 = a.x , a.fx\n x1 , f1 = b.x , b.fx\n\n if f0 == f1 or isequal ( f0 , f1 ) : return None\n\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )","def __truediv__(self, other):\n try:\n value = -1 / (other.val * other.val)\n total = {self.var: 1 / other.val, other.var: value * self.val}\n return AutoDiffReverse(self.val / other.val, None, total)\n except AttributeError:\n total = {self.var: 1 / other}\n return AutoDiffReverse(self.val / other, None, total)","def subtract(value1, value2):\n return 1 / (1.0 / value1 - 1.0 / value2)","def subtraction(self, first_value, second_value):\n return first_value - second_value","def __sub__(self, other):\n if isinstance(other, Vector):\n a = self._ar - other._ar\n else:\n a = self._ar - numpy.array(other)\n return Vector(a)","def dy(self) -> np.ndarray:\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])","def __sub__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self.coefficients, other.coefficients\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\n \n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## shortcut \n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\n #\n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n \n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def mirror_vector_vector(v1, v2):\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))","def __rsub__(self, other):\n if type(other) == int:\n other = float(other)\n\n if type(other) == float:\n other = Tensor(other)\n\n return F.Sub.apply(other, self)","def v_from_z(z1, z2):\n R = (1+z1) / (1+z2)\n v = const.c * (R**2 - 1)/(1+R**2) \n\n return v.to('km/s')","def pairwise_sub(first_tensor: tf.Tensor, second_tensor: tf.Tensor) -> tf.Tensor:\n\n column = tf.expand_dims(first_tensor, 2)\n row = tf.expand_dims(second_tensor, 1)\n return tf.subtract(column, row)","def __sub__(self, other):\n if not self.unit.is_compatible(other.unit):\n raise TypeError('Cannot subtract two quantities with incompatible units \"%s\" and \"%s\".' % (self.unit, other.unit))\n value = self._value - other.value_in_unit(self.unit)\n unit = self.unit\n return Quantity(value, unit)","def sub(self, first, second):\n try:\n if isinstance(second, str):\n second = self._variables[second]\n self._variables[first] -= second\n except:\n print(f\"Could not subtract {first} - {second}\")","def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]","def test__vector_subtraction__given_two_vectors__return_correct_vector():\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))","def __sub__(self, other):\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])","def __sub__(self, other):\n n = len(self)\n\n if n != len(other):\n raise(VetorError, \"Vetor dimensions are not equal\")\n\n v = zeros_como(self)\n\n for i in range(n):\n v[i] = self[i] - other[i]\n\n return v","def velocity(df0, df1):\n velocity = df1 - df0\n return velocity","def __sub__(self, m):\n nv=Matrice()\n if self.__mm_type(m):\n ls=len(self)\n nv.generate(ls,self.desc())\n for i in self.desc():\n for j in range(len(self)):\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\n return nv","def convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )","def diff(self, x1, x2):\n return x2 - x1","def subtract(self,ctSub):\n\n # First confirm eligible for subtraction\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\n raise Exception(\"Can't subtract because not meshed the same\")\n\n ctResult = copy.deepcopy(ctSub)# copy the class\n\n \n # Original method\n # ctResult.u = self.u - ctSub.u\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\n\n # New method\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\n\n\n return ctResult","def mult(m1, m2):\n assert np.shape(m1) == (2, 3)\n assert np.shape(m2) == (2, 3)\n\n m1_temp = np.vstack((m1, [0, 0, 1]))\n m2_temp = np.vstack((m2, [0, 0, 1]))\n result = m1_temp * m2_temp\n\n return result[:2, :]","def diff(self, word1, word2):\n v = self._vecs[self._index[word1]] - self._vecs[self._index[word2]]\n return v / np.linalg.norm(v)","def __sub__(self, other):\n if type(other) == int:\n other = float(other)\n\n if type(other) == float:\n other = Tensor(other)\n\n return F.Sub.apply(self, other)","def rmsd(a1, a2):\n # Check that the arrays are the same size\n if np.shape(a1) != np.shape(a2):\n raise Exception(\"\"\"The shape of array 1 is not the same as the shape of array 2. If these arrays represent\n geometries, the molecules are not the same!\"\"\")\n\n # Rotate and translate a2 so that it is as close to a1 as possible\n R, t = SVD_rotate(a1, a2)\n a2 = np.dot(R, a2.T)\n a2 = a2.T + t \n\n return np.sqrt(np.mean((a1-a2)**2))","def calc(operand_1, operand_2):\n return operand_1 - operand_2","def calc(operand_1, operand_2):\n return operand_1 - operand_2","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def matmul(x, y):\n if len(list(y.size())) == 2:\n # if one of them is a vector (i.e. wanting to do MV mult)\n z = torch.zeros(2, x.size()[1], dtype=torch.double, device=x.device)\n z[0] = torch.mv(x[0], y[0]) - torch.mv(x[1], y[1])\n z[1] = torch.mv(x[0], y[1]) + torch.mv(x[1], y[0])\n\n if len(list(y.size())) == 3:\n z = torch.zeros(\n 2, x.size()[1], y.size()[2], dtype=torch.double, device=x.device\n )\n z[0] = torch.matmul(x[0], y[0]) - torch.matmul(x[1], y[1])\n z[1] = torch.matmul(x[0], y[1]) + torch.matmul(x[1], y[0])\n\n return z","def vector(p0, p1):\n a = p1[0] - p0[0]\n b = p1[1] - p0[1]\n return (a, b)","def subtract(self, vec2):\n if type(vec2) != Vector:\n raise TypeError(\"Not a vector\")\n\n if len(vec2) != len(self):\n raise DifferentLengthVectors(self, vec2)\n\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])","def compose_transform(T1, T2):\n aux_vec = np.array([0, 0, 1]).reshape(1, 3)\n\n T1 = np.concatenate((T1, aux_vec), axis=0)\n T2 = np.concatenate((T2, aux_vec), axis=0)\n\n T1_inv = np.linalg.inv(T1)\n T = T1_inv@T2\n\n return T[0:2]","def __rmul__(self, other):\n\t\t# Maintain state of self and create new trace variable new_var\n\t\tnew_var = Var(self.val, self.der)\n\t\treturn new_var.__mul__(other)","def _relative_velocity(vel1, vel2):\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]","def __sub__(self, other):\n return (self.x - other.x, self.y - other.y)","def Vec2_diff(r1, r2, shear=0.0, Lx=1.0, Ly=1.0):\n dx, dy = (r1 - r2).T\n im = np.round(dy / Ly)\n dy = dy - im * Ly\n dx = dx - np.round(dx / Lx - im * shear) * Lx - im * shear * Lx\n return np.array((dx, dy)).T","def __mul__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\n return self","def __sub__(self, other):\n\t\tif isinstance(other, int) or isinstance(other, float):\n\t\t\t# Maintain state of self and create new trace variable new_var\n\t\t\tnew_var = Var(self.val, self.der)\n\t\t\treturn new_var.__add__(-other)\n\t\treturn (-other).__add__(self)","def msre(x1, x2, axis=0):\n x1 = np.asanyarray(x1)\n x2 = np.asanyarray(x2)\n return np.mean((((x1 - x2) ** 2) / x1), axis=axis)","def __sub__(self, other):\n if isinstance(other, int) or isinstance(other, float):\n return Volt(self.volts - other, self.volt_unit, self.freq, self.freq_unit)\n if self.volt_unit != other.volt_unit:\n raise ArithmeticError(f\"The objects' volt units {self.volt_unit} and {other.volt_unit} are not the same.\")\n if self.freq != other.frequency:\n raise ArithmeticError(f\"The objects' frequency {self.freq} and {other.frequency} are not the same.\")\n if self.freq_unit != other.freq_unit:\n raise ArithmeticError(f\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \"\n f\"are not the same.\")\n volt_sum = self.volts - other.volts\n return Volt(volt_sum, self.volt_unit, self.freq, self.freq_unit)","def __sub__(self, other):\n # \n # TODO - your code here\n #\n result = [];\n for i in range(self.h):\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\n \n return Matrix(result);","def sub(o1, o2):\n return o1-o2","def __rtruediv__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other / obj\n\n return other * self.inv()","def __sub__(self, other):\n if isinstance(other, Vec2Array):\n if len(self) == len(other):\n return self.from_points(\n a - b for a, b in zip(self, other))\n else:\n raise ValueError(\n \"cannot subtract arrays with different lengths\")\n else:\n try:\n b = Vec2(*other)\n except Exception:\n return NotImplemented\n return self.from_points(a - b for a in self)","def __rmul__(self, other):\n return TensorWithIndices(other*self._tensor, \n self._con + '_' + self._cov)"],"string":"[\n \"def aminusb_1ax( mv1, mv2 ):\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARNING: aminusb_1ax1 is subtracting variables with different units!\\\",mv1,mv1\\n if mv1 is None or mv2 is None: return None\\n missing = mv1.get_fill_value()\\n axis1 = allAxes(mv1)[0]\\n axis2 = allAxes(mv2)[0]\\n if len(axis1)<=len(axis2):\\n a = mv1\\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\\n else:\\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\\n b = mv2\\n aminusb = a - b\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def subm(f1, f2):\\n from numpy import array, clip\\n\\n if type(f2) is array:\\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\\n bottom,top=limits(f1)\\n y = clip(f1.astype('d') - f2, bottom, top)\\n y = y.astype(f1.dtype)\\n return y\",\n \"def basic_sub(mv1, mv2):\\n obj = expand(mv1.obj - mv2.obj)\\n return MV(obj)\",\n \"def displacement(cls, v1, v2):\\n return np.array([v2 - v1])\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def vector_sub(v1,v2):\\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)\",\n \"def displacement(cls, v1, v2):\\n return (v2 - v1).copy()\",\n \"def v1Mv2(v1, M, v2):\\r\\n return v1[:, None] * M * v2[None, :]\",\n \"def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\\n\\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n ##\\n res = float ( var1 ) - float ( var2 )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## \\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return var1 ## SHORTCUT\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n\\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def __rsub__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if not mv:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other - obj\\n newValue = other.value - self.value\\n\\n return self._newMV(newValue)\",\n \"def __sub__(self, other: TranslationType):\\n return Translation(\\n self.x - other.x,\\n self.y - other.y,\\n self.z - other.z)\",\n \"def sub(first, other):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)\",\n \"def __sub__(self, other):\\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])\",\n \"def interp2( newaxis1, mv ):\\n missing = mv.get_fill_value()\\n axes = allAxes(mv)\\n if len(newaxis1[:])>len(axes[1][:]): return mv\\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\\n for i in range(len( axes[0] )):\\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\\n # the mask - which numpy.interp treats False as 0, True as 1:\\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\\n right=missing ) )>0\\n return new_vals\",\n \"def __sub__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\\n return self\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def __sub__(self, other):\\n tmp = VectorHeat1D(self.size)\\n tmp.set_values(self.get_values() - other.get_values())\\n return tmp\",\n \"def measurement(params1, params2):\\n s0 = state(params1)\\n s1 = state(params2)\\n val = (np.absolute(np.conj(s0)@s1))**2\\n return val\",\n \"def vd(v2,v1):\\n return v2-v1\",\n \"def get_cross2d(v1, v2):\\n return v1[0]*v2[1] - v1[1]*v2[0]\",\n \"def subtract_vectors(vector_1, vector_2):\\n new_coordinates = []\\n index = 0\\n while index < vector_1.dimension:\\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\\n new_coordinates.append(new_value)\\n index += 1\\n new_vector = Vector(new_coordinates)\\n return new_vector\",\n \"def vector_subtract(v1, v2):\\n return v1[0] - v2[0], v1[1] - v2[1]\",\n \"def df(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\\n out = -y1\\n div = y1 * y2\\n div.exp_().add_(1)\\n out.div_(div)\\n return out\",\n \"def diff_v_x2(x1, x2, t=0.):\\n return (omega) ** 2 * x2\",\n \"def calc_difference(ndvi_tile1, ndvi_tile2, output):\\n \\n #open dataset and get Affine transformation and bounding properties \\n with rio.open(ndvi1) as src1:\\n meta = src1.meta.copy()\\n transform = src1.meta[\\\"transform\\\"]\\n x = meta['width']\\n y = meta['height']\\n band1 = src1.read()\\n \\n #open dataset \\n with rio.open(ndvi2) as src2:\\n #read the band as ndarray with the same dimension of src1\\n band2 = src2.read(out_shape=(src1.height, src1.width), \\n resampling=rio.enums.Resampling.bilinear)\\n #create destination for reprojection of src2\\n dst_crs = {'init': 'EPSG:32632'}\\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\\n #reproject the src2 to match src1\\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \\n dst_transform=transform, dst_crs=dst_crs) \\n \\n #calculate difference between reprojected band2 and band1\\n difference = np.subtract(proj_band2, band1)\\n #create outfile\\n outfile = output\\n #write outfile with the properties and resolution of src1\\n with rio.open(outfile, 'w', **meta) as dst:\\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\\n\\n return outfile\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, vec4):\\r\\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def diff_v_x1(x1, x2, t=0.):\\n return (omega) ** 2 * x1\",\n \"def __sub__(self,other):\\n return np.linalg.norm(self.ngdv-other.ngdv)\",\n \"def subtract(x, y):\\n return Shape(x.wallTime, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk)\",\n \"def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\\n return np.linalg.norm(t1 - t2)\",\n \"def d2(x0,y0,x1,y1):\\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)\",\n \"def __rtruediv__(self, other):\\n value = -1 / (self.val * self.val)\\n total = {self.var: other * value}\\n return AutoDiffReverse(other / self.val, None, total)\",\n \"def __sub__(self,other):\\n return Vector(self.x - other.x, self.y-other.y)\\n pass\",\n \"def __rmul__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.gmt_func(other.value, self.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other*obj\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def diff(self, x0, x1):\\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\\n q0 = x0[:nq]\\n q1 = x1[:nq]\\n v0 = x0[-nv:]\\n v1 = x1[-nv:]\\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\\n return np.concatenate([dq.flat, v1 - v0])\",\n \"def _canonical_sub(poly1, poly2):\\r\\n return _canonical_add(poly1, -poly2)\",\n \"def from_pts(one, two):\\n\\t\\treturn Vec2(two[0] - one[0], two[1] - one[1])\",\n \"def aminusb_2ax( mv1, mv2 ):\\n return mv2\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n missing = mv1.get_fill_value()\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n if axes1 is None or axes2 is None: return None\\n if len(axes1)!=2: print \\\"ERROR @1, wrong number of axes for aminusb_2ax\\\",axes1\\n if len(axes2)!=2: print \\\"ERROR @2, wrong number of axes for aminusb_2ax\\\",axes2\\n if len(axes1[0])==len(axes2[0]):\\n # Only axis2 differs, there's a better way...\\n return aminusb_ax2( mv1, mv2 )\\n if len(axes1[0])<=len(axes2[0]):\\n if len(axes1[1])<=len(axes2[1]):\\n mv1new = mv1\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid1 = mv1.getGrid()\\n mv2new = mv2.regrid(grid1)\\n else:\\n # Interpolate mv1 from axis1[1] to axis2[1]\\n # Interpolate mv2 from axis2[0] to axis1[0]\\n print \\\"ERROR @3, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n if len(axes1[1])<=len(axes2[1]):\\n # Interpolate mv1 from axis1[0] to axis2[0]\\n # Interpolate mv2 from axis2[1] to axis1[1]\\n print \\\"ERROR @4, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n mv2new = mv2\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid2 = mv2.getGrid()\\n mv1new = mv1.regrid(grid2)\\n aminusb = mv1new - mv2new\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def mag2(self) -> numbers.Number:\\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\\n return mv_val[0]\",\n \"def diffMat(t1,t2):\\n if len(t1.shape) > 1:\\n T = multVarDiffMat(t1,t2)\\n else:\\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\\n return T\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, mat4):\\r\\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def __rsub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: -1})\",\n \"def quaternion_subtraction(self, q1, q2):\\n\\n # Unpack these quaternions\\n a_scalar, a_vecx, a_vecy, a_vecz = torch.unbind(q1,\\n dim=-1)\\n b_scalar, b_vecx, b_vecy, b_vecz = torch.unbind(q2,\\n dim=-1)\\n\\n r_scalar = a_scalar - b_scalar\\n r_vecx = a_vecx - b_vecx\\n r_vecy = a_vecy - b_vecy\\n r_vecz = a_vecz - b_vecz\\n\\n return torch.stack(\\n [r_scalar, r_vecx, r_vecy, r_vecz],\\n dim=-1\\n )\",\n \"def TVD(p1, p2):\\n assert p1.shape == p2.shape\\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))\",\n \"def m1(el1, daz1, el2, daz2):\\n x1=math.cos(el1 * math.pi/180.0)\\n x2=math.cos(el2 * math.pi/180.0)\\n b = (daz2-daz1)/(x2-x1)\\n a = b*x1-daz1\\n return (a,b)\",\n \"def subtract(raster1, raster2):\\n valid_mask = (\\n (raster1 != nodata) &\\n (raster2 != nodata))\\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\\n result[:] = nodata\\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\\n return result\",\n \"def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)\",\n \"def testCalculateTranslationDiff(self):\\n # Test Identity\\n transform1 = numpy.eye(4)\\n transform2 = numpy.eye(4)\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertEqual(result, 0.0)\\n # Test nonzero\\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\\n transform1[0:3, 3] = vector1\\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\\n transform2[0:3, 3] = vector2\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertAlmostEqual(result, 26.9130545, 6)\\n # Order shouldn't matter\\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\\n self.assertAlmostEqual(result, 26.9130545, 6)\",\n \"def subtract(self, other, label=None, atol=1.0E-12):\\n # check the two solutions share the same grid\\n assert numpy.allclose(self.x, other.x, atol=atol)\\n assert numpy.allclose(self.y, other.y, atol=atol)\\n assert self.values.shape == other.values.shape\\n if not label:\\n label = self.label + '-subtracted'\\n return Field(label=label,\\n time_step=self.time_step,\\n x=self.x, y=self.y,\\n values=self.values - other.values)\",\n \"def __sub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: 1})\",\n \"def cross(self, other):\\n if isinstance(other, float):\\n return Vector(other*self.y, -other*self.x)\\n\\n if isinstance(other, Vector):\\n return self.x*other.y - self.y*other.x\",\n \"def __rmul__(self, el2):\\n if type(el2) is float or type(el2) is int:\\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\\n elif type(el2) is vector:\\n return vector(el2.y * self.z - el2.z * self.y,\\n el2.z * self.x - el2.x * self.z,\\n el2.x * self.y - el2.y * self.x)\\n else:\\n raise TypeError('Cannot multiply a vector with something'\\n 'that is neither a vector, a float or an int')\",\n \"def inverse_linear ( a , b ) :\\n \\n x0 , f0 = a.x , a.fx\\n x1 , f1 = b.x , b.fx\\n\\n if f0 == f1 or isequal ( f0 , f1 ) : return None\\n\\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )\",\n \"def __truediv__(self, other):\\n try:\\n value = -1 / (other.val * other.val)\\n total = {self.var: 1 / other.val, other.var: value * self.val}\\n return AutoDiffReverse(self.val / other.val, None, total)\\n except AttributeError:\\n total = {self.var: 1 / other}\\n return AutoDiffReverse(self.val / other, None, total)\",\n \"def subtract(value1, value2):\\n return 1 / (1.0 / value1 - 1.0 / value2)\",\n \"def subtraction(self, first_value, second_value):\\n return first_value - second_value\",\n \"def __sub__(self, other):\\n if isinstance(other, Vector):\\n a = self._ar - other._ar\\n else:\\n a = self._ar - numpy.array(other)\\n return Vector(a)\",\n \"def dy(self) -> np.ndarray:\\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])\",\n \"def __sub__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self.coefficients, other.coefficients\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\\n \\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## shortcut \\n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\\n #\\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n \\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def mirror_vector_vector(v1, v2):\\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))\",\n \"def __rsub__(self, other):\\n if type(other) == int:\\n other = float(other)\\n\\n if type(other) == float:\\n other = Tensor(other)\\n\\n return F.Sub.apply(other, self)\",\n \"def v_from_z(z1, z2):\\n R = (1+z1) / (1+z2)\\n v = const.c * (R**2 - 1)/(1+R**2) \\n\\n return v.to('km/s')\",\n \"def pairwise_sub(first_tensor: tf.Tensor, second_tensor: tf.Tensor) -> tf.Tensor:\\n\\n column = tf.expand_dims(first_tensor, 2)\\n row = tf.expand_dims(second_tensor, 1)\\n return tf.subtract(column, row)\",\n \"def __sub__(self, other):\\n if not self.unit.is_compatible(other.unit):\\n raise TypeError('Cannot subtract two quantities with incompatible units \\\"%s\\\" and \\\"%s\\\".' % (self.unit, other.unit))\\n value = self._value - other.value_in_unit(self.unit)\\n unit = self.unit\\n return Quantity(value, unit)\",\n \"def sub(self, first, second):\\n try:\\n if isinstance(second, str):\\n second = self._variables[second]\\n self._variables[first] -= second\\n except:\\n print(f\\\"Could not subtract {first} - {second}\\\")\",\n \"def getVector(c1, c2):\\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]\",\n \"def test__vector_subtraction__given_two_vectors__return_correct_vector():\\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))\",\n \"def __sub__(self, other):\\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])\",\n \"def __sub__(self, other):\\n n = len(self)\\n\\n if n != len(other):\\n raise(VetorError, \\\"Vetor dimensions are not equal\\\")\\n\\n v = zeros_como(self)\\n\\n for i in range(n):\\n v[i] = self[i] - other[i]\\n\\n return v\",\n \"def velocity(df0, df1):\\n velocity = df1 - df0\\n return velocity\",\n \"def __sub__(self, m):\\n nv=Matrice()\\n if self.__mm_type(m):\\n ls=len(self)\\n nv.generate(ls,self.desc())\\n for i in self.desc():\\n for j in range(len(self)):\\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\\n return nv\",\n \"def convert_axis( mv, axisold, axisindnew ):\\n (axisnew, indexina3) = axisindnew\\n axes = allAxes(mv)\\n kold = None\\n for k in range(len(axes)):\\n if axes[k]==axisold: kold=k\\n if kold==None:\\n print \\\"ERROR. convert_axis cannot find axis\\\",axisold,\\\" in variable\\\",mv\\n if len(axisold)==len(axisnew):\\n mv.setAxis( kold, axisnew )\\n return\\n # Here's what we would do in 1-D:\\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # for i in range(len(axisold)):\\n # newdata[ indexina3[i] ] = ma[i]\\n # newmv = cdms2.createVariable( newdata, id=mv.id )\\n # >1-D is the same idea, but more dimensions are coming along for the ride,\\n # making it more complicated...\\n shape0 = mv.shape\\n shape0[kold] = len(axisnew)\\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\\n # There seems to be nothing in numpy for treating one axis differently from the rest\\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\\n # The following will do the job. It would be very slow for an array with many big dimensions,\\n # but the arrays here have already been reduced for graphics; the index sets will be small or\\n # empty...\\n ranges = map( range, shape0[0:kold] )\\n for i in range(len(axisold)):\\n for idx in apply(itertools.product,ranges):\\n idx = idx + [indexina3(i)] + [Ellipsis]\\n idxo = idx + [i] + [Ellipsis]\\n newdata[ tuple(idx) ] = mv[idxo]\\n newmv = cdms2.createVariable( newdata, id=mv.id )\",\n \"def diff(self, x1, x2):\\n return x2 - x1\",\n \"def subtract(self,ctSub):\\n\\n # First confirm eligible for subtraction\\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\\n raise Exception(\\\"Can't subtract because not meshed the same\\\")\\n\\n ctResult = copy.deepcopy(ctSub)# copy the class\\n\\n \\n # Original method\\n # ctResult.u = self.u - ctSub.u\\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\\n\\n # New method\\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\\n\\n\\n return ctResult\",\n \"def mult(m1, m2):\\n assert np.shape(m1) == (2, 3)\\n assert np.shape(m2) == (2, 3)\\n\\n m1_temp = np.vstack((m1, [0, 0, 1]))\\n m2_temp = np.vstack((m2, [0, 0, 1]))\\n result = m1_temp * m2_temp\\n\\n return result[:2, :]\",\n \"def diff(self, word1, word2):\\n v = self._vecs[self._index[word1]] - self._vecs[self._index[word2]]\\n return v / np.linalg.norm(v)\",\n \"def __sub__(self, other):\\n if type(other) == int:\\n other = float(other)\\n\\n if type(other) == float:\\n other = Tensor(other)\\n\\n return F.Sub.apply(self, other)\",\n \"def rmsd(a1, a2):\\n # Check that the arrays are the same size\\n if np.shape(a1) != np.shape(a2):\\n raise Exception(\\\"\\\"\\\"The shape of array 1 is not the same as the shape of array 2. If these arrays represent\\n geometries, the molecules are not the same!\\\"\\\"\\\")\\n\\n # Rotate and translate a2 so that it is as close to a1 as possible\\n R, t = SVD_rotate(a1, a2)\\n a2 = np.dot(R, a2.T)\\n a2 = a2.T + t \\n\\n return np.sqrt(np.mean((a1-a2)**2))\",\n \"def calc(operand_1, operand_2):\\n return operand_1 - operand_2\",\n \"def calc(operand_1, operand_2):\\n return operand_1 - operand_2\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def matmul(x, y):\\n if len(list(y.size())) == 2:\\n # if one of them is a vector (i.e. wanting to do MV mult)\\n z = torch.zeros(2, x.size()[1], dtype=torch.double, device=x.device)\\n z[0] = torch.mv(x[0], y[0]) - torch.mv(x[1], y[1])\\n z[1] = torch.mv(x[0], y[1]) + torch.mv(x[1], y[0])\\n\\n if len(list(y.size())) == 3:\\n z = torch.zeros(\\n 2, x.size()[1], y.size()[2], dtype=torch.double, device=x.device\\n )\\n z[0] = torch.matmul(x[0], y[0]) - torch.matmul(x[1], y[1])\\n z[1] = torch.matmul(x[0], y[1]) + torch.matmul(x[1], y[0])\\n\\n return z\",\n \"def vector(p0, p1):\\n a = p1[0] - p0[0]\\n b = p1[1] - p0[1]\\n return (a, b)\",\n \"def subtract(self, vec2):\\n if type(vec2) != Vector:\\n raise TypeError(\\\"Not a vector\\\")\\n\\n if len(vec2) != len(self):\\n raise DifferentLengthVectors(self, vec2)\\n\\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])\",\n \"def compose_transform(T1, T2):\\n aux_vec = np.array([0, 0, 1]).reshape(1, 3)\\n\\n T1 = np.concatenate((T1, aux_vec), axis=0)\\n T2 = np.concatenate((T2, aux_vec), axis=0)\\n\\n T1_inv = np.linalg.inv(T1)\\n T = T1_inv@T2\\n\\n return T[0:2]\",\n \"def __rmul__(self, other):\\n\\t\\t# Maintain state of self and create new trace variable new_var\\n\\t\\tnew_var = Var(self.val, self.der)\\n\\t\\treturn new_var.__mul__(other)\",\n \"def _relative_velocity(vel1, vel2):\\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]\",\n \"def __sub__(self, other):\\n return (self.x - other.x, self.y - other.y)\",\n \"def Vec2_diff(r1, r2, shear=0.0, Lx=1.0, Ly=1.0):\\n dx, dy = (r1 - r2).T\\n im = np.round(dy / Ly)\\n dy = dy - im * Ly\\n dx = dx - np.round(dx / Lx - im * shear) * Lx - im * shear * Lx\\n return np.array((dx, dy)).T\",\n \"def __mul__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\\n return self\",\n \"def __sub__(self, other):\\n\\t\\tif isinstance(other, int) or isinstance(other, float):\\n\\t\\t\\t# Maintain state of self and create new trace variable new_var\\n\\t\\t\\tnew_var = Var(self.val, self.der)\\n\\t\\t\\treturn new_var.__add__(-other)\\n\\t\\treturn (-other).__add__(self)\",\n \"def msre(x1, x2, axis=0):\\n x1 = np.asanyarray(x1)\\n x2 = np.asanyarray(x2)\\n return np.mean((((x1 - x2) ** 2) / x1), axis=axis)\",\n \"def __sub__(self, other):\\n if isinstance(other, int) or isinstance(other, float):\\n return Volt(self.volts - other, self.volt_unit, self.freq, self.freq_unit)\\n if self.volt_unit != other.volt_unit:\\n raise ArithmeticError(f\\\"The objects' volt units {self.volt_unit} and {other.volt_unit} are not the same.\\\")\\n if self.freq != other.frequency:\\n raise ArithmeticError(f\\\"The objects' frequency {self.freq} and {other.frequency} are not the same.\\\")\\n if self.freq_unit != other.freq_unit:\\n raise ArithmeticError(f\\\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \\\"\\n f\\\"are not the same.\\\")\\n volt_sum = self.volts - other.volts\\n return Volt(volt_sum, self.volt_unit, self.freq, self.freq_unit)\",\n \"def __sub__(self, other):\\n # \\n # TODO - your code here\\n #\\n result = [];\\n for i in range(self.h):\\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\\n \\n return Matrix(result);\",\n \"def sub(o1, o2):\\n return o1-o2\",\n \"def __rtruediv__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other / obj\\n\\n return other * self.inv()\",\n \"def __sub__(self, other):\\n if isinstance(other, Vec2Array):\\n if len(self) == len(other):\\n return self.from_points(\\n a - b for a, b in zip(self, other))\\n else:\\n raise ValueError(\\n \\\"cannot subtract arrays with different lengths\\\")\\n else:\\n try:\\n b = Vec2(*other)\\n except Exception:\\n return NotImplemented\\n return self.from_points(a - b for a in self)\",\n \"def __rmul__(self, other):\\n return TensorWithIndices(other*self._tensor, \\n self._con + '_' + self._cov)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6669163","0.64997256","0.6459063","0.6129442","0.59882194","0.5982143","0.59319377","0.59233034","0.58952814","0.5881865","0.585033","0.5835218","0.57343096","0.5712189","0.5709772","0.56709397","0.5657024","0.563904","0.56342083","0.5616154","0.55805236","0.5518626","0.5459865","0.5456379","0.54510194","0.5429913","0.5384608","0.5378155","0.53775716","0.53732276","0.53565186","0.5350402","0.534607","0.53085405","0.5302489","0.5286843","0.5271553","0.5244373","0.5236913","0.5234271","0.52021086","0.5189859","0.51856333","0.51773113","0.5168706","0.51648253","0.5163928","0.51638734","0.5163801","0.5163482","0.51632386","0.51625425","0.5158432","0.5144749","0.5144626","0.51417553","0.5136084","0.5118079","0.5116071","0.51111287","0.51076007","0.50916094","0.5080375","0.50657105","0.5064747","0.50635993","0.506167","0.50469816","0.504521","0.5044932","0.50304085","0.50270987","0.5013376","0.50121796","0.500993","0.5009628","0.50067717","0.5006241","0.5002131","0.4997222","0.49971226","0.49971226","0.4997078","0.49905255","0.49904406","0.49891454","0.49808985","0.49790138","0.49786305","0.49735978","0.496861","0.4968292","0.49646628","0.49557975","0.49549407","0.49466252","0.49444985","0.49441993","0.4930437","0.4928737"],"string":"[\n \"0.6669163\",\n \"0.64997256\",\n \"0.6459063\",\n \"0.6129442\",\n \"0.59882194\",\n \"0.5982143\",\n \"0.59319377\",\n \"0.59233034\",\n \"0.58952814\",\n \"0.5881865\",\n \"0.585033\",\n \"0.5835218\",\n \"0.57343096\",\n \"0.5712189\",\n \"0.5709772\",\n \"0.56709397\",\n \"0.5657024\",\n \"0.563904\",\n \"0.56342083\",\n \"0.5616154\",\n \"0.55805236\",\n \"0.5518626\",\n \"0.5459865\",\n \"0.5456379\",\n \"0.54510194\",\n \"0.5429913\",\n \"0.5384608\",\n \"0.5378155\",\n \"0.53775716\",\n \"0.53732276\",\n \"0.53565186\",\n \"0.5350402\",\n \"0.534607\",\n \"0.53085405\",\n \"0.5302489\",\n \"0.5286843\",\n \"0.5271553\",\n \"0.5244373\",\n \"0.5236913\",\n \"0.5234271\",\n \"0.52021086\",\n \"0.5189859\",\n \"0.51856333\",\n \"0.51773113\",\n \"0.5168706\",\n \"0.51648253\",\n \"0.5163928\",\n \"0.51638734\",\n \"0.5163801\",\n \"0.5163482\",\n \"0.51632386\",\n \"0.51625425\",\n \"0.5158432\",\n \"0.5144749\",\n \"0.5144626\",\n \"0.51417553\",\n \"0.5136084\",\n \"0.5118079\",\n \"0.5116071\",\n \"0.51111287\",\n \"0.51076007\",\n \"0.50916094\",\n \"0.5080375\",\n \"0.50657105\",\n \"0.5064747\",\n \"0.50635993\",\n \"0.506167\",\n \"0.50469816\",\n \"0.504521\",\n \"0.5044932\",\n \"0.50304085\",\n \"0.50270987\",\n \"0.5013376\",\n \"0.50121796\",\n \"0.500993\",\n \"0.5009628\",\n \"0.50067717\",\n \"0.5006241\",\n \"0.5002131\",\n \"0.4997222\",\n \"0.49971226\",\n \"0.49971226\",\n \"0.4997078\",\n \"0.49905255\",\n \"0.49904406\",\n \"0.49891454\",\n \"0.49808985\",\n \"0.49790138\",\n \"0.49786305\",\n \"0.49735978\",\n \"0.496861\",\n \"0.4968292\",\n \"0.49646628\",\n \"0.49557975\",\n \"0.49549407\",\n \"0.49466252\",\n \"0.49444985\",\n \"0.49441993\",\n \"0.4930437\",\n \"0.4928737\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6472477"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":19885,"cells":{"query":{"kind":"string","value":"returns a transient variable representing mv1mv2, where mv1 and mv2 are variables, normally transient variables, which depend on exactly two axes, typically lonlat. To perform the subtraction, the variables will be interpolated as necessary to the axes which are minimal (fewest points) in each direction. Note that if mv1 _or_ mv2 have a missing value at index i, then the return value (mv1mv2) will also have a missing value at index i."},"document":{"kind":"string","value":"def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb"},"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 aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb","def basic_sub(mv1, mv2):\n obj = expand(mv1.obj - mv2.obj)\n return MV(obj)","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def displacement(cls, v1, v2):\n return np.array([v2 - v1])","def displacement(cls, v1, v2):\n return (v2 - v1).copy()","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def vector_sub(v1,v2):\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)","def __rsub__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if not mv:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other - obj\n newValue = other.value - self.value\n\n return self._newMV(newValue)","def subm(f1, f2):\n from numpy import array, clip\n\n if type(f2) is array:\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\n bottom,top=limits(f1)\n y = clip(f1.astype('d') - f2, bottom, top)\n y = y.astype(f1.dtype)\n return y","def v1Mv2(v1, M, v2):\r\n return v1[:, None] * M * v2[None, :]","def vd(v2,v1):\n return v2-v1","def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\n\n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n ##\n res = float ( var1 ) - float ( var2 )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## \n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return var1 ## SHORTCUT\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n\n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def subtract_vectors(vector_1, vector_2):\n new_coordinates = []\n index = 0\n while index < vector_1.dimension:\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\n new_coordinates.append(new_value)\n index += 1\n new_vector = Vector(new_coordinates)\n return new_vector","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def sub(first, other):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals","def vector_subtract(v1, v2):\n return v1[0] - v2[0], v1[1] - v2[1]","def __sub__(self, other: TranslationType):\n return Translation(\n self.x - other.x,\n self.y - other.y,\n self.z - other.z)","def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will be fast enough:\n lataxis = latAxis( mv )\n lmin = -1\n lmax = len(lataxis)\n if lataxis[0]>=latmin: lmin = 0\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\n if lmin==-1 or lmax==len(lataxis):\n for l,ax in enumerate(lataxis):\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\n mv2shape = list(mv.shape)\n mv2shape[ilat] = lmax-lmin+1\n axes[ilat] = lataxis_shrunk\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\n mv2 = cdms2.createVariable( mvdata, axes=axes )\n\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n avmv = averager( mv2, axis=axes_string )\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\n ammv.units = mv.units\n\n return avmv","def diff(self, x0, x1):\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\n q0 = x0[:nq]\n q1 = x1[:nq]\n v0 = x0[-nv:]\n v1 = x1[-nv:]\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\n return np.concatenate([dq.flat, v1 - v0])","def __sub__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\n return self","def measurement(params1, params2):\n s0 = state(params1)\n s1 = state(params2)\n val = (np.absolute(np.conj(s0)@s1))**2\n return val","def __rmul__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.gmt_func(other.value, self.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other*obj\n newValue = other*self.value\n\n return self._newMV(newValue)","def __sub__(self, other):\n tmp = VectorHeat1D(self.size)\n tmp.set_values(self.get_values() - other.get_values())\n return tmp","def diff_v_x1(x1, x2, t=0.):\n return (omega) ** 2 * x1","def __sub__(self, other):\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])","def mag2(self) -> numbers.Number:\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\n return mv_val[0]","def aminusb0( mv1, mv2 ):\n mv = mv1[0,] - mv2[0,]\n if hasattr(mv,'long_name'):\n if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name\n mv.long_name = ''\n return mv","def testCalculateTranslationDiff(self):\n # Test Identity\n transform1 = numpy.eye(4)\n transform2 = numpy.eye(4)\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertEqual(result, 0.0)\n # Test nonzero\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\n transform1[0:3, 3] = vector1\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\n transform2[0:3, 3] = vector2\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertAlmostEqual(result, 26.9130545, 6)\n # Order shouldn't matter\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\n self.assertAlmostEqual(result, 26.9130545, 6)","def calc_difference(ndvi_tile1, ndvi_tile2, output):\n \n #open dataset and get Affine transformation and bounding properties \n with rio.open(ndvi1) as src1:\n meta = src1.meta.copy()\n transform = src1.meta[\"transform\"]\n x = meta['width']\n y = meta['height']\n band1 = src1.read()\n \n #open dataset \n with rio.open(ndvi2) as src2:\n #read the band as ndarray with the same dimension of src1\n band2 = src2.read(out_shape=(src1.height, src1.width), \n resampling=rio.enums.Resampling.bilinear)\n #create destination for reprojection of src2\n dst_crs = {'init': 'EPSG:32632'}\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\n #reproject the src2 to match src1\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \n dst_transform=transform, dst_crs=dst_crs) \n \n #calculate difference between reprojected band2 and band1\n difference = np.subtract(proj_band2, band1)\n #create outfile\n outfile = output\n #write outfile with the properties and resolution of src1\n with rio.open(outfile, 'w', **meta) as dst:\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\n\n return outfile","def substract(self, vector):\n\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\n # self.vector]))\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)","def __rtruediv__(self, other):\n value = -1 / (self.val * self.val)\n total = {self.var: other * value}\n return AutoDiffReverse(other / self.val, None, total)","def diff_v_x2(x1, x2, t=0.):\n return (omega) ** 2 * x2","def m1(el1, daz1, el2, daz2):\n x1=math.cos(el1 * math.pi/180.0)\n x2=math.cos(el2 * math.pi/180.0)\n b = (daz2-daz1)/(x2-x1)\n a = b*x1-daz1\n return (a,b)","def __sub__(self,other):\n return np.linalg.norm(self.ngdv-other.ngdv)","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def vector(p0, p1):\n a = p1[0] - p0[0]\n b = p1[1] - p0[1]\n return (a, b)","def _relative_velocity(vel1, vel2):\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]","def v_from_z(z1, z2):\n R = (1+z1) / (1+z2)\n v = const.c * (R**2 - 1)/(1+R**2) \n\n return v.to('km/s')","def _canonical_sub(poly1, poly2):\r\n return _canonical_add(poly1, -poly2)","def subtract(raster1, raster2):\n valid_mask = (\n (raster1 != nodata) &\n (raster2 != nodata))\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\n result[:] = nodata\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\n return result","def __sub__(self,other):\n return Vector(self.x - other.x, self.y-other.y)\n pass","def __rsub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: -1})","def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\n \n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## shortcut \n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\n #\n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n \n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def velocity(df0, df1):\n velocity = df1 - df0\n return velocity","def __sub__(self, other):\r\n if isinstance(other, vec4):\r\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]","def __sub__(self, m):\n nv=Matrice()\n if self.__mm_type(m):\n ls=len(self)\n nv.generate(ls,self.desc())\n for i in self.desc():\n for j in range(len(self)):\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\n return nv","def __sub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: 1})","def get_cross2d(v1, v2):\n return v1[0]*v2[1] - v1[1]*v2[0]","def diff(self, x1, x2):\n return x2 - x1","def pv(self, other):\n\n assert self.n == other.n == 3, \"Produto vetorial definido somente em R3\"\n\n u, v = self, other\n\n return Vetor([u[1] * v[2] - u[2] * v[1],\n u[2] * v[0] - u[0] * v[2],\n u[0] * v[1] - u[1] * v[0]])","def subtract(self,ctSub):\n\n # First confirm eligible for subtraction\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\n raise Exception(\"Can't subtract because not meshed the same\")\n\n ctResult = copy.deepcopy(ctSub)# copy the class\n\n \n # Original method\n # ctResult.u = self.u - ctSub.u\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\n\n # New method\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\n\n\n return ctResult","def __truediv__(self, other):\n try:\n value = -1 / (other.val * other.val)\n total = {self.var: 1 / other.val, other.var: value * self.val}\n return AutoDiffReverse(self.val / other.val, None, total)\n except AttributeError:\n total = {self.var: 1 / other}\n return AutoDiffReverse(self.val / other, None, total)","def distance(v1, v2):\r\n return magnitude(*subtract(v2, v1))","def subtract(value1, value2):\n return 1 / (1.0 / value1 - 1.0 / value2)","def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\n return np.linalg.norm(t1 - t2)","def mirror_vector_vector(v1, v2):\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))","def test__vector_subtraction__given_two_vectors__return_correct_vector():\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))","def dy(self) -> np.ndarray:\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])","def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def subtraction(self, first_value, second_value):\n return first_value - second_value","def subtract(self, vec2):\n if type(vec2) != Vector:\n raise TypeError(\"Not a vector\")\n\n if len(vec2) != len(self):\n raise DifferentLengthVectors(self, vec2)\n\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])","def get_mo_ovlp(mo1, mo2, ovlp):\n ovlp = np.asarray(ovlp)\n mo1 = np.asarray(mo1)\n mo2 = np.asarray(mo2)\n if mo1.ndim == 2:\n res = reduce(np.dot, (mo1.conj().T, ovlp, mo2))\n else:\n assert mo1.shape[0] == mo2.shape[0]\n spin, nao, nmo1 = mo1.shape\n nmo2 = mo2.shape[-1]\n res = np.zeros((spin, nmo1, nmo2), dtype=np.result_type(mo1, mo2))\n for s in range(spin):\n res[s] = reduce(np.dot, (mo1[s].conj().T, ovlp, mo2[s]))\n return res","def __rmul__(self, el2):\n if type(el2) is float or type(el2) is int:\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\n elif type(el2) is vector:\n return vector(el2.y * self.z - el2.z * self.y,\n el2.z * self.x - el2.x * self.z,\n el2.x * self.y - el2.y * self.x)\n else:\n raise TypeError('Cannot multiply a vector with something'\n 'that is neither a vector, a float or an int')","def from_pts(one, two):\n\t\treturn Vec2(two[0] - one[0], two[1] - one[1])","def __truediv__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n return self * other.inv()\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return obj/other\n newValue = self.value / other\n return self._newMV(newValue)","def __sub__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self.coefficients, other.coefficients\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def __sub__(self, other):\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def __sub__(self, other):\r\n if isinstance(other, mat4):\r\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def TVD(p1, p2):\n assert p1.shape == p2.shape\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))","def __rtruediv__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other / obj\n\n return other * self.inv()","def cross(self, other):\n if isinstance(other, float):\n return Vector(other*self.y, -other*self.x)\n\n if isinstance(other, Vector):\n return self.x*other.y - self.y*other.x","def difference(self, mass_function):\n result = copy.deepcopy(self)\n for focal, value in mass_function.items():\n result.remove_mass((focal, value))\n\n newFocals = {}\n for focal, value in result.items():\n if value != 0:\n newFocals[focal] = value\n result.focals = newFocals\n return result","def l1(x1, x2):\n return np.abs(x1 - x2)","def get_vector(self, transform: pylot.utils.Transform,\n min_distance: float):\n wp_index = self._get_index(transform, min_distance)\n return self.waypoints[wp_index].location.as_vector_2D() - \\\n transform.location.as_vector_2D()","def update_variables_momentum(alpha, beta1, var, grad, v):\n v = beta1 * v + (1-beta1) * grad\n var = var - alpha * v\n return var, v","def __sub__(self,other):\n self._obj['u'] -= other._obj['u']\n self._obj['v'] -= other._obj['v']\n return self._obj","def inverse_linear ( a , b ) :\n \n x0 , f0 = a.x , a.fx\n x1 , f1 = b.x , b.fx\n\n if f0 == f1 or isequal ( f0 , f1 ) : return None\n\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def diffMat(t1,t2):\n if len(t1.shape) > 1:\n T = multVarDiffMat(t1,t2)\n else:\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\n return T","def I2_u1(self) -> complex:\n # \"Phase 2 current [A]\" is wrong. We need to calculate it ourselves\n return - self.I1_u1() - self.I3_u1()","def __sub__(self, other):\n n = len(self)\n\n if n != len(other):\n raise(VetorError, \"Vetor dimensions are not equal\")\n\n v = zeros_como(self)\n\n for i in range(n):\n v[i] = self[i] - other[i]\n\n return v","def __sub__(self, other):\n return (self.x - other.x, self.y - other.y)","def d2(x0,y0,x1,y1):\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)","def _normal_vector(o, p0_3d, p1_3d):\n # The vector between middle point of v1-v2 and object center location\n # is the normal vector I'm looking for\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\n # normalize so I can to length computation on it\n vn.normalize()\n return vn","def impulse(self,v1,v2):\n dv_peri = self.v_peri - v1\n \n dv_aphe = self.v_peri - v2\n \n return dv_peri, dv_aphe","def rmsd(a1, a2):\n # Check that the arrays are the same size\n if np.shape(a1) != np.shape(a2):\n raise Exception(\"\"\"The shape of array 1 is not the same as the shape of array 2. If these arrays represent\n geometries, the molecules are not the same!\"\"\")\n\n # Rotate and translate a2 so that it is as close to a1 as possible\n R, t = SVD_rotate(a1, a2)\n a2 = np.dot(R, a2.T)\n a2 = a2.T + t \n\n return np.sqrt(np.mean((a1-a2)**2))","def linear_interpolate_release(mvi, j):\n set_system_state(mvi, 1)\n lam1 = mvi.system.lambda_()[j]\n set_system_state(mvi, 2)\n lam2 = mvi.system.lambda_()[j]\n\n # If either of the following loops are entered, there are likely going to\n # be problems.\n if (lam1 < 0) and (lam2 < 0):\n #add_constraints(mvi, mvi._state1_releases)\n #print mvi.lambda1c[j]\n #print mvi\n #raise Exception(\"Bad release interpolation.\")\n print 'WARNING: BAD INTERPOLANT'\n return mvi.t1, mvi.q1\n\n if lam1 < 0:\n return mvi.t1, mvi.q1\n\n tr = mvi.t1 - (lam1/(lam2-lam1))*(mvi.t2-mvi.t1)\n frac = (tr-mvi.t1)/(mvi.t2-mvi.t1)\n qr = frac*(mvi.q2-mvi.q1)+mvi.q1\n\n return tr, qr","def sub(o1, o2):\n return o1-o2","def __sub__(self, body):\n p = self.position.au - body.position.au\n if self.velocity is None or body.velocity is None:\n v = None\n else:\n v = body.velocity.au_per_d - self.velocity.au_per_d\n return ICRS(p, v, self.jd)","def subtract(self, m): \n f = m.negate()\n return self.add(f)","def __mul__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\n return self","def projection(v1, v2):\n v1 = v1.astype(np.float64)\n\n if np.any(v1):\n result = (np.dot(v1, v2) / np.dot(v1, v1)) * v1\n else:\n result = np.zeros(3)\n\n return result","def uncertainty_mm(self,m1,m2):\n # ID and isolation uncertainty (TO BE FIXED)\n unc = (self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')/self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')+ \\\n self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1')/self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1'))**2\n \n## # trigger (approximate) ==== FIXME!! ===============\n## hlt_sf_run2011_a_unc = (self._mu7TrgWeight [(m1.pt(),m1.eta())][1]/self._mu7TrgWeight [(m1.pt(),m1.eta())][0] + \\\n## self._mu7TrgWeight [(m2.pt(),m2.eta())][1]/self._mu7TrgWeight [(m2.pt(),m2.eta())][0])**2\n## hlt_sf_run2011_b_unc = (abs(self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_b_unc += ((self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_c_unc = (abs(self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_c_unc += ((self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## unc += 0.002*hlt_sf_run2011_a_unc + 0.643*hlt_sf_run2011_b_unc + 0.024*hlt_sf_run2011_c_unc\n \n return sqrt(unc)","def __sub__(self, other):\n if isinstance(other, Vector):\n a = self._ar - other._ar\n else:\n a = self._ar - numpy.array(other)\n return Vector(a)"],"string":"[\n \"def aminusb_1ax( mv1, mv2 ):\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARNING: aminusb_1ax1 is subtracting variables with different units!\\\",mv1,mv1\\n if mv1 is None or mv2 is None: return None\\n missing = mv1.get_fill_value()\\n axis1 = allAxes(mv1)[0]\\n axis2 = allAxes(mv2)[0]\\n if len(axis1)<=len(axis2):\\n a = mv1\\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\\n else:\\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\\n b = mv2\\n aminusb = a - b\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def basic_sub(mv1, mv2):\\n obj = expand(mv1.obj - mv2.obj)\\n return MV(obj)\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def displacement(cls, v1, v2):\\n return np.array([v2 - v1])\",\n \"def displacement(cls, v1, v2):\\n return (v2 - v1).copy()\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def vector_sub(v1,v2):\\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)\",\n \"def __rsub__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if not mv:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other - obj\\n newValue = other.value - self.value\\n\\n return self._newMV(newValue)\",\n \"def subm(f1, f2):\\n from numpy import array, clip\\n\\n if type(f2) is array:\\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\\n bottom,top=limits(f1)\\n y = clip(f1.astype('d') - f2, bottom, top)\\n y = y.astype(f1.dtype)\\n return y\",\n \"def v1Mv2(v1, M, v2):\\r\\n return v1[:, None] * M * v2[None, :]\",\n \"def vd(v2,v1):\\n return v2-v1\",\n \"def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\\n\\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n ##\\n res = float ( var1 ) - float ( var2 )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## \\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return var1 ## SHORTCUT\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n\\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def subtract_vectors(vector_1, vector_2):\\n new_coordinates = []\\n index = 0\\n while index < vector_1.dimension:\\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\\n new_coordinates.append(new_value)\\n index += 1\\n new_vector = Vector(new_coordinates)\\n return new_vector\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def sub(first, other):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def interp2( newaxis1, mv ):\\n missing = mv.get_fill_value()\\n axes = allAxes(mv)\\n if len(newaxis1[:])>len(axes[1][:]): return mv\\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\\n for i in range(len( axes[0] )):\\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\\n # the mask - which numpy.interp treats False as 0, True as 1:\\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\\n right=missing ) )>0\\n return new_vals\",\n \"def vector_subtract(v1, v2):\\n return v1[0] - v2[0], v1[1] - v2[1]\",\n \"def __sub__(self, other: TranslationType):\\n return Translation(\\n self.x - other.x,\\n self.y - other.y,\\n self.z - other.z)\",\n \"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n ilat = None\\n for i,ax in enumerate(axes):\\n if ax.id=='lat': ilat = i\\n # reduce size of lat axis to (latmin,latmax)\\n # Let's home a direct search will be fast enough:\\n lataxis = latAxis( mv )\\n lmin = -1\\n lmax = len(lataxis)\\n if lataxis[0]>=latmin: lmin = 0\\n if lataxis[-1]<=latmax: lmax = len(lataxis)-1\\n if lmin==-1 or lmax==len(lataxis):\\n for l,ax in enumerate(lataxis):\\n if lmin==-1 and ax>=latmin: lmin = max( 0, l )\\n if lmax==len(lataxis) and ax>=latmax: lmax = min( l, len(lataxis) )\\n lataxis_shrunk = lataxis.subaxis(lmin,lmax)\\n mv2shape = list(mv.shape)\\n mv2shape[ilat] = lmax-lmin+1\\n axes[ilat] = lataxis_shrunk\\n mvd1 = numpy.delete( mv, slice(0,lmin), ilat )\\n mvdata = numpy.delete( mvd1, slice(lmax-lmin,len(lataxis)-lmin), ilat )\\n mv2 = cdms2.createVariable( mvdata, axes=axes )\\n\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n avmv = averager( mv2, axis=axes_string )\\n avmv.id = vid # Note that the averager function returns a variable with meaningless id.\\n ammv.units = mv.units\\n\\n return avmv\",\n \"def diff(self, x0, x1):\\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\\n q0 = x0[:nq]\\n q1 = x1[:nq]\\n v0 = x0[-nv:]\\n v1 = x1[-nv:]\\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\\n return np.concatenate([dq.flat, v1 - v0])\",\n \"def __sub__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\\n return self\",\n \"def measurement(params1, params2):\\n s0 = state(params1)\\n s1 = state(params2)\\n val = (np.absolute(np.conj(s0)@s1))**2\\n return val\",\n \"def __rmul__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.gmt_func(other.value, self.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other*obj\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def __sub__(self, other):\\n tmp = VectorHeat1D(self.size)\\n tmp.set_values(self.get_values() - other.get_values())\\n return tmp\",\n \"def diff_v_x1(x1, x2, t=0.):\\n return (omega) ** 2 * x1\",\n \"def __sub__(self, other):\\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])\",\n \"def mag2(self) -> numbers.Number:\\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\\n return mv_val[0]\",\n \"def aminusb0( mv1, mv2 ):\\n mv = mv1[0,] - mv2[0,]\\n if hasattr(mv,'long_name'):\\n if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name\\n mv.long_name = ''\\n return mv\",\n \"def testCalculateTranslationDiff(self):\\n # Test Identity\\n transform1 = numpy.eye(4)\\n transform2 = numpy.eye(4)\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertEqual(result, 0.0)\\n # Test nonzero\\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\\n transform1[0:3, 3] = vector1\\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\\n transform2[0:3, 3] = vector2\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertAlmostEqual(result, 26.9130545, 6)\\n # Order shouldn't matter\\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\\n self.assertAlmostEqual(result, 26.9130545, 6)\",\n \"def calc_difference(ndvi_tile1, ndvi_tile2, output):\\n \\n #open dataset and get Affine transformation and bounding properties \\n with rio.open(ndvi1) as src1:\\n meta = src1.meta.copy()\\n transform = src1.meta[\\\"transform\\\"]\\n x = meta['width']\\n y = meta['height']\\n band1 = src1.read()\\n \\n #open dataset \\n with rio.open(ndvi2) as src2:\\n #read the band as ndarray with the same dimension of src1\\n band2 = src2.read(out_shape=(src1.height, src1.width), \\n resampling=rio.enums.Resampling.bilinear)\\n #create destination for reprojection of src2\\n dst_crs = {'init': 'EPSG:32632'}\\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\\n #reproject the src2 to match src1\\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \\n dst_transform=transform, dst_crs=dst_crs) \\n \\n #calculate difference between reprojected band2 and band1\\n difference = np.subtract(proj_band2, band1)\\n #create outfile\\n outfile = output\\n #write outfile with the properties and resolution of src1\\n with rio.open(outfile, 'w', **meta) as dst:\\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\\n\\n return outfile\",\n \"def substract(self, vector):\\n\\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\\n # self.vector]))\\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)\",\n \"def __rtruediv__(self, other):\\n value = -1 / (self.val * self.val)\\n total = {self.var: other * value}\\n return AutoDiffReverse(other / self.val, None, total)\",\n \"def diff_v_x2(x1, x2, t=0.):\\n return (omega) ** 2 * x2\",\n \"def m1(el1, daz1, el2, daz2):\\n x1=math.cos(el1 * math.pi/180.0)\\n x2=math.cos(el2 * math.pi/180.0)\\n b = (daz2-daz1)/(x2-x1)\\n a = b*x1-daz1\\n return (a,b)\",\n \"def __sub__(self,other):\\n return np.linalg.norm(self.ngdv-other.ngdv)\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def vector(p0, p1):\\n a = p1[0] - p0[0]\\n b = p1[1] - p0[1]\\n return (a, b)\",\n \"def _relative_velocity(vel1, vel2):\\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]\",\n \"def v_from_z(z1, z2):\\n R = (1+z1) / (1+z2)\\n v = const.c * (R**2 - 1)/(1+R**2) \\n\\n return v.to('km/s')\",\n \"def _canonical_sub(poly1, poly2):\\r\\n return _canonical_add(poly1, -poly2)\",\n \"def subtract(raster1, raster2):\\n valid_mask = (\\n (raster1 != nodata) &\\n (raster2 != nodata))\\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\\n result[:] = nodata\\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\\n return result\",\n \"def __sub__(self,other):\\n return Vector(self.x - other.x, self.y-other.y)\\n pass\",\n \"def __rsub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: -1})\",\n \"def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\\n \\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## shortcut \\n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\\n #\\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n \\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def velocity(df0, df1):\\n velocity = df1 - df0\\n return velocity\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, vec4):\\r\\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def getVector(c1, c2):\\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]\",\n \"def __sub__(self, m):\\n nv=Matrice()\\n if self.__mm_type(m):\\n ls=len(self)\\n nv.generate(ls,self.desc())\\n for i in self.desc():\\n for j in range(len(self)):\\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\\n return nv\",\n \"def __sub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: 1})\",\n \"def get_cross2d(v1, v2):\\n return v1[0]*v2[1] - v1[1]*v2[0]\",\n \"def diff(self, x1, x2):\\n return x2 - x1\",\n \"def pv(self, other):\\n\\n assert self.n == other.n == 3, \\\"Produto vetorial definido somente em R3\\\"\\n\\n u, v = self, other\\n\\n return Vetor([u[1] * v[2] - u[2] * v[1],\\n u[2] * v[0] - u[0] * v[2],\\n u[0] * v[1] - u[1] * v[0]])\",\n \"def subtract(self,ctSub):\\n\\n # First confirm eligible for subtraction\\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\\n raise Exception(\\\"Can't subtract because not meshed the same\\\")\\n\\n ctResult = copy.deepcopy(ctSub)# copy the class\\n\\n \\n # Original method\\n # ctResult.u = self.u - ctSub.u\\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\\n\\n # New method\\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\\n\\n\\n return ctResult\",\n \"def __truediv__(self, other):\\n try:\\n value = -1 / (other.val * other.val)\\n total = {self.var: 1 / other.val, other.var: value * self.val}\\n return AutoDiffReverse(self.val / other.val, None, total)\\n except AttributeError:\\n total = {self.var: 1 / other}\\n return AutoDiffReverse(self.val / other, None, total)\",\n \"def distance(v1, v2):\\r\\n return magnitude(*subtract(v2, v1))\",\n \"def subtract(value1, value2):\\n return 1 / (1.0 / value1 - 1.0 / value2)\",\n \"def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\\n return np.linalg.norm(t1 - t2)\",\n \"def mirror_vector_vector(v1, v2):\\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))\",\n \"def test__vector_subtraction__given_two_vectors__return_correct_vector():\\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))\",\n \"def dy(self) -> np.ndarray:\\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])\",\n \"def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def subtraction(self, first_value, second_value):\\n return first_value - second_value\",\n \"def subtract(self, vec2):\\n if type(vec2) != Vector:\\n raise TypeError(\\\"Not a vector\\\")\\n\\n if len(vec2) != len(self):\\n raise DifferentLengthVectors(self, vec2)\\n\\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])\",\n \"def get_mo_ovlp(mo1, mo2, ovlp):\\n ovlp = np.asarray(ovlp)\\n mo1 = np.asarray(mo1)\\n mo2 = np.asarray(mo2)\\n if mo1.ndim == 2:\\n res = reduce(np.dot, (mo1.conj().T, ovlp, mo2))\\n else:\\n assert mo1.shape[0] == mo2.shape[0]\\n spin, nao, nmo1 = mo1.shape\\n nmo2 = mo2.shape[-1]\\n res = np.zeros((spin, nmo1, nmo2), dtype=np.result_type(mo1, mo2))\\n for s in range(spin):\\n res[s] = reduce(np.dot, (mo1[s].conj().T, ovlp, mo2[s]))\\n return res\",\n \"def __rmul__(self, el2):\\n if type(el2) is float or type(el2) is int:\\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\\n elif type(el2) is vector:\\n return vector(el2.y * self.z - el2.z * self.y,\\n el2.z * self.x - el2.x * self.z,\\n el2.x * self.y - el2.y * self.x)\\n else:\\n raise TypeError('Cannot multiply a vector with something'\\n 'that is neither a vector, a float or an int')\",\n \"def from_pts(one, two):\\n\\t\\treturn Vec2(two[0] - one[0], two[1] - one[1])\",\n \"def __truediv__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n return self * other.inv()\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return obj/other\\n newValue = self.value / other\\n return self._newMV(newValue)\",\n \"def __sub__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self.coefficients, other.coefficients\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def __sub__(self, other):\\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, mat4):\\r\\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def TVD(p1, p2):\\n assert p1.shape == p2.shape\\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))\",\n \"def __rtruediv__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other / obj\\n\\n return other * self.inv()\",\n \"def cross(self, other):\\n if isinstance(other, float):\\n return Vector(other*self.y, -other*self.x)\\n\\n if isinstance(other, Vector):\\n return self.x*other.y - self.y*other.x\",\n \"def difference(self, mass_function):\\n result = copy.deepcopy(self)\\n for focal, value in mass_function.items():\\n result.remove_mass((focal, value))\\n\\n newFocals = {}\\n for focal, value in result.items():\\n if value != 0:\\n newFocals[focal] = value\\n result.focals = newFocals\\n return result\",\n \"def l1(x1, x2):\\n return np.abs(x1 - x2)\",\n \"def get_vector(self, transform: pylot.utils.Transform,\\n min_distance: float):\\n wp_index = self._get_index(transform, min_distance)\\n return self.waypoints[wp_index].location.as_vector_2D() - \\\\\\n transform.location.as_vector_2D()\",\n \"def update_variables_momentum(alpha, beta1, var, grad, v):\\n v = beta1 * v + (1-beta1) * grad\\n var = var - alpha * v\\n return var, v\",\n \"def __sub__(self,other):\\n self._obj['u'] -= other._obj['u']\\n self._obj['v'] -= other._obj['v']\\n return self._obj\",\n \"def inverse_linear ( a , b ) :\\n \\n x0 , f0 = a.x , a.fx\\n x1 , f1 = b.x , b.fx\\n\\n if f0 == f1 or isequal ( f0 , f1 ) : return None\\n\\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def diffMat(t1,t2):\\n if len(t1.shape) > 1:\\n T = multVarDiffMat(t1,t2)\\n else:\\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\\n return T\",\n \"def I2_u1(self) -> complex:\\n # \\\"Phase 2 current [A]\\\" is wrong. We need to calculate it ourselves\\n return - self.I1_u1() - self.I3_u1()\",\n \"def __sub__(self, other):\\n n = len(self)\\n\\n if n != len(other):\\n raise(VetorError, \\\"Vetor dimensions are not equal\\\")\\n\\n v = zeros_como(self)\\n\\n for i in range(n):\\n v[i] = self[i] - other[i]\\n\\n return v\",\n \"def __sub__(self, other):\\n return (self.x - other.x, self.y - other.y)\",\n \"def d2(x0,y0,x1,y1):\\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)\",\n \"def _normal_vector(o, p0_3d, p1_3d):\\n # The vector between middle point of v1-v2 and object center location\\n # is the normal vector I'm looking for\\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\\n # normalize so I can to length computation on it\\n vn.normalize()\\n return vn\",\n \"def impulse(self,v1,v2):\\n dv_peri = self.v_peri - v1\\n \\n dv_aphe = self.v_peri - v2\\n \\n return dv_peri, dv_aphe\",\n \"def rmsd(a1, a2):\\n # Check that the arrays are the same size\\n if np.shape(a1) != np.shape(a2):\\n raise Exception(\\\"\\\"\\\"The shape of array 1 is not the same as the shape of array 2. If these arrays represent\\n geometries, the molecules are not the same!\\\"\\\"\\\")\\n\\n # Rotate and translate a2 so that it is as close to a1 as possible\\n R, t = SVD_rotate(a1, a2)\\n a2 = np.dot(R, a2.T)\\n a2 = a2.T + t \\n\\n return np.sqrt(np.mean((a1-a2)**2))\",\n \"def linear_interpolate_release(mvi, j):\\n set_system_state(mvi, 1)\\n lam1 = mvi.system.lambda_()[j]\\n set_system_state(mvi, 2)\\n lam2 = mvi.system.lambda_()[j]\\n\\n # If either of the following loops are entered, there are likely going to\\n # be problems.\\n if (lam1 < 0) and (lam2 < 0):\\n #add_constraints(mvi, mvi._state1_releases)\\n #print mvi.lambda1c[j]\\n #print mvi\\n #raise Exception(\\\"Bad release interpolation.\\\")\\n print 'WARNING: BAD INTERPOLANT'\\n return mvi.t1, mvi.q1\\n\\n if lam1 < 0:\\n return mvi.t1, mvi.q1\\n\\n tr = mvi.t1 - (lam1/(lam2-lam1))*(mvi.t2-mvi.t1)\\n frac = (tr-mvi.t1)/(mvi.t2-mvi.t1)\\n qr = frac*(mvi.q2-mvi.q1)+mvi.q1\\n\\n return tr, qr\",\n \"def sub(o1, o2):\\n return o1-o2\",\n \"def __sub__(self, body):\\n p = self.position.au - body.position.au\\n if self.velocity is None or body.velocity is None:\\n v = None\\n else:\\n v = body.velocity.au_per_d - self.velocity.au_per_d\\n return ICRS(p, v, self.jd)\",\n \"def subtract(self, m): \\n f = m.negate()\\n return self.add(f)\",\n \"def __mul__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\\n return self\",\n \"def projection(v1, v2):\\n v1 = v1.astype(np.float64)\\n\\n if np.any(v1):\\n result = (np.dot(v1, v2) / np.dot(v1, v1)) * v1\\n else:\\n result = np.zeros(3)\\n\\n return result\",\n \"def uncertainty_mm(self,m1,m2):\\n # ID and isolation uncertainty (TO BE FIXED)\\n unc = (self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')/self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')+ \\\\\\n self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1')/self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1'))**2\\n \\n## # trigger (approximate) ==== FIXME!! ===============\\n## hlt_sf_run2011_a_unc = (self._mu7TrgWeight [(m1.pt(),m1.eta())][1]/self._mu7TrgWeight [(m1.pt(),m1.eta())][0] + \\\\\\n## self._mu7TrgWeight [(m2.pt(),m2.eta())][1]/self._mu7TrgWeight [(m2.pt(),m2.eta())][0])**2\\n## hlt_sf_run2011_b_unc = (abs(self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_b_unc += ((self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_c_unc = (abs(self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_c_unc += ((self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## unc += 0.002*hlt_sf_run2011_a_unc + 0.643*hlt_sf_run2011_b_unc + 0.024*hlt_sf_run2011_c_unc\\n \\n return sqrt(unc)\",\n \"def __sub__(self, other):\\n if isinstance(other, Vector):\\n a = self._ar - other._ar\\n else:\\n a = self._ar - numpy.array(other)\\n return Vector(a)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6842053","0.6623479","0.6418362","0.6201654","0.6115403","0.6079604","0.6074351","0.588521","0.5873079","0.5828353","0.57805383","0.5740809","0.5714796","0.56725395","0.56446743","0.55954033","0.55467427","0.55024266","0.5496881","0.5487313","0.54748785","0.54630286","0.54496825","0.54305613","0.5418633","0.5405435","0.5384061","0.53684366","0.5313283","0.5254234","0.52126145","0.52074355","0.51876616","0.51811635","0.5180406","0.51714337","0.5145252","0.5119302","0.51068985","0.5092851","0.50873923","0.5082714","0.50768715","0.50679207","0.5061786","0.5053691","0.5035341","0.50243104","0.50237876","0.50105715","0.5007824","0.5003513","0.49856675","0.49827492","0.49679112","0.496662","0.496539","0.49551266","0.49384913","0.49143437","0.4907107","0.48974824","0.4880167","0.48794073","0.4878945","0.4874282","0.4868803","0.48654538","0.48545754","0.48518372","0.48484486","0.48447517","0.4841682","0.48394045","0.4835087","0.4834547","0.48226297","0.48224428","0.48211747","0.481329","0.47989306","0.4798411","0.4790591","0.4786222","0.4784766","0.47791335","0.47555456","0.47481608","0.47475934","0.47473955","0.47472167","0.47409266","0.4734393","0.47305197","0.47254404","0.4721176","0.47209662","0.47140273","0.4712793","0.471194"],"string":"[\n \"0.6842053\",\n \"0.6623479\",\n \"0.6418362\",\n \"0.6201654\",\n \"0.6115403\",\n \"0.6079604\",\n \"0.6074351\",\n \"0.588521\",\n \"0.5873079\",\n \"0.5828353\",\n \"0.57805383\",\n \"0.5740809\",\n \"0.5714796\",\n \"0.56725395\",\n \"0.56446743\",\n \"0.55954033\",\n \"0.55467427\",\n \"0.55024266\",\n \"0.5496881\",\n \"0.5487313\",\n \"0.54748785\",\n \"0.54630286\",\n \"0.54496825\",\n \"0.54305613\",\n \"0.5418633\",\n \"0.5405435\",\n \"0.5384061\",\n \"0.53684366\",\n \"0.5313283\",\n \"0.5254234\",\n \"0.52126145\",\n \"0.52074355\",\n \"0.51876616\",\n \"0.51811635\",\n \"0.5180406\",\n \"0.51714337\",\n \"0.5145252\",\n \"0.5119302\",\n \"0.51068985\",\n \"0.5092851\",\n \"0.50873923\",\n \"0.5082714\",\n \"0.50768715\",\n \"0.50679207\",\n \"0.5061786\",\n \"0.5053691\",\n \"0.5035341\",\n \"0.50243104\",\n \"0.50237876\",\n \"0.50105715\",\n \"0.5007824\",\n \"0.5003513\",\n \"0.49856675\",\n \"0.49827492\",\n \"0.49679112\",\n \"0.496662\",\n \"0.496539\",\n \"0.49551266\",\n \"0.49384913\",\n \"0.49143437\",\n \"0.4907107\",\n \"0.48974824\",\n \"0.4880167\",\n \"0.48794073\",\n \"0.4878945\",\n \"0.4874282\",\n \"0.4868803\",\n \"0.48654538\",\n \"0.48545754\",\n \"0.48518372\",\n \"0.48484486\",\n \"0.48447517\",\n \"0.4841682\",\n \"0.48394045\",\n \"0.4835087\",\n \"0.4834547\",\n \"0.48226297\",\n \"0.48224428\",\n \"0.48211747\",\n \"0.481329\",\n \"0.47989306\",\n \"0.4798411\",\n \"0.4790591\",\n \"0.4786222\",\n \"0.4784766\",\n \"0.47791335\",\n \"0.47555456\",\n \"0.47481608\",\n \"0.47475934\",\n \"0.47473955\",\n \"0.47472167\",\n \"0.47409266\",\n \"0.4734393\",\n \"0.47305197\",\n \"0.47254404\",\n \"0.4721176\",\n \"0.47209662\",\n \"0.47140273\",\n \"0.4712793\",\n \"0.471194\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5110343"},"document_rank":{"kind":"string","value":"38"}}},{"rowIdx":19886,"cells":{"query":{"kind":"string","value":"returns a transient variable representing mv1mv2, where mv1 and mv2 are variables, normally transient variables, which are required to depend only one axis. To perform the subtraction, one of the variables is linearly interpolated to the axis of the other. The axis used will be the coarsest (fewest points) of the two axes. Note that if mv1 _or_ mv2 have a missing value at index i, then the return value (mv1mv2) will also have a missing value at index i."},"document":{"kind":"string","value":"def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb"},"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 basic_sub(mv1, mv2):\n obj = expand(mv1.obj - mv2.obj)\n return MV(obj)","def displacement(cls, v1, v2):\n return np.array([v2 - v1])","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def __rsub__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if not mv:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other - obj\n newValue = other.value - self.value\n\n return self._newMV(newValue)","def displacement(cls, v1, v2):\n return (v2 - v1).copy()","def vector_sub(v1,v2):\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)","def subm(f1, f2):\n from numpy import array, clip\n\n if type(f2) is array:\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\n bottom,top=limits(f1)\n y = clip(f1.astype('d') - f2, bottom, top)\n y = y.astype(f1.dtype)\n return y","def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\n\n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n ##\n res = float ( var1 ) - float ( var2 )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## \n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return var1 ## SHORTCUT\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_subtract ( var1 , var2 , name , title )\n\n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def vd(v2,v1):\n return v2-v1","def v1Mv2(v1, M, v2):\r\n return v1[:, None] * M * v2[None, :]","def sub(first, other):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)","def __sub__(self, other: TranslationType):\n return Translation(\n self.x - other.x,\n self.y - other.y,\n self.z - other.z)","def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals","def __sub__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\n return self","def vector_subtract(v1, v2):\n return v1[0] - v2[0], v1[1] - v2[1]","def subtract_vectors(vector_1, vector_2):\n new_coordinates = []\n index = 0\n while index < vector_1.dimension:\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\n new_coordinates.append(new_value)\n index += 1\n new_vector = Vector(new_coordinates)\n return new_vector","def __sub__(self, other):\n tmp = VectorHeat1D(self.size)\n tmp.set_values(self.get_values() - other.get_values())\n return tmp","def __rtruediv__(self, other):\n value = -1 / (self.val * self.val)\n total = {self.var: other * value}\n return AutoDiffReverse(other / self.val, None, total)","def __sub__(self, other):\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def diff_v_x1(x1, x2, t=0.):\n return (omega) ** 2 * x1","def measurement(params1, params2):\n s0 = state(params1)\n s1 = state(params2)\n val = (np.absolute(np.conj(s0)@s1))**2\n return val","def __truediv__(self, other):\n try:\n value = -1 / (other.val * other.val)\n total = {self.var: 1 / other.val, other.var: value * self.val}\n return AutoDiffReverse(self.val / other.val, None, total)\n except AttributeError:\n total = {self.var: 1 / other}\n return AutoDiffReverse(self.val / other, None, total)","def get_cross2d(v1, v2):\n return v1[0]*v2[1] - v1[1]*v2[0]","def diff(self, x0, x1):\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\n q0 = x0[:nq]\n q1 = x1[:nq]\n v0 = x0[-nv:]\n v1 = x1[-nv:]\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\n return np.concatenate([dq.flat, v1 - v0])","def __rmul__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.gmt_func(other.value, self.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other*obj\n newValue = other*self.value\n\n return self._newMV(newValue)","def levvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lev_axis1 = levAxis(mv1)\n lev_axis2 = levAxis(mv2)\n if len(lev_axis1)<=len(lev_axis2):\n lev_axis = lev_axis1\n mv = mv1\n else:\n lev_axis = lev_axis2\n mv = mv2\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\n attributes={'units':lev_axis.units} )\n return levmv","def diff_v_x2(x1, x2, t=0.):\n return (omega) ** 2 * x2","def __truediv__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n return self * other.inv()\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return obj/other\n newValue = self.value / other\n return self._newMV(newValue)","def __sub__(self,other):\n return np.linalg.norm(self.ngdv-other.ngdv)","def __rsub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: -1})","def cross(self, other):\n if isinstance(other, float):\n return Vector(other*self.y, -other*self.x)\n\n if isinstance(other, Vector):\n return self.x*other.y - self.y*other.x","def substract(self, vector):\n\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\n # self.vector]))\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)","def __sub__(self, other):\n try:\n total = {self.var: 1, other.var: -1}\n return AutoDiffReverse(self.val - other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val - other, None, {self.var: 1})","def __sub__(self, other):\r\n if isinstance(other, vec4):\r\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def __rtruediv__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other / obj\n\n return other * self.inv()","def __sub__(self,other):\n return Vector(self.x - other.x, self.y-other.y)\n pass","def inverse_linear ( a , b ) :\n \n x0 , f0 = a.x , a.fx\n x1 , f1 = b.x , b.fx\n\n if f0 == f1 or isequal ( f0 , f1 ) : return None\n\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )","def testCalculateTranslationDiff(self):\n # Test Identity\n transform1 = numpy.eye(4)\n transform2 = numpy.eye(4)\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertEqual(result, 0.0)\n # Test nonzero\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\n transform1[0:3, 3] = vector1\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\n transform2[0:3, 3] = vector2\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertAlmostEqual(result, 26.9130545, 6)\n # Order shouldn't matter\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\n self.assertAlmostEqual(result, 26.9130545, 6)","def __sub__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self.coefficients, other.coefficients\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def pv(self, other):\n\n assert self.n == other.n == 3, \"Produto vetorial definido somente em R3\"\n\n u, v = self, other\n\n return Vetor([u[1] * v[2] - u[2] * v[1],\n u[2] * v[0] - u[0] * v[2],\n u[0] * v[1] - u[1] * v[0]])","def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb","def velocity(df0, df1):\n velocity = df1 - df0\n return velocity","def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)","def subtract(value1, value2):\n return 1 / (1.0 / value1 - 1.0 / value2)","def mag2(self) -> numbers.Number:\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\n return mv_val[0]","def calc_difference(ndvi_tile1, ndvi_tile2, output):\n \n #open dataset and get Affine transformation and bounding properties \n with rio.open(ndvi1) as src1:\n meta = src1.meta.copy()\n transform = src1.meta[\"transform\"]\n x = meta['width']\n y = meta['height']\n band1 = src1.read()\n \n #open dataset \n with rio.open(ndvi2) as src2:\n #read the band as ndarray with the same dimension of src1\n band2 = src2.read(out_shape=(src1.height, src1.width), \n resampling=rio.enums.Resampling.bilinear)\n #create destination for reprojection of src2\n dst_crs = {'init': 'EPSG:32632'}\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\n #reproject the src2 to match src1\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \n dst_transform=transform, dst_crs=dst_crs) \n \n #calculate difference between reprojected band2 and band1\n difference = np.subtract(proj_band2, band1)\n #create outfile\n outfile = output\n #write outfile with the properties and resolution of src1\n with rio.open(outfile, 'w', **meta) as dst:\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\n\n return outfile","def subtraction(self, first_value, second_value):\n return first_value - second_value","def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\n \n f1 = isinstance ( var1 , num_types )\n f2 = isinstance ( var2 , num_types )\n\n if f1 and f2 :\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\n return ROOT.RooRealConstant.value ( res ) \n elif f1 :\n ## shortcut \n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\n #\n var1 = ROOT.RooRealConstant.value ( var1 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n elif f2 :\n ## shortcut \n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\n #\n var2 = ROOT.RooRealConstant.value ( var2 ) \n return self.vars_asymmetry ( var1 , var2 , name , title )\n \n self.aux_keep.append ( var1 )\n self.aux_keep.append ( var2 )\n\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\n self.aux_keep.append ( result )\n \n return result","def impulse(self,v1,v2):\n dv_peri = self.v_peri - v1\n \n dv_aphe = self.v_peri - v2\n \n return dv_peri, dv_aphe","def df(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\n out = -y1\n div = y1 * y2\n div.exp_().add_(1)\n out.div_(div)\n return out","def subtract(self, vec2):\n if type(vec2) != Vector:\n raise TypeError(\"Not a vector\")\n\n if len(vec2) != len(self):\n raise DifferentLengthVectors(self, vec2)\n\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])","def vector(p0, p1):\n a = p1[0] - p0[0]\n b = p1[1] - p0[1]\n return (a, b)","def diff(self, x1, x2):\n return x2 - x1","def __sub__(self, other):\n if isinstance(other, Vector):\n a = self._ar - other._ar\n else:\n a = self._ar - numpy.array(other)\n return Vector(a)","def quaternion_subtraction(self, q1, q2):\n\n # Unpack these quaternions\n a_scalar, a_vecx, a_vecy, a_vecz = torch.unbind(q1,\n dim=-1)\n b_scalar, b_vecx, b_vecy, b_vecz = torch.unbind(q2,\n dim=-1)\n\n r_scalar = a_scalar - b_scalar\n r_vecx = a_vecx - b_vecx\n r_vecy = a_vecy - b_vecy\n r_vecz = a_vecz - b_vecz\n\n return torch.stack(\n [r_scalar, r_vecx, r_vecy, r_vecz],\n dim=-1\n )","def __sub__(self, other):\n n = len(self)\n\n if n != len(other):\n raise(VetorError, \"Vetor dimensions are not equal\")\n\n v = zeros_como(self)\n\n for i in range(n):\n v[i] = self[i] - other[i]\n\n return v","def __rmul__(self, el2):\n if type(el2) is float or type(el2) is int:\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\n elif type(el2) is vector:\n return vector(el2.y * self.z - el2.z * self.y,\n el2.z * self.x - el2.x * self.z,\n el2.x * self.y - el2.y * self.x)\n else:\n raise TypeError('Cannot multiply a vector with something'\n 'that is neither a vector, a float or an int')","def __rmul__(self, other):\n\t\t# Maintain state of self and create new trace variable new_var\n\t\tnew_var = Var(self.val, self.der)\n\t\treturn new_var.__mul__(other)","def subtract(self, other, label=None, atol=1.0E-12):\n # check the two solutions share the same grid\n assert numpy.allclose(self.x, other.x, atol=atol)\n assert numpy.allclose(self.y, other.y, atol=atol)\n assert self.values.shape == other.values.shape\n if not label:\n label = self.label + '-subtracted'\n return Field(label=label,\n time_step=self.time_step,\n x=self.x, y=self.y,\n values=self.values - other.values)","def dy(self) -> np.ndarray:\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])","def mirror_vector_vector(v1, v2):\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))","def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\n return np.linalg.norm(t1 - t2)","def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]","def test__vector_subtraction__given_two_vectors__return_correct_vector():\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))","def __sub__(self, other):\r\n if isinstance(other, mat4):\r\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\r\n else:\r\n raise TypeError, \"unsupported operand type for -\"","def subtract(raster1, raster2):\n valid_mask = (\n (raster1 != nodata) &\n (raster2 != nodata))\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\n result[:] = nodata\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\n return result","def __sub__(self, other):\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])","def _canonical_sub(poly1, poly2):\r\n return _canonical_add(poly1, -poly2)","def __sub__(self, m):\n nv=Matrice()\n if self.__mm_type(m):\n ls=len(self)\n nv.generate(ls,self.desc())\n for i in self.desc():\n for j in range(len(self)):\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\n return nv","def TVD(p1, p2):\n assert p1.shape == p2.shape\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))","def __sub__(self, other):\n\t\tif isinstance(other, int) or isinstance(other, float):\n\t\t\t# Maintain state of self and create new trace variable new_var\n\t\t\tnew_var = Var(self.val, self.der)\n\t\t\treturn new_var.__add__(-other)\n\t\treturn (-other).__add__(self)","def subtract(self,ctSub):\n\n # First confirm eligible for subtraction\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\n raise Exception(\"Can't subtract because not meshed the same\")\n\n ctResult = copy.deepcopy(ctSub)# copy the class\n\n \n # Original method\n # ctResult.u = self.u - ctSub.u\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\n\n # New method\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\n\n\n return ctResult","def I2_u1(self) -> complex:\n # \"Phase 2 current [A]\" is wrong. We need to calculate it ourselves\n return - self.I1_u1() - self.I3_u1()","def diffMat(t1,t2):\n if len(t1.shape) > 1:\n T = multVarDiffMat(t1,t2)\n else:\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\n return T","def v_from_z(z1, z2):\n R = (1+z1) / (1+z2)\n v = const.c * (R**2 - 1)/(1+R**2) \n\n return v.to('km/s')","def subtract(x, y):\n return Shape(x.wallTime, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk)","def interpolate(qfv, rm1, qweight):\n\n\t# set variables\n\trm3 = defaultdict(float)\n\tvocab = set()\n\n\t# update vocab w/ terms from both feature vectors\n\tvocab.update(qfv.keys())\n\tvocab.update(rm1.keys())\n\n\t# interpolate\n\tfor term in vocab:\n\t\tweight = qweight * qfv[term] + (1 - qweight) * rm1[term]\n\t\trm3[term] = weight\n\treturn rm3","def value(self):\n nd1 = super().nd1()\n nd2 = super().nd2()\n f1 = nd1 * self.s\n f2 = nd2 * self.x * math.e ** (-self.rf * self.t)\n return f1 - f2","def __sub__(self, other):\n if not self.unit.is_compatible(other.unit):\n raise TypeError('Cannot subtract two quantities with incompatible units \"%s\" and \"%s\".' % (self.unit, other.unit))\n value = self._value - other.value_in_unit(self.unit)\n unit = self.unit\n return Quantity(value, unit)","def __rmul__(self, other):\n return TensorWithIndices(other*self._tensor, \n self._con + '_' + self._cov)","def __rsub__(self, other):\n other = _to_complex(other)\n return ComplexVal(other.r - self.r, other.i - self.i)","def __mul__(self, other: float) -> 'Translation':\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\n return self","def cross(self, other):\n return type(self)(\n self.y * other.z - self.z * other.y,\n -self.x * other.z + self.z * other.x,\n self.x * other.y - self.y * other.x,\n )","def cpvunrotate(self, other):\n return Vec2d(self.x*other.x + self.y*other.y, self.y*other.x - self.x*other.y)","def d2(x0,y0,x1,y1):\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)","def diff(self, word1, word2):\n v = self._vecs[self._index[word1]] - self._vecs[self._index[word2]]\n return v / np.linalg.norm(v)","def get_mo_ovlp(mo1, mo2, ovlp):\n ovlp = np.asarray(ovlp)\n mo1 = np.asarray(mo1)\n mo2 = np.asarray(mo2)\n if mo1.ndim == 2:\n res = reduce(np.dot, (mo1.conj().T, ovlp, mo2))\n else:\n assert mo1.shape[0] == mo2.shape[0]\n spin, nao, nmo1 = mo1.shape\n nmo2 = mo2.shape[-1]\n res = np.zeros((spin, nmo1, nmo2), dtype=np.result_type(mo1, mo2))\n for s in range(spin):\n res[s] = reduce(np.dot, (mo1[s].conj().T, ovlp, mo2[s]))\n return res","def __sub__(self, other):\n if isinstance(other, int) or isinstance(other, float):\n return Volt(self.volts - other, self.volt_unit, self.freq, self.freq_unit)\n if self.volt_unit != other.volt_unit:\n raise ArithmeticError(f\"The objects' volt units {self.volt_unit} and {other.volt_unit} are not the same.\")\n if self.freq != other.frequency:\n raise ArithmeticError(f\"The objects' frequency {self.freq} and {other.frequency} are not the same.\")\n if self.freq_unit != other.freq_unit:\n raise ArithmeticError(f\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \"\n f\"are not the same.\")\n volt_sum = self.volts - other.volts\n return Volt(volt_sum, self.volt_unit, self.freq, self.freq_unit)","def __sub__(self, other):\n if isinstance(other, Factorization):\n other = other.value()\n return self.value() - other","def sub(o1, o2):\n return o1-o2","def calc(operand_1, operand_2):\n return operand_1 - operand_2","def calc(operand_1, operand_2):\n return operand_1 - operand_2","def cross(v1: Vector, v2: Vector) -> Vector: # Function is fucked TODO\n if len(v1.coords) != 3 or len(v2.coords) != 3:\n raise ValueError(\"Vectors have to be 3 fucking D, nøøb\")\n x = v1.y * v2.z - v1.z * v2.y\n y = v1.z * v2.x - v1.x * v2.z\n z = v1.x * v2.y - v1.y * v2.x\n return Vector(x, y, z)","def aminusb0( mv1, mv2 ):\n mv = mv1[0,] - mv2[0,]\n if hasattr(mv,'long_name'):\n if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name\n mv.long_name = ''\n return mv","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def test_subtracting_constant():\n a = fwd.Variable()\n assert equals((a-1).derivative_at(a, {a: 0.0}), 1.0)\n assert equals((1-a).derivative_at(a, {a: 0.0}), -1.0)","def _relative_velocity(vel1, vel2):\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]","def GetCorr_and_RMSE(v1, v2):\n\treturn pearsonr(v1,v2)[0], math.sqrt(np.mean([(a-b)**2 for a,b in zip(v1,v2)]))"],"string":"[\n \"def basic_sub(mv1, mv2):\\n obj = expand(mv1.obj - mv2.obj)\\n return MV(obj)\",\n \"def displacement(cls, v1, v2):\\n return np.array([v2 - v1])\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def __rsub__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if not mv:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other - obj\\n newValue = other.value - self.value\\n\\n return self._newMV(newValue)\",\n \"def displacement(cls, v1, v2):\\n return (v2 - v1).copy()\",\n \"def vector_sub(v1,v2):\\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)\",\n \"def subm(f1, f2):\\n from numpy import array, clip\\n\\n if type(f2) is array:\\n assert f1.dtype == f2.dtype, 'Cannot have different datatypes:'\\n bottom,top=limits(f1)\\n y = clip(f1.astype('d') - f2, bottom, top)\\n y = y.astype(f1.dtype)\\n return y\",\n \"def vars_subtract ( self , var1 , var2 , name = '' , title = '' ) :\\n\\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n ##\\n res = float ( var1 ) - float ( var2 )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## \\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return var1 ## SHORTCUT\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_subtract ( var1 , var2 , name , title )\\n\\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Subtraction ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def vd(v2,v1):\\n return v2-v1\",\n \"def v1Mv2(v1, M, v2):\\r\\n return v1[:, None] * M * v2[None, :]\",\n \"def sub(first, other):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)\",\n \"def __sub__(self, other: TranslationType):\\n return Translation(\\n self.x - other.x,\\n self.y - other.y,\\n self.z - other.z)\",\n \"def interp2( newaxis1, mv ):\\n missing = mv.get_fill_value()\\n axes = allAxes(mv)\\n if len(newaxis1[:])>len(axes[1][:]): return mv\\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\\n for i in range(len( axes[0] )):\\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\\n # the mask - which numpy.interp treats False as 0, True as 1:\\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\\n right=missing ) )>0\\n return new_vals\",\n \"def __sub__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x - other, self._vector.y - other, self._vector.z - other))\\n return self\",\n \"def vector_subtract(v1, v2):\\n return v1[0] - v2[0], v1[1] - v2[1]\",\n \"def subtract_vectors(vector_1, vector_2):\\n new_coordinates = []\\n index = 0\\n while index < vector_1.dimension:\\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\\n new_coordinates.append(new_value)\\n index += 1\\n new_vector = Vector(new_coordinates)\\n return new_vector\",\n \"def __sub__(self, other):\\n tmp = VectorHeat1D(self.size)\\n tmp.set_values(self.get_values() - other.get_values())\\n return tmp\",\n \"def __rtruediv__(self, other):\\n value = -1 / (self.val * self.val)\\n total = {self.var: other * value}\\n return AutoDiffReverse(other / self.val, None, total)\",\n \"def __sub__(self, other):\\n return Vec2d(self.v[0] - other[0], self.v[1] - other[1])\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def diff_v_x1(x1, x2, t=0.):\\n return (omega) ** 2 * x1\",\n \"def measurement(params1, params2):\\n s0 = state(params1)\\n s1 = state(params2)\\n val = (np.absolute(np.conj(s0)@s1))**2\\n return val\",\n \"def __truediv__(self, other):\\n try:\\n value = -1 / (other.val * other.val)\\n total = {self.var: 1 / other.val, other.var: value * self.val}\\n return AutoDiffReverse(self.val / other.val, None, total)\\n except AttributeError:\\n total = {self.var: 1 / other}\\n return AutoDiffReverse(self.val / other, None, total)\",\n \"def get_cross2d(v1, v2):\\n return v1[0]*v2[1] - v1[1]*v2[0]\",\n \"def diff(self, x0, x1):\\n nq, nv, nx = self.model.nq, self.model.nv, self.nx\\n assert (x0.shape == (nx, ) and x1.shape == (nx, ))\\n q0 = x0[:nq]\\n q1 = x1[:nq]\\n v0 = x0[-nv:]\\n v1 = x1[-nv:]\\n dq = pinocchio.difference(self.model, a2m(q0), a2m(q1))\\n return np.concatenate([dq.flat, v1 - v0])\",\n \"def __rmul__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.gmt_func(other.value, self.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other*obj\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def levvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lev_axis1 = levAxis(mv1)\\n lev_axis2 = levAxis(mv2)\\n if len(lev_axis1)<=len(lev_axis2):\\n lev_axis = lev_axis1\\n mv = mv1\\n else:\\n lev_axis = lev_axis2\\n mv = mv2\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='levels',\\n attributes={'units':lev_axis.units} )\\n return levmv\",\n \"def diff_v_x2(x1, x2, t=0.):\\n return (omega) ** 2 * x2\",\n \"def __truediv__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n return self * other.inv()\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return obj/other\\n newValue = self.value / other\\n return self._newMV(newValue)\",\n \"def __sub__(self,other):\\n return np.linalg.norm(self.ngdv-other.ngdv)\",\n \"def __rsub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: -1})\",\n \"def cross(self, other):\\n if isinstance(other, float):\\n return Vector(other*self.y, -other*self.x)\\n\\n if isinstance(other, Vector):\\n return self.x*other.y - self.y*other.x\",\n \"def substract(self, vector):\\n\\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\\n # self.vector]))\\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)\",\n \"def __sub__(self, other):\\n try:\\n total = {self.var: 1, other.var: -1}\\n return AutoDiffReverse(self.val - other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val - other, None, {self.var: 1})\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, vec4):\\r\\n return vec4(self.x-other.x, self.y-other.y, self.z-other.z, self.w-other.w)\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def __rtruediv__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other / obj\\n\\n return other * self.inv()\",\n \"def __sub__(self,other):\\n return Vector(self.x - other.x, self.y-other.y)\\n pass\",\n \"def inverse_linear ( a , b ) :\\n \\n x0 , f0 = a.x , a.fx\\n x1 , f1 = b.x , b.fx\\n\\n if f0 == f1 or isequal ( f0 , f1 ) : return None\\n\\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )\",\n \"def testCalculateTranslationDiff(self):\\n # Test Identity\\n transform1 = numpy.eye(4)\\n transform2 = numpy.eye(4)\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertEqual(result, 0.0)\\n # Test nonzero\\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\\n transform1[0:3, 3] = vector1\\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\\n transform2[0:3, 3] = vector2\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertAlmostEqual(result, 26.9130545, 6)\\n # Order shouldn't matter\\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\\n self.assertAlmostEqual(result, 26.9130545, 6)\",\n \"def __sub__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self.coefficients, other.coefficients\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def pv(self, other):\\n\\n assert self.n == other.n == 3, \\\"Produto vetorial definido somente em R3\\\"\\n\\n u, v = self, other\\n\\n return Vetor([u[1] * v[2] - u[2] * v[1],\\n u[2] * v[0] - u[0] * v[2],\\n u[0] * v[1] - u[1] * v[0]])\",\n \"def aminusb_2ax( mv1, mv2 ):\\n return mv2\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n missing = mv1.get_fill_value()\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n if axes1 is None or axes2 is None: return None\\n if len(axes1)!=2: print \\\"ERROR @1, wrong number of axes for aminusb_2ax\\\",axes1\\n if len(axes2)!=2: print \\\"ERROR @2, wrong number of axes for aminusb_2ax\\\",axes2\\n if len(axes1[0])==len(axes2[0]):\\n # Only axis2 differs, there's a better way...\\n return aminusb_ax2( mv1, mv2 )\\n if len(axes1[0])<=len(axes2[0]):\\n if len(axes1[1])<=len(axes2[1]):\\n mv1new = mv1\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid1 = mv1.getGrid()\\n mv2new = mv2.regrid(grid1)\\n else:\\n # Interpolate mv1 from axis1[1] to axis2[1]\\n # Interpolate mv2 from axis2[0] to axis1[0]\\n print \\\"ERROR @3, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n if len(axes1[1])<=len(axes2[1]):\\n # Interpolate mv1 from axis1[0] to axis2[0]\\n # Interpolate mv2 from axis2[1] to axis1[1]\\n print \\\"ERROR @4, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n mv2new = mv2\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid2 = mv2.getGrid()\\n mv1new = mv1.regrid(grid2)\\n aminusb = mv1new - mv2new\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def velocity(df0, df1):\\n velocity = df1 - df0\\n return velocity\",\n \"def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)\",\n \"def subtract(value1, value2):\\n return 1 / (1.0 / value1 - 1.0 / value2)\",\n \"def mag2(self) -> numbers.Number:\\n mv_val = self.layout.gmt_func(self.layout.adjoint_func(self.value), self.value)\\n return mv_val[0]\",\n \"def calc_difference(ndvi_tile1, ndvi_tile2, output):\\n \\n #open dataset and get Affine transformation and bounding properties \\n with rio.open(ndvi1) as src1:\\n meta = src1.meta.copy()\\n transform = src1.meta[\\\"transform\\\"]\\n x = meta['width']\\n y = meta['height']\\n band1 = src1.read()\\n \\n #open dataset \\n with rio.open(ndvi2) as src2:\\n #read the band as ndarray with the same dimension of src1\\n band2 = src2.read(out_shape=(src1.height, src1.width), \\n resampling=rio.enums.Resampling.bilinear)\\n #create destination for reprojection of src2\\n dst_crs = {'init': 'EPSG:32632'}\\n proj_band2 = np.empty(src1.shape, dtype=np.float32)\\n #reproject the src2 to match src1\\n warp.reproject(band2, destination=proj_band2, src_transform=src2.transform, src_crs=src2.crs, \\n dst_transform=transform, dst_crs=dst_crs) \\n \\n #calculate difference between reprojected band2 and band1\\n difference = np.subtract(proj_band2, band1)\\n #create outfile\\n outfile = output\\n #write outfile with the properties and resolution of src1\\n with rio.open(outfile, 'w', **meta) as dst:\\n dst.write(difference, window=rio.windows.Window(col_off=0, row_off=0, width=x, height=y))\\n\\n return outfile\",\n \"def subtraction(self, first_value, second_value):\\n return first_value - second_value\",\n \"def vars_asymmetry ( self , var1 , var2 , name = '' , title = '' ) :\\n \\n f1 = isinstance ( var1 , num_types )\\n f2 = isinstance ( var2 , num_types )\\n\\n if f1 and f2 :\\n res = ( float ( var1 ) - float ( var2 ) ) / ( float ( var2 ) + float ( var1 ) )\\n return ROOT.RooRealConstant.value ( res ) \\n elif f1 :\\n ## shortcut \\n if 0 == var1 : return ROOT.RooRealConstant.value ( -1 ) ## shortcut\\n #\\n var1 = ROOT.RooRealConstant.value ( var1 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n elif f2 :\\n ## shortcut \\n if 0 == var2 : return ROOT.RooRealConstant.value ( 1 ) ## shortcut\\n #\\n var2 = ROOT.RooRealConstant.value ( var2 ) \\n return self.vars_asymmetry ( var1 , var2 , name , title )\\n \\n self.aux_keep.append ( var1 )\\n self.aux_keep.append ( var2 )\\n\\n result = Ostap.MoreRooFit.Asymmetry ( var1 , var2 )\\n self.aux_keep.append ( result )\\n \\n return result\",\n \"def impulse(self,v1,v2):\\n dv_peri = self.v_peri - v1\\n \\n dv_aphe = self.v_peri - v2\\n \\n return dv_peri, dv_aphe\",\n \"def df(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\\n out = -y1\\n div = y1 * y2\\n div.exp_().add_(1)\\n out.div_(div)\\n return out\",\n \"def subtract(self, vec2):\\n if type(vec2) != Vector:\\n raise TypeError(\\\"Not a vector\\\")\\n\\n if len(vec2) != len(self):\\n raise DifferentLengthVectors(self, vec2)\\n\\n return Vector(*[self[i]-vec2[i] for i in range(len(self))])\",\n \"def vector(p0, p1):\\n a = p1[0] - p0[0]\\n b = p1[1] - p0[1]\\n return (a, b)\",\n \"def diff(self, x1, x2):\\n return x2 - x1\",\n \"def __sub__(self, other):\\n if isinstance(other, Vector):\\n a = self._ar - other._ar\\n else:\\n a = self._ar - numpy.array(other)\\n return Vector(a)\",\n \"def quaternion_subtraction(self, q1, q2):\\n\\n # Unpack these quaternions\\n a_scalar, a_vecx, a_vecy, a_vecz = torch.unbind(q1,\\n dim=-1)\\n b_scalar, b_vecx, b_vecy, b_vecz = torch.unbind(q2,\\n dim=-1)\\n\\n r_scalar = a_scalar - b_scalar\\n r_vecx = a_vecx - b_vecx\\n r_vecy = a_vecy - b_vecy\\n r_vecz = a_vecz - b_vecz\\n\\n return torch.stack(\\n [r_scalar, r_vecx, r_vecy, r_vecz],\\n dim=-1\\n )\",\n \"def __sub__(self, other):\\n n = len(self)\\n\\n if n != len(other):\\n raise(VetorError, \\\"Vetor dimensions are not equal\\\")\\n\\n v = zeros_como(self)\\n\\n for i in range(n):\\n v[i] = self[i] - other[i]\\n\\n return v\",\n \"def __rmul__(self, el2):\\n if type(el2) is float or type(el2) is int:\\n return vector(el2 * self.x, el2 * self.y, el2 * self.z)\\n elif type(el2) is vector:\\n return vector(el2.y * self.z - el2.z * self.y,\\n el2.z * self.x - el2.x * self.z,\\n el2.x * self.y - el2.y * self.x)\\n else:\\n raise TypeError('Cannot multiply a vector with something'\\n 'that is neither a vector, a float or an int')\",\n \"def __rmul__(self, other):\\n\\t\\t# Maintain state of self and create new trace variable new_var\\n\\t\\tnew_var = Var(self.val, self.der)\\n\\t\\treturn new_var.__mul__(other)\",\n \"def subtract(self, other, label=None, atol=1.0E-12):\\n # check the two solutions share the same grid\\n assert numpy.allclose(self.x, other.x, atol=atol)\\n assert numpy.allclose(self.y, other.y, atol=atol)\\n assert self.values.shape == other.values.shape\\n if not label:\\n label = self.label + '-subtracted'\\n return Field(label=label,\\n time_step=self.time_step,\\n x=self.x, y=self.y,\\n values=self.values - other.values)\",\n \"def dy(self) -> np.ndarray:\\n return np.array([self.p1[1], self.p2[1] - self.p1[1], 1 - self.p2[1]])\",\n \"def mirror_vector_vector(v1, v2):\\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))\",\n \"def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\\n return np.linalg.norm(t1 - t2)\",\n \"def getVector(c1, c2):\\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]\",\n \"def test__vector_subtraction__given_two_vectors__return_correct_vector():\\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))\",\n \"def __sub__(self, other):\\r\\n if isinstance(other, mat4):\\r\\n return mat4(map(lambda x,y: x-y, self.mlist, other.mlist))\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for -\\\"\",\n \"def subtract(raster1, raster2):\\n valid_mask = (\\n (raster1 != nodata) &\\n (raster2 != nodata))\\n result = numpy.empty(raster1.shape, dtype=numpy.float32)\\n result[:] = nodata\\n result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]\\n return result\",\n \"def __sub__(self, other):\\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])\",\n \"def _canonical_sub(poly1, poly2):\\r\\n return _canonical_add(poly1, -poly2)\",\n \"def __sub__(self, m):\\n nv=Matrice()\\n if self.__mm_type(m):\\n ls=len(self)\\n nv.generate(ls,self.desc())\\n for i in self.desc():\\n for j in range(len(self)):\\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\\n return nv\",\n \"def TVD(p1, p2):\\n assert p1.shape == p2.shape\\n return 0.5 * np.sum(np.absolute(np.subtract(p1, p2)))\",\n \"def __sub__(self, other):\\n\\t\\tif isinstance(other, int) or isinstance(other, float):\\n\\t\\t\\t# Maintain state of self and create new trace variable new_var\\n\\t\\t\\tnew_var = Var(self.val, self.der)\\n\\t\\t\\treturn new_var.__add__(-other)\\n\\t\\treturn (-other).__add__(self)\",\n \"def subtract(self,ctSub):\\n\\n # First confirm eligible for subtraction\\n if (not np.array_equal(self.x1_flat,ctSub.x1_flat)) or (not np.array_equal(self.x2_flat,ctSub.x2_flat)):\\n raise Exception(\\\"Can't subtract because not meshed the same\\\")\\n\\n ctResult = copy.deepcopy(ctSub)# copy the class\\n\\n \\n # Original method\\n # ctResult.u = self.u - ctSub.u\\n # ctResult.uMesh = griddata(np.column_stack([ctResult.y, ctResult.z]),ctResult.u,(ctResult.yMesh.flatten(), ctResult.zMesh.flatten()), method='cubic')\\n\\n # New method\\n ctResult.u_mesh = self.u_mesh - ctSub.u_mesh\\n ctResult.v_mesh = self.v_mesh - ctSub.v_mesh\\n ctResult.w_mesh = self.w_mesh - ctSub.w_mesh\\n ctResult.u_cubed = self.u_cubed - ctSub.u_cubed\\n\\n\\n return ctResult\",\n \"def I2_u1(self) -> complex:\\n # \\\"Phase 2 current [A]\\\" is wrong. We need to calculate it ourselves\\n return - self.I1_u1() - self.I3_u1()\",\n \"def diffMat(t1,t2):\\n if len(t1.shape) > 1:\\n T = multVarDiffMat(t1,t2)\\n else:\\n T = np.outer(t1,np.ones(len(t2))) - np.outer(np.ones(len(t1)),t2)\\n return T\",\n \"def v_from_z(z1, z2):\\n R = (1+z1) / (1+z2)\\n v = const.c * (R**2 - 1)/(1+R**2) \\n\\n return v.to('km/s')\",\n \"def subtract(x, y):\\n return Shape(x.wallTime, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk)\",\n \"def interpolate(qfv, rm1, qweight):\\n\\n\\t# set variables\\n\\trm3 = defaultdict(float)\\n\\tvocab = set()\\n\\n\\t# update vocab w/ terms from both feature vectors\\n\\tvocab.update(qfv.keys())\\n\\tvocab.update(rm1.keys())\\n\\n\\t# interpolate\\n\\tfor term in vocab:\\n\\t\\tweight = qweight * qfv[term] + (1 - qweight) * rm1[term]\\n\\t\\trm3[term] = weight\\n\\treturn rm3\",\n \"def value(self):\\n nd1 = super().nd1()\\n nd2 = super().nd2()\\n f1 = nd1 * self.s\\n f2 = nd2 * self.x * math.e ** (-self.rf * self.t)\\n return f1 - f2\",\n \"def __sub__(self, other):\\n if not self.unit.is_compatible(other.unit):\\n raise TypeError('Cannot subtract two quantities with incompatible units \\\"%s\\\" and \\\"%s\\\".' % (self.unit, other.unit))\\n value = self._value - other.value_in_unit(self.unit)\\n unit = self.unit\\n return Quantity(value, unit)\",\n \"def __rmul__(self, other):\\n return TensorWithIndices(other*self._tensor, \\n self._con + '_' + self._cov)\",\n \"def __rsub__(self, other):\\n other = _to_complex(other)\\n return ComplexVal(other.r - self.r, other.i - self.i)\",\n \"def __mul__(self, other: float) -> 'Translation':\\n self._vector.setWithArray((self._vector.x * other, self._vector.y * other, self._vector.z * other))\\n return self\",\n \"def cross(self, other):\\n return type(self)(\\n self.y * other.z - self.z * other.y,\\n -self.x * other.z + self.z * other.x,\\n self.x * other.y - self.y * other.x,\\n )\",\n \"def cpvunrotate(self, other):\\n return Vec2d(self.x*other.x + self.y*other.y, self.y*other.x - self.x*other.y)\",\n \"def d2(x0,y0,x1,y1):\\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)\",\n \"def diff(self, word1, word2):\\n v = self._vecs[self._index[word1]] - self._vecs[self._index[word2]]\\n return v / np.linalg.norm(v)\",\n \"def get_mo_ovlp(mo1, mo2, ovlp):\\n ovlp = np.asarray(ovlp)\\n mo1 = np.asarray(mo1)\\n mo2 = np.asarray(mo2)\\n if mo1.ndim == 2:\\n res = reduce(np.dot, (mo1.conj().T, ovlp, mo2))\\n else:\\n assert mo1.shape[0] == mo2.shape[0]\\n spin, nao, nmo1 = mo1.shape\\n nmo2 = mo2.shape[-1]\\n res = np.zeros((spin, nmo1, nmo2), dtype=np.result_type(mo1, mo2))\\n for s in range(spin):\\n res[s] = reduce(np.dot, (mo1[s].conj().T, ovlp, mo2[s]))\\n return res\",\n \"def __sub__(self, other):\\n if isinstance(other, int) or isinstance(other, float):\\n return Volt(self.volts - other, self.volt_unit, self.freq, self.freq_unit)\\n if self.volt_unit != other.volt_unit:\\n raise ArithmeticError(f\\\"The objects' volt units {self.volt_unit} and {other.volt_unit} are not the same.\\\")\\n if self.freq != other.frequency:\\n raise ArithmeticError(f\\\"The objects' frequency {self.freq} and {other.frequency} are not the same.\\\")\\n if self.freq_unit != other.freq_unit:\\n raise ArithmeticError(f\\\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \\\"\\n f\\\"are not the same.\\\")\\n volt_sum = self.volts - other.volts\\n return Volt(volt_sum, self.volt_unit, self.freq, self.freq_unit)\",\n \"def __sub__(self, other):\\n if isinstance(other, Factorization):\\n other = other.value()\\n return self.value() - other\",\n \"def sub(o1, o2):\\n return o1-o2\",\n \"def calc(operand_1, operand_2):\\n return operand_1 - operand_2\",\n \"def calc(operand_1, operand_2):\\n return operand_1 - operand_2\",\n \"def cross(v1: Vector, v2: Vector) -> Vector: # Function is fucked TODO\\n if len(v1.coords) != 3 or len(v2.coords) != 3:\\n raise ValueError(\\\"Vectors have to be 3 fucking D, nøøb\\\")\\n x = v1.y * v2.z - v1.z * v2.y\\n y = v1.z * v2.x - v1.x * v2.z\\n z = v1.x * v2.y - v1.y * v2.x\\n return Vector(x, y, z)\",\n \"def aminusb0( mv1, mv2 ):\\n mv = mv1[0,] - mv2[0,]\\n if hasattr(mv,'long_name'):\\n if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name\\n mv.long_name = ''\\n return mv\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def test_subtracting_constant():\\n a = fwd.Variable()\\n assert equals((a-1).derivative_at(a, {a: 0.0}), 1.0)\\n assert equals((1-a).derivative_at(a, {a: 0.0}), -1.0)\",\n \"def _relative_velocity(vel1, vel2):\\n return [ v1 - v2 for (v1, v2) in zip(vel1, vel2)]\",\n \"def GetCorr_and_RMSE(v1, v2):\\n\\treturn pearsonr(v1,v2)[0], math.sqrt(np.mean([(a-b)**2 for a,b in zip(v1,v2)]))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6467121","0.6038152","0.60112774","0.598649","0.5940264","0.59214985","0.5907114","0.5860278","0.5774416","0.57667285","0.5750668","0.56914055","0.5675003","0.5616137","0.56054354","0.5589946","0.5553921","0.55365384","0.55223125","0.5514815","0.5504505","0.5477639","0.54443294","0.54415566","0.53941643","0.53935504","0.53863615","0.53774726","0.53668","0.5295524","0.5281681","0.52787054","0.5252831","0.5228903","0.52218693","0.5204078","0.51977336","0.51956075","0.51888686","0.51599884","0.5126391","0.5122489","0.5109208","0.51075315","0.5095993","0.5089764","0.5084439","0.50758153","0.5062741","0.5058518","0.5052651","0.5045361","0.5041928","0.5034104","0.50332433","0.50197923","0.5017249","0.50140595","0.500996","0.50068426","0.50001657","0.49943507","0.49906772","0.49776","0.497491","0.4973415","0.4968303","0.4967159","0.49619383","0.49615574","0.49525473","0.49521843","0.49463105","0.4942616","0.49375135","0.49251628","0.4911397","0.4908474","0.49035245","0.49035138","0.4901967","0.48991698","0.489633","0.48868933","0.48852813","0.48824286","0.48713768","0.48707092","0.48689187","0.4858049","0.48563835","0.48496786","0.48457843","0.48457843","0.4845314","0.48409238","0.4816774","0.48118955","0.48062253","0.48046625"],"string":"[\n \"0.6467121\",\n \"0.6038152\",\n \"0.60112774\",\n \"0.598649\",\n \"0.5940264\",\n \"0.59214985\",\n \"0.5907114\",\n \"0.5860278\",\n \"0.5774416\",\n \"0.57667285\",\n \"0.5750668\",\n \"0.56914055\",\n \"0.5675003\",\n \"0.5616137\",\n \"0.56054354\",\n \"0.5589946\",\n \"0.5553921\",\n \"0.55365384\",\n \"0.55223125\",\n \"0.5514815\",\n \"0.5504505\",\n \"0.5477639\",\n \"0.54443294\",\n \"0.54415566\",\n \"0.53941643\",\n \"0.53935504\",\n \"0.53863615\",\n \"0.53774726\",\n \"0.53668\",\n \"0.5295524\",\n \"0.5281681\",\n \"0.52787054\",\n \"0.5252831\",\n \"0.5228903\",\n \"0.52218693\",\n \"0.5204078\",\n \"0.51977336\",\n \"0.51956075\",\n \"0.51888686\",\n \"0.51599884\",\n \"0.5126391\",\n \"0.5122489\",\n \"0.5109208\",\n \"0.51075315\",\n \"0.5095993\",\n \"0.5089764\",\n \"0.5084439\",\n \"0.50758153\",\n \"0.5062741\",\n \"0.5058518\",\n \"0.5052651\",\n \"0.5045361\",\n \"0.5041928\",\n \"0.5034104\",\n \"0.50332433\",\n \"0.50197923\",\n \"0.5017249\",\n \"0.50140595\",\n \"0.500996\",\n \"0.50068426\",\n \"0.50001657\",\n \"0.49943507\",\n \"0.49906772\",\n \"0.49776\",\n \"0.497491\",\n \"0.4973415\",\n \"0.4968303\",\n \"0.4967159\",\n \"0.49619383\",\n \"0.49615574\",\n \"0.49525473\",\n \"0.49521843\",\n \"0.49463105\",\n \"0.4942616\",\n \"0.49375135\",\n \"0.49251628\",\n \"0.4911397\",\n \"0.4908474\",\n \"0.49035245\",\n \"0.49035138\",\n \"0.4901967\",\n \"0.48991698\",\n \"0.489633\",\n \"0.48868933\",\n \"0.48852813\",\n \"0.48824286\",\n \"0.48713768\",\n \"0.48707092\",\n \"0.48689187\",\n \"0.4858049\",\n \"0.48563835\",\n \"0.48496786\",\n \"0.48457843\",\n \"0.48457843\",\n \"0.4845314\",\n \"0.48409238\",\n \"0.4816774\",\n \"0.48118955\",\n \"0.48062253\",\n \"0.48046625\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66377026"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19887,"cells":{"query":{"kind":"string","value":"Returns time averages of the cems2 variable mv. The average is comuted only over times which lie in the specified season(s). The returned variable has the same number of dimensions as mv, but the time axis has been reduced to the number of seasons requested. The seasons are specified as an object of type cdutil.times.Seasons, and defaults to the whole year."},"document":{"kind":"string","value":"def timeave_seasonal( mv, seasons=seasonsyr ):\n return seasons.climatology(mv)"},"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 reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax is None:\n print \"WARNING- no time axis in\",mv.id\n return None\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n print \"WARNING- cannot compute climatology for\",mv.id,seasons.seasons\n print \"...probably there is no data for times in the requested season.\"\n return None\n avmv = mvseas\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string)>2:\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n avmv = averager( mv, axis=axes_string )\n else:\n avmv = mv\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \n the_season=np.array(the_season,dtype=np.int32)\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n else:\n if lat_slice.stop is None:\n num_lats=var_nc.shape[2]\n else:\n num_lats=lat_slice.stop - lat_slice.start\n if lon_slice.stop is None:\n num_lons=var_nc.shape[3]\n else:\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n num_years=var_nc.shape[0]//12\n\n for the_year in np.arange(0,num_years):\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n the_season=the_season+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def getSeasonStats(self):\n df_season_agg = self.toSeasonAggFormat()\n\n # Calculate Possessions for each game\n df_season_agg['possessions'] = 0.5 * (df_season_agg['FGA'] + 0.475 * df_season_agg['FTA'] - df_season_agg['OR'] + df_season_agg['TO']) \\\n + 0.5 * (df_season_agg['OppFGA'] + 0.475 * df_season_agg['OppFTA'] - df_season_agg['OppOR'] + df_season_agg['OppTO'])\n\n # Aggregate to Season Summary Level\n season_stats = df_season_agg.groupby(['TeamID', 'Season']).sum()\n\n season_stats = season_stats.rename(columns={'Win':'wins'})\n\n # Season Advanced Stats\n season_stats['o_eff'] = season_stats['Score'] / season_stats['possessions'] * 100\n season_stats['d_eff'] = season_stats['OppScore'] / season_stats['possessions'] * 100\n season_stats['net_eff'] = season_stats['o_eff'] - season_stats['d_eff']\n\n season_stats.drop('DayNum', axis=1, inplace=True)\n season_stats.drop('OppTeamID', axis=1, inplace=True)\n season_stats.drop('rand', axis=1, inplace=True)\n\n return season_stats","def compute_mse(self, results, T, nSegments):\n times_per_day = 56\n mse=0\n for i in range(nSegments):\n mse += T * np.mean(results[i][0].mse_path_[np.where(results[i][0].alphas_ == results[i][0].alpha_)[0][0]])\n mse += ((times_per_day-1)-T) * np.mean(results[i][1].mse_path_[np.where(results[i][1].alphas_ == results[i][1].alpha_)[0][0]])\n mse = mse/((times_per_day-1)*nSegments)\n return mse","def get_dryspells_perseason(dryspells, seasons=((12, 1, 2), (3, 4, 5),\n (6, 7, 8), (9, 10, 11))):\n dryspells_seasons = []\n for season in seasons:\n eveSeas = []\n for eveLand in dryspells:\n eves = [e for e in eveLand if e.start_date().month in season]\n eveSeas.append(eves)\n dryspells_seasons.append(eveSeas)\n\n return dryspells_seasons","def seasonal_mean(args_file):\n product, start_date, end_date, variable_name, shape_file = Utility.read_yml_params(args_file)\n stat = Statistic.Mean\n time = TimePeriod.Seasonal\n\n ds = get_data_set(product, shape_file)\n\n result = Utility.Apply_stat(ds, start_date, end_date, variable_name, stat, time)\n return result","def timeseriesCVscore(self, params):\n errors = []\n\n # values = series.values\n values = self.train_ts\n self.alpha, self.beta, self.gamma = params\n\n # set the number of folds for cross-validation\n tscv = TimeSeriesSplit(n_splits=3)\n\n # iterating over folds, train model on each, forecast and calculate error\n for train, test in tscv.split(values):\n\n self.train = values[train]\n self.test = values[test]\n self.triple_exponential_smoothing()\n predictions = self.result[-len(self.test) :]\n actual = values[test]\n error = mape(list(actual), predictions)\n errors.append(error)\n\n # print \"error: \"\n # print errors\n return np.mean(np.array(errors))","def seasonal_means(t, y, edges=None, hard=False):\n ts, ys = seasonal_series(t, y, edges=edges, hard=hard)\n t_means = [t.jyear.mean() for t in ts]\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\n y_means = np.array([y.mean() for y in ys])\n y_std = np.array([y.std() for y in ys])\n y_N = np.array([y.size for y in ys])\n return t_means, y_means, y_std, y_N","def timeave_old( mv ):\n # I haven't thought yet about how missing values would work with this...\n # If time intervals be unequal, this will have to be changed...\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\n n = sh[0]\n # BTW, this is the size of everything else:\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\n mvta = numpy.sum( mv.__array__(), axis=0 )\n mvta /= n\n return mvta","def calcSeason(ra, time):\n # Reference RA and equinox to anchor ra/season reference - RA = 0 is overhead at autumnal equinox\n # autumn equinox 2014 happened on september 23 --> equinox MJD\n Equinox = 2456923.5 - 2400000.5\n # convert ra into 'days'\n dayRA = ra / 360 * 365.25\n firstSeasonBegan = Equinox + dayRA - 0.5 * 365.25\n seasons = (time - firstSeasonBegan) / 365.25\n # Set first season to 0\n seasons = seasons - np.floor(np.min(seasons))\n return seasons","def get_gas_by_month(self, year, month, deseasonalize=False):\n df = self.conc_trend if deseasonalize else self.conc_seasonal\n ts = pd.Timestamp(year, month, 1)\n info_dict = {'latency': df.latency[ts]}\n return df.dmf_mean[ts], info_dict","def interpolateseasons(self):\n\n remainder = self.season - self.startseason\n f1 = 1.0 - remainder\n self.data = (self.startdata * f1) + (self.stopdata * remainder)","def distributeSeason(self):\n i = 1\n for day in self.daylist:\n if i >= monthbeg[5] and i < monthbeg[9]: #june through SEpt as per SCE\n day.season = 'summer' #https://www.sce.com/residential/rates/Time-Of-Use-Residential-Rate-Plans\n i = i + 1\n else:\n day.season = 'winter'\n i = i+1","def reduce2scalar( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def test_aggregate_from_month_to_seasons(\n self, months, seasons, monthly_data, monthly_data_as_seasons\n ):\n adaptor = IntervalAdaptor(\"test-month-season\")\n from_spec = Spec(\n name=\"test-var\", dtype=\"float\", dims=[\"months\"], coords={\"months\": months}\n )\n adaptor.add_input(from_spec)\n to_spec = Spec(\n name=\"test-var\",\n dtype=\"float\",\n dims=[\"seasons\"],\n coords={\"seasons\": seasons},\n )\n adaptor.add_output(to_spec)\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\n\n data_array = DataArray(from_spec, monthly_data)\n\n data_handle = Mock()\n data_handle.get_data = Mock(return_value=data_array)\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\n\n adaptor.simulate(data_handle)\n actual = data_handle.set_results.call_args[0][1]\n expected = monthly_data_as_seasons\n\n assert np.allclose(actual, expected, rtol=1e-05, atol=1e-08)","def season_rounds(cls, season):\r\n\t\t\r\n\t\tfolder_name = cls.season_folder(season)\r\n\t\tround_list = os.listdir(f'Data/{folder_name}')\r\n\r\n\t\tall_rounds = []\r\n\r\n\t\tfor round_file in round_list:\r\n\t\t\twith open(f'Data/{folder_name}/{round_file}', 'r', encoding='utf-8') as f:\r\n\t\t\t\tround_info = f.read().splitlines()\r\n\r\n\t\t\tround_number = round_file[:-4]\r\n\t\t\tfull_round_name = f\"{season} R{round_number}\"\r\n\r\n\t\t\tround_date = int(round_info[0])\r\n\t\t\tlookup_ind = DATES.month_diff(round_date, DATES.MIN_DATE)\r\n\r\n\t\t\t# If the round isn't actually counted for TWOW Glicko\r\n\t\t\tif full_round_name not in cls.ROUNDS[lookup_ind].keys():\r\n\t\t\t\tcontinue\r\n\r\n\t\t\tcontestant_count = len(round_info) - 1\r\n\r\n\t\t\tstrength = cls.ROUNDS[lookup_ind][full_round_name][0]\r\n\r\n\t\t\tall_rounds.append([\r\n\t\t\t\tround_number,\r\n\t\t\t\tround_date,\r\n\t\t\t\tcontestant_count,\r\n\t\t\t\tstrength\r\n\t\t\t])\r\n\t\t\r\n\t\treturn all_rounds","def rmsse(self, seasonality: int = 1) -> float:\n q = np.abs(self._error()) / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))\n return float(np.sqrt(np.mean(np.square(q))))","def seasonal_calc(t, y, func, edges=None):\n ts, ys = seasonal_series(t, y, edges=edges)\n t_means = [t.jyear.mean() for t in ts]\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\n f_y = np.array([func(y) for y in ys])\n return t_means, f_y","def mov_mean_std(ts, m):\n\n if m <= 1:\n raise ValueError(\"Query length must be longer than one\")\n\n ts = ts.astype(\"float\")\n\n # Add zero to the beginning of the cumsum of ts\n s = np.insert(np.cumsum(ts), 0, 0)\n\n # Add zero to the beginning of the cumsum of ts ** 2\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\n seg_sum = s[m:] - s[:-m]\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\n return seg_sum / m, np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)","def calcSeasonModified( monthNum ):\r\n\r\n if monthNum == 12 or monthNum == 1 or monthNum == 2:\r\n return 0\r\n\r\n elif monthNum == 6 or monthNum == 7 or monthNum == 7:\r\n return 1\r\n\r\n else:\r\n return 3","def m_average_fun(self, dx=df.dx):\n\n mx = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([1, 0, 0])) * dx)\n my = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 1, 0])) * dx)\n mz = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 0, 1])) * dx)\n volume = df.assemble(self.material._Ms_dg * dx)\n\n return np.array([mx, my, mz]) / volume","def mase(self, seasonality: int = 1):\n return self.mae() / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))","def enstrophy_average(\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3): # vorticity-3 component\n #---------------------------------------------------------------------#\n # Defining the domain variables #\n #---------------------------------------------------------------------#\n dim = omega1.shape\n time = dim[-1]\n avg = np.zeros(time)\n #---------------------------------------------------------------------#\n # Looping over the time variable #\n #---------------------------------------------------------------------#\n print_count = 51\n for i in range(0, time):\n term1 = np.square(omega1[:,:,:,i])\n term2 = np.square(omega2[:,:,:,i])\n term3 = np.square(omega3[:,:,:,i])\n enst = 0.5*(term1 + term2 + term3)\n avg[i] = np.mean(enst)\n #-----------------------------------------------------------------#\n # Printing statement #\n #-----------------------------------------------------------------#\n if print_count > 20:\n print('Enstrophy average ---> t_step = %i' %(i))\n print_count = 0\n print_count += 1\n\n return avg","def getNumSeasons(self):\n searchURL = \"http://api.tvmaze.com/shows/\" + str(self.__showID) \\\n + \"/seasons\"\n\n response = requests.get(searchURL)\n data = response.json()\n\n return data[-1][\"number\"]","def parse_episodes_by_season (self, response_data):\n episodes = {}\n raw_episodes = response_data['value']['videos']\n for episode_id in raw_episodes:\n if self._is_size_key(key=episode_id) == False:\n if (raw_episodes[episode_id]['summary']['type'] == 'episode'):\n episodes.update(self.parse_episode(episode=raw_episodes[episode_id], genres=response_data['value']['genres']))\n return episodes","def test_time_only_conversion_disagg(self, months, seasons):\n adaptor = IntervalAdaptor(\"test-season-month\")\n from_spec = Spec(\n name=\"test-var\",\n dtype=\"float\",\n dims=[\"seasons\"],\n coords={\"seasons\": seasons},\n )\n adaptor.add_input(from_spec)\n to_spec = Spec(\n name=\"test-var\", dtype=\"float\", dims=[\"months\"], coords={\"months\": months}\n )\n adaptor.add_output(to_spec)\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\n\n data = np.array([3, 3, 3, 3])\n data_array = DataArray(from_spec, data)\n data_handle = Mock()\n data_handle.get_data = Mock(return_value=data_array)\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\n\n adaptor.simulate(data_handle)\n actual = data_handle.set_results.call_args[0][1]\n expected = np.array(\n [\n 1.033333,\n 0.933333,\n 1.01087,\n 0.978261,\n 1.01087,\n 0.978261,\n 1.01087,\n 1.01087,\n 0.989011,\n 1.021978,\n 0.989011,\n 1.033333,\n ]\n )\n np.testing.assert_allclose(actual, expected, rtol=1e-3)","def seasonality(df):\n df_datetime = pd.DatetimeIndex(df.date_time)\n df[\"month\"] = df_datetime.month\n df = drop_cols(df, [\"date_time\"])\n\n return df","def season_info(cls, season):\r\n\r\n\t\traw_info = cls.season_rounds(season)\r\n\r\n\t\tinfo = [\r\n\t\t\tseason,\t\t\t\t\t\t\t\t\t\t# 0 -> Season name\r\n\t\t\tlen(raw_info),\t\t\t\t\t\t\t\t# 1 -> Amount of rounds\r\n\t\t\tmin([round[1] for round in raw_info]),\t\t# 2 -> Starting date\r\n\t\t\tmax([round[1] for round in raw_info]),\t\t# 3 -> Latest round date\r\n\t\t\tnp.mean([round[3] for round in raw_info])\t# 4 -> Average round strength\r\n\t\t]\r\n\r\n\t\treturn info","def season(obs, season_gap=80., mjdCol='observationStartMJD'):\n\n # check wether season has already been estimated\n if 'season' in obs.dtype.names:\n return obs\n\n obs.sort(order=mjdCol)\n\n \"\"\"\n if len(obs) == 1:\n obs = np.atleast_1d(obs)\n obs = rf.append_fields([obs], 'season', [1.])\n return obs\n diff = obs[mjdCol][1:]-obs[mjdCol][:-1]\n\n flag = np.argwhere(diff > season_gap)\n if len(flag) > 0:\n seas = np.zeros((len(obs),), dtype=int)\n flag += 1\n seas[0:flag[0][0]] = 1\n for iflag in range(len(flag)-1):\n seas[flag[iflag][0]:flag[iflag+1][0]] = iflag+2\n seas[flag[-1][0]:] = len(flag)+1\n obs = rf.append_fields(obs, 'season', seas)\n else:\n obs = rf.append_fields(obs, 'season', [1]*len(obs))\n \"\"\"\n seasoncalc = np.ones(obs.size, dtype=int)\n\n if len(obs) > 1:\n diff = np.diff(obs[mjdCol])\n flag = np.where(diff > season_gap)[0]\n\n if len(flag) > 0:\n for i, indx in enumerate(flag):\n seasoncalc[indx+1:] = i+2\n\n obs = rf.append_fields(obs, 'season', seasoncalc)\n return obs","def speed_setting_season(self):\n if self.season == \"spring\":\n self.grid.speed_values[self.path_color] = 4\n self.grid.speed_values[(0, 0, 255)] = 0.1\n elif self.season == \"winter\":\n self.grid.speed_values[self.path_color] = 3\n self.grid.speed_values[(0, 0, 255)] = 0.1\n elif self.season == \"fall\":\n self.grid.speed_values[self.path_color] = 6\n elif self.season == \"summer\":\n pass","def get_variance_maps_models(variable=\"pr\",models=None,cmip_dir = None,period=12):\n if models is None:\n f = cdms.open(\"/work/marvel1/SEASONAL/MMA/cmip5.ZONALMMA.historical-rcp85.rip.mo.atm.Amon.pr.ver-1.AmpPhase.nc\")\n phase = f(\"phase\")\n models = eval(phase.getAxis(0).models)\n f.close()\n if cmip_dir is None:\n cmip_dir = \"/work/cmip5/historical-rcp85/atm/mo/\"+variable+\"/\"\n fobs = cdms.open(\"/work/marvel1/SEASONAL/OBS/GPCP.precip.mon.mean.nc\")\n the_grid = fobs(\"precip\").getGrid()\n nlat,nlon=the_grid.shape\n fobs.close()\n VarianceMaps = np.zeros((len(models),nlat))+1.e20\n counter=0\n for model in models:\n print model\n try:\n fname = sorted(glob.glob(cmip_dir+\"*.\"+model+\".*\"))[0]\n fp = cdms.open(fname)\n prtest = fp(variable,time=(\"1979-1-1\",\"2014-12-31\")).regrid(the_grid,regridTool='regrid2')\n przonal = cdutil.averager(prtest,axis='x')\n dom = variance_map(przonal,period=period)\n VarianceMaps[counter]=dom\n fp.close()\n counter+=1\n except:\n continue\n \n modax = cdms.createAxis(range(len(models)))\n modax.id = \"model\"\n modax.models = str(models)\n VarianceMaps = MV.array(VarianceMaps)\n VarianceMaps.setAxis(0,modax)\n VarianceMaps.setAxis(1,the_grid.getLatitude())\n return MV.masked_where(VarianceMaps>1.e10,VarianceMaps)","def parse_seasons (self, id, response_data):\n raw_seasons = response_data['value']\n videos = raw_seasons['videos']\n\n # get art video key\n video = {}\n for key, video_candidate in videos.iteritems():\n if not self._is_size_key(key):\n video = video_candidate\n\n # get season index\n sorting = {}\n for idx, season_list_entry in video['seasonList'].iteritems():\n if self._is_size_key(key=idx) == False and idx != 'summary':\n sorting[int(season_list_entry[1])] = int(idx)\n\n seasons = {}\n\n for season in raw_seasons['seasons']:\n if self._is_size_key(key=season) == False:\n seasons.update(self._parse_season_entry(season=raw_seasons['seasons'][season], video=video, sorting=sorting))\n return seasons","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def test_time_only_conversion(self, months, seasons):\n adaptor = IntervalAdaptor(\"test-month-season\")\n from_spec = Spec(\n name=\"test-var\", dtype=\"float\", dims=[\"months\"], coords={\"months\": months}\n )\n adaptor.add_input(from_spec)\n to_spec = Spec(\n name=\"test-var\",\n dtype=\"float\",\n dims=[\"seasons\"],\n coords={\"seasons\": seasons},\n )\n adaptor.add_output(to_spec)\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\n\n data = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n\n data_array = DataArray(from_spec, data)\n\n data_handle = Mock()\n data_handle.get_data = Mock(return_value=data_array)\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\n\n adaptor.simulate(data_handle)\n actual = data_handle.set_results.call_args[0][1]\n expected = np.array([3, 3, 3, 3])\n np.testing.assert_array_equal(actual, expected)","def ann_mean(ds, season=None, time_bnds_varname='time_bnds', time_centered=True, n_req=None):\n \n ds = ds.copy() #deep=True)\n\n if n_req is None:\n if season is not None:\n n_req = 2\n else:\n n_req = 8\n \n if time_bnds_varname is None and not time_centered:\n raise NotImplementedError('time_bnds_varname cannot be \"None\" if time_centered=False')\n \n if not time_centered:\n time_units = ds.time.encoding['units']\n time_calendar = ds.time.encoding['calendar']\n\n # compute time bounds array\n time_bound_data = cftime.date2num(\n ds[time_bnds_varname].data, \n units=time_units, \n calendar=time_calendar) \n\n # center time\n time_centered = cftime.num2date(\n time_bound_data.mean(axis=1),\n units=time_units, \n calendar=time_calendar\n ) \n time_attrs = ds.time.attrs\n time_encoding = ds.time.encoding\n\n ds['time'] = xr.DataArray(\n time_centered,\n dims=('time')\n ) \n \n ones = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n time_mask = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n\n group_by_year = 'time.year'\n rename = {'year': 'time'}\n \n if season is not None:\n season = season.upper()\n if season not in ['DJF', 'MAM', 'JJA', 'SON']:\n raise ValueError(f'unknown season: {season}') \n\n ds['austral_year'] = xr.where(ds['time.month'] > 6, ds['time.year'] + 1, ds['time.year'])\n ds = ds.set_coords('austral_year')\n ones = ones.assign_coords({'austral_year': ds.austral_year})\n time_mask = time_mask.assign_coords({'austral_year': ds.austral_year})\n time_mask = time_mask.where(ds['time.season'] == season).fillna(0)\n \n if season == 'DJF':\n group_by_year = 'austral_year'\n rename = {'austral_year': 'time'}\n \n if time_bnds_varname is not None:\n time_wgt = ds[time_bnds_varname].diff(dim=ds[time_bnds_varname].dims[1])\n if time_wgt.dtype == '<m8[ns]':\n time_wgt = time_wgt / np.timedelta64(1, 'D')\n else: \n time_wgt = xr.DataArray(\n np.ones((len(ds.time))), \n dims=('time'), \n coords={'time': ds.time},\n )\n time_wgt = time_wgt.assign_coords(\n {c: da for c, da in ds.coords.items() if 'time' in da.dims}\n )\n \n time_wgt = time_wgt.where(time_mask==1) #.fillna(0.)\n\n ones = ones.where(time_mask==1)\n time_wgt_grouped = time_wgt.groupby(group_by_year, restore_coord_dims=False)\n time_wgt = time_wgt_grouped / time_wgt_grouped.sum(dim=xr.ALL_DIMS)\n\n nyr = len(time_wgt_grouped.groups)\n \n time_wgt = time_wgt.squeeze()\n\n idx_not_nans = ~np.isnan(time_wgt)\n sum_wgt = time_wgt.groupby(group_by_year).sum(dim=xr.ALL_DIMS)\n idx_not_nans = (sum_wgt > 0)\n\n np.testing.assert_almost_equal(\n sum_wgt[idx_not_nans], \n np.ones(idx_not_nans.sum().values)\n )\n\n nontime_vars = set([v for v in ds.variables if 'time' not in ds[v].dims]) - set(ds.coords)\n dsop = ds.drop_vars(nontime_vars)\n\n if time_bnds_varname is not None:\n dsop = dsop.drop_vars(time_bnds_varname) \n \n def weighted_mean_arr(darr, wgts=None):\n # if NaN are present, we need to use individual weights\n cond = darr.isnull()\n ones = xr.where(cond, 0.0, 1.0)\n if season is None:\n mask = (\n darr.resample({'time': 'A'}, restore_coord_dims=False).mean(dim='time').notnull()\n )\n da_sum = (\n (darr * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n ones_out = (\n (ones * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n count = (\n (ones * wgts.notnull()).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\n )\n else:\n mask = (\n darr.groupby(group_by_year, restore_coord_dims=False).mean(dim='time').notnull()\n ).rename(rename)\n \n da_sum = (\n (darr * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n \n ones_out = (\n (ones * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n \n count = (\n (ones * wgts.notnull()).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\n ).rename(rename)\n\n ones_out = ones_out.where(ones_out > 0.0)\n da_weighted_mean = da_sum / ones_out\n\n return da_weighted_mean.where(mask).where(count >= n_req) \n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n ds_ann = dsop.map(weighted_mean_arr, wgts=time_wgt)\n\n # copy attrs\n for v in ds_ann:\n ds_ann[v].attrs = ds[v].attrs\n\n # restore coords\n ds_ann = xr.merge((ds_ann, ds[list(nontime_vars)]))\n\n # eliminate partials\n ndx = (time_wgt_grouped.count(dim=xr.ALL_DIMS) >= n_req).values\n if not ndx.all():\n ds_ann = ds_ann.isel(time=ndx)\n\n return ds_ann","def time_average(new_cube):\n\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\n\n return time_average_cube","def parse_season(filename):\n print_info('Attempting to parse {0}'.format(filename))\n print_info('Extracting season from {0}'.format(filename))\n for regex in SEASON_REGEX:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_season = m.group('Season').lower()\n print_info('Extracted season: {0}'.format(extracted_season))\n\n season_num = int(extracted_season)\n if season_num is not None and season_num > 0:\n print_info('Season might be: {0}'.format(season_num))\n return 'S' + format_num(season_num)\n return 'S01'","def parse_season_information_for_video (self, video):\n season_info = {\n 'episode_count': None,\n 'seasons_label': None,\n 'seasons_count': None\n }\n if video['summary']['type'] == 'show':\n season_info = {\n 'episode_count': video['episodeCount'],\n 'seasons_label': video['numSeasonsLabel'],\n 'seasons_count': video['seasonCount']\n }\n return season_info","def average(self, times=2):\n for i in range(times):\n self.statistics()\n global t, avlist\n length = len(t)\n avlist.append(t)\n t = []\n\n total_list = []\n\n for l in range(length):\n total_list.append([])\n\n for j in range(times):\n \"\"\"per time\"\"\"\n for i in range(length):\n total_list[i].append(avlist[j][i])\n\n \"\"\"calculate\"\"\"\n ylist = []\n avlist = []\n for a in total_list:\n avg = 0\n for b in a:\n avg += b\n ylist.append(avg/times)\n self.listy = ylist\n\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\n self.listx.append(e)","def seasons(self):\n if self._season_cache_ver == self._db._version:\n return self._season_cache\n\n # Find out how many seasons in this series by fetching the highest season.\n seasons = self._db.query(type='episode', parent=self._dbrow, attrs=['season'], distinct=True)\n self._season_cache = [Season(self._db, self, row['season']) for row in seasons]\n self._season_cache_ver = self._db._version\n return self._season_cache","def forced_trend(varname, cvdp_loc):\n\n if not cvdp_loc.endswith('/'):\n cvdp_loc = cvdp_loc + '/'\n\n # Can use CVDP output\n fnames = sorted(glob('%sCESM1-CAM5-BGC-LE_*.cvdp_data.*.nc' % cvdp_loc))\n\n cvdp_name = 'tas_global_avg_mon'\n\n nfiles = len(fnames)\n ds = Dataset(fnames[0], 'r')\n time = ds['time'][:]\n time_units = ds['time'].units\n gm_em_units = ds[cvdp_name].units\n\n n = len(time)\n glob_mean = np.empty((nfiles, n))\n for counter, file in enumerate(fnames):\n ds = Dataset(file, 'r')\n glob_mean[counter, :] = ds[cvdp_name][:]\n\n # Take average across ensemble members\n gm_em = np.mean(glob_mean, axis=0)\n\n return gm_em, gm_em_units, time, time_units","def get_average_duration_episode_in_seconds(self) -> NamedTuple:\n times = [ep.itunes_duration for ep in self.entries]\n format_times = []\n\n for time in times:\n if not time.startswith('00'):\n time = '0' + time\n format_times.append(time)\n\n dts = [datetime.strptime(x, '%H:%M:%S') for x in format_times]\n secs = [timedelta(\n hours=x.hour,\n minutes=x.minute,\n seconds=x.second\n ).seconds for x in dts]\n\n return Duration(\n floor(mean(secs)),\n max(format_times),\n min(format_times)\n )","def add_dreamteam_count(df, raw_seasons):\n df17 = df.loc[df['season'] == 17].copy()\n df18 = df.loc[df['season'] == 18].copy()\n df19 = df.loc[df['season'] == 19].copy()\n df20 = df.loc[df['season'] == 20].copy()\n df21 = df.loc[df['season'] == 21].copy()\n\n dreamteam_count_yearly_average = []\n\n for _, row in df21.iterrows():\n dreamteam_count_yearly_average.append(create_dreamteam_count_yearly(row['name'], raw_seasons))\n df21['dreamteam_yearly_average'] = dreamteam_count_yearly_average\n\n complete_data = pd.concat([df17, df18, df19, df20, df21])\n\n return complete_data","def season_limits(self):\n if self.season == \"summer\":\n return\n neighbors = [(0, 1), (1, 0), (-1, 0), (0, -1)]\n points_list = []\n season_pixels = []\n season_edges = []\n width = self.grid.width\n height = self.grid.height\n x = 0\n while x < width:\n y = 0\n while y < height:\n points_list.append((x, y))\n if self.season == \"spring\" or self.season == \"winter\":\n if self.grid.pix_copy[x, y] == (0, 0, 255):\n season_pixels.append((x, y))\n else:\n if self.grid.pix_copy[x, y] == (255, 255, 255):\n season_pixels.append((x, y))\n y += 1\n x += 1\n for points in points_list:\n k = 0\n while k < (len(neighbors)):\n xp = points[0] + neighbors[k][0]\n yp = points[1] + neighbors[k][1]\n condition = self.filter_edges_one(points[0], points[1], xp, yp, season_edges)\n if condition:\n season_edges.append((xp, yp))\n k += 1\n return season_edges","def season_months(season):\n\n ssn=['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',\n 'sep', 'oct', 'nov', 'dec', 'djf', 'mam', 'jja', 'son',\n 'mayjun', 'julaug', 'marapr', 'jjas', 'ond', 'ann']\n\n imon = [1, 2, 3, 4, 5, 6, 7, 8,\n 9, 10, 11, 12, [1,2,12], [3,4,5], [6,7,8], [9,10,11],\n [5,6], [7,8], [3,4], [6,7,8,9], [10,11,12], list(range(1,13))]\n\n try:\n ifind = ssn.index(season.lower())\n except ValueError:\n raise ValueError('Season not found! Valid seasons: ' + ', '.join(ssn))\n\n months = imon[ifind]\n\n # Make sure the output is a list\n if isinstance(months, int):\n months =[months]\n\n return months","def av(self, data):\n ts_ = self.ts(data)\n if 'year' not in ts_.coords:\n return ts_\n return ts_.mean('year')","def calcVmoy(self, V, idx, n):\n i = max(idx-n, 0)\n f = min(idx+n+1, V.shape[0])\n av = np.mean(V[i:f])\n return av","def test_seasons(self):\n response = Tmdb.season(tmdb_show_id = 69740, season_number = 1)\n self.assertTrue(int(response.status_code) == 200)\n data = response.json()\n self.assertTrue(isinstance(data['episodes'], list))\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)","def get_seasons(link, debug=False):\n\n if debug:\n print(\"begin get_seasons()\")\n\n # get the BeautifulSoup data\n show_url = \"https://www.imdb.com/\" + link + \"episodes/\"\n tv_soup = bs4.BeautifulSoup(requests.get(show_url).text, features=\"html.parser\")\n\n # We are acquiring this data from a drop down, which the below line selects\n select_elem = tv_soup.select('#bySeason')\n seasons = []\n # account for the possibility of a one season show\n if len(select_elem) == 0:\n seasons.append(1)\n else:\n # get contents of drop down\n options = select_elem[0].select('option')\n\n # add each season\n for season in options:\n seasons.append(season.get('value'))\n if debug:\n print(f\"Seasons {seasons}\")\n\n return seasons","def calculate_clim_anoms(var, var_dates):\n d_counts=[]\n var_clim = np.zeros_like(var)\n var_climstd = np.zeros_like(var)\n for m in range(1,13): #for each month\n mo_ind = (var_dates[1,:]==m)\n day_options = np.unique(var_dates[2,mo_ind])\n \n #print(day_options) #for diagnostics \n for d in range(0,np.size(day_options)): #for each possible day\n d_ind = (mo_ind) & (var_dates[2,:]==day_options[d])\n\n var_days = var[:,:,d_ind]\n var_daysav = np.nanmean(var_days,2)\n var_daysstd = np.nanstd(var_days,2)\n \n var_clim[:,:,d_ind] = np.transpose(np.tile(var_daysav,(np.sum(d_ind),1,1)),(1,2,0))\n var_climstd[:,:,d_ind] = np.transpose(np.tile(var_daysstd,(np.sum(d_ind),1,1)),(1,2,0))\n \n d_counts.append(np.sum(d_ind)) #this is just for diagnostics\n \n var_anom = var - var_clim\n var_anom_scaled = var_anom/var_climstd\n \n return var_anom, var_anom_scaled;","def map_season(x, figsize=(8, 6), **kwargs):\n\n from pycmbs.mapping import map_plot\n\n nvals = len(x.data)\n if nvals == 12:\n year = True\n elif nvals == 4:\n year = False\n else:\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\n\n #/// checks ///\n if x.data.ndim != 3:\n print x.data.ndim\n raise ValueError('only 3D data supported')\n\n if 'vmin' not in kwargs.keys():\n raise ValueError('vmin argument is obligatory for map_seasons()')\n if 'vmax' not in kwargs.keys():\n raise ValueError('vmax argument is obligatory for map_seasons()')\n\n if kwargs['vmin'] is None:\n raise ValueError('vmin MUST NOT be None!')\n if kwargs['vmax'] is None:\n raise ValueError('vmax MUST NOT be None!')\n\n #/// figure and axes\n if 'figure' in kwargs:\n f = kwargs['figure']\n else:\n f = plt.figure(figsize=figsize)\n\n if 'title' in kwargs:\n tit = kwargs.pop('title')\n else:\n tit = x.label\n\n if 'drawparallels' in kwargs:\n drawparallels = kwargs.pop('drawparallels')\n else:\n drawparallels = False\n\n if 'savefile' in kwargs:\n savefile = kwargs.pop('savefile')\n if '.nc' in savefile:\n savefile = savefile[:-3]\n else:\n savefile = None\n\n # plot\n if year:\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\n else:\n labels = ['DJF', 'MAM', 'JJA', 'SON']\n\n # check dates\n if year:\n mo = 1\n for t in x.time:\n if x.num2date(t).month != mo:\n print x.num2date(t), mo\n raise ValueError('Invalid monthly sequence! Can not plot results!')\n mo += 1\n\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\n if 'overlay' in kwargs.keys():\n overlays = kwargs.pop('overlay')\n else:\n overlays = None\n\n for i in range(nvals):\n if year:\n ax = f.add_subplot(4, 3, i + 1)\n #if i % 3 == 2:\n if i > 8:\n show_colorbar = True\n else:\n show_colorbar = False\n else:\n ax = f.add_subplot(2, 2, i + 1)\n if 'show_colorbar' in kwargs:\n show_colorbar = kwargs.pop('show_colorbar')\n else:\n show_colorbar = True\n\n d = x.copy()\n d.data = x.data[i, :, :]\n d.label = labels[i]\n\n if overlays is None:\n overlay = None\n else:\n overlay = overlays[i, :, :]\n\n if savefile is not None:\n tmpoutname = savefile + '_' + labels[i]\n else:\n tmpoutname = None\n\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\n savefile=tmpoutname, colorbar_orientation='horizontal',\n drawparallels=drawparallels, **kwargs)\n del d\n f.suptitle(tit, size=16)\n return f","def seasonStats(personId,type = 'gameLog',group = 'hitting'):\n\n #playerInfo = get('people', {'personIds':personId})\n\n\n teamStats = get('person',{ 'ver':'v1' , 'personId':personId,'hydrate':['stats(group={},type={})'.format(group,type),'currentTeam']})\n return teamStats\n #iterate of stats and find the right player id\n #career stats broken\n #fix the season :2019\n #make function to get team id","def aggregate_full_season_tracking_stats_for_seasons(\n measure_type: TrackingMeasureType,\n seasons: List[str],\n season_types: List[SeasonType],\n player_or_team: PlayerOrTeam,\n **kwargs,\n) -> Tuple[List[Any], Any]:\n stats_by_season = get_tracking_stats(\n measure_type, seasons, season_types, player_or_team, **kwargs\n )\n\n stats = sum_tracking_totals(player_or_team, measure_type, stats_by_season)\n league_totals = sum_tracking_totals(\"league\", measure_type, stats)\n return stats, league_totals","def pw_rmsd(mols):\n m = len(mols)\n k = 0\n pw = []\n for mol1 in mols:\n k += 1\n if k > m:\n break\n for i in range(k, m):\n mol2 = mols[i]\n pw.append(rmsd.rmsd(mol1, mol2))\n ave_rmsd = np.mean(pw)\n return ave_rmsd","def year_average_price_rule(_m, y):\r\n\r\n # Total revenue\r\n return sum(m.SCENARIO_REVENUE[y, s] for s in m.S) / sum(m.SCENARIO_DEMAND[y, s] for s in m.S)","def season(self, seasonnum, order='aired'):\n if order=='aired':\n seasons = self.seasons\n elif order == 'dvd':\n seasons = self.dvd_seasons\n try:\n return seasons[seasonnum]\n except KeyError:\n raise SeasonNotFoundError(\n 'Season no %s does not exists' % seasonnum\n ), None, sys.exc_info()[2]","def fetch_episodes_by_season(self, params):\n raw_episode_list = self.netflix_session.fetch_episodes_by_season(\n season_id=params.get('season_id')[0])\n if 'error' in raw_episode_list:\n return raw_episode_list\n episodes = self.netflix_session.parse_episodes_by_season(\n response_data=raw_episode_list)\n return episodes","def extract_seasonal_component(original_ts, ppy):\n \"\"\"\n # === get in-sample data\n original_ts = original_ts[:-out_of_sample]\n \"\"\"\n if seasonality_test(original_ts, ppy):\n # print(\"seasonal\")\n # ==== get moving averages\n ma_ts = moving_averages(original_ts, ppy)\n\n # ==== get seasonality indices\n le_ts = original_ts * 100 / ma_ts\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\n le_ts = np.reshape(le_ts, (-1, ppy))\n si = np.nanmean(le_ts, 0)\n norm = np.sum(si) / (ppy * 100)\n si = si / norm\n else:\n # print(\"NOT seasonal\")\n si = np.full(ppy, 100)\n return si","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def mass_variance(self, logM, k = [], pk = [], var = 'cb', window = 'th', **kwargs):\n return self.mass_variance_multipoles(logM = logM, k = k, pk = pk, var = var, window = window, **kwargs)","def empirical_covariance_multiple(system, excitation, ms):\n observations = [system() @ excitation() for _ in range(max(ms))]\n\n Cs = [np.cov(np.array(observations[0:m]).T) for m in ms]\n return Cs","def season_edges(t):\n offset = season_offset(t)\n yr_min = t.datetime.min().year\n left_frac = t.jyear.min() % yr_min\n if left_frac < offset:\n ex_left = 1\n else:\n ex_left = 0\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\n return astropy.time.Time(edges, format='jyear')","def get_average_for_month(self, month, weekend):\n\t\tif weekend:\n\t\t\treturn self.averages_weekend[month]\n\t\telse:\n\t\t\treturn self.averages_weekday[month]","def seasonality(time, period, amplitude=1 , phase=0):\n season_time = ((time + phase) % period) / period\n return amplitude * seasonal_pattern(season_time)","def land_sm_top(clim_file, model_file, model_dataset, config, ancestors):\n # Work through each season\n metrics = {}\n for index, season in enumerate(SEASONS):\n\n constr_season = iris.Constraint(season_number=index)\n ecv_clim = iris.load_cube(clim_file, constr_season)\n\n vol_sm1_run = volumetric_soil_moisture(model_file, constr_season)\n\n # update the coordinate system ECV data with a WGS84 coord system\n # unify coord systems for regridder\n vol_sm1_run.coord('longitude').coord_system = \\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\n inverse_flattening=298.257223563)\n vol_sm1_run.coord('latitude').coord_system = \\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\n inverse_flattening=298.257223563)\n ecv_clim.coord('longitude').coord_system = \\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\n inverse_flattening=298.257223563)\n ecv_clim.coord('latitude').coord_system = \\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\n inverse_flattening=298.257223563)\n\n # Interpolate to the grid of the climatology and form the difference\n vol_sm1_run = regrid(vol_sm1_run, ecv_clim, 'linear')\n\n # mask invalids\n vol_sm1_run.data = np.ma.masked_invalid(vol_sm1_run.data)\n ecv_clim.data = np.ma.masked_invalid(ecv_clim.data)\n\n # diff the cubes\n dff = vol_sm1_run - ecv_clim\n\n # save output and populate metric\n caption = f\"{model_dataset} minus CCI soil moisture clim for {season}\"\n provenance_record = get_provenance_record(caption, ancestors)\n save_data(f\"soilmoist_diff_{model_dataset}_{season}\",\n provenance_record, config, dff)\n\n name = f\"soilmoisture MedAbsErr {season}\"\n metrics[name] = float(np.ma.median(np.ma.abs(dff.data)))\n\n return metrics","def disk_average(self, var, r_lim):\n # change the mask for the one in Flux\n npx = self.params['npx']\n npy = self.params['npy']\n npz = self.params['npz']\n number_domains = npx*npy*npz # so far only works for number_domains<100\n Lx = self.params['Lx']\n Ly = self.params['Ly']\n Lz = self.params['Lz']\n x0 = Lx/2 # center point in the x domain.\n y0 = Ly/2 # center point in the y domain.\n nz = self.params['nz']\n\n if var == 'NN': # maybe interpolate is field...\n nz = nz - 1\n\n t = self.read_vars(['t'])['t']\n n_time = t.shape[0]\n\n r_max = r_lim #0.45 # as in forced_plume_nudging.py\n z_max = 0.95\n\n means = np.zeros((n_time, nz))\n\n fields = self.read_vars([var, 'x', 'y'])\n\n if var in ['u', 'v', 'w']:\n axis_vel = {'u': 3, 'v': 2, 'w':1}\n fields[var] = velocity_interpolation(fields[var], axis=axis_vel[var])\n\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\n fields['y']/Ly - 0.5)\n\n r = np.sqrt(XX**2 + YY**2)\n mask = ma.masked_outside(r, 0, r_max)\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\n\n for t in range(n_time):\n for z_lvl in range(nz):\n field_new = ma.masked_array(fields[var][t, z_lvl, :, :], mask.mask)\n means[t, z_lvl] = field_new.mean()\n\n #means = means/number_domains\n return means","def dynamics_prediction_variance_scorer(dynamics, episodes, window_size=1024):\n total_variances = []\n for episode in episodes:\n for batch in _make_batches(episode, window_size, dynamics.n_frames):\n pred = dynamics.predict(batch.observations, batch.actions, True)\n total_variances += pred[2].tolist()\n # smaller is better\n return -np.mean(total_variances)","def _em_variance(self, result, endog, exog, betas, tmp=None):\n k_exog = 0 if exog is None else exog.shape[1]\n\n if self.switching_variance:\n variance = np.zeros(self.k_regimes)\n for i in range(self.k_regimes):\n if k_exog > 0:\n resid = endog - np.dot(exog, betas[i])\n else:\n resid = endog\n variance[i] = (\n np.sum(resid ** 2 *\n result.smoothed_marginal_probabilities[i]) /\n np.sum(result.smoothed_marginal_probabilities[i]))\n else:\n variance = 0\n if tmp is None:\n tmp = np.sqrt(result.smoothed_marginal_probabilities)\n for i in range(self.k_regimes):\n tmp_endog = tmp[i] * endog\n if k_exog > 0:\n tmp_exog = tmp[i][:, np.newaxis] * exog\n resid = tmp_endog - np.dot(tmp_exog, betas[i])\n else:\n resid = tmp_endog\n variance += np.sum(resid ** 2)\n variance /= self.nobs\n return variance","def monthly_avg_2darray(x):\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()","def global_average_speed(cars):\n velocities = [car.velocity for car in cars]\n average_speed = sum(velocities)/len(cars)\n return average_speed","def winter_avg(var_nc,lat_slice=None,lon_slice=None): \n #\n # accumulate in shape [plev,lat,lon]\n #\n # use the whole array if slice objects are missing\n #\n if (lat_slice is None) and (lon_slice is None):\n num_lats=var_nc.shape[2]\n num_lons=var_nc.shape[3]\n lat_slice=slice(0,num_lats)\n lon_slice=slice(0,num_lons)\n print \"in winter avg: \",lat_slice,lon_slice\n else:\n num_lats=lat_slice.stop - lat_slice.start\n num_lons=lon_slice.stop - lon_slice.start\n num_levs=var_nc.shape[1]\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\n #\n # year 0 is special case since it doesn't have a december\n #\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\n accumulate+=the_slice\n num_years=var_nc.shape[0]//12\n #\n # now year 1 has year 0's december\n #\n djf=np.array([11,12,13],dtype=np.int32)\n #\n # iterate one year less because we've alread\n # done year zero as a special case\n #\n for the_year in np.arange(0,num_years-1):\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\n the_slice=ma.mean(the_slice,axis=0)\n accumulate+=the_slice\n djf=djf+12\n accumulate=accumulate/num_years \n the_avg=ma.mean(accumulate,axis=1)\n the_avg=ma.mean(the_avg,axis=1)\n return the_avg","def get_te_season_totals():\n te_totals = redis_cache('te_games_key', NFL_TE_Game_2015.query.filter_by(is_season_totals=True).all)\n return te_totals","def mv(series, window=30):\n if not isinstance(series, pd.Series):\n raise ValueError('expect input pandas series dataframe, but get %s'%(type(series)))\n\n return series.rolling(window=window, min_periods=1).mean()","def set_season_time(season): \n if season == '2021-22':\n startdate = time.strptime('13-08-2021', '%d-%m-%Y')\n startdate = datetime.fromtimestamp(mktime(startdate))\n enddate = time.strptime('08-10-2021', '%d-%m-%Y')\n enddate = datetime.fromtimestamp(mktime(enddate))\n if season == '2020-21':\n startdate = time.strptime('12-08-2020', '%d-%m-%Y')\n startdate = datetime.fromtimestamp(mktime(startdate))\n enddate = time.strptime('26-07-2021', '%d-%m-%Y')\n enddate = datetime.fromtimestamp(mktime(enddate))\n if season == '2019-20':\n startdate = time.strptime('09-08-2019', '%d-%m-%Y')\n startdate = datetime.fromtimestamp(mktime(startdate))\n enddate = time.strptime('26-07-2020', '%d-%m-%Y')\n enddate = datetime.fromtimestamp(mktime(enddate))\n return startdate, enddate","def getSeason(date):\n\n date = validate.timestamp(date)\n day = date.dayofyear\n leap_year = int(date.is_leap_year)\n\n spring = numpy.arange(80, 172) + leap_year\n summer = numpy.arange(172, 264) + leap_year\n autumn = numpy.arange(264, 355) + leap_year\n\n if day in spring:\n season = \"spring\"\n elif day in summer:\n season = \"summer\"\n elif day in autumn:\n season = \"autumn\"\n else:\n season = \"winter\"\n\n return season","def season_series(game_id, pref_team, other_team, last_season=False):\n\n # Init empty dictionaries and lists\n games_against = list()\n pref_toi = dict()\n pref_goals = dict()\n pref_assists = dict()\n pref_points = dict()\n pref_record = {\"wins\": 0, \"losses\": 0, \"ot\": 0}\n roster_player = True\n\n # If this is the first game of the season, we can set the 'last_season' flag to enable the\n # season series function to check last year's season series between the two teams.\n if not last_season:\n season_start = str(game_id)[0:4]\n season_end = str(int(season_start) + 1)\n yesterday = datetime.now() - timedelta(days=1)\n # yesterday = datetime.now() + timedelta(days=50)\n # schedule_url = (\n # f\"/schedule?teamId={pref_team.team_id}\"\n # f\"&expand=schedule.broadcasts,schedule.teams&startDate=\"\n # f\"{season_start}-08-01&endDate={yesterday:%Y-%m-%d}\"\n # )\n schedule_url = (\n f\"/schedule?teamId={pref_team.team_id}\"\n f\"&expand=schedule.broadcasts,schedule.teams\"\n f\"&season={season_start}{season_end}\"\n )\n else:\n season_start = int(str(game_id)[0:4]) - 1\n season_end = str(int(season_start) + 1)\n yesterday = datetime.now() - timedelta(days=1)\n # yesterday = datetime.now() + timedelta(days=50)\n # schedule_url = (\n # f\"/schedule?teamId={pref_team.team_id}\"\n # f\"&expand=schedule.broadcasts,schedule.teams&startDate=\"\n # f\"{season_start}-08-01&endDate={season_end}-06-01\"\n # )\n schedule_url = (\n f\"/schedule?teamId={pref_team.team_id}\"\n f\"&expand=schedule.broadcasts,schedule.teams\"\n f\"&season={season_start}{season_end}\"\n )\n\n schedule = api.nhl_api(schedule_url).json()\n dates = schedule[\"dates\"]\n\n # Loop through scheduled to get previously played games against\n for date in dates:\n game = date[\"games\"][0]\n game_type = game[\"gameType\"]\n game_id = game[\"gamePk\"]\n game_team_home = game[\"teams\"][\"home\"][\"team\"][\"name\"]\n game_team_away = game[\"teams\"][\"away\"][\"team\"][\"name\"]\n teams = [game_team_away, game_team_home]\n game_status = game[\"status\"][\"abstractGameState\"]\n if game_type == \"R\" and game_status == \"Final\" and other_team.team_name in teams:\n game_feed = f\"/game/{game_id}/feed/live\"\n games_against.append(game_feed)\n\n # If the two teams haven't played yet, just exit this function\n if not games_against:\n return None, None, None\n\n # Loop through newly created games_against list to get each stats\n for feed in games_against:\n game = api.nhl_api(feed).json()\n game_data = game[\"gameData\"]\n home_team_name = game_data[\"teams\"][\"home\"][\"name\"]\n pref_homeaway = \"home\" if home_team_name == pref_team.team_name else \"away\"\n other_homeaway = \"away\" if home_team_name == pref_team.team_name else \"home\"\n\n # Get season series\n end_period = game[\"liveData\"][\"linescore\"][\"currentPeriod\"]\n extra_time = True if end_period > 3 else False\n pref_score = game[\"liveData\"][\"linescore\"][\"teams\"][pref_homeaway][\"goals\"]\n other_score = game[\"liveData\"][\"linescore\"][\"teams\"][other_homeaway][\"goals\"]\n if pref_score > other_score:\n pref_record[\"wins\"] += 1\n elif other_score > pref_score and extra_time:\n pref_record[\"ot\"] += 1\n else:\n pref_record[\"losses\"] += 1\n\n season_series_str = f\"Series: {pref_record['wins']}-\" f\"{pref_record['losses']}-{pref_record['ot']}\"\n\n # Get stats leaders\n # pref_teamstats = game[\"liveData\"][\"boxscore\"][\"teams\"][pref_homeaway][\"teamStats\"]\n pref_playerstats = game[\"liveData\"][\"boxscore\"][\"teams\"][pref_homeaway][\"players\"]\n for id, player in pref_playerstats.items():\n try:\n # Calculate TOI\n player_toi_str = player[\"stats\"][\"skaterStats\"][\"timeOnIce\"]\n player_toi_minutes = int(player_toi_str.split(\":\")[0])\n player_toi_seconds = int(player_toi_str.split(\":\")[1])\n player_toi = (player_toi_minutes * 60) + player_toi_seconds\n pref_toi[id] = pref_toi.get(id, 0) + player_toi\n\n # Point Totals\n player_goal_str = player[\"stats\"][\"skaterStats\"][\"goals\"]\n pref_goals[id] = pref_goals.get(id, 0) + int(player_goal_str)\n player_assist_str = player[\"stats\"][\"skaterStats\"][\"assists\"]\n pref_assists[id] = pref_assists.get(id, 0) + int(player_assist_str)\n player_points = int(player_goal_str) + int(player_assist_str)\n pref_points[id] = pref_points.get(id, 0) + int(player_points)\n\n except KeyError:\n pass\n\n # Calculate Stats Leaders\n sorted_toi = sorted(pref_toi.values(), reverse=True)\n leader_toi = sorted_toi[0]\n\n sorted_points = sorted(pref_points.values(), reverse=True)\n leader_points = sorted_points[0]\n\n # Get TOI leader\n for id in pref_toi.keys():\n if pref_toi[id] == leader_toi:\n player_name = roster.player_attr_by_id(pref_team.roster, id, \"fullName\")\n if player_name is None:\n roster_player = False\n player_id_only = id.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n leader_toi_avg = leader_toi / len(games_against)\n m, s = divmod(leader_toi_avg, 60)\n toi_m = int(m)\n toi_s = int(s)\n toi_s = \"0{}\".format(toi_s) if toi_s < 10 else toi_s\n toi_avg = \"{}:{}\".format(toi_m, toi_s)\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n toi_leader_str = \"TOI Leader: {} with {} / game.\".format(player_short_name, toi_avg)\n\n # Handle tied points leaders\n point_leaders = list()\n for id in pref_points.keys():\n if pref_points[id] == leader_points:\n point_leaders.append(id)\n\n if leader_points == 0:\n points_leader_str = \"Points Leader: None (all players have 0 points).\"\n\n elif len(point_leaders) == 1:\n leader = point_leaders[0]\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n # If the player is no longer on the team, get their information (change string here?)\n if player_name is None:\n roster_player = False\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n if not roster_player:\n points_leader_str = (\n f\"Points Leader: {player_name} with {leader_points} points \"\n f\"({player_goals}G {player_assists}A) \"\n )\n else:\n points_leader_str = \"Points Leader: {} with {} ({}G {}A).\".format(\n player_name, leader_points, player_goals, player_assists\n )\n\n elif len(point_leaders) > 3:\n point_leaders_with_attrs = list()\n for leader in point_leaders:\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n if player_name is None:\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n point_leaders_with_attrs.append(player_short_name)\n\n point_leaders_joined = \", \".join(point_leaders_with_attrs[0:3])\n leftover_leaders = len(point_leaders) - 3\n points_leader_str = (\n f\"Points Leaders: {point_leaders_joined} & {leftover_leaders} others ({leader_points} each).\"\n )\n\n else:\n point_leaders_with_attrs = list()\n for leader in point_leaders:\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n if player_name is None:\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n player_str = f\"{player_short_name} ({player_goals}G {player_assists}A)\"\n point_leaders_with_attrs.append(player_str)\n\n point_leaders_joined = (\n f\", \".join(point_leaders_with_attrs[:-1]) + f\" & {point_leaders_with_attrs[-1]}\"\n )\n points_leader_str = \"Points Leaders: {} with {} each.\".format(point_leaders_joined, leader_points)\n\n return season_series_str, points_leader_str, toi_leader_str","def test_one_region_time_aggregation(self, months, seasons, regions_rect):\n data = np.array(\n [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]], dtype=float\n ) # area a, months 1-12\n\n expected = np.array(\n [[31 + 31 + 28, 31 + 30 + 31, 30 + 31 + 31, 30 + 31 + 30]], dtype=float\n ) # area a, seasons 1-4\n\n adaptor = IntervalAdaptor(\"test-month-seasons\")\n from_spec = Spec(\n name=\"test-var\",\n dtype=\"float\",\n dims=[\"rect\", \"months\"],\n coords={\"months\": months, \"rect\": regions_rect},\n )\n adaptor.add_input(from_spec)\n to_spec = Spec(\n name=\"test-var\",\n dtype=\"float\",\n dims=[\"rect\", \"seasons\"],\n coords={\"seasons\": seasons, \"rect\": regions_rect},\n )\n adaptor.add_output(to_spec)\n\n data_array = DataArray(from_spec, data)\n\n data_handle = Mock()\n data_handle.get_data = Mock(return_value=data_array)\n data_handle.read_coefficients = Mock(side_effect=SmifDataNotFoundError)\n\n adaptor.simulate(data_handle)\n actual = data_handle.set_results.call_args[0][1]\n\n assert np.allclose(actual, expected)","def fun_average_mse_sd(filtered):\n res = 0.0\n num = 0\n # Sometimes there was \"inf\" in the results. We will ignore those elements.\n for p in filtered:\n x = float(p[\"result.best.mse\"])\n if not \"n\" in str(x):\n res += x\n num += 1\n else:\n print(\"Nan encountered\")\n avg = res / num\n sd = 0.0\n for p in filtered:\n x = float(p[\"result.best.mse\"])\n if not \"n\" in str(x):\n sd += (x - avg) ** 2.0\n sd = math.sqrt(sd / num)\n if num == 0:\n return \"-\"\n else:\n return r\"${0} \\pm{1}$\".format(avg, sd)","def load_class_avg(self, mrcs, factor):\n \n global shape\n \n projection_2D = {}\n extract_2D = {}\n \n if len(factor) == 0: # Empty entry, set factor 1\n factor = 1\n\n with mrcfile.open(mrcs) as mrc:\n for i, data in enumerate(mrc.data):\n projection_2D[i] = data\n mrc.close()\n \n shape = transform.rotate(projection_2D[0].copy(), 45, resize=True).shape[0]\n\n for k, avg in projection_2D.items():\n if factor == 1:\n extract_2D[k] = extract_class_avg(avg)\n else:\n scaled_img = transform.rescale(\n avg, \n scale=(1/float(factor)), \n anti_aliasing=True, \n multichannel=False, # Add to supress warning\n mode='constant' # Add to supress warning\n ) \n extract_2D[k] = extract_class_avg(scaled_img)\n\n return projection_2D, extract_2D","def calcExpMovAvg(self, windowLength, smoothingFactor):\n\n if smoothingFactor < 0 or smoothingFactor > 1:\n raise ValueError(\n \"Value of smoothing factor should be in between 0-1\")\n\n EMA_prev = sum(self.x[:windowLength])/windowLength\n n = len(self.x)\n\n EMA = []\n\n for i in range(n):\n if i >= windowLength:\n temp = smoothingFactor*self.x[i] + (1-smoothingFactor)*EMA_prev\n EMA.append(temp)\n EMA_prev = temp\n return [None]*windowLength + EMA","def mov_std(ts, m):\n\n if m <= 1:\n raise ValueError(\"Query length must be longer than one\")\n\n ts = ts.astype(\"float\")\n # Add zero to the beginning of the cumsum of ts\n s = np.insert(np.cumsum(ts), 0, 0)\n # Add zero to the beginning of the cumsum of ts ** 2\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\n seg_sum = s[m:] - s[:-m]\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\n return np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)","def set_season(date_obj):\n date_year = date_obj.year\n\n for key, val in SEASONS.items():\n start = datetime(year=date_year, month=val['start']['month'], day=val['start']['day'])\n end = datetime(year=date_year, month=val['end']['month'], day=val['end']['day'])\n if key == 'Winter':\n start_year = date_year - 1 if date_obj.month in [1, 2, 3] else date_year\n end_year = date_year + 1 if date_obj.month == 12 else date_year\n start = datetime(year=start_year, month=val['start']['month'], day=val['start']['day'])\n end = datetime(year=end_year, month=val['end']['month'], day=val['end']['day'])\n\n if start <= date_obj <= end:\n return key","def compute_GS(GMtcs):\n\n GS = np.mean(GMtcs,axis=0) #average over voxels\n\n return GS","def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n if vid==None:\n vid = 'reduced_'+mv.id\n time,lat,lon = tllAxes(mv)\n if hasattr(mv.parent,'variables'):\n fil = mv.parent # mv is a fileVariable and fil is a file.\n lat_bnds = fil[lat.bounds]\n else:\n lataxis = latAxis(mv) # mv is a TransientVariable\n lat_bnds = lataxis._bounds_\n\n mvta = timeave_old( mv )\n\n # In computing the average, we use area weighting.\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\n # With equally spaced lon, we don't need delta(lon) for weights.\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\n wgtsum = 0\n zm = 0\n for i,lati in enumerate(lat):\n # The following test could be sped up a lot, because lat[i] is ordered...\n # >>> to do: partial overlaps\n if latmin<=lati and lati<latmax:\n latlo = lat_bnds[i,0]\n lathi = lat_bnds[i,1]\n wgti = sin(radians(lathi))-sin(radians(latlo))\n zi = 0.0\n for j in range(len(lon)):\n zi += mvta[i,j]\n zi *= wgti\n wgtsum += wgti*len(lon)\n zm += zi\n zm /= wgtsum\n # zm is a scalar, so createVariable gets no axes argument:\n zmv = cdms2.createVariable( zm, id=vid )\n return zmv","def mean_by_mass(self, name):\n m = np.asanyarray(self[\"mass\"])\n ret = array.SimArray(\n (self[name].transpose() * m).transpose().mean(axis=0) / m.mean(), self[name].units)\n\n return ret","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def average( names):\n\n rs = radioastronomy.Spectrum() # create input and average structures\n asum = radioastronomy.Spectrum()\n nsum = 0\n\n # now average coldest data for calibration\n for filename in names:\n\n rs.read_spec_ast(filename)\n rs.azel2radec() # compute ra,dec from az,el\n\n if nsum == 0:\n asum = copy.deepcopy( rs)\n firstlon = rs.gallon\n asum.ydataA = rs.ydataA * rs.durationSec\n asum.gallat = rs.gallat * rs.durationSec\n asum.gallon = rs.gallon * rs.durationSec\n nsum = 1\n firstutc = rs.utc\n lastutc = rs.utc\n else:\n asum.ydataA = asum.ydataA + (rs.ydataA * rs.durationSec)\n asum.count = asum.count + rs.count\n asum.durationSec = asum.durationSec + rs.durationSec\n # fix wrap of longitudes\n if abs(rs.gallon - firstlon) > 180:\n crossZero = True\n if rs.gallon > firstlon:\n rs.gallon = rs.gallon - 360.\n else:\n rs.gallon = rs.gallon + 360.\n asum.gallon = asum.gallon + (rs.gallon * rs.durationSec)\n asum.gallat = asum.gallat + (rs.gallat * rs.durationSec)\n # keep track of observing time for weighted sum\n lastutc = rs.utc\n nsum = nsum + 1\n #end for all files loop\n\n if nsum < 1:\n print \"No acceptable files in average list\"\n else:\n asum.ydataA = asum.ydataA/float(asum.durationSec)\n asum.gallon = asum.gallon/float(asum.durationSec)\n asum.gallat = asum.gallat/float(asum.durationSec)\n aveutc,duration = radioastronomy.aveutcs( firstutc, lastutc)\n asum.utc = aveutc\n if (duration < 1.):\n print 'hotcold.average: very short average interval: ',duration\n return nsum, asum","def extract_events_from_mc(self, sources, mc, ):\n sig_events = np.empty((0, ),\n dtype=[(\"ra\", np.float), (\"sinDec\", np.float),\n (\"sigma\", np.float), (\"logE\", np.float),\n (\"dec\", np.float), ('timeMJD', np.float),\n ])\n\n # Sets detector livetime in seconds\n livetime = self.Livetime * (60. * 60. * 24.)\n\n # Conservative\n dec_bandwidth = np.deg2rad(5.)\n TotMuN = 0.\n\n # Loops over sources to add in expected number of neutrinos\n for source in sources:\n\n # Checks to see if source_path is actually overlapping a given season\n\n if self.UseTime is True:\n if not source['weight_time'] > 0.0:\n continue\n\n # Only includes events lying in a +/- 5 degree declination band\n SourceMC, omega, band_mask = self.find_and_apply_band_mask(\n source, mc, dec_bandwidth)\n\n if self._ReturnInjectorNExp is True:\n source['weight_distance'] = 1.\n\n # If using time, calculates the Fluence using the time model\n # Otherwise calculates Fluence as flux * livetime (i.e. constant)\n if self.UseTime is True:\n fluence = source['flux'] * self.SimTimeLength * (60. * 60. * 24.)\n\n # EfficencyFactor = livetime / (\n # (self.DataEnd - self.DataStart) * 24. * 60. * 60.)\n # TotalTime = self.SimTimeLength * (60. * 60. * 24.)\n # fluence = EfficencyFactor * TotalTime * source['flux']\n # print EfficencyFactor\n # raw_input(\"prompt\")\n else:\n fluence = source['flux'] * livetime\n\n # Recalculates the one weights to account for the band mask?\n SourceMC['ow'] = (self.WeightsInject[band_mask] / omega) * source[\n 'weight_distance'] * fluence\n\n # Expectation number of Neutrinos, equal to sum of one weights\n MuN = np.sum(SourceMC['ow'], dtype=np.float)\n\n if self._ReturnInjectorNExp is True:\n return MuN\n\n # If weighting for time, calculates weighted expectation value\n # for number of neutrinos, and adds it to total expectation value.\n if self.UseTime is True:\n weightedMuN = MuN * source['sim_TimeNorm']\n TotMuN += weightedMuN\n\n # If not time weighting, simply adds expectation value to total.\n else:\n TotMuN += MuN\n\n # print weightedMuN, source[\"weight_time\"]\n\n # Draws random number from expectation value of neutrinos\n n_signal = np.random.poisson(MuN)\n if n_signal < 1:\n continue\n\n # Creates a normalised array of OneWeights\n p_select = SourceMC['ow'] / np.sum(SourceMC['ow'])\n\n # Creates an array with n_signal entries.\n # Each entry is a random integer between 0 and no. of sources.\n # The probability for each integer is equal to the OneWeight of\n # the corresponding source_path.\n ind = np.random.choice(len(SourceMC['ow']), size=n_signal,\n p=p_select)\n\n # Selects the sources corresponding to the random integer array\n sam_ev = SourceMC[ind]\n\n # Rotates the Monte Carlo events onto the source_path\n sam_ev = self.rotate_struct(sam_ev, source['ra'], source['dec'])\n\n # Generates random numbers according to Time profile\n if self.UseTime is True:\n sam_ev['timeMJD'] = (\n self.generate_n_random_numbers(n_signal) +\n source['discoverydate_mjd'])\n\n # Checks that events lie within a given season\n sam_ev = self.check_time_borders(sam_ev, )\n\n sig_events = np.concatenate((sig_events, sam_ev))\n\n # print len(sig_events), sig_events, self.DataStart\n # raw_input(\"prompt\")\n\n return sig_events","def getMeanRMS (self,arr):\n # in base class we return redshift and zero varinace\n # repeat that here because mean RMS is meaningless for Template SED PDFs\n N=len(arr)\n return arr[\"z\"],np.zeros(N)","def get_wr_season_totals():\n wr_totals = redis_cache('wr_games_key', NFL_WR_Game_2015.query.filter_by(is_season_totals=True).all)\n return wr_totals","def _parse_season_entry (self, season, video, sorting):\n return {\n season['summary']['id']: {\n 'idx': sorting[season['summary']['id']],\n 'id': season['summary']['id'],\n 'text': season['summary']['name'],\n 'shortName': season['summary']['shortName'],\n 'boxarts': {\n 'small': video['boxarts']['_342x192']['jpg']['url'],\n 'big': video['boxarts']['_1280x720']['jpg']['url']\n },\n 'interesting_moment': video['interestingMoment']['_665x375']['jpg']['url'],\n }\n }","def seasonality(time, period, amplitude=1, phase=0):\n\tseason_time = ((time + phase) % period) / period\n\treturn amplitude * seasonal_pattern(season_time)","def rolling_mean_dispersion(\n data: np.ndarray, time_windows: np.ndarray, fps: int\n ) -> np.ndarray:\n\n results = np.full((data.shape[0], time_windows.shape[0]), -1)\n for time_window in prange(time_windows.shape[0]):\n jump_frms = int(time_windows[time_window] * fps)\n for current_frm in prange(jump_frms, results.shape[0] + 1):\n data_window = np.deg2rad(data[current_frm - jump_frms : current_frm])\n results[current_frm - 1][time_window] = np.rad2deg(\n stats.circmean(data_window)\n ).astype(int)\n return results","def monthly_avgs(HC):\n monthlies = np.zeros((int(len(HC)/12),12))\n counter_m = 0 #keeps track of years\n counter_n = 0 #keeps track of months\n for i in range(len(HC)):\n if counter_n<12:\n monthlies[counter_m,counter_n] = HC[i]\n counter_n += 1\n else:\n counter_m += 1\n monthlies[counter_m,0] = HC[i]\n counter_n = 1\n monthly_avgs = np.zeros((12))\n months = np.zeros((12))\n for i in range(12):\n monthly_avgs[i] = np.mean(monthlies[:,i])\n months[i] = i+1\n \n return months, monthly_avgs","def class_average_speed(cars):\n # Sort by class name\n class_sorted = sorted(cars, key=lambda car: type(car).__name__)\n class_velocities = []\n class_names = []\n # Group the cars of same class and average their velocities, save class names\n for key, group in groupby(cars, key=lambda car: type(car).__name__):\n velocities = [car.velocity for car in group]\n class_velocity = sum(velocities) / len(velocities)\n class_velocities.append([class_velocity])\n class_names.append(key)\n return class_velocities, class_names","def cal_beam_AvgRMS(infile):\n \n data = np.loadtxt(infile)\n rms = data[:,3]\n avg_rms = round(np.mean(rms), 3)\n \n return avg_rms"],"string":"[\n \"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax is None:\\n print \\\"WARNING- no time axis in\\\",mv.id\\n return None\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n print \\\"WARNING- cannot compute climatology for\\\",mv.id,seasons.seasons\\n print \\\"...probably there is no data for times in the requested season.\\\"\\n return None\\n avmv = mvseas\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def reduce_time( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id=='time' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n if len(axes_string)>2:\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n avmv = averager( mv, axis=axes_string )\\n else:\\n avmv = mv\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def seasonal_avg(var_nc,the_season,lat_slice=None,lon_slice=None): \\n the_season=np.array(the_season,dtype=np.int32)\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n else:\\n if lat_slice.stop is None:\\n num_lats=var_nc.shape[2]\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n if lon_slice.stop is None:\\n num_lons=var_nc.shape[3]\\n else:\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n num_years=var_nc.shape[0]//12\\n\\n for the_year in np.arange(0,num_years):\\n the_slice=var_nc[the_season,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n the_season=the_season+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def getSeasonStats(self):\\n df_season_agg = self.toSeasonAggFormat()\\n\\n # Calculate Possessions for each game\\n df_season_agg['possessions'] = 0.5 * (df_season_agg['FGA'] + 0.475 * df_season_agg['FTA'] - df_season_agg['OR'] + df_season_agg['TO']) \\\\\\n + 0.5 * (df_season_agg['OppFGA'] + 0.475 * df_season_agg['OppFTA'] - df_season_agg['OppOR'] + df_season_agg['OppTO'])\\n\\n # Aggregate to Season Summary Level\\n season_stats = df_season_agg.groupby(['TeamID', 'Season']).sum()\\n\\n season_stats = season_stats.rename(columns={'Win':'wins'})\\n\\n # Season Advanced Stats\\n season_stats['o_eff'] = season_stats['Score'] / season_stats['possessions'] * 100\\n season_stats['d_eff'] = season_stats['OppScore'] / season_stats['possessions'] * 100\\n season_stats['net_eff'] = season_stats['o_eff'] - season_stats['d_eff']\\n\\n season_stats.drop('DayNum', axis=1, inplace=True)\\n season_stats.drop('OppTeamID', axis=1, inplace=True)\\n season_stats.drop('rand', axis=1, inplace=True)\\n\\n return season_stats\",\n \"def compute_mse(self, results, T, nSegments):\\n times_per_day = 56\\n mse=0\\n for i in range(nSegments):\\n mse += T * np.mean(results[i][0].mse_path_[np.where(results[i][0].alphas_ == results[i][0].alpha_)[0][0]])\\n mse += ((times_per_day-1)-T) * np.mean(results[i][1].mse_path_[np.where(results[i][1].alphas_ == results[i][1].alpha_)[0][0]])\\n mse = mse/((times_per_day-1)*nSegments)\\n return mse\",\n \"def get_dryspells_perseason(dryspells, seasons=((12, 1, 2), (3, 4, 5),\\n (6, 7, 8), (9, 10, 11))):\\n dryspells_seasons = []\\n for season in seasons:\\n eveSeas = []\\n for eveLand in dryspells:\\n eves = [e for e in eveLand if e.start_date().month in season]\\n eveSeas.append(eves)\\n dryspells_seasons.append(eveSeas)\\n\\n return dryspells_seasons\",\n \"def seasonal_mean(args_file):\\n product, start_date, end_date, variable_name, shape_file = Utility.read_yml_params(args_file)\\n stat = Statistic.Mean\\n time = TimePeriod.Seasonal\\n\\n ds = get_data_set(product, shape_file)\\n\\n result = Utility.Apply_stat(ds, start_date, end_date, variable_name, stat, time)\\n return result\",\n \"def timeseriesCVscore(self, params):\\n errors = []\\n\\n # values = series.values\\n values = self.train_ts\\n self.alpha, self.beta, self.gamma = params\\n\\n # set the number of folds for cross-validation\\n tscv = TimeSeriesSplit(n_splits=3)\\n\\n # iterating over folds, train model on each, forecast and calculate error\\n for train, test in tscv.split(values):\\n\\n self.train = values[train]\\n self.test = values[test]\\n self.triple_exponential_smoothing()\\n predictions = self.result[-len(self.test) :]\\n actual = values[test]\\n error = mape(list(actual), predictions)\\n errors.append(error)\\n\\n # print \\\"error: \\\"\\n # print errors\\n return np.mean(np.array(errors))\",\n \"def seasonal_means(t, y, edges=None, hard=False):\\n ts, ys = seasonal_series(t, y, edges=edges, hard=hard)\\n t_means = [t.jyear.mean() for t in ts]\\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\\n y_means = np.array([y.mean() for y in ys])\\n y_std = np.array([y.std() for y in ys])\\n y_N = np.array([y.size for y in ys])\\n return t_means, y_means, y_std, y_N\",\n \"def timeave_old( mv ):\\n # I haven't thought yet about how missing values would work with this...\\n # If time intervals be unequal, this will have to be changed...\\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\\n n = sh[0]\\n # BTW, this is the size of everything else:\\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\\n mvta = numpy.sum( mv.__array__(), axis=0 )\\n mvta /= n\\n return mvta\",\n \"def calcSeason(ra, time):\\n # Reference RA and equinox to anchor ra/season reference - RA = 0 is overhead at autumnal equinox\\n # autumn equinox 2014 happened on september 23 --> equinox MJD\\n Equinox = 2456923.5 - 2400000.5\\n # convert ra into 'days'\\n dayRA = ra / 360 * 365.25\\n firstSeasonBegan = Equinox + dayRA - 0.5 * 365.25\\n seasons = (time - firstSeasonBegan) / 365.25\\n # Set first season to 0\\n seasons = seasons - np.floor(np.min(seasons))\\n return seasons\",\n \"def get_gas_by_month(self, year, month, deseasonalize=False):\\n df = self.conc_trend if deseasonalize else self.conc_seasonal\\n ts = pd.Timestamp(year, month, 1)\\n info_dict = {'latency': df.latency[ts]}\\n return df.dmf_mean[ts], info_dict\",\n \"def interpolateseasons(self):\\n\\n remainder = self.season - self.startseason\\n f1 = 1.0 - remainder\\n self.data = (self.startdata * f1) + (self.stopdata * remainder)\",\n \"def distributeSeason(self):\\n i = 1\\n for day in self.daylist:\\n if i >= monthbeg[5] and i < monthbeg[9]: #june through SEpt as per SCE\\n day.season = 'summer' #https://www.sce.com/residential/rates/Time-Of-Use-Residential-Rate-Plans\\n i = i + 1\\n else:\\n day.season = 'winter'\\n i = i+1\",\n \"def reduce2scalar( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def test_aggregate_from_month_to_seasons(\\n self, months, seasons, monthly_data, monthly_data_as_seasons\\n ):\\n adaptor = IntervalAdaptor(\\\"test-month-season\\\")\\n from_spec = Spec(\\n name=\\\"test-var\\\", dtype=\\\"float\\\", dims=[\\\"months\\\"], coords={\\\"months\\\": months}\\n )\\n adaptor.add_input(from_spec)\\n to_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"seasons\\\"],\\n coords={\\\"seasons\\\": seasons},\\n )\\n adaptor.add_output(to_spec)\\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\\n\\n data_array = DataArray(from_spec, monthly_data)\\n\\n data_handle = Mock()\\n data_handle.get_data = Mock(return_value=data_array)\\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\\n\\n adaptor.simulate(data_handle)\\n actual = data_handle.set_results.call_args[0][1]\\n expected = monthly_data_as_seasons\\n\\n assert np.allclose(actual, expected, rtol=1e-05, atol=1e-08)\",\n \"def season_rounds(cls, season):\\r\\n\\t\\t\\r\\n\\t\\tfolder_name = cls.season_folder(season)\\r\\n\\t\\tround_list = os.listdir(f'Data/{folder_name}')\\r\\n\\r\\n\\t\\tall_rounds = []\\r\\n\\r\\n\\t\\tfor round_file in round_list:\\r\\n\\t\\t\\twith open(f'Data/{folder_name}/{round_file}', 'r', encoding='utf-8') as f:\\r\\n\\t\\t\\t\\tround_info = f.read().splitlines()\\r\\n\\r\\n\\t\\t\\tround_number = round_file[:-4]\\r\\n\\t\\t\\tfull_round_name = f\\\"{season} R{round_number}\\\"\\r\\n\\r\\n\\t\\t\\tround_date = int(round_info[0])\\r\\n\\t\\t\\tlookup_ind = DATES.month_diff(round_date, DATES.MIN_DATE)\\r\\n\\r\\n\\t\\t\\t# If the round isn't actually counted for TWOW Glicko\\r\\n\\t\\t\\tif full_round_name not in cls.ROUNDS[lookup_ind].keys():\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\r\\n\\t\\t\\tcontestant_count = len(round_info) - 1\\r\\n\\r\\n\\t\\t\\tstrength = cls.ROUNDS[lookup_ind][full_round_name][0]\\r\\n\\r\\n\\t\\t\\tall_rounds.append([\\r\\n\\t\\t\\t\\tround_number,\\r\\n\\t\\t\\t\\tround_date,\\r\\n\\t\\t\\t\\tcontestant_count,\\r\\n\\t\\t\\t\\tstrength\\r\\n\\t\\t\\t])\\r\\n\\t\\t\\r\\n\\t\\treturn all_rounds\",\n \"def rmsse(self, seasonality: int = 1) -> float:\\n q = np.abs(self._error()) / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))\\n return float(np.sqrt(np.mean(np.square(q))))\",\n \"def seasonal_calc(t, y, func, edges=None):\\n ts, ys = seasonal_series(t, y, edges=edges)\\n t_means = [t.jyear.mean() for t in ts]\\n t_means = astropy.time.Time(t_means, format='jyear', scale=t.scale)\\n f_y = np.array([func(y) for y in ys])\\n return t_means, f_y\",\n \"def mov_mean_std(ts, m):\\n\\n if m <= 1:\\n raise ValueError(\\\"Query length must be longer than one\\\")\\n\\n ts = ts.astype(\\\"float\\\")\\n\\n # Add zero to the beginning of the cumsum of ts\\n s = np.insert(np.cumsum(ts), 0, 0)\\n\\n # Add zero to the beginning of the cumsum of ts ** 2\\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\\n seg_sum = s[m:] - s[:-m]\\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\\n return seg_sum / m, np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)\",\n \"def calcSeasonModified( monthNum ):\\r\\n\\r\\n if monthNum == 12 or monthNum == 1 or monthNum == 2:\\r\\n return 0\\r\\n\\r\\n elif monthNum == 6 or monthNum == 7 or monthNum == 7:\\r\\n return 1\\r\\n\\r\\n else:\\r\\n return 3\",\n \"def m_average_fun(self, dx=df.dx):\\n\\n mx = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([1, 0, 0])) * dx)\\n my = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 1, 0])) * dx)\\n mz = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 0, 1])) * dx)\\n volume = df.assemble(self.material._Ms_dg * dx)\\n\\n return np.array([mx, my, mz]) / volume\",\n \"def mase(self, seasonality: int = 1):\\n return self.mae() / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))\",\n \"def enstrophy_average(\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3): # vorticity-3 component\\n #---------------------------------------------------------------------#\\n # Defining the domain variables #\\n #---------------------------------------------------------------------#\\n dim = omega1.shape\\n time = dim[-1]\\n avg = np.zeros(time)\\n #---------------------------------------------------------------------#\\n # Looping over the time variable #\\n #---------------------------------------------------------------------#\\n print_count = 51\\n for i in range(0, time):\\n term1 = np.square(omega1[:,:,:,i])\\n term2 = np.square(omega2[:,:,:,i])\\n term3 = np.square(omega3[:,:,:,i])\\n enst = 0.5*(term1 + term2 + term3)\\n avg[i] = np.mean(enst)\\n #-----------------------------------------------------------------#\\n # Printing statement #\\n #-----------------------------------------------------------------#\\n if print_count > 20:\\n print('Enstrophy average ---> t_step = %i' %(i))\\n print_count = 0\\n print_count += 1\\n\\n return avg\",\n \"def getNumSeasons(self):\\n searchURL = \\\"http://api.tvmaze.com/shows/\\\" + str(self.__showID) \\\\\\n + \\\"/seasons\\\"\\n\\n response = requests.get(searchURL)\\n data = response.json()\\n\\n return data[-1][\\\"number\\\"]\",\n \"def parse_episodes_by_season (self, response_data):\\n episodes = {}\\n raw_episodes = response_data['value']['videos']\\n for episode_id in raw_episodes:\\n if self._is_size_key(key=episode_id) == False:\\n if (raw_episodes[episode_id]['summary']['type'] == 'episode'):\\n episodes.update(self.parse_episode(episode=raw_episodes[episode_id], genres=response_data['value']['genres']))\\n return episodes\",\n \"def test_time_only_conversion_disagg(self, months, seasons):\\n adaptor = IntervalAdaptor(\\\"test-season-month\\\")\\n from_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"seasons\\\"],\\n coords={\\\"seasons\\\": seasons},\\n )\\n adaptor.add_input(from_spec)\\n to_spec = Spec(\\n name=\\\"test-var\\\", dtype=\\\"float\\\", dims=[\\\"months\\\"], coords={\\\"months\\\": months}\\n )\\n adaptor.add_output(to_spec)\\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\\n\\n data = np.array([3, 3, 3, 3])\\n data_array = DataArray(from_spec, data)\\n data_handle = Mock()\\n data_handle.get_data = Mock(return_value=data_array)\\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\\n\\n adaptor.simulate(data_handle)\\n actual = data_handle.set_results.call_args[0][1]\\n expected = np.array(\\n [\\n 1.033333,\\n 0.933333,\\n 1.01087,\\n 0.978261,\\n 1.01087,\\n 0.978261,\\n 1.01087,\\n 1.01087,\\n 0.989011,\\n 1.021978,\\n 0.989011,\\n 1.033333,\\n ]\\n )\\n np.testing.assert_allclose(actual, expected, rtol=1e-3)\",\n \"def seasonality(df):\\n df_datetime = pd.DatetimeIndex(df.date_time)\\n df[\\\"month\\\"] = df_datetime.month\\n df = drop_cols(df, [\\\"date_time\\\"])\\n\\n return df\",\n \"def season_info(cls, season):\\r\\n\\r\\n\\t\\traw_info = cls.season_rounds(season)\\r\\n\\r\\n\\t\\tinfo = [\\r\\n\\t\\t\\tseason,\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# 0 -> Season name\\r\\n\\t\\t\\tlen(raw_info),\\t\\t\\t\\t\\t\\t\\t\\t# 1 -> Amount of rounds\\r\\n\\t\\t\\tmin([round[1] for round in raw_info]),\\t\\t# 2 -> Starting date\\r\\n\\t\\t\\tmax([round[1] for round in raw_info]),\\t\\t# 3 -> Latest round date\\r\\n\\t\\t\\tnp.mean([round[3] for round in raw_info])\\t# 4 -> Average round strength\\r\\n\\t\\t]\\r\\n\\r\\n\\t\\treturn info\",\n \"def season(obs, season_gap=80., mjdCol='observationStartMJD'):\\n\\n # check wether season has already been estimated\\n if 'season' in obs.dtype.names:\\n return obs\\n\\n obs.sort(order=mjdCol)\\n\\n \\\"\\\"\\\"\\n if len(obs) == 1:\\n obs = np.atleast_1d(obs)\\n obs = rf.append_fields([obs], 'season', [1.])\\n return obs\\n diff = obs[mjdCol][1:]-obs[mjdCol][:-1]\\n\\n flag = np.argwhere(diff > season_gap)\\n if len(flag) > 0:\\n seas = np.zeros((len(obs),), dtype=int)\\n flag += 1\\n seas[0:flag[0][0]] = 1\\n for iflag in range(len(flag)-1):\\n seas[flag[iflag][0]:flag[iflag+1][0]] = iflag+2\\n seas[flag[-1][0]:] = len(flag)+1\\n obs = rf.append_fields(obs, 'season', seas)\\n else:\\n obs = rf.append_fields(obs, 'season', [1]*len(obs))\\n \\\"\\\"\\\"\\n seasoncalc = np.ones(obs.size, dtype=int)\\n\\n if len(obs) > 1:\\n diff = np.diff(obs[mjdCol])\\n flag = np.where(diff > season_gap)[0]\\n\\n if len(flag) > 0:\\n for i, indx in enumerate(flag):\\n seasoncalc[indx+1:] = i+2\\n\\n obs = rf.append_fields(obs, 'season', seasoncalc)\\n return obs\",\n \"def speed_setting_season(self):\\n if self.season == \\\"spring\\\":\\n self.grid.speed_values[self.path_color] = 4\\n self.grid.speed_values[(0, 0, 255)] = 0.1\\n elif self.season == \\\"winter\\\":\\n self.grid.speed_values[self.path_color] = 3\\n self.grid.speed_values[(0, 0, 255)] = 0.1\\n elif self.season == \\\"fall\\\":\\n self.grid.speed_values[self.path_color] = 6\\n elif self.season == \\\"summer\\\":\\n pass\",\n \"def get_variance_maps_models(variable=\\\"pr\\\",models=None,cmip_dir = None,period=12):\\n if models is None:\\n f = cdms.open(\\\"/work/marvel1/SEASONAL/MMA/cmip5.ZONALMMA.historical-rcp85.rip.mo.atm.Amon.pr.ver-1.AmpPhase.nc\\\")\\n phase = f(\\\"phase\\\")\\n models = eval(phase.getAxis(0).models)\\n f.close()\\n if cmip_dir is None:\\n cmip_dir = \\\"/work/cmip5/historical-rcp85/atm/mo/\\\"+variable+\\\"/\\\"\\n fobs = cdms.open(\\\"/work/marvel1/SEASONAL/OBS/GPCP.precip.mon.mean.nc\\\")\\n the_grid = fobs(\\\"precip\\\").getGrid()\\n nlat,nlon=the_grid.shape\\n fobs.close()\\n VarianceMaps = np.zeros((len(models),nlat))+1.e20\\n counter=0\\n for model in models:\\n print model\\n try:\\n fname = sorted(glob.glob(cmip_dir+\\\"*.\\\"+model+\\\".*\\\"))[0]\\n fp = cdms.open(fname)\\n prtest = fp(variable,time=(\\\"1979-1-1\\\",\\\"2014-12-31\\\")).regrid(the_grid,regridTool='regrid2')\\n przonal = cdutil.averager(prtest,axis='x')\\n dom = variance_map(przonal,period=period)\\n VarianceMaps[counter]=dom\\n fp.close()\\n counter+=1\\n except:\\n continue\\n \\n modax = cdms.createAxis(range(len(models)))\\n modax.id = \\\"model\\\"\\n modax.models = str(models)\\n VarianceMaps = MV.array(VarianceMaps)\\n VarianceMaps.setAxis(0,modax)\\n VarianceMaps.setAxis(1,the_grid.getLatitude())\\n return MV.masked_where(VarianceMaps>1.e10,VarianceMaps)\",\n \"def parse_seasons (self, id, response_data):\\n raw_seasons = response_data['value']\\n videos = raw_seasons['videos']\\n\\n # get art video key\\n video = {}\\n for key, video_candidate in videos.iteritems():\\n if not self._is_size_key(key):\\n video = video_candidate\\n\\n # get season index\\n sorting = {}\\n for idx, season_list_entry in video['seasonList'].iteritems():\\n if self._is_size_key(key=idx) == False and idx != 'summary':\\n sorting[int(season_list_entry[1])] = int(idx)\\n\\n seasons = {}\\n\\n for season in raw_seasons['seasons']:\\n if self._is_size_key(key=season) == False:\\n seasons.update(self._parse_season_entry(season=raw_seasons['seasons'][season], video=video, sorting=sorting))\\n return seasons\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def test_time_only_conversion(self, months, seasons):\\n adaptor = IntervalAdaptor(\\\"test-month-season\\\")\\n from_spec = Spec(\\n name=\\\"test-var\\\", dtype=\\\"float\\\", dims=[\\\"months\\\"], coords={\\\"months\\\": months}\\n )\\n adaptor.add_input(from_spec)\\n to_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"seasons\\\"],\\n coords={\\\"seasons\\\": seasons},\\n )\\n adaptor.add_output(to_spec)\\n actual_coefficients = adaptor.generate_coefficients(from_spec, to_spec)\\n\\n data = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\\n\\n data_array = DataArray(from_spec, data)\\n\\n data_handle = Mock()\\n data_handle.get_data = Mock(return_value=data_array)\\n data_handle.read_coefficients = Mock(return_value=actual_coefficients)\\n\\n adaptor.simulate(data_handle)\\n actual = data_handle.set_results.call_args[0][1]\\n expected = np.array([3, 3, 3, 3])\\n np.testing.assert_array_equal(actual, expected)\",\n \"def ann_mean(ds, season=None, time_bnds_varname='time_bnds', time_centered=True, n_req=None):\\n \\n ds = ds.copy() #deep=True)\\n\\n if n_req is None:\\n if season is not None:\\n n_req = 2\\n else:\\n n_req = 8\\n \\n if time_bnds_varname is None and not time_centered:\\n raise NotImplementedError('time_bnds_varname cannot be \\\"None\\\" if time_centered=False')\\n \\n if not time_centered:\\n time_units = ds.time.encoding['units']\\n time_calendar = ds.time.encoding['calendar']\\n\\n # compute time bounds array\\n time_bound_data = cftime.date2num(\\n ds[time_bnds_varname].data, \\n units=time_units, \\n calendar=time_calendar) \\n\\n # center time\\n time_centered = cftime.num2date(\\n time_bound_data.mean(axis=1),\\n units=time_units, \\n calendar=time_calendar\\n ) \\n time_attrs = ds.time.attrs\\n time_encoding = ds.time.encoding\\n\\n ds['time'] = xr.DataArray(\\n time_centered,\\n dims=('time')\\n ) \\n \\n ones = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n time_mask = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n\\n group_by_year = 'time.year'\\n rename = {'year': 'time'}\\n \\n if season is not None:\\n season = season.upper()\\n if season not in ['DJF', 'MAM', 'JJA', 'SON']:\\n raise ValueError(f'unknown season: {season}') \\n\\n ds['austral_year'] = xr.where(ds['time.month'] > 6, ds['time.year'] + 1, ds['time.year'])\\n ds = ds.set_coords('austral_year')\\n ones = ones.assign_coords({'austral_year': ds.austral_year})\\n time_mask = time_mask.assign_coords({'austral_year': ds.austral_year})\\n time_mask = time_mask.where(ds['time.season'] == season).fillna(0)\\n \\n if season == 'DJF':\\n group_by_year = 'austral_year'\\n rename = {'austral_year': 'time'}\\n \\n if time_bnds_varname is not None:\\n time_wgt = ds[time_bnds_varname].diff(dim=ds[time_bnds_varname].dims[1])\\n if time_wgt.dtype == '<m8[ns]':\\n time_wgt = time_wgt / np.timedelta64(1, 'D')\\n else: \\n time_wgt = xr.DataArray(\\n np.ones((len(ds.time))), \\n dims=('time'), \\n coords={'time': ds.time},\\n )\\n time_wgt = time_wgt.assign_coords(\\n {c: da for c, da in ds.coords.items() if 'time' in da.dims}\\n )\\n \\n time_wgt = time_wgt.where(time_mask==1) #.fillna(0.)\\n\\n ones = ones.where(time_mask==1)\\n time_wgt_grouped = time_wgt.groupby(group_by_year, restore_coord_dims=False)\\n time_wgt = time_wgt_grouped / time_wgt_grouped.sum(dim=xr.ALL_DIMS)\\n\\n nyr = len(time_wgt_grouped.groups)\\n \\n time_wgt = time_wgt.squeeze()\\n\\n idx_not_nans = ~np.isnan(time_wgt)\\n sum_wgt = time_wgt.groupby(group_by_year).sum(dim=xr.ALL_DIMS)\\n idx_not_nans = (sum_wgt > 0)\\n\\n np.testing.assert_almost_equal(\\n sum_wgt[idx_not_nans], \\n np.ones(idx_not_nans.sum().values)\\n )\\n\\n nontime_vars = set([v for v in ds.variables if 'time' not in ds[v].dims]) - set(ds.coords)\\n dsop = ds.drop_vars(nontime_vars)\\n\\n if time_bnds_varname is not None:\\n dsop = dsop.drop_vars(time_bnds_varname) \\n \\n def weighted_mean_arr(darr, wgts=None):\\n # if NaN are present, we need to use individual weights\\n cond = darr.isnull()\\n ones = xr.where(cond, 0.0, 1.0)\\n if season is None:\\n mask = (\\n darr.resample({'time': 'A'}, restore_coord_dims=False).mean(dim='time').notnull()\\n )\\n da_sum = (\\n (darr * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n ones_out = (\\n (ones * wgts).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n count = (\\n (ones * wgts.notnull()).resample({'time': 'A'}, restore_coord_dims=False).sum(dim='time')\\n )\\n else:\\n mask = (\\n darr.groupby(group_by_year, restore_coord_dims=False).mean(dim='time').notnull()\\n ).rename(rename)\\n \\n da_sum = (\\n (darr * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n ones_out = (\\n (ones * wgts).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n \\n count = (\\n (ones * wgts.notnull()).groupby(group_by_year, restore_coord_dims=False).sum(dim='time')\\n ).rename(rename)\\n\\n ones_out = ones_out.where(ones_out > 0.0)\\n da_weighted_mean = da_sum / ones_out\\n\\n return da_weighted_mean.where(mask).where(count >= n_req) \\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n ds_ann = dsop.map(weighted_mean_arr, wgts=time_wgt)\\n\\n # copy attrs\\n for v in ds_ann:\\n ds_ann[v].attrs = ds[v].attrs\\n\\n # restore coords\\n ds_ann = xr.merge((ds_ann, ds[list(nontime_vars)]))\\n\\n # eliminate partials\\n ndx = (time_wgt_grouped.count(dim=xr.ALL_DIMS) >= n_req).values\\n if not ndx.all():\\n ds_ann = ds_ann.isel(time=ndx)\\n\\n return ds_ann\",\n \"def time_average(new_cube):\\n\\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\\n\\n return time_average_cube\",\n \"def parse_season(filename):\\n print_info('Attempting to parse {0}'.format(filename))\\n print_info('Extracting season from {0}'.format(filename))\\n for regex in SEASON_REGEX:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_season = m.group('Season').lower()\\n print_info('Extracted season: {0}'.format(extracted_season))\\n\\n season_num = int(extracted_season)\\n if season_num is not None and season_num > 0:\\n print_info('Season might be: {0}'.format(season_num))\\n return 'S' + format_num(season_num)\\n return 'S01'\",\n \"def parse_season_information_for_video (self, video):\\n season_info = {\\n 'episode_count': None,\\n 'seasons_label': None,\\n 'seasons_count': None\\n }\\n if video['summary']['type'] == 'show':\\n season_info = {\\n 'episode_count': video['episodeCount'],\\n 'seasons_label': video['numSeasonsLabel'],\\n 'seasons_count': video['seasonCount']\\n }\\n return season_info\",\n \"def average(self, times=2):\\n for i in range(times):\\n self.statistics()\\n global t, avlist\\n length = len(t)\\n avlist.append(t)\\n t = []\\n\\n total_list = []\\n\\n for l in range(length):\\n total_list.append([])\\n\\n for j in range(times):\\n \\\"\\\"\\\"per time\\\"\\\"\\\"\\n for i in range(length):\\n total_list[i].append(avlist[j][i])\\n\\n \\\"\\\"\\\"calculate\\\"\\\"\\\"\\n ylist = []\\n avlist = []\\n for a in total_list:\\n avg = 0\\n for b in a:\\n avg += b\\n ylist.append(avg/times)\\n self.listy = ylist\\n\\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\\n self.listx.append(e)\",\n \"def seasons(self):\\n if self._season_cache_ver == self._db._version:\\n return self._season_cache\\n\\n # Find out how many seasons in this series by fetching the highest season.\\n seasons = self._db.query(type='episode', parent=self._dbrow, attrs=['season'], distinct=True)\\n self._season_cache = [Season(self._db, self, row['season']) for row in seasons]\\n self._season_cache_ver = self._db._version\\n return self._season_cache\",\n \"def forced_trend(varname, cvdp_loc):\\n\\n if not cvdp_loc.endswith('/'):\\n cvdp_loc = cvdp_loc + '/'\\n\\n # Can use CVDP output\\n fnames = sorted(glob('%sCESM1-CAM5-BGC-LE_*.cvdp_data.*.nc' % cvdp_loc))\\n\\n cvdp_name = 'tas_global_avg_mon'\\n\\n nfiles = len(fnames)\\n ds = Dataset(fnames[0], 'r')\\n time = ds['time'][:]\\n time_units = ds['time'].units\\n gm_em_units = ds[cvdp_name].units\\n\\n n = len(time)\\n glob_mean = np.empty((nfiles, n))\\n for counter, file in enumerate(fnames):\\n ds = Dataset(file, 'r')\\n glob_mean[counter, :] = ds[cvdp_name][:]\\n\\n # Take average across ensemble members\\n gm_em = np.mean(glob_mean, axis=0)\\n\\n return gm_em, gm_em_units, time, time_units\",\n \"def get_average_duration_episode_in_seconds(self) -> NamedTuple:\\n times = [ep.itunes_duration for ep in self.entries]\\n format_times = []\\n\\n for time in times:\\n if not time.startswith('00'):\\n time = '0' + time\\n format_times.append(time)\\n\\n dts = [datetime.strptime(x, '%H:%M:%S') for x in format_times]\\n secs = [timedelta(\\n hours=x.hour,\\n minutes=x.minute,\\n seconds=x.second\\n ).seconds for x in dts]\\n\\n return Duration(\\n floor(mean(secs)),\\n max(format_times),\\n min(format_times)\\n )\",\n \"def add_dreamteam_count(df, raw_seasons):\\n df17 = df.loc[df['season'] == 17].copy()\\n df18 = df.loc[df['season'] == 18].copy()\\n df19 = df.loc[df['season'] == 19].copy()\\n df20 = df.loc[df['season'] == 20].copy()\\n df21 = df.loc[df['season'] == 21].copy()\\n\\n dreamteam_count_yearly_average = []\\n\\n for _, row in df21.iterrows():\\n dreamteam_count_yearly_average.append(create_dreamteam_count_yearly(row['name'], raw_seasons))\\n df21['dreamteam_yearly_average'] = dreamteam_count_yearly_average\\n\\n complete_data = pd.concat([df17, df18, df19, df20, df21])\\n\\n return complete_data\",\n \"def season_limits(self):\\n if self.season == \\\"summer\\\":\\n return\\n neighbors = [(0, 1), (1, 0), (-1, 0), (0, -1)]\\n points_list = []\\n season_pixels = []\\n season_edges = []\\n width = self.grid.width\\n height = self.grid.height\\n x = 0\\n while x < width:\\n y = 0\\n while y < height:\\n points_list.append((x, y))\\n if self.season == \\\"spring\\\" or self.season == \\\"winter\\\":\\n if self.grid.pix_copy[x, y] == (0, 0, 255):\\n season_pixels.append((x, y))\\n else:\\n if self.grid.pix_copy[x, y] == (255, 255, 255):\\n season_pixels.append((x, y))\\n y += 1\\n x += 1\\n for points in points_list:\\n k = 0\\n while k < (len(neighbors)):\\n xp = points[0] + neighbors[k][0]\\n yp = points[1] + neighbors[k][1]\\n condition = self.filter_edges_one(points[0], points[1], xp, yp, season_edges)\\n if condition:\\n season_edges.append((xp, yp))\\n k += 1\\n return season_edges\",\n \"def season_months(season):\\n\\n ssn=['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',\\n 'sep', 'oct', 'nov', 'dec', 'djf', 'mam', 'jja', 'son',\\n 'mayjun', 'julaug', 'marapr', 'jjas', 'ond', 'ann']\\n\\n imon = [1, 2, 3, 4, 5, 6, 7, 8,\\n 9, 10, 11, 12, [1,2,12], [3,4,5], [6,7,8], [9,10,11],\\n [5,6], [7,8], [3,4], [6,7,8,9], [10,11,12], list(range(1,13))]\\n\\n try:\\n ifind = ssn.index(season.lower())\\n except ValueError:\\n raise ValueError('Season not found! Valid seasons: ' + ', '.join(ssn))\\n\\n months = imon[ifind]\\n\\n # Make sure the output is a list\\n if isinstance(months, int):\\n months =[months]\\n\\n return months\",\n \"def av(self, data):\\n ts_ = self.ts(data)\\n if 'year' not in ts_.coords:\\n return ts_\\n return ts_.mean('year')\",\n \"def calcVmoy(self, V, idx, n):\\n i = max(idx-n, 0)\\n f = min(idx+n+1, V.shape[0])\\n av = np.mean(V[i:f])\\n return av\",\n \"def test_seasons(self):\\n response = Tmdb.season(tmdb_show_id = 69740, season_number = 1)\\n self.assertTrue(int(response.status_code) == 200)\\n data = response.json()\\n self.assertTrue(isinstance(data['episodes'], list))\\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)\",\n \"def get_seasons(link, debug=False):\\n\\n if debug:\\n print(\\\"begin get_seasons()\\\")\\n\\n # get the BeautifulSoup data\\n show_url = \\\"https://www.imdb.com/\\\" + link + \\\"episodes/\\\"\\n tv_soup = bs4.BeautifulSoup(requests.get(show_url).text, features=\\\"html.parser\\\")\\n\\n # We are acquiring this data from a drop down, which the below line selects\\n select_elem = tv_soup.select('#bySeason')\\n seasons = []\\n # account for the possibility of a one season show\\n if len(select_elem) == 0:\\n seasons.append(1)\\n else:\\n # get contents of drop down\\n options = select_elem[0].select('option')\\n\\n # add each season\\n for season in options:\\n seasons.append(season.get('value'))\\n if debug:\\n print(f\\\"Seasons {seasons}\\\")\\n\\n return seasons\",\n \"def calculate_clim_anoms(var, var_dates):\\n d_counts=[]\\n var_clim = np.zeros_like(var)\\n var_climstd = np.zeros_like(var)\\n for m in range(1,13): #for each month\\n mo_ind = (var_dates[1,:]==m)\\n day_options = np.unique(var_dates[2,mo_ind])\\n \\n #print(day_options) #for diagnostics \\n for d in range(0,np.size(day_options)): #for each possible day\\n d_ind = (mo_ind) & (var_dates[2,:]==day_options[d])\\n\\n var_days = var[:,:,d_ind]\\n var_daysav = np.nanmean(var_days,2)\\n var_daysstd = np.nanstd(var_days,2)\\n \\n var_clim[:,:,d_ind] = np.transpose(np.tile(var_daysav,(np.sum(d_ind),1,1)),(1,2,0))\\n var_climstd[:,:,d_ind] = np.transpose(np.tile(var_daysstd,(np.sum(d_ind),1,1)),(1,2,0))\\n \\n d_counts.append(np.sum(d_ind)) #this is just for diagnostics\\n \\n var_anom = var - var_clim\\n var_anom_scaled = var_anom/var_climstd\\n \\n return var_anom, var_anom_scaled;\",\n \"def map_season(x, figsize=(8, 6), **kwargs):\\n\\n from pycmbs.mapping import map_plot\\n\\n nvals = len(x.data)\\n if nvals == 12:\\n year = True\\n elif nvals == 4:\\n year = False\\n else:\\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\\n\\n #/// checks ///\\n if x.data.ndim != 3:\\n print x.data.ndim\\n raise ValueError('only 3D data supported')\\n\\n if 'vmin' not in kwargs.keys():\\n raise ValueError('vmin argument is obligatory for map_seasons()')\\n if 'vmax' not in kwargs.keys():\\n raise ValueError('vmax argument is obligatory for map_seasons()')\\n\\n if kwargs['vmin'] is None:\\n raise ValueError('vmin MUST NOT be None!')\\n if kwargs['vmax'] is None:\\n raise ValueError('vmax MUST NOT be None!')\\n\\n #/// figure and axes\\n if 'figure' in kwargs:\\n f = kwargs['figure']\\n else:\\n f = plt.figure(figsize=figsize)\\n\\n if 'title' in kwargs:\\n tit = kwargs.pop('title')\\n else:\\n tit = x.label\\n\\n if 'drawparallels' in kwargs:\\n drawparallels = kwargs.pop('drawparallels')\\n else:\\n drawparallels = False\\n\\n if 'savefile' in kwargs:\\n savefile = kwargs.pop('savefile')\\n if '.nc' in savefile:\\n savefile = savefile[:-3]\\n else:\\n savefile = None\\n\\n # plot\\n if year:\\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\\n else:\\n labels = ['DJF', 'MAM', 'JJA', 'SON']\\n\\n # check dates\\n if year:\\n mo = 1\\n for t in x.time:\\n if x.num2date(t).month != mo:\\n print x.num2date(t), mo\\n raise ValueError('Invalid monthly sequence! Can not plot results!')\\n mo += 1\\n\\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\\n if 'overlay' in kwargs.keys():\\n overlays = kwargs.pop('overlay')\\n else:\\n overlays = None\\n\\n for i in range(nvals):\\n if year:\\n ax = f.add_subplot(4, 3, i + 1)\\n #if i % 3 == 2:\\n if i > 8:\\n show_colorbar = True\\n else:\\n show_colorbar = False\\n else:\\n ax = f.add_subplot(2, 2, i + 1)\\n if 'show_colorbar' in kwargs:\\n show_colorbar = kwargs.pop('show_colorbar')\\n else:\\n show_colorbar = True\\n\\n d = x.copy()\\n d.data = x.data[i, :, :]\\n d.label = labels[i]\\n\\n if overlays is None:\\n overlay = None\\n else:\\n overlay = overlays[i, :, :]\\n\\n if savefile is not None:\\n tmpoutname = savefile + '_' + labels[i]\\n else:\\n tmpoutname = None\\n\\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\\n savefile=tmpoutname, colorbar_orientation='horizontal',\\n drawparallels=drawparallels, **kwargs)\\n del d\\n f.suptitle(tit, size=16)\\n return f\",\n \"def seasonStats(personId,type = 'gameLog',group = 'hitting'):\\n\\n #playerInfo = get('people', {'personIds':personId})\\n\\n\\n teamStats = get('person',{ 'ver':'v1' , 'personId':personId,'hydrate':['stats(group={},type={})'.format(group,type),'currentTeam']})\\n return teamStats\\n #iterate of stats and find the right player id\\n #career stats broken\\n #fix the season :2019\\n #make function to get team id\",\n \"def aggregate_full_season_tracking_stats_for_seasons(\\n measure_type: TrackingMeasureType,\\n seasons: List[str],\\n season_types: List[SeasonType],\\n player_or_team: PlayerOrTeam,\\n **kwargs,\\n) -> Tuple[List[Any], Any]:\\n stats_by_season = get_tracking_stats(\\n measure_type, seasons, season_types, player_or_team, **kwargs\\n )\\n\\n stats = sum_tracking_totals(player_or_team, measure_type, stats_by_season)\\n league_totals = sum_tracking_totals(\\\"league\\\", measure_type, stats)\\n return stats, league_totals\",\n \"def pw_rmsd(mols):\\n m = len(mols)\\n k = 0\\n pw = []\\n for mol1 in mols:\\n k += 1\\n if k > m:\\n break\\n for i in range(k, m):\\n mol2 = mols[i]\\n pw.append(rmsd.rmsd(mol1, mol2))\\n ave_rmsd = np.mean(pw)\\n return ave_rmsd\",\n \"def year_average_price_rule(_m, y):\\r\\n\\r\\n # Total revenue\\r\\n return sum(m.SCENARIO_REVENUE[y, s] for s in m.S) / sum(m.SCENARIO_DEMAND[y, s] for s in m.S)\",\n \"def season(self, seasonnum, order='aired'):\\n if order=='aired':\\n seasons = self.seasons\\n elif order == 'dvd':\\n seasons = self.dvd_seasons\\n try:\\n return seasons[seasonnum]\\n except KeyError:\\n raise SeasonNotFoundError(\\n 'Season no %s does not exists' % seasonnum\\n ), None, sys.exc_info()[2]\",\n \"def fetch_episodes_by_season(self, params):\\n raw_episode_list = self.netflix_session.fetch_episodes_by_season(\\n season_id=params.get('season_id')[0])\\n if 'error' in raw_episode_list:\\n return raw_episode_list\\n episodes = self.netflix_session.parse_episodes_by_season(\\n response_data=raw_episode_list)\\n return episodes\",\n \"def extract_seasonal_component(original_ts, ppy):\\n \\\"\\\"\\\"\\n # === get in-sample data\\n original_ts = original_ts[:-out_of_sample]\\n \\\"\\\"\\\"\\n if seasonality_test(original_ts, ppy):\\n # print(\\\"seasonal\\\")\\n # ==== get moving averages\\n ma_ts = moving_averages(original_ts, ppy)\\n\\n # ==== get seasonality indices\\n le_ts = original_ts * 100 / ma_ts\\n le_ts = np.hstack((le_ts, np.full((ppy - (len(le_ts) % ppy)), np.nan)))\\n le_ts = np.reshape(le_ts, (-1, ppy))\\n si = np.nanmean(le_ts, 0)\\n norm = np.sum(si) / (ppy * 100)\\n si = si / norm\\n else:\\n # print(\\\"NOT seasonal\\\")\\n si = np.full(ppy, 100)\\n return si\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def mass_variance(self, logM, k = [], pk = [], var = 'cb', window = 'th', **kwargs):\\n return self.mass_variance_multipoles(logM = logM, k = k, pk = pk, var = var, window = window, **kwargs)\",\n \"def empirical_covariance_multiple(system, excitation, ms):\\n observations = [system() @ excitation() for _ in range(max(ms))]\\n\\n Cs = [np.cov(np.array(observations[0:m]).T) for m in ms]\\n return Cs\",\n \"def season_edges(t):\\n offset = season_offset(t)\\n yr_min = t.datetime.min().year\\n left_frac = t.jyear.min() % yr_min\\n if left_frac < offset:\\n ex_left = 1\\n else:\\n ex_left = 0\\n edges = np.arange(yr_min - ex_left + offset, t.jyear.max() + 1, 1.0)\\n return astropy.time.Time(edges, format='jyear')\",\n \"def get_average_for_month(self, month, weekend):\\n\\t\\tif weekend:\\n\\t\\t\\treturn self.averages_weekend[month]\\n\\t\\telse:\\n\\t\\t\\treturn self.averages_weekday[month]\",\n \"def seasonality(time, period, amplitude=1 , phase=0):\\n season_time = ((time + phase) % period) / period\\n return amplitude * seasonal_pattern(season_time)\",\n \"def land_sm_top(clim_file, model_file, model_dataset, config, ancestors):\\n # Work through each season\\n metrics = {}\\n for index, season in enumerate(SEASONS):\\n\\n constr_season = iris.Constraint(season_number=index)\\n ecv_clim = iris.load_cube(clim_file, constr_season)\\n\\n vol_sm1_run = volumetric_soil_moisture(model_file, constr_season)\\n\\n # update the coordinate system ECV data with a WGS84 coord system\\n # unify coord systems for regridder\\n vol_sm1_run.coord('longitude').coord_system = \\\\\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\\n inverse_flattening=298.257223563)\\n vol_sm1_run.coord('latitude').coord_system = \\\\\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\\n inverse_flattening=298.257223563)\\n ecv_clim.coord('longitude').coord_system = \\\\\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\\n inverse_flattening=298.257223563)\\n ecv_clim.coord('latitude').coord_system = \\\\\\n iris.coord_systems.GeogCS(semi_major_axis=6378137.0,\\n inverse_flattening=298.257223563)\\n\\n # Interpolate to the grid of the climatology and form the difference\\n vol_sm1_run = regrid(vol_sm1_run, ecv_clim, 'linear')\\n\\n # mask invalids\\n vol_sm1_run.data = np.ma.masked_invalid(vol_sm1_run.data)\\n ecv_clim.data = np.ma.masked_invalid(ecv_clim.data)\\n\\n # diff the cubes\\n dff = vol_sm1_run - ecv_clim\\n\\n # save output and populate metric\\n caption = f\\\"{model_dataset} minus CCI soil moisture clim for {season}\\\"\\n provenance_record = get_provenance_record(caption, ancestors)\\n save_data(f\\\"soilmoist_diff_{model_dataset}_{season}\\\",\\n provenance_record, config, dff)\\n\\n name = f\\\"soilmoisture MedAbsErr {season}\\\"\\n metrics[name] = float(np.ma.median(np.ma.abs(dff.data)))\\n\\n return metrics\",\n \"def disk_average(self, var, r_lim):\\n # change the mask for the one in Flux\\n npx = self.params['npx']\\n npy = self.params['npy']\\n npz = self.params['npz']\\n number_domains = npx*npy*npz # so far only works for number_domains<100\\n Lx = self.params['Lx']\\n Ly = self.params['Ly']\\n Lz = self.params['Lz']\\n x0 = Lx/2 # center point in the x domain.\\n y0 = Ly/2 # center point in the y domain.\\n nz = self.params['nz']\\n\\n if var == 'NN': # maybe interpolate is field...\\n nz = nz - 1\\n\\n t = self.read_vars(['t'])['t']\\n n_time = t.shape[0]\\n\\n r_max = r_lim #0.45 # as in forced_plume_nudging.py\\n z_max = 0.95\\n\\n means = np.zeros((n_time, nz))\\n\\n fields = self.read_vars([var, 'x', 'y'])\\n\\n if var in ['u', 'v', 'w']:\\n axis_vel = {'u': 3, 'v': 2, 'w':1}\\n fields[var] = velocity_interpolation(fields[var], axis=axis_vel[var])\\n\\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\\n fields['y']/Ly - 0.5)\\n\\n r = np.sqrt(XX**2 + YY**2)\\n mask = ma.masked_outside(r, 0, r_max)\\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\\n\\n for t in range(n_time):\\n for z_lvl in range(nz):\\n field_new = ma.masked_array(fields[var][t, z_lvl, :, :], mask.mask)\\n means[t, z_lvl] = field_new.mean()\\n\\n #means = means/number_domains\\n return means\",\n \"def dynamics_prediction_variance_scorer(dynamics, episodes, window_size=1024):\\n total_variances = []\\n for episode in episodes:\\n for batch in _make_batches(episode, window_size, dynamics.n_frames):\\n pred = dynamics.predict(batch.observations, batch.actions, True)\\n total_variances += pred[2].tolist()\\n # smaller is better\\n return -np.mean(total_variances)\",\n \"def _em_variance(self, result, endog, exog, betas, tmp=None):\\n k_exog = 0 if exog is None else exog.shape[1]\\n\\n if self.switching_variance:\\n variance = np.zeros(self.k_regimes)\\n for i in range(self.k_regimes):\\n if k_exog > 0:\\n resid = endog - np.dot(exog, betas[i])\\n else:\\n resid = endog\\n variance[i] = (\\n np.sum(resid ** 2 *\\n result.smoothed_marginal_probabilities[i]) /\\n np.sum(result.smoothed_marginal_probabilities[i]))\\n else:\\n variance = 0\\n if tmp is None:\\n tmp = np.sqrt(result.smoothed_marginal_probabilities)\\n for i in range(self.k_regimes):\\n tmp_endog = tmp[i] * endog\\n if k_exog > 0:\\n tmp_exog = tmp[i][:, np.newaxis] * exog\\n resid = tmp_endog - np.dot(tmp_exog, betas[i])\\n else:\\n resid = tmp_endog\\n variance += np.sum(resid ** 2)\\n variance /= self.nobs\\n return variance\",\n \"def monthly_avg_2darray(x):\\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()\",\n \"def global_average_speed(cars):\\n velocities = [car.velocity for car in cars]\\n average_speed = sum(velocities)/len(cars)\\n return average_speed\",\n \"def winter_avg(var_nc,lat_slice=None,lon_slice=None): \\n #\\n # accumulate in shape [plev,lat,lon]\\n #\\n # use the whole array if slice objects are missing\\n #\\n if (lat_slice is None) and (lon_slice is None):\\n num_lats=var_nc.shape[2]\\n num_lons=var_nc.shape[3]\\n lat_slice=slice(0,num_lats)\\n lon_slice=slice(0,num_lons)\\n print \\\"in winter avg: \\\",lat_slice,lon_slice\\n else:\\n num_lats=lat_slice.stop - lat_slice.start\\n num_lons=lon_slice.stop - lon_slice.start\\n num_levs=var_nc.shape[1]\\n accumulate=ma.zeros([num_levs,num_lats,num_lons],dtype=var_nc.dtype)\\n #\\n # year 0 is special case since it doesn't have a december\\n #\\n djf0=np.array([0,1],dtype=np.int32) #january and feburary\\n the_slice=var_nc[djf0,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0) #average over the two months\\n accumulate+=the_slice\\n num_years=var_nc.shape[0]//12\\n #\\n # now year 1 has year 0's december\\n #\\n djf=np.array([11,12,13],dtype=np.int32)\\n #\\n # iterate one year less because we've alread\\n # done year zero as a special case\\n #\\n for the_year in np.arange(0,num_years-1):\\n the_slice=var_nc[djf,:,lat_slice,lon_slice]\\n the_slice=ma.mean(the_slice,axis=0)\\n accumulate+=the_slice\\n djf=djf+12\\n accumulate=accumulate/num_years \\n the_avg=ma.mean(accumulate,axis=1)\\n the_avg=ma.mean(the_avg,axis=1)\\n return the_avg\",\n \"def get_te_season_totals():\\n te_totals = redis_cache('te_games_key', NFL_TE_Game_2015.query.filter_by(is_season_totals=True).all)\\n return te_totals\",\n \"def mv(series, window=30):\\n if not isinstance(series, pd.Series):\\n raise ValueError('expect input pandas series dataframe, but get %s'%(type(series)))\\n\\n return series.rolling(window=window, min_periods=1).mean()\",\n \"def set_season_time(season): \\n if season == '2021-22':\\n startdate = time.strptime('13-08-2021', '%d-%m-%Y')\\n startdate = datetime.fromtimestamp(mktime(startdate))\\n enddate = time.strptime('08-10-2021', '%d-%m-%Y')\\n enddate = datetime.fromtimestamp(mktime(enddate))\\n if season == '2020-21':\\n startdate = time.strptime('12-08-2020', '%d-%m-%Y')\\n startdate = datetime.fromtimestamp(mktime(startdate))\\n enddate = time.strptime('26-07-2021', '%d-%m-%Y')\\n enddate = datetime.fromtimestamp(mktime(enddate))\\n if season == '2019-20':\\n startdate = time.strptime('09-08-2019', '%d-%m-%Y')\\n startdate = datetime.fromtimestamp(mktime(startdate))\\n enddate = time.strptime('26-07-2020', '%d-%m-%Y')\\n enddate = datetime.fromtimestamp(mktime(enddate))\\n return startdate, enddate\",\n \"def getSeason(date):\\n\\n date = validate.timestamp(date)\\n day = date.dayofyear\\n leap_year = int(date.is_leap_year)\\n\\n spring = numpy.arange(80, 172) + leap_year\\n summer = numpy.arange(172, 264) + leap_year\\n autumn = numpy.arange(264, 355) + leap_year\\n\\n if day in spring:\\n season = \\\"spring\\\"\\n elif day in summer:\\n season = \\\"summer\\\"\\n elif day in autumn:\\n season = \\\"autumn\\\"\\n else:\\n season = \\\"winter\\\"\\n\\n return season\",\n \"def season_series(game_id, pref_team, other_team, last_season=False):\\n\\n # Init empty dictionaries and lists\\n games_against = list()\\n pref_toi = dict()\\n pref_goals = dict()\\n pref_assists = dict()\\n pref_points = dict()\\n pref_record = {\\\"wins\\\": 0, \\\"losses\\\": 0, \\\"ot\\\": 0}\\n roster_player = True\\n\\n # If this is the first game of the season, we can set the 'last_season' flag to enable the\\n # season series function to check last year's season series between the two teams.\\n if not last_season:\\n season_start = str(game_id)[0:4]\\n season_end = str(int(season_start) + 1)\\n yesterday = datetime.now() - timedelta(days=1)\\n # yesterday = datetime.now() + timedelta(days=50)\\n # schedule_url = (\\n # f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n # f\\\"&expand=schedule.broadcasts,schedule.teams&startDate=\\\"\\n # f\\\"{season_start}-08-01&endDate={yesterday:%Y-%m-%d}\\\"\\n # )\\n schedule_url = (\\n f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n f\\\"&expand=schedule.broadcasts,schedule.teams\\\"\\n f\\\"&season={season_start}{season_end}\\\"\\n )\\n else:\\n season_start = int(str(game_id)[0:4]) - 1\\n season_end = str(int(season_start) + 1)\\n yesterday = datetime.now() - timedelta(days=1)\\n # yesterday = datetime.now() + timedelta(days=50)\\n # schedule_url = (\\n # f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n # f\\\"&expand=schedule.broadcasts,schedule.teams&startDate=\\\"\\n # f\\\"{season_start}-08-01&endDate={season_end}-06-01\\\"\\n # )\\n schedule_url = (\\n f\\\"/schedule?teamId={pref_team.team_id}\\\"\\n f\\\"&expand=schedule.broadcasts,schedule.teams\\\"\\n f\\\"&season={season_start}{season_end}\\\"\\n )\\n\\n schedule = api.nhl_api(schedule_url).json()\\n dates = schedule[\\\"dates\\\"]\\n\\n # Loop through scheduled to get previously played games against\\n for date in dates:\\n game = date[\\\"games\\\"][0]\\n game_type = game[\\\"gameType\\\"]\\n game_id = game[\\\"gamePk\\\"]\\n game_team_home = game[\\\"teams\\\"][\\\"home\\\"][\\\"team\\\"][\\\"name\\\"]\\n game_team_away = game[\\\"teams\\\"][\\\"away\\\"][\\\"team\\\"][\\\"name\\\"]\\n teams = [game_team_away, game_team_home]\\n game_status = game[\\\"status\\\"][\\\"abstractGameState\\\"]\\n if game_type == \\\"R\\\" and game_status == \\\"Final\\\" and other_team.team_name in teams:\\n game_feed = f\\\"/game/{game_id}/feed/live\\\"\\n games_against.append(game_feed)\\n\\n # If the two teams haven't played yet, just exit this function\\n if not games_against:\\n return None, None, None\\n\\n # Loop through newly created games_against list to get each stats\\n for feed in games_against:\\n game = api.nhl_api(feed).json()\\n game_data = game[\\\"gameData\\\"]\\n home_team_name = game_data[\\\"teams\\\"][\\\"home\\\"][\\\"name\\\"]\\n pref_homeaway = \\\"home\\\" if home_team_name == pref_team.team_name else \\\"away\\\"\\n other_homeaway = \\\"away\\\" if home_team_name == pref_team.team_name else \\\"home\\\"\\n\\n # Get season series\\n end_period = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"currentPeriod\\\"]\\n extra_time = True if end_period > 3 else False\\n pref_score = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"teams\\\"][pref_homeaway][\\\"goals\\\"]\\n other_score = game[\\\"liveData\\\"][\\\"linescore\\\"][\\\"teams\\\"][other_homeaway][\\\"goals\\\"]\\n if pref_score > other_score:\\n pref_record[\\\"wins\\\"] += 1\\n elif other_score > pref_score and extra_time:\\n pref_record[\\\"ot\\\"] += 1\\n else:\\n pref_record[\\\"losses\\\"] += 1\\n\\n season_series_str = f\\\"Series: {pref_record['wins']}-\\\" f\\\"{pref_record['losses']}-{pref_record['ot']}\\\"\\n\\n # Get stats leaders\\n # pref_teamstats = game[\\\"liveData\\\"][\\\"boxscore\\\"][\\\"teams\\\"][pref_homeaway][\\\"teamStats\\\"]\\n pref_playerstats = game[\\\"liveData\\\"][\\\"boxscore\\\"][\\\"teams\\\"][pref_homeaway][\\\"players\\\"]\\n for id, player in pref_playerstats.items():\\n try:\\n # Calculate TOI\\n player_toi_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"timeOnIce\\\"]\\n player_toi_minutes = int(player_toi_str.split(\\\":\\\")[0])\\n player_toi_seconds = int(player_toi_str.split(\\\":\\\")[1])\\n player_toi = (player_toi_minutes * 60) + player_toi_seconds\\n pref_toi[id] = pref_toi.get(id, 0) + player_toi\\n\\n # Point Totals\\n player_goal_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"goals\\\"]\\n pref_goals[id] = pref_goals.get(id, 0) + int(player_goal_str)\\n player_assist_str = player[\\\"stats\\\"][\\\"skaterStats\\\"][\\\"assists\\\"]\\n pref_assists[id] = pref_assists.get(id, 0) + int(player_assist_str)\\n player_points = int(player_goal_str) + int(player_assist_str)\\n pref_points[id] = pref_points.get(id, 0) + int(player_points)\\n\\n except KeyError:\\n pass\\n\\n # Calculate Stats Leaders\\n sorted_toi = sorted(pref_toi.values(), reverse=True)\\n leader_toi = sorted_toi[0]\\n\\n sorted_points = sorted(pref_points.values(), reverse=True)\\n leader_points = sorted_points[0]\\n\\n # Get TOI leader\\n for id in pref_toi.keys():\\n if pref_toi[id] == leader_toi:\\n player_name = roster.player_attr_by_id(pref_team.roster, id, \\\"fullName\\\")\\n if player_name is None:\\n roster_player = False\\n player_id_only = id.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n leader_toi_avg = leader_toi / len(games_against)\\n m, s = divmod(leader_toi_avg, 60)\\n toi_m = int(m)\\n toi_s = int(s)\\n toi_s = \\\"0{}\\\".format(toi_s) if toi_s < 10 else toi_s\\n toi_avg = \\\"{}:{}\\\".format(toi_m, toi_s)\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n toi_leader_str = \\\"TOI Leader: {} with {} / game.\\\".format(player_short_name, toi_avg)\\n\\n # Handle tied points leaders\\n point_leaders = list()\\n for id in pref_points.keys():\\n if pref_points[id] == leader_points:\\n point_leaders.append(id)\\n\\n if leader_points == 0:\\n points_leader_str = \\\"Points Leader: None (all players have 0 points).\\\"\\n\\n elif len(point_leaders) == 1:\\n leader = point_leaders[0]\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n # If the player is no longer on the team, get their information (change string here?)\\n if player_name is None:\\n roster_player = False\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n if not roster_player:\\n points_leader_str = (\\n f\\\"Points Leader: {player_name} with {leader_points} points \\\"\\n f\\\"({player_goals}G {player_assists}A) \\\"\\n )\\n else:\\n points_leader_str = \\\"Points Leader: {} with {} ({}G {}A).\\\".format(\\n player_name, leader_points, player_goals, player_assists\\n )\\n\\n elif len(point_leaders) > 3:\\n point_leaders_with_attrs = list()\\n for leader in point_leaders:\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n if player_name is None:\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n point_leaders_with_attrs.append(player_short_name)\\n\\n point_leaders_joined = \\\", \\\".join(point_leaders_with_attrs[0:3])\\n leftover_leaders = len(point_leaders) - 3\\n points_leader_str = (\\n f\\\"Points Leaders: {point_leaders_joined} & {leftover_leaders} others ({leader_points} each).\\\"\\n )\\n\\n else:\\n point_leaders_with_attrs = list()\\n for leader in point_leaders:\\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \\\"fullName\\\")\\n if player_name is None:\\n player_id_only = leader.replace(\\\"ID\\\", \\\"\\\")\\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \\\"fullName\\\")\\n player_goals = pref_goals[leader]\\n player_assists = pref_assists[leader]\\n player_short_name = f\\\"{player_name[0]}. {' '.join(player_name.split()[1:])}\\\"\\n player_str = f\\\"{player_short_name} ({player_goals}G {player_assists}A)\\\"\\n point_leaders_with_attrs.append(player_str)\\n\\n point_leaders_joined = (\\n f\\\", \\\".join(point_leaders_with_attrs[:-1]) + f\\\" & {point_leaders_with_attrs[-1]}\\\"\\n )\\n points_leader_str = \\\"Points Leaders: {} with {} each.\\\".format(point_leaders_joined, leader_points)\\n\\n return season_series_str, points_leader_str, toi_leader_str\",\n \"def test_one_region_time_aggregation(self, months, seasons, regions_rect):\\n data = np.array(\\n [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]], dtype=float\\n ) # area a, months 1-12\\n\\n expected = np.array(\\n [[31 + 31 + 28, 31 + 30 + 31, 30 + 31 + 31, 30 + 31 + 30]], dtype=float\\n ) # area a, seasons 1-4\\n\\n adaptor = IntervalAdaptor(\\\"test-month-seasons\\\")\\n from_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"rect\\\", \\\"months\\\"],\\n coords={\\\"months\\\": months, \\\"rect\\\": regions_rect},\\n )\\n adaptor.add_input(from_spec)\\n to_spec = Spec(\\n name=\\\"test-var\\\",\\n dtype=\\\"float\\\",\\n dims=[\\\"rect\\\", \\\"seasons\\\"],\\n coords={\\\"seasons\\\": seasons, \\\"rect\\\": regions_rect},\\n )\\n adaptor.add_output(to_spec)\\n\\n data_array = DataArray(from_spec, data)\\n\\n data_handle = Mock()\\n data_handle.get_data = Mock(return_value=data_array)\\n data_handle.read_coefficients = Mock(side_effect=SmifDataNotFoundError)\\n\\n adaptor.simulate(data_handle)\\n actual = data_handle.set_results.call_args[0][1]\\n\\n assert np.allclose(actual, expected)\",\n \"def fun_average_mse_sd(filtered):\\n res = 0.0\\n num = 0\\n # Sometimes there was \\\"inf\\\" in the results. We will ignore those elements.\\n for p in filtered:\\n x = float(p[\\\"result.best.mse\\\"])\\n if not \\\"n\\\" in str(x):\\n res += x\\n num += 1\\n else:\\n print(\\\"Nan encountered\\\")\\n avg = res / num\\n sd = 0.0\\n for p in filtered:\\n x = float(p[\\\"result.best.mse\\\"])\\n if not \\\"n\\\" in str(x):\\n sd += (x - avg) ** 2.0\\n sd = math.sqrt(sd / num)\\n if num == 0:\\n return \\\"-\\\"\\n else:\\n return r\\\"${0} \\\\pm{1}$\\\".format(avg, sd)\",\n \"def load_class_avg(self, mrcs, factor):\\n \\n global shape\\n \\n projection_2D = {}\\n extract_2D = {}\\n \\n if len(factor) == 0: # Empty entry, set factor 1\\n factor = 1\\n\\n with mrcfile.open(mrcs) as mrc:\\n for i, data in enumerate(mrc.data):\\n projection_2D[i] = data\\n mrc.close()\\n \\n shape = transform.rotate(projection_2D[0].copy(), 45, resize=True).shape[0]\\n\\n for k, avg in projection_2D.items():\\n if factor == 1:\\n extract_2D[k] = extract_class_avg(avg)\\n else:\\n scaled_img = transform.rescale(\\n avg, \\n scale=(1/float(factor)), \\n anti_aliasing=True, \\n multichannel=False, # Add to supress warning\\n mode='constant' # Add to supress warning\\n ) \\n extract_2D[k] = extract_class_avg(scaled_img)\\n\\n return projection_2D, extract_2D\",\n \"def calcExpMovAvg(self, windowLength, smoothingFactor):\\n\\n if smoothingFactor < 0 or smoothingFactor > 1:\\n raise ValueError(\\n \\\"Value of smoothing factor should be in between 0-1\\\")\\n\\n EMA_prev = sum(self.x[:windowLength])/windowLength\\n n = len(self.x)\\n\\n EMA = []\\n\\n for i in range(n):\\n if i >= windowLength:\\n temp = smoothingFactor*self.x[i] + (1-smoothingFactor)*EMA_prev\\n EMA.append(temp)\\n EMA_prev = temp\\n return [None]*windowLength + EMA\",\n \"def mov_std(ts, m):\\n\\n if m <= 1:\\n raise ValueError(\\\"Query length must be longer than one\\\")\\n\\n ts = ts.astype(\\\"float\\\")\\n # Add zero to the beginning of the cumsum of ts\\n s = np.insert(np.cumsum(ts), 0, 0)\\n # Add zero to the beginning of the cumsum of ts ** 2\\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\\n seg_sum = s[m:] - s[:-m]\\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\\n return np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)\",\n \"def set_season(date_obj):\\n date_year = date_obj.year\\n\\n for key, val in SEASONS.items():\\n start = datetime(year=date_year, month=val['start']['month'], day=val['start']['day'])\\n end = datetime(year=date_year, month=val['end']['month'], day=val['end']['day'])\\n if key == 'Winter':\\n start_year = date_year - 1 if date_obj.month in [1, 2, 3] else date_year\\n end_year = date_year + 1 if date_obj.month == 12 else date_year\\n start = datetime(year=start_year, month=val['start']['month'], day=val['start']['day'])\\n end = datetime(year=end_year, month=val['end']['month'], day=val['end']['day'])\\n\\n if start <= date_obj <= end:\\n return key\",\n \"def compute_GS(GMtcs):\\n\\n GS = np.mean(GMtcs,axis=0) #average over voxels\\n\\n return GS\",\n \"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time,lat,lon = tllAxes(mv)\\n if hasattr(mv.parent,'variables'):\\n fil = mv.parent # mv is a fileVariable and fil is a file.\\n lat_bnds = fil[lat.bounds]\\n else:\\n lataxis = latAxis(mv) # mv is a TransientVariable\\n lat_bnds = lataxis._bounds_\\n\\n mvta = timeave_old( mv )\\n\\n # In computing the average, we use area weighting.\\n # Sometimes the area is available in cell_measures, but for now I'll just use the backup method:\\n # The area of a lonlat cell is R^2*delta(lon)*delta(sin(lat)).\\n # With equally spaced lon, we don't need delta(lon) for weights.\\n # I'll assume that lat,lon are in degrees, which is the only way I've ever seen them.\\n wgtsum = 0\\n zm = 0\\n for i,lati in enumerate(lat):\\n # The following test could be sped up a lot, because lat[i] is ordered...\\n # >>> to do: partial overlaps\\n if latmin<=lati and lati<latmax:\\n latlo = lat_bnds[i,0]\\n lathi = lat_bnds[i,1]\\n wgti = sin(radians(lathi))-sin(radians(latlo))\\n zi = 0.0\\n for j in range(len(lon)):\\n zi += mvta[i,j]\\n zi *= wgti\\n wgtsum += wgti*len(lon)\\n zm += zi\\n zm /= wgtsum\\n # zm is a scalar, so createVariable gets no axes argument:\\n zmv = cdms2.createVariable( zm, id=vid )\\n return zmv\",\n \"def mean_by_mass(self, name):\\n m = np.asanyarray(self[\\\"mass\\\"])\\n ret = array.SimArray(\\n (self[name].transpose() * m).transpose().mean(axis=0) / m.mean(), self[name].units)\\n\\n return ret\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def average( names):\\n\\n rs = radioastronomy.Spectrum() # create input and average structures\\n asum = radioastronomy.Spectrum()\\n nsum = 0\\n\\n # now average coldest data for calibration\\n for filename in names:\\n\\n rs.read_spec_ast(filename)\\n rs.azel2radec() # compute ra,dec from az,el\\n\\n if nsum == 0:\\n asum = copy.deepcopy( rs)\\n firstlon = rs.gallon\\n asum.ydataA = rs.ydataA * rs.durationSec\\n asum.gallat = rs.gallat * rs.durationSec\\n asum.gallon = rs.gallon * rs.durationSec\\n nsum = 1\\n firstutc = rs.utc\\n lastutc = rs.utc\\n else:\\n asum.ydataA = asum.ydataA + (rs.ydataA * rs.durationSec)\\n asum.count = asum.count + rs.count\\n asum.durationSec = asum.durationSec + rs.durationSec\\n # fix wrap of longitudes\\n if abs(rs.gallon - firstlon) > 180:\\n crossZero = True\\n if rs.gallon > firstlon:\\n rs.gallon = rs.gallon - 360.\\n else:\\n rs.gallon = rs.gallon + 360.\\n asum.gallon = asum.gallon + (rs.gallon * rs.durationSec)\\n asum.gallat = asum.gallat + (rs.gallat * rs.durationSec)\\n # keep track of observing time for weighted sum\\n lastutc = rs.utc\\n nsum = nsum + 1\\n #end for all files loop\\n\\n if nsum < 1:\\n print \\\"No acceptable files in average list\\\"\\n else:\\n asum.ydataA = asum.ydataA/float(asum.durationSec)\\n asum.gallon = asum.gallon/float(asum.durationSec)\\n asum.gallat = asum.gallat/float(asum.durationSec)\\n aveutc,duration = radioastronomy.aveutcs( firstutc, lastutc)\\n asum.utc = aveutc\\n if (duration < 1.):\\n print 'hotcold.average: very short average interval: ',duration\\n return nsum, asum\",\n \"def extract_events_from_mc(self, sources, mc, ):\\n sig_events = np.empty((0, ),\\n dtype=[(\\\"ra\\\", np.float), (\\\"sinDec\\\", np.float),\\n (\\\"sigma\\\", np.float), (\\\"logE\\\", np.float),\\n (\\\"dec\\\", np.float), ('timeMJD', np.float),\\n ])\\n\\n # Sets detector livetime in seconds\\n livetime = self.Livetime * (60. * 60. * 24.)\\n\\n # Conservative\\n dec_bandwidth = np.deg2rad(5.)\\n TotMuN = 0.\\n\\n # Loops over sources to add in expected number of neutrinos\\n for source in sources:\\n\\n # Checks to see if source_path is actually overlapping a given season\\n\\n if self.UseTime is True:\\n if not source['weight_time'] > 0.0:\\n continue\\n\\n # Only includes events lying in a +/- 5 degree declination band\\n SourceMC, omega, band_mask = self.find_and_apply_band_mask(\\n source, mc, dec_bandwidth)\\n\\n if self._ReturnInjectorNExp is True:\\n source['weight_distance'] = 1.\\n\\n # If using time, calculates the Fluence using the time model\\n # Otherwise calculates Fluence as flux * livetime (i.e. constant)\\n if self.UseTime is True:\\n fluence = source['flux'] * self.SimTimeLength * (60. * 60. * 24.)\\n\\n # EfficencyFactor = livetime / (\\n # (self.DataEnd - self.DataStart) * 24. * 60. * 60.)\\n # TotalTime = self.SimTimeLength * (60. * 60. * 24.)\\n # fluence = EfficencyFactor * TotalTime * source['flux']\\n # print EfficencyFactor\\n # raw_input(\\\"prompt\\\")\\n else:\\n fluence = source['flux'] * livetime\\n\\n # Recalculates the one weights to account for the band mask?\\n SourceMC['ow'] = (self.WeightsInject[band_mask] / omega) * source[\\n 'weight_distance'] * fluence\\n\\n # Expectation number of Neutrinos, equal to sum of one weights\\n MuN = np.sum(SourceMC['ow'], dtype=np.float)\\n\\n if self._ReturnInjectorNExp is True:\\n return MuN\\n\\n # If weighting for time, calculates weighted expectation value\\n # for number of neutrinos, and adds it to total expectation value.\\n if self.UseTime is True:\\n weightedMuN = MuN * source['sim_TimeNorm']\\n TotMuN += weightedMuN\\n\\n # If not time weighting, simply adds expectation value to total.\\n else:\\n TotMuN += MuN\\n\\n # print weightedMuN, source[\\\"weight_time\\\"]\\n\\n # Draws random number from expectation value of neutrinos\\n n_signal = np.random.poisson(MuN)\\n if n_signal < 1:\\n continue\\n\\n # Creates a normalised array of OneWeights\\n p_select = SourceMC['ow'] / np.sum(SourceMC['ow'])\\n\\n # Creates an array with n_signal entries.\\n # Each entry is a random integer between 0 and no. of sources.\\n # The probability for each integer is equal to the OneWeight of\\n # the corresponding source_path.\\n ind = np.random.choice(len(SourceMC['ow']), size=n_signal,\\n p=p_select)\\n\\n # Selects the sources corresponding to the random integer array\\n sam_ev = SourceMC[ind]\\n\\n # Rotates the Monte Carlo events onto the source_path\\n sam_ev = self.rotate_struct(sam_ev, source['ra'], source['dec'])\\n\\n # Generates random numbers according to Time profile\\n if self.UseTime is True:\\n sam_ev['timeMJD'] = (\\n self.generate_n_random_numbers(n_signal) +\\n source['discoverydate_mjd'])\\n\\n # Checks that events lie within a given season\\n sam_ev = self.check_time_borders(sam_ev, )\\n\\n sig_events = np.concatenate((sig_events, sam_ev))\\n\\n # print len(sig_events), sig_events, self.DataStart\\n # raw_input(\\\"prompt\\\")\\n\\n return sig_events\",\n \"def getMeanRMS (self,arr):\\n # in base class we return redshift and zero varinace\\n # repeat that here because mean RMS is meaningless for Template SED PDFs\\n N=len(arr)\\n return arr[\\\"z\\\"],np.zeros(N)\",\n \"def get_wr_season_totals():\\n wr_totals = redis_cache('wr_games_key', NFL_WR_Game_2015.query.filter_by(is_season_totals=True).all)\\n return wr_totals\",\n \"def _parse_season_entry (self, season, video, sorting):\\n return {\\n season['summary']['id']: {\\n 'idx': sorting[season['summary']['id']],\\n 'id': season['summary']['id'],\\n 'text': season['summary']['name'],\\n 'shortName': season['summary']['shortName'],\\n 'boxarts': {\\n 'small': video['boxarts']['_342x192']['jpg']['url'],\\n 'big': video['boxarts']['_1280x720']['jpg']['url']\\n },\\n 'interesting_moment': video['interestingMoment']['_665x375']['jpg']['url'],\\n }\\n }\",\n \"def seasonality(time, period, amplitude=1, phase=0):\\n\\tseason_time = ((time + phase) % period) / period\\n\\treturn amplitude * seasonal_pattern(season_time)\",\n \"def rolling_mean_dispersion(\\n data: np.ndarray, time_windows: np.ndarray, fps: int\\n ) -> np.ndarray:\\n\\n results = np.full((data.shape[0], time_windows.shape[0]), -1)\\n for time_window in prange(time_windows.shape[0]):\\n jump_frms = int(time_windows[time_window] * fps)\\n for current_frm in prange(jump_frms, results.shape[0] + 1):\\n data_window = np.deg2rad(data[current_frm - jump_frms : current_frm])\\n results[current_frm - 1][time_window] = np.rad2deg(\\n stats.circmean(data_window)\\n ).astype(int)\\n return results\",\n \"def monthly_avgs(HC):\\n monthlies = np.zeros((int(len(HC)/12),12))\\n counter_m = 0 #keeps track of years\\n counter_n = 0 #keeps track of months\\n for i in range(len(HC)):\\n if counter_n<12:\\n monthlies[counter_m,counter_n] = HC[i]\\n counter_n += 1\\n else:\\n counter_m += 1\\n monthlies[counter_m,0] = HC[i]\\n counter_n = 1\\n monthly_avgs = np.zeros((12))\\n months = np.zeros((12))\\n for i in range(12):\\n monthly_avgs[i] = np.mean(monthlies[:,i])\\n months[i] = i+1\\n \\n return months, monthly_avgs\",\n \"def class_average_speed(cars):\\n # Sort by class name\\n class_sorted = sorted(cars, key=lambda car: type(car).__name__)\\n class_velocities = []\\n class_names = []\\n # Group the cars of same class and average their velocities, save class names\\n for key, group in groupby(cars, key=lambda car: type(car).__name__):\\n velocities = [car.velocity for car in group]\\n class_velocity = sum(velocities) / len(velocities)\\n class_velocities.append([class_velocity])\\n class_names.append(key)\\n return class_velocities, class_names\",\n \"def cal_beam_AvgRMS(infile):\\n \\n data = np.loadtxt(infile)\\n rms = data[:,3]\\n avg_rms = round(np.mean(rms), 3)\\n \\n return avg_rms\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7113886","0.68064904","0.6650361","0.61950076","0.5758541","0.5734643","0.55560625","0.54895353","0.5439703","0.522154","0.51681584","0.5160492","0.5129565","0.5069776","0.50522226","0.50236505","0.4989968","0.49448606","0.49113876","0.48840415","0.4866676","0.4850736","0.48409486","0.4814644","0.48000026","0.47813103","0.4770627","0.47444415","0.47058216","0.47034478","0.46749255","0.46607965","0.46586338","0.4658248","0.46519858","0.46437237","0.46410233","0.4635656","0.46218053","0.46155977","0.4609586","0.46083277","0.4601332","0.45995185","0.45641404","0.4524796","0.45139936","0.44954383","0.44923407","0.44865444","0.44809732","0.44772825","0.44735134","0.4470409","0.44623688","0.44490573","0.44284478","0.4395612","0.43878636","0.43869156","0.43855768","0.43804356","0.4375907","0.43724245","0.43577254","0.43573013","0.43517858","0.43442452","0.4342218","0.43415576","0.43307838","0.43214792","0.43189335","0.43122664","0.43083864","0.43057597","0.43043616","0.4297518","0.42975068","0.4297427","0.4294353","0.4290852","0.42904758","0.42901635","0.4285377","0.42835924","0.4283179","0.42765665","0.42751122","0.42681307","0.42620438","0.42620328","0.42592147","0.42559406","0.42408642","0.42408434","0.42398003","0.42309043","0.42221436","0.4217812"],"string":"[\n \"0.7113886\",\n \"0.68064904\",\n \"0.6650361\",\n \"0.61950076\",\n \"0.5758541\",\n \"0.5734643\",\n \"0.55560625\",\n \"0.54895353\",\n \"0.5439703\",\n \"0.522154\",\n \"0.51681584\",\n \"0.5160492\",\n \"0.5129565\",\n \"0.5069776\",\n \"0.50522226\",\n \"0.50236505\",\n \"0.4989968\",\n \"0.49448606\",\n \"0.49113876\",\n \"0.48840415\",\n \"0.4866676\",\n \"0.4850736\",\n \"0.48409486\",\n \"0.4814644\",\n \"0.48000026\",\n \"0.47813103\",\n \"0.4770627\",\n \"0.47444415\",\n \"0.47058216\",\n \"0.47034478\",\n \"0.46749255\",\n \"0.46607965\",\n \"0.46586338\",\n \"0.4658248\",\n \"0.46519858\",\n \"0.46437237\",\n \"0.46410233\",\n \"0.4635656\",\n \"0.46218053\",\n \"0.46155977\",\n \"0.4609586\",\n \"0.46083277\",\n \"0.4601332\",\n \"0.45995185\",\n \"0.45641404\",\n \"0.4524796\",\n \"0.45139936\",\n \"0.44954383\",\n \"0.44923407\",\n \"0.44865444\",\n \"0.44809732\",\n \"0.44772825\",\n \"0.44735134\",\n \"0.4470409\",\n \"0.44623688\",\n \"0.44490573\",\n \"0.44284478\",\n \"0.4395612\",\n \"0.43878636\",\n \"0.43869156\",\n \"0.43855768\",\n \"0.43804356\",\n \"0.4375907\",\n \"0.43724245\",\n \"0.43577254\",\n \"0.43573013\",\n \"0.43517858\",\n \"0.43442452\",\n \"0.4342218\",\n \"0.43415576\",\n \"0.43307838\",\n \"0.43214792\",\n \"0.43189335\",\n \"0.43122664\",\n \"0.43083864\",\n \"0.43057597\",\n \"0.43043616\",\n \"0.4297518\",\n \"0.42975068\",\n \"0.4297427\",\n \"0.4294353\",\n \"0.4290852\",\n \"0.42904758\",\n \"0.42901635\",\n \"0.4285377\",\n \"0.42835924\",\n \"0.4283179\",\n \"0.42765665\",\n \"0.42751122\",\n \"0.42681307\",\n \"0.42620438\",\n \"0.42620328\",\n \"0.42592147\",\n \"0.42559406\",\n \"0.42408642\",\n \"0.42408434\",\n \"0.42398003\",\n \"0.42309043\",\n \"0.42221436\",\n \"0.4217812\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6935159"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":19888,"cells":{"query":{"kind":"string","value":"Returns a time average of the cdms2 variable mv. mv is a cdms2 variable, assumed to be timedependent and indexed as is usual for CFcompliant variables, i.e. mv(time,...). What's returned is a numpy array, not a cdms2 variable. (I may change this in the future)."},"document":{"kind":"string","value":"def timeave_old( mv ):\n # I haven't thought yet about how missing values would work with this...\n # If time intervals be unequal, this will have to be changed...\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\n n = sh[0]\n # BTW, this is the size of everything else:\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\n mvta = numpy.sum( mv.__array__(), axis=0 )\n mvta /= n\n return mvta"},"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 reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string)>2:\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n avmv = averager( mv, axis=axes_string )\n else:\n avmv = mv\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def reduce2scalar( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def m_average_fun(self, dx=df.dx):\n\n mx = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([1, 0, 0])) * dx)\n my = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 1, 0])) * dx)\n mz = df.assemble(\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 0, 1])) * dx)\n volume = df.assemble(self.material._Ms_dg * dx)\n\n return np.array([mx, my, mz]) / volume","def monthly_avg_2darray(x):\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()","def time_average(new_cube):\n\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\n\n return time_average_cube","def timeave_seasonal( mv, seasons=seasonsyr ):\n return seasons.climatology(mv)","def mov_mean_std(ts, m):\n\n if m <= 1:\n raise ValueError(\"Query length must be longer than one\")\n\n ts = ts.astype(\"float\")\n\n # Add zero to the beginning of the cumsum of ts\n s = np.insert(np.cumsum(ts), 0, 0)\n\n # Add zero to the beginning of the cumsum of ts ** 2\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\n seg_sum = s[m:] - s[:-m]\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\n return seg_sum / m, np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)","def compute(dm,do):\n mae = MV.average(MV.absolute(MV.subtract(dm,do)))\n return float(mae)","def TemporalAverage(video_handle):\n temp_avg = np.zeros((int(video_handle.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(video_handle.get(\n cv2.CAP_PROP_FRAME_WIDTH))))\n\n while video_handle.isOpened():\n ret, frame = video_handle.read()\n if not ret:\n break\n # Converts input RGB frames to Grayscale and adds the pixel values of successive frames\n temp_avg += GrayScale(frame)\n # Find the average of each pixel in the video\n temp_avg = temp_avg / video_handle.get(cv2.CAP_PROP_FRAME_COUNT)\n\n return temp_avg","def getMeanRMS (self,arr):\n # in base class we return redshift and zero varinace\n # repeat that here because mean RMS is meaningless for Template SED PDFs\n N=len(arr)\n return arr[\"z\"],np.zeros(N)","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def calcVmoy(self, V, idx, n):\n i = max(idx-n, 0)\n f = min(idx+n+1, V.shape[0])\n av = np.mean(V[i:f])\n return av","def cal_beam_AvgRMS(infile):\n \n data = np.loadtxt(infile)\n rms = data[:,3]\n avg_rms = round(np.mean(rms), 3)\n \n return avg_rms","def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax is None:\n print \"WARNING- no time axis in\",mv.id\n return None\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n print \"WARNING- cannot compute climatology for\",mv.id,seasons.seasons\n print \"...probably there is no data for times in the requested season.\"\n return None\n avmv = mvseas\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def find_mean_time_to_absorbtion(self):\n T = self.discrete_transition_matrix[:-3, :-3]\n S = np.linalg.inv(np.identity(len(T)) - T)\n steps2absorb = [sum([S[i,j] for j in range(len(S))]) for i in range(len(S))]\n time2absorb = [s*self.time_step for s in steps2absorb]\n self.mean_steps_to_absorbtion = {str(self.State_Space[i]): steps2absorb[i] for i in range(len(steps2absorb))}\n self.mean_time_to_absorbtion = {str(self.State_Space[i]): float(time2absorb[i]) for i in range(len(time2absorb))}","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def averageTime(self):\n \n pass","def forced_trend(varname, cvdp_loc):\n\n if not cvdp_loc.endswith('/'):\n cvdp_loc = cvdp_loc + '/'\n\n # Can use CVDP output\n fnames = sorted(glob('%sCESM1-CAM5-BGC-LE_*.cvdp_data.*.nc' % cvdp_loc))\n\n cvdp_name = 'tas_global_avg_mon'\n\n nfiles = len(fnames)\n ds = Dataset(fnames[0], 'r')\n time = ds['time'][:]\n time_units = ds['time'].units\n gm_em_units = ds[cvdp_name].units\n\n n = len(time)\n glob_mean = np.empty((nfiles, n))\n for counter, file in enumerate(fnames):\n ds = Dataset(file, 'r')\n glob_mean[counter, :] = ds[cvdp_name][:]\n\n # Take average across ensemble members\n gm_em = np.mean(glob_mean, axis=0)\n\n return gm_em, gm_em_units, time, time_units","def annual_avg_2darray(x):\n return x.reshape(-1,12).mean(1).reshape(x.shape[0],int(x.shape[1]/12))","def SimpleMovingAverage(self, timeperiod = 14): \r\n return ta.SMA(self.data.close,timeperiod)","def enstrophy_average(\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3): # vorticity-3 component\n #---------------------------------------------------------------------#\n # Defining the domain variables #\n #---------------------------------------------------------------------#\n dim = omega1.shape\n time = dim[-1]\n avg = np.zeros(time)\n #---------------------------------------------------------------------#\n # Looping over the time variable #\n #---------------------------------------------------------------------#\n print_count = 51\n for i in range(0, time):\n term1 = np.square(omega1[:,:,:,i])\n term2 = np.square(omega2[:,:,:,i])\n term3 = np.square(omega3[:,:,:,i])\n enst = 0.5*(term1 + term2 + term3)\n avg[i] = np.mean(enst)\n #-----------------------------------------------------------------#\n # Printing statement #\n #-----------------------------------------------------------------#\n if print_count > 20:\n print('Enstrophy average ---> t_step = %i' %(i))\n print_count = 0\n print_count += 1\n\n return avg","def avgtime(self):\n return (self._total_time['value'] / 1000) / self._total_time['count'] if self._total_time['count'] else 0","def extract_avg_charge_time_5(batch,index):\n avg_time = []\n for ind in index:\n cell_no = list(batch.keys())[ind]\n avg_time_ = np.average(batch[cell_no]['summary']['chargetime'][1:6]) #Cycle 2 to cycle 6\n # avg_time.append(avg_time_)\n avg_time.append(log(abs(avg_time_),10))\n avg_time = np.reshape(avg_time,(-1,1))\n return avg_time\n pass","def metric_average(val, name, hvd):\n tensor = val.clone().detach()\n avg_tensor = hvd.allreduce(tensor, name=name)\n return avg_tensor.item()","def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))","def mv_to_typet(mv):\n tab1 = [\n 0.0000000E+00,\n 2.5949192E+01,\n -2.1316967E-01,\n 7.9018692E-01,\n 4.2527777E-01,\n 1.3304473E-01,\n 2.0241446E-02,\n 1.2668171E-03,\n ]\n\n tab2 = [\n 0.000000E+00,\n 2.592800E+01,\n -7.602961E-01,\n 4.637791E-02,\n -2.165394E-03,\n 6.048144E-05,\n -7.293422E-07,\n 0.000000E+00,\n ]\n\n if -5.603 <= mv <= 0:\n c = tab1\n elif 0 < mv <= 20.872:\n c = tab2\n else:\n raise ValueError(\"Voltage specified is out of range for Type T thermocouple\")\n\n t = 0.0\n for p in range(0, len(c)):\n t += c[p] * math.pow(mv, p)\n return t","def part_b(filename):\n\n data = np.genfromtxt(get_filepath(filename), names=['abs_time', 'key'], delimiter=\",\")\n\n rel_time = [curr - last for last, curr in zip(np.concatenate(([0], data['abs_time'])), data['abs_time'])]\n rel_time_squared = [x * x for x in rel_time]\n\n return np.mean(rel_time_squared)","def opc_calcs(df_param_indexed):\n \n df_param_indexed = df_param_indexed.copy()\n \n ''' commented 20180210 after Calmetrix update\n # Remove for cc1 data exported with cc2\n mix_start = datetime.strptime(\n df_param_indexed.loc['Mix Time', 1], \"%d-%b-%Y %H:%M:%S\")\n log_start = datetime.strptime(\n df_param_indexed.loc['Start Time', 1], \"%d-%b-%Y %H:%M:%S\")\n time_difference = (log_start - mix_start).total_seconds()\n '''\n # select values from DataFrame and calculate mass of binder in sample\n # may be worth checking if any of these values are 0 at some point in the future\n \n m_water = float(df_param_indexed.loc['Water Mass, g', 1])\n m_cem = float(df_param_indexed.loc['Cement Mass, g', 1])\n m_sample = float(df_param_indexed.loc['Sample Mass, g', 1])\n m_sample_cem = m_sample / (m_cem + m_water) * m_cem\n \n return m_sample_cem","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def cal_mosaic_Stats(infile):\n\n data = np.loadtxt(infile)\n rms = data[:,3]\n\n med_rms = np.median(rms)\n mad_rms = round(median_absolute_deviation(rms), 3)\n\n return mad_rms, med_rms","def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def msub(trace):\n \n return(trace - np.mean(trace))","def monthly_avgs(HC):\n monthlies = np.zeros((int(len(HC)/12),12))\n counter_m = 0 #keeps track of years\n counter_n = 0 #keeps track of months\n for i in range(len(HC)):\n if counter_n<12:\n monthlies[counter_m,counter_n] = HC[i]\n counter_n += 1\n else:\n counter_m += 1\n monthlies[counter_m,0] = HC[i]\n counter_n = 1\n monthly_avgs = np.zeros((12))\n months = np.zeros((12))\n for i in range(12):\n monthly_avgs[i] = np.mean(monthlies[:,i])\n months[i] = i+1\n \n return months, monthly_avgs","def ams_estimate(self):\n return int(_mean([x ** 2 for x in self.ams_estimates]))","def get_average_for_month(self, month, weekend):\n\t\tif weekend:\n\t\t\treturn self.averages_weekend[month]\n\t\telse:\n\t\t\treturn self.averages_weekday[month]","def pc_work_time_avg(self) -> \"float\":\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)","def time_avg(dacycle,avg='transcom'):\n \n if avg not in ['transcom','transcom_extended','olson','olson_extended','country','flux1x1']:\n raise IOError,'Choice of averaging invalid'\n\n analysisdir = dacycle['dir.analysis']\n\n if not os.path.exists(analysisdir):\n raise IOError,'analysis dir requested (%s) does not exist, exiting...'%analysisdir\n\n daily_avg(dacycle,avg)\n\n monthly_avg(dacycle,avg)\n\n yearly_avg(dacycle,avg)\n\n longterm_avg(dacycle,avg)","def get_avg_correlation_from_matrix(zz):\n L=zz.shape[0]\n ns=L-1\n #zzbar = np.zeros((ns, *zz.shape[2:]))\n zzbar = np.zeros_like(zz)\n for i in range(ns):\n s=i+1\n zzbar[i, ...] = np.mean(np.asarray([zz[ii, ii+s, ...] for ii in range(L-s)]), axis=0)\n return zzbar","def MOA(self):\n return self.get_class_average(self.MOA_class_level)","def conditional_component_means(self, x2 = None):\n return np.array([d.conditional_mean(x2) for d in self.conditionalMVNs])","def compute_mse(self, results, T, nSegments):\n times_per_day = 56\n mse=0\n for i in range(nSegments):\n mse += T * np.mean(results[i][0].mse_path_[np.where(results[i][0].alphas_ == results[i][0].alpha_)[0][0]])\n mse += ((times_per_day-1)-T) * np.mean(results[i][1].mse_path_[np.where(results[i][1].alphas_ == results[i][1].alpha_)[0][0]])\n mse = mse/((times_per_day-1)*nSegments)\n return mse","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def part_a(filename):\n\n data = np.genfromtxt(get_filepath(filename), names = ['abs_time', 'key'], delimiter=\",\")\n\n # Fancy list comprehension to convert our absolute times to \"time from last keypress until next keypress\"\n # Notice that we need to start our left hand zip at 0ms. We don't have an explicit keypress at 0ms, but we\n # need to start doing the diff on the first keypress against 0.\n rel_time = [curr - last for last, curr in zip(np.concatenate(([0], data['abs_time'])), data['abs_time'])]\n\n return np.mean(rel_time)","def mad(v):\n return np.mean(np.abs(v - np.mean(v)))","def mov_std(ts, m):\n\n if m <= 1:\n raise ValueError(\"Query length must be longer than one\")\n\n ts = ts.astype(\"float\")\n # Add zero to the beginning of the cumsum of ts\n s = np.insert(np.cumsum(ts), 0, 0)\n # Add zero to the beginning of the cumsum of ts ** 2\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\n seg_sum = s[m:] - s[:-m]\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\n return np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)","def average(self, times=2):\n for i in range(times):\n self.statistics()\n global t, avlist\n length = len(t)\n avlist.append(t)\n t = []\n\n total_list = []\n\n for l in range(length):\n total_list.append([])\n\n for j in range(times):\n \"\"\"per time\"\"\"\n for i in range(length):\n total_list[i].append(avlist[j][i])\n\n \"\"\"calculate\"\"\"\n ylist = []\n avlist = []\n for a in total_list:\n avg = 0\n for b in a:\n avg += b\n ylist.append(avg/times)\n self.listy = ylist\n\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\n self.listx.append(e)","def moments2nd(data):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol)) \n rowgrid = rowgrid - rowmean # centered\n colgrid = colgrid - colmean\n Mrr = np.sum(rowgrid**2*data)/Isum\n Mcc = np.sum(colgrid**2*data)/Isum\n Mrc = np.sum(np.outer(rowgrid,colgrid)*data)/Isum \n return Mcc, Mrr, Mrc","def time_average(self, time_since_out, time_step):\n\n for variable in self._energy_state:\n bar_variable = \"{}_bar\".format(variable)\n bar_value = getattr(self, bar_variable)\n ta = time_average(bar_value, time_since_out,\n getattr(self, variable), time_step)\n setattr(self, bar_variable, ta)\n\n self.E_s_sum += self.E_s\n self.melt_sum += self.melt\n self.swi_sum += self.swi","def get_MSMC_results(filename, name):\n lines = []\n with open(filename, \"r\") as f:\n for line in f:\n lines.append(line)\n time = [v.split('\\t')[1] for v in lines]\n time = [float(v) for v in time[1:]]\n IICR_k = [v.split('\\t')[3] for v in lines]\n IICR_k = [float(v) for v in IICR_k[1:]]\n\n return {'name': name, 'model':'msmc', 'x_vector' : time, 'y_vector': IICR_k}","def average(self):\n if self._average is None: # only first time\n self._average = self._obj.mean(dim='t')\n self._average.attrs = self._obj.attrs # we need units in quiver\n\n return self._average","def current_mean(self):\r\n values = self._timings\r\n return np.mean(values)","def computeMSD2(trajectory, t_step): \n assert t_step > 0, 'timestep should be positive'\n assert len(trajectory.index) > 0, 'not enough points'\n \n delays = trajectory.index.copy()\n shifts = np.floor(delays/t_step).astype(np.int)\n msds = np.zeros(shifts.size)\n\n for i, shift in enumerate(shifts):\n diffs = trajectory - trajectory.shift(-shift)\n sqdist = np.square(diffs)\n msds[i] = sqdist.mean()\n\n return delays, msds","def av(self, data):\n ts_ = self.ts(data)\n if 'year' not in ts_.coords:\n return ts_\n return ts_.mean('year')","def get_vwmacd(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.VW_MACD(data)\n if result is None:\n raise IndicatorException\n return result","def avgtr(self):\n return np.diff(self.trtimes).mean()","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def _compute_mean(self, C, mag, rjb, rake):\n mean = (C['a1'] +\n self._compute_linear_magnitude_term(C, mag) +\n self._compute_quadratic_magnitude_term(C, mag) +\n self._compute_logarithmic_distance_term(C, mag, rjb) +\n self._compute_faulting_style_term(C, rake))\n\n return mean","def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def mc2ms(mc,eta):\n root = np.sqrt(0.25-eta)\n fraction = (0.5+root) / (0.5-root)\n invfraction = 1/fraction\n\n m2= mc * np.power((1+fraction),0.2) / np.power(fraction,0.6)\n\n m1= mc* np.power(1+invfraction,0.2) / np.power(invfraction,0.6)\n return (m1,m2)","def dt_avg(self, print_output=True, output_file = \"dt.csv\"):\t\n\n\t\tavg = self.dt.mean(axis=2)\n\t\tif print_output: np.savetxt(output_file, avg, delimiter = \",\")\n\t\treturn avg","def avg(ev):\n profData = getProfilingData(ev)\n if profData is not None:\n return profData.Tavg()\n return \"\"","def mv_to_typee(mv):\n tab1 = [\n 0.0000000E+00,\n 1.6977288E+01,\n -4.3514970E-01,\n -1.5859697E-01,\n -9.2502871E-02,\n -2.6084314E-02,\n -4.1360199E-03,\n -3.4034030E-04,\n -1.1564890E-05,\n 0.0000000E+00,\n ]\n\n tab2 = [\n 0.0000000E+00,\n 1.7057035E+01,\n -2.3301759E-01,\n 6.5435585E-03,\n -7.3562749E-05,\n -1.7896001E-06,\n 8.4036165E-08,\n -1.3735879E-09,\n 1.0629823E-11,\n -3.2447087E-14,\n ]\n\n if -8.825 <= mv <= 0.0:\n c = tab1\n elif 0.0 < mv <= 76.373:\n c = tab2\n else:\n raise ValueError(\"Voltage specified is out of range for Type E thermocouple\")\n\n t = 0.0\n for p in range(0, len(c)):\n t += c[p] * math.pow(mv, p)\n return t","def average_seconds(data, board):\n return str(\n timedelta(seconds=mean(data[board]))\n ).split(\".\")[0]","def time_then_chan_avg(inms, tbin, chanbin, outms=\"\", zaptemp=True,\n zaporig=False, chanselstr=\"\", datacolstr='corrected'):\n casalog.origin('time_then_chan_avg')\n inms_root = inms.rpartition(\".ms\")[0]\n if not inms_root:\n inms_root = inms\n inms_root = os.path.basename(inms_root) # Keep outms in local directory.\n troot = inms_root + '_' + chanselstr + \"_timebin\" + tbin\n tms = troot + \".ms\"\n\n funnyshapes = False\n \n try:\n # Do time averaging.\n if (chanselstr.find(':') > -1) and ((chanselstr.find(',') > -1) or\n (chanselstr.find(';') > -1)):\n funnyshapes = True\n\n ## print 'tbin =', tbin\n ## print 'tavspw =', chanselstr\n ## print 'tavdc =', datacolstr\n ## print 'inms =', inms\n casalog.post(\"Time averaging to \" + tms)\n split(vis=inms, outputvis=tms, timebin=tbin, spw=chanselstr,\n datacolumn=datacolstr)\n ms.open(tms)\n nrows_aft_tavg = ms.nrow()\n ms.close()\n except Exception, e:\n casalog.post(\n\"\"\"Error from split(vis='%s', outputvis='%s',\n timebin='%s', spw='%s', datacolumn='%s').\"\"\" % (inms, tms,\n tbin,\n chanselstr,\n datacolstr),\n 'SEVERE')\n if os.path.isdir(tms):\n casalog.post(\"\\t%s has been left on disk for your inspection.\" % tms,\n 'SEVERE')\n raise e\n\n if outms == \"\":\n outms = \"%s_width%d.ms\" % (troot, chanbin)\n try:\n # Do channel averaging.\n casalog.post(\"Channel averaging to \" + outms)\n if datacolstr.lower() not in ['all', 'float_data', 'lag_data']:\n datacolstr = 'data'\n split(vis=tms, outputvis=outms, datacolumn=datacolstr, width=chanbin)\n tb.open(outms)\n if funnyshapes:\n dat = tb.getvarcol('DATA')\n nrows_aft_cavg = len(dat)\n shape_aft_cavg = set([d.shape for d in dat.itervalues()])\n else:\n dat = tb.getcol('DATA')\n shape_aft_cavg = dat.shape\n nrows_aft_cavg = shape_aft_cavg[-1]\n tb.close()\n except Exception, e:\n casalog.post(\n\"\"\"Error from split(vis='%s', outputvis='%s',\n datacolumn='data', width=%d, spw='%s').\"\"\" % (tms, outms,\n chanbin,\n chanselstr),\n 'SEVERE')\n raise e\n if zaptemp:\n shutil.rmtree(tms)\n if zaporig:\n casalog.post(\"Following your instruction to shutil.rmtree(\" + inms + \")\", 'WARN')\n shutil.rmtree(inms)\n return nrows_aft_tavg, nrows_aft_cavg, shape_aft_cavg","def calccalmean(self,blk):\n calind=self.getcalind(blk)\n x=self.spec[calind,:]\n return np.nanmean(x,axis=0)","def get_average_for_month_at_time(self, month, hour, minute, weekend):\n\t\tif weekend:\n\t\t\treturn self.averages_weekend[month][self.get_list_id(hour, minute)]\n\t\telse:\n\t\t\treturn self.averages_weekday[month][self.get_list_id(hour, minute)]","def average(self, returns):\r\n return returns.mean() * self.day","def kinetic_energy(v, Mm=1.):\n speed_squared = v[:, 0] ** 2 + v[:, 1] ** 2\n # timeit.timeit('vt[:,0]**2+vt[:,1]**2', setup='import numpy as np; vt = np.random.rand(10000,2)', number=1000)\n KE = 0.5 * sum(Mm * speed_squared)\n return KE","def average_tod(self,d,feed_tod,feed_weights,mask): \n\n frequency = d['level1/spectrometer/frequency'][...]\n # This becomes (nBands, 64) \n self.frequency = np.mean(np.reshape(frequency,(frequency.shape[0],frequency.shape[1]//16,16)) ,axis=-1)\n all_tod = np.zeros((8, feed_tod.shape[-1]))\n all_weights=np.zeros((8, feed_tod.shape[-1]))\n all_frequency=np.zeros((8))\n for ichan, (flow,fhigh) in enumerate(zip(np.arange(8)+26,np.arange(8)+27)):\n sel = ((self.frequency >= flow) & (self.frequency < fhigh))\n top = np.sum(feed_tod[sel,:]*feed_weights[sel,:],axis=0)\n bot = np.sum(feed_weights[sel,:],axis=0)\n all_tod[ichan,:] = top/bot\n all_weights[ichan,:] = bot\n all_frequency[ichan] = (fhigh+flow)/2.\n \n diff = all_tod[:,mask]\n N = int(diff.shape[1]//2*2)\n diff = (diff[:,:N:2]-diff[:,1:N:2])\n auto = stats.MAD(diff.T)\n\n amean_rms = np.sqrt(1./np.nanmedian(all_weights[:,mask],axis=1))\n\n # Add the weighted average uncertainties to the auto-rms uncertainties\n all_weights = 1./(1./all_weights + auto[:,None]**2)\n\n return all_tod, all_weights, auto, all_frequency","def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean","def getMeanRMS (self,arr):\n print \"You are trying get mean rms for a gaussian error with catastrophic errorbar.\"\n print \"I refuse to do so, but feel free to give me hard time about it\"\n raise NotImplementedError","def dt_avg(self, print_output=True, output_file = \"dt_query.csv\"):\t\n\n\t\tavg = self.dt.mean(axis=2)\n\t\tif print_output: np.savetxt(output_file, avg, delimiter = \",\")\n\t\treturn avg","def reduce2levlat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def _calc_time(time_lines: list) -> np.ndarray:\n time = [time_to_fraction_hour(line.split()[1]) for line in time_lines]\n return np.array(time)","def get_center_of_masses(self) -> np.array:\n com = np.average(self.obj[:, :2], weights=self.obj[:, 2], axis=0)\n return com","def get_video_average(video_path):\n vidcap = cv2.VideoCapture(video_path)\n\n width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\n height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n num_color_channels = 3\n\n avg_frame = np.zeros((height, width, num_color_channels), dtype=np.float64)\n frames = 0\n\n while True:\n success, img = vidcap.read()\n if not success:\n break\n avg_frame += img\n frames += 1\n\n avg_frame = avg_frame / frames\n ####avg_frame = cv2.cvtColor(avg_frame, cv2.COLOR_BGR2RGB)\n avg_frame = avg_frame.astype(np.uint8)\n cv2.imwrite(\"average_frame.png\", avg_frame)","def obtain_monthly_mean(data=pd.DataFrame()):\n return data.resample(\"MS\").mean()","def avg_ttm_2y(df):\n return 0.5 * (df + df.shift(4))","def calculateAverage(self): \n if not self.lastTransferAverage: \n size=[0,0,0,0]\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n size[i]=self.lastNbrSamplesPerSeg\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\n nbrSamp=self.lastNbrSamplesPerSeg\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n nbrSeg=self.lastNbrSegmentsArray[i]\n for j in range (0,nbrSamp):\n for k in range(0,nbrSeg): \n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\n self.lastAverageArray[i][j]/=nbrSeg\n self.lastAverageCalculated=True\n else: print \"NOn averaged data are not available\"","def generate_observed_mdv(self):\n id_array = []\n ratio_array = []\n std_array = []\n use_array = []\n raw_data_array = []\n for time in sorted(self.mdvtc.keys()):\n ids, mdv_exp_original, mdv_std_original, mdv_use, target_emu_list, rawdata = self.mdvtc[time].generate_observed_mdv()\n id_array.extend(ids)\n ratio_array.extend(mdv_exp_original)\n std_array.extend(mdv_std_original)\n use_array.extend(mdv_use)\n raw_data_array.extend(rawdata)\n\n\n return id_array, numpy.array(ratio_array), numpy.array(std_array), use_array, target_emu_list, raw_data_array","def calc_mse(data, ax=0):\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)","def Moving_Average_System(signal,M = 10):\t\t\t\t\t\t\t\t# Function of Moving Average System using Ideal Delay System\n\tp,q,s = M,signal.shape[0]- M,signal.shape[0]\n\tsignal_new = np.zeros(s+M)\n\t\n\tfor i in range(M+1):\n\t\tsignal_new[M-i:M-i+s] += Signal_Ideal_Delay(signal,d=i)[0]\n\t\t\n\tsignal_new = signal_new/(M + 1)\t\t\n\ttime = np.arange(0,s+M)\n\t\n\treturn signal_new,time","def calculate_mean_vec(self,matrix1):\n mean_vec = []\n matrix_transposed = matrix1.T\n for t in matrix_transposed:\n mean_vec.append(np.mean(t))\n return mean_vec","def calc_10M_average(self, inputs):\n self.Vm_sum += self.getAtt('Vm', inputs)\n if self.time % 10 == 0:\n if self.time == 0:\n average = self.Vm_sum / 2\n else:\n average = self.Vm_sum / 10\n self.Vm_10M_average = average\n self.Vm_sum = 0.0","def reprojection_error_mean(*args, **kwargs):\n return np.mean(reprojection_error_vector(*args, **kwargs))","def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n if levAxis(mv) is None: return None\n if latAxis(mv) is None: return None\n axes = allAxes( mv )\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n\n return avmv","def vel2acc(timeseries, dt):\n return np.diff(np.hstack(([0], timeseries)) * (1.0 / dt))","def rtt_avg_ms(self):\n\n return represent_seconds_in_milliseconds(self.__rtt_avg)","def computeMACD(x, slow=26, fast=12):\n emaslow = ExpMovingAverage(x, slow)\n emafast = ExpMovingAverage(x, fast)\n return emaslow, emafast, emafast - emaslow","def timeseriesCVscore(self, params):\n errors = []\n\n # values = series.values\n values = self.train_ts\n self.alpha, self.beta, self.gamma = params\n\n # set the number of folds for cross-validation\n tscv = TimeSeriesSplit(n_splits=3)\n\n # iterating over folds, train model on each, forecast and calculate error\n for train, test in tscv.split(values):\n\n self.train = values[train]\n self.test = values[test]\n self.triple_exponential_smoothing()\n predictions = self.result[-len(self.test) :]\n actual = values[test]\n error = mape(list(actual), predictions)\n errors.append(error)\n\n # print \"error: \"\n # print errors\n return np.mean(np.array(errors))","def mean_std_ci(measures, mul=1., tex=False):\n measures = np.array(measures)*mul\n ms = np.mean(measures), np.std(measures), half_int(measures)\n return ms if not tex else r\"${:.2f} \\pm {:.2f}$\".format(ms[0], ms[2])","def average_dnu(self):\n\n freqs = self.star.ds.mode_id['f0'].as_matrix()\n f1 = freqs[1:]\n f2 = freqs[:-1]\n diff = f1-f2\n self.dnu = np.mean(diff)","def sma(ohlcv, period=10, ohlcv_series=\"close\"):\n _ohlcv = ohlcv[[ohlcv_series]].copy(deep=True)\n indicator_values = _ohlcv[ohlcv_series].rolling(window=period, min_periods=period).mean()\n\n return indicator_values","def compute_MAE(e):\n\n return np.mean(np.abs(e))","def get_averaged_ms(ms_name, tbin=None, cbin=None, chunks=None, taql_where='',\n columns=None, chan=None, corr=None, data_col=None,\n group_cols=None, iter_axis=None):\n\n if chunks is None:\n chunks = dict(row=10000)\n\n # these are the defaults in averager\n if tbin is None:\n tbin = 1\n if cbin is None:\n cbin = 1\n\n # ensure that these are in the selected columns\n for _ in [\"TIME\", \"ANTENNA1\", \"ANTENNA2\", \"INTERVAL\", \"FLAG\", \"FLAG_ROW\", data_col]:\n if _ not in columns:\n columns.append(_)\n\n # must be grouped this way because of time averaging\n ms_obj = xm.xds_from_ms(ms_name,\n group_cols=[\"DATA_DESC_ID\",\n \"FIELD_ID\", \"SCAN_NUMBER\"],\n columns=columns,\n taql_where=taql_where)\n\n # some channels have been selected\n # corr selection is performed after averaging!!\n if chan is not None:\n ms_obj = [_.sel(chan=chan) for _ in ms_obj]\n\n logger.info(\"Averaging MAIN table\")\n\n # perform averaging to the MS\n avg_mss = average_main(main_ds=ms_obj, time_bin_secs=tbin,\n chan_bin_size=cbin, group_row_chunks=100000,\n respect_flag_row=False, sel_cols=columns,\n viscolumn=data_col)\n n_ams = len(avg_mss)\n\n # writes_ms = xm.xds_to_table(avg_mss, \"tesxt\", \"ALL\")\n logger.info(\"Creating averaged xarray Dataset\")\n\n x_datasets = []\n for _a, ams in enumerate(avg_mss):\n ams = ams.compute()\n logger.info(f\"Averaging {_a+1} / {n_ams}\")\n\n datas = {k: (v.dims, v.data, v.attrs)\n for k, v in ams.data_vars.items() if k != \"FLAG_CATEGORY\"}\n\n new_ds = xr.Dataset(datas, attrs=ams.attrs, coords=ams.coords)\n new_ds = new_ds.chunk(chunks)\n\n x_datasets.append(new_ds)\n\n # data will always be grouped by SPW unless iterating over antenna\n # the most amount of grouping that will occur will be between to columns\n all_grps = []\n\n if len(group_cols) == 0:\n # return a single dataset\n subs = xr.combine_nested(x_datasets, concat_dim=\"row\",\n compat=\"no_conflicts\", data_vars=\"all\",\n coords=\"different\", join=\"outer\")\n subs.attrs = {}\n subs = subs.chunk(chunks)\n all_grps.append(subs)\n\n elif (set(group_cols) <= {\"DATA_DESC_ID\", \"ANTENNA1\", \"ANTENNA2\"} or\n iter_axis == \"antenna\"):\n uniques = np.unique([_.attrs[\"DATA_DESC_ID\"] for _ in x_datasets])\n uants = np.arange(vu.get_antennas(ms_name).size)\n\n for _d in uniques:\n subs = []\n for _ in x_datasets:\n if _.attrs[\"DATA_DESC_ID\"] == _d:\n subs.append(_)\n subs = xr.combine_nested(subs, concat_dim=\"row\",\n compat=\"no_conflicts\", data_vars=\"all\",\n coords=\"different\", join=\"outer\")\n subs.attrs = {\"DATA_DESC_ID\": _d}\n subs = subs.chunk(chunks)\n\n if {\"ANTENNA1\", \"ANTENNA2\"} <= set(group_cols):\n u_bl = combinations(uants, 2)\n for p, q in u_bl:\n n_subs = subs.where((subs.ANTENNA1 == p) &\n (subs.ANTENNA2 == q), drop=True)\n n_subs.attrs = {\"DATA_DESC_ID\": _d,\n \"ANTENNA1\": p,\n \"ANTENNA2\": q}\n all_grps.append(n_subs)\n elif \"ANTENNA1\" in group_cols:\n for p in uants[:-1]:\n n_subs = subs.where((subs.ANTENNA1 == p), drop=True)\n n_subs.attrs = {\"DATA_DESC_ID\": _d,\n \"ANTENNA1\": p}\n all_grps.append(n_subs)\n elif \"ANTENNA2\" in group_cols:\n for q in uants[:-1] + 1:\n n_subs = subs.where((subs.ANTENNA2 == q), drop=True)\n n_subs.attrs = {\"DATA_DESC_ID\": _d,\n \"ANTENNA2\": q}\n all_grps.append(n_subs)\n elif iter_axis == \"antenna\":\n for p in uants:\n n_subs = subs.where((subs.ANTENNA1 == p) |\n (subs.ANTENNA2 == p), drop=True)\n n_subs.attrs = {\"DATA_DESC_ID\": _d,\n \"ANTENNA\": p}\n all_grps.append(n_subs)\n else:\n all_grps.append(subs)\n\n elif set(group_cols) <= {\"DATA_DESC_ID\", \"FIELD_ID\", \"SCAN_NUMBER\"}:\n grps = {}\n # must be ddid + something else\n # if it is something other than fid and scan e.g\n # by default group by ddid\n for grp in group_cols:\n uniques = np.unique([_.attrs[grp] for _ in x_datasets])\n grps[grp] = uniques\n # grps.append(uniques)\n for com in product(*grps.values()):\n subs = []\n natt = {k: v for k, v in zip(group_cols, com)}\n for _ in x_datasets:\n if set(natt.items()) <= set(_.attrs.items()):\n subs.append(_)\n subs = xr.combine_nested(subs, concat_dim=\"row\",\n compat=\"no_conflicts\",\n data_vars=\"all\", coords=\"different\",\n join=\"outer\")\n subs.attrs = natt\n subs = subs.chunk(chunks)\n all_grps.append(subs)\n\n # select a corr\n if corr is not None:\n all_grps = [_.sel(corr=corr) for _ in all_grps]\n\n logger.info(\"Averaging completed.\")\n\n return all_grps","def mae(t, y):\n\treturn mean_absolute_error(t, y)","def computeMACD(x, slow=26, fast=12):\n emaslow = ExpMovingAverage(x, slow)\n emafast = ExpMovingAverage(x, fast)\n return (emaslow, emafast, emafast - emaslow)"],"string":"[\n \"def reduce_time( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id=='time' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n if len(axes_string)>2:\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n avmv = averager( mv, axis=axes_string )\\n else:\\n avmv = mv\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def reduce2scalar( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def m_average_fun(self, dx=df.dx):\\n\\n mx = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([1, 0, 0])) * dx)\\n my = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 1, 0])) * dx)\\n mz = df.assemble(\\n self.material._Ms_dg * df.dot(self._m, df.Constant([0, 0, 1])) * dx)\\n volume = df.assemble(self.material._Ms_dg * dx)\\n\\n return np.array([mx, my, mz]) / volume\",\n \"def monthly_avg_2darray(x):\\n return x.reshape(-1,12).transpose().reshape(-1,int(x.shape[1]/12)).mean(1).reshape(12,-1).transpose()\",\n \"def time_average(new_cube):\\n\\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\\n\\n return time_average_cube\",\n \"def timeave_seasonal( mv, seasons=seasonsyr ):\\n return seasons.climatology(mv)\",\n \"def mov_mean_std(ts, m):\\n\\n if m <= 1:\\n raise ValueError(\\\"Query length must be longer than one\\\")\\n\\n ts = ts.astype(\\\"float\\\")\\n\\n # Add zero to the beginning of the cumsum of ts\\n s = np.insert(np.cumsum(ts), 0, 0)\\n\\n # Add zero to the beginning of the cumsum of ts ** 2\\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\\n seg_sum = s[m:] - s[:-m]\\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\\n return seg_sum / m, np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)\",\n \"def compute(dm,do):\\n mae = MV.average(MV.absolute(MV.subtract(dm,do)))\\n return float(mae)\",\n \"def TemporalAverage(video_handle):\\n temp_avg = np.zeros((int(video_handle.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(video_handle.get(\\n cv2.CAP_PROP_FRAME_WIDTH))))\\n\\n while video_handle.isOpened():\\n ret, frame = video_handle.read()\\n if not ret:\\n break\\n # Converts input RGB frames to Grayscale and adds the pixel values of successive frames\\n temp_avg += GrayScale(frame)\\n # Find the average of each pixel in the video\\n temp_avg = temp_avg / video_handle.get(cv2.CAP_PROP_FRAME_COUNT)\\n\\n return temp_avg\",\n \"def getMeanRMS (self,arr):\\n # in base class we return redshift and zero varinace\\n # repeat that here because mean RMS is meaningless for Template SED PDFs\\n N=len(arr)\\n return arr[\\\"z\\\"],np.zeros(N)\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def calcVmoy(self, V, idx, n):\\n i = max(idx-n, 0)\\n f = min(idx+n+1, V.shape[0])\\n av = np.mean(V[i:f])\\n return av\",\n \"def cal_beam_AvgRMS(infile):\\n \\n data = np.loadtxt(infile)\\n rms = data[:,3]\\n avg_rms = round(np.mean(rms), 3)\\n \\n return avg_rms\",\n \"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax is None:\\n print \\\"WARNING- no time axis in\\\",mv.id\\n return None\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n print \\\"WARNING- cannot compute climatology for\\\",mv.id,seasons.seasons\\n print \\\"...probably there is no data for times in the requested season.\\\"\\n return None\\n avmv = mvseas\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def find_mean_time_to_absorbtion(self):\\n T = self.discrete_transition_matrix[:-3, :-3]\\n S = np.linalg.inv(np.identity(len(T)) - T)\\n steps2absorb = [sum([S[i,j] for j in range(len(S))]) for i in range(len(S))]\\n time2absorb = [s*self.time_step for s in steps2absorb]\\n self.mean_steps_to_absorbtion = {str(self.State_Space[i]): steps2absorb[i] for i in range(len(steps2absorb))}\\n self.mean_time_to_absorbtion = {str(self.State_Space[i]): float(time2absorb[i]) for i in range(len(time2absorb))}\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def averageTime(self):\\n \\n pass\",\n \"def forced_trend(varname, cvdp_loc):\\n\\n if not cvdp_loc.endswith('/'):\\n cvdp_loc = cvdp_loc + '/'\\n\\n # Can use CVDP output\\n fnames = sorted(glob('%sCESM1-CAM5-BGC-LE_*.cvdp_data.*.nc' % cvdp_loc))\\n\\n cvdp_name = 'tas_global_avg_mon'\\n\\n nfiles = len(fnames)\\n ds = Dataset(fnames[0], 'r')\\n time = ds['time'][:]\\n time_units = ds['time'].units\\n gm_em_units = ds[cvdp_name].units\\n\\n n = len(time)\\n glob_mean = np.empty((nfiles, n))\\n for counter, file in enumerate(fnames):\\n ds = Dataset(file, 'r')\\n glob_mean[counter, :] = ds[cvdp_name][:]\\n\\n # Take average across ensemble members\\n gm_em = np.mean(glob_mean, axis=0)\\n\\n return gm_em, gm_em_units, time, time_units\",\n \"def annual_avg_2darray(x):\\n return x.reshape(-1,12).mean(1).reshape(x.shape[0],int(x.shape[1]/12))\",\n \"def SimpleMovingAverage(self, timeperiod = 14): \\r\\n return ta.SMA(self.data.close,timeperiod)\",\n \"def enstrophy_average(\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3): # vorticity-3 component\\n #---------------------------------------------------------------------#\\n # Defining the domain variables #\\n #---------------------------------------------------------------------#\\n dim = omega1.shape\\n time = dim[-1]\\n avg = np.zeros(time)\\n #---------------------------------------------------------------------#\\n # Looping over the time variable #\\n #---------------------------------------------------------------------#\\n print_count = 51\\n for i in range(0, time):\\n term1 = np.square(omega1[:,:,:,i])\\n term2 = np.square(omega2[:,:,:,i])\\n term3 = np.square(omega3[:,:,:,i])\\n enst = 0.5*(term1 + term2 + term3)\\n avg[i] = np.mean(enst)\\n #-----------------------------------------------------------------#\\n # Printing statement #\\n #-----------------------------------------------------------------#\\n if print_count > 20:\\n print('Enstrophy average ---> t_step = %i' %(i))\\n print_count = 0\\n print_count += 1\\n\\n return avg\",\n \"def avgtime(self):\\n return (self._total_time['value'] / 1000) / self._total_time['count'] if self._total_time['count'] else 0\",\n \"def extract_avg_charge_time_5(batch,index):\\n avg_time = []\\n for ind in index:\\n cell_no = list(batch.keys())[ind]\\n avg_time_ = np.average(batch[cell_no]['summary']['chargetime'][1:6]) #Cycle 2 to cycle 6\\n # avg_time.append(avg_time_)\\n avg_time.append(log(abs(avg_time_),10))\\n avg_time = np.reshape(avg_time,(-1,1))\\n return avg_time\\n pass\",\n \"def metric_average(val, name, hvd):\\n tensor = val.clone().detach()\\n avg_tensor = hvd.allreduce(tensor, name=name)\\n return avg_tensor.item()\",\n \"def get_mean(self):\\r\\n for i in range(1,len(self.data[0])):\\r\\n self.prom.append(np.mean(self.data[:,i]))\",\n \"def mv_to_typet(mv):\\n tab1 = [\\n 0.0000000E+00,\\n 2.5949192E+01,\\n -2.1316967E-01,\\n 7.9018692E-01,\\n 4.2527777E-01,\\n 1.3304473E-01,\\n 2.0241446E-02,\\n 1.2668171E-03,\\n ]\\n\\n tab2 = [\\n 0.000000E+00,\\n 2.592800E+01,\\n -7.602961E-01,\\n 4.637791E-02,\\n -2.165394E-03,\\n 6.048144E-05,\\n -7.293422E-07,\\n 0.000000E+00,\\n ]\\n\\n if -5.603 <= mv <= 0:\\n c = tab1\\n elif 0 < mv <= 20.872:\\n c = tab2\\n else:\\n raise ValueError(\\\"Voltage specified is out of range for Type T thermocouple\\\")\\n\\n t = 0.0\\n for p in range(0, len(c)):\\n t += c[p] * math.pow(mv, p)\\n return t\",\n \"def part_b(filename):\\n\\n data = np.genfromtxt(get_filepath(filename), names=['abs_time', 'key'], delimiter=\\\",\\\")\\n\\n rel_time = [curr - last for last, curr in zip(np.concatenate(([0], data['abs_time'])), data['abs_time'])]\\n rel_time_squared = [x * x for x in rel_time]\\n\\n return np.mean(rel_time_squared)\",\n \"def opc_calcs(df_param_indexed):\\n \\n df_param_indexed = df_param_indexed.copy()\\n \\n ''' commented 20180210 after Calmetrix update\\n # Remove for cc1 data exported with cc2\\n mix_start = datetime.strptime(\\n df_param_indexed.loc['Mix Time', 1], \\\"%d-%b-%Y %H:%M:%S\\\")\\n log_start = datetime.strptime(\\n df_param_indexed.loc['Start Time', 1], \\\"%d-%b-%Y %H:%M:%S\\\")\\n time_difference = (log_start - mix_start).total_seconds()\\n '''\\n # select values from DataFrame and calculate mass of binder in sample\\n # may be worth checking if any of these values are 0 at some point in the future\\n \\n m_water = float(df_param_indexed.loc['Water Mass, g', 1])\\n m_cem = float(df_param_indexed.loc['Cement Mass, g', 1])\\n m_sample = float(df_param_indexed.loc['Sample Mass, g', 1])\\n m_sample_cem = m_sample / (m_cem + m_water) * m_cem\\n \\n return m_sample_cem\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def cal_mosaic_Stats(infile):\\n\\n data = np.loadtxt(infile)\\n rms = data[:,3]\\n\\n med_rms = np.median(rms)\\n mad_rms = round(median_absolute_deviation(rms), 3)\\n\\n return mad_rms, med_rms\",\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def msub(trace):\\n \\n return(trace - np.mean(trace))\",\n \"def monthly_avgs(HC):\\n monthlies = np.zeros((int(len(HC)/12),12))\\n counter_m = 0 #keeps track of years\\n counter_n = 0 #keeps track of months\\n for i in range(len(HC)):\\n if counter_n<12:\\n monthlies[counter_m,counter_n] = HC[i]\\n counter_n += 1\\n else:\\n counter_m += 1\\n monthlies[counter_m,0] = HC[i]\\n counter_n = 1\\n monthly_avgs = np.zeros((12))\\n months = np.zeros((12))\\n for i in range(12):\\n monthly_avgs[i] = np.mean(monthlies[:,i])\\n months[i] = i+1\\n \\n return months, monthly_avgs\",\n \"def ams_estimate(self):\\n return int(_mean([x ** 2 for x in self.ams_estimates]))\",\n \"def get_average_for_month(self, month, weekend):\\n\\t\\tif weekend:\\n\\t\\t\\treturn self.averages_weekend[month]\\n\\t\\telse:\\n\\t\\t\\treturn self.averages_weekday[month]\",\n \"def pc_work_time_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)\",\n \"def time_avg(dacycle,avg='transcom'):\\n \\n if avg not in ['transcom','transcom_extended','olson','olson_extended','country','flux1x1']:\\n raise IOError,'Choice of averaging invalid'\\n\\n analysisdir = dacycle['dir.analysis']\\n\\n if not os.path.exists(analysisdir):\\n raise IOError,'analysis dir requested (%s) does not exist, exiting...'%analysisdir\\n\\n daily_avg(dacycle,avg)\\n\\n monthly_avg(dacycle,avg)\\n\\n yearly_avg(dacycle,avg)\\n\\n longterm_avg(dacycle,avg)\",\n \"def get_avg_correlation_from_matrix(zz):\\n L=zz.shape[0]\\n ns=L-1\\n #zzbar = np.zeros((ns, *zz.shape[2:]))\\n zzbar = np.zeros_like(zz)\\n for i in range(ns):\\n s=i+1\\n zzbar[i, ...] = np.mean(np.asarray([zz[ii, ii+s, ...] for ii in range(L-s)]), axis=0)\\n return zzbar\",\n \"def MOA(self):\\n return self.get_class_average(self.MOA_class_level)\",\n \"def conditional_component_means(self, x2 = None):\\n return np.array([d.conditional_mean(x2) for d in self.conditionalMVNs])\",\n \"def compute_mse(self, results, T, nSegments):\\n times_per_day = 56\\n mse=0\\n for i in range(nSegments):\\n mse += T * np.mean(results[i][0].mse_path_[np.where(results[i][0].alphas_ == results[i][0].alpha_)[0][0]])\\n mse += ((times_per_day-1)-T) * np.mean(results[i][1].mse_path_[np.where(results[i][1].alphas_ == results[i][1].alpha_)[0][0]])\\n mse = mse/((times_per_day-1)*nSegments)\\n return mse\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def part_a(filename):\\n\\n data = np.genfromtxt(get_filepath(filename), names = ['abs_time', 'key'], delimiter=\\\",\\\")\\n\\n # Fancy list comprehension to convert our absolute times to \\\"time from last keypress until next keypress\\\"\\n # Notice that we need to start our left hand zip at 0ms. We don't have an explicit keypress at 0ms, but we\\n # need to start doing the diff on the first keypress against 0.\\n rel_time = [curr - last for last, curr in zip(np.concatenate(([0], data['abs_time'])), data['abs_time'])]\\n\\n return np.mean(rel_time)\",\n \"def mad(v):\\n return np.mean(np.abs(v - np.mean(v)))\",\n \"def mov_std(ts, m):\\n\\n if m <= 1:\\n raise ValueError(\\\"Query length must be longer than one\\\")\\n\\n ts = ts.astype(\\\"float\\\")\\n # Add zero to the beginning of the cumsum of ts\\n s = np.insert(np.cumsum(ts), 0, 0)\\n # Add zero to the beginning of the cumsum of ts ** 2\\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\\n seg_sum = s[m:] - s[:-m]\\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\\n return np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)\",\n \"def average(self, times=2):\\n for i in range(times):\\n self.statistics()\\n global t, avlist\\n length = len(t)\\n avlist.append(t)\\n t = []\\n\\n total_list = []\\n\\n for l in range(length):\\n total_list.append([])\\n\\n for j in range(times):\\n \\\"\\\"\\\"per time\\\"\\\"\\\"\\n for i in range(length):\\n total_list[i].append(avlist[j][i])\\n\\n \\\"\\\"\\\"calculate\\\"\\\"\\\"\\n ylist = []\\n avlist = []\\n for a in total_list:\\n avg = 0\\n for b in a:\\n avg += b\\n ylist.append(avg/times)\\n self.listy = ylist\\n\\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\\n self.listx.append(e)\",\n \"def moments2nd(data):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol)) \\n rowgrid = rowgrid - rowmean # centered\\n colgrid = colgrid - colmean\\n Mrr = np.sum(rowgrid**2*data)/Isum\\n Mcc = np.sum(colgrid**2*data)/Isum\\n Mrc = np.sum(np.outer(rowgrid,colgrid)*data)/Isum \\n return Mcc, Mrr, Mrc\",\n \"def time_average(self, time_since_out, time_step):\\n\\n for variable in self._energy_state:\\n bar_variable = \\\"{}_bar\\\".format(variable)\\n bar_value = getattr(self, bar_variable)\\n ta = time_average(bar_value, time_since_out,\\n getattr(self, variable), time_step)\\n setattr(self, bar_variable, ta)\\n\\n self.E_s_sum += self.E_s\\n self.melt_sum += self.melt\\n self.swi_sum += self.swi\",\n \"def get_MSMC_results(filename, name):\\n lines = []\\n with open(filename, \\\"r\\\") as f:\\n for line in f:\\n lines.append(line)\\n time = [v.split('\\\\t')[1] for v in lines]\\n time = [float(v) for v in time[1:]]\\n IICR_k = [v.split('\\\\t')[3] for v in lines]\\n IICR_k = [float(v) for v in IICR_k[1:]]\\n\\n return {'name': name, 'model':'msmc', 'x_vector' : time, 'y_vector': IICR_k}\",\n \"def average(self):\\n if self._average is None: # only first time\\n self._average = self._obj.mean(dim='t')\\n self._average.attrs = self._obj.attrs # we need units in quiver\\n\\n return self._average\",\n \"def current_mean(self):\\r\\n values = self._timings\\r\\n return np.mean(values)\",\n \"def computeMSD2(trajectory, t_step): \\n assert t_step > 0, 'timestep should be positive'\\n assert len(trajectory.index) > 0, 'not enough points'\\n \\n delays = trajectory.index.copy()\\n shifts = np.floor(delays/t_step).astype(np.int)\\n msds = np.zeros(shifts.size)\\n\\n for i, shift in enumerate(shifts):\\n diffs = trajectory - trajectory.shift(-shift)\\n sqdist = np.square(diffs)\\n msds[i] = sqdist.mean()\\n\\n return delays, msds\",\n \"def av(self, data):\\n ts_ = self.ts(data)\\n if 'year' not in ts_.coords:\\n return ts_\\n return ts_.mean('year')\",\n \"def get_vwmacd(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.VW_MACD(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def avgtr(self):\\n return np.diff(self.trtimes).mean()\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def _compute_mean(self, C, mag, rjb, rake):\\n mean = (C['a1'] +\\n self._compute_linear_magnitude_term(C, mag) +\\n self._compute_quadratic_magnitude_term(C, mag) +\\n self._compute_logarithmic_distance_term(C, mag, rjb) +\\n self._compute_faulting_style_term(C, rake))\\n\\n return mean\",\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def mc2ms(mc,eta):\\n root = np.sqrt(0.25-eta)\\n fraction = (0.5+root) / (0.5-root)\\n invfraction = 1/fraction\\n\\n m2= mc * np.power((1+fraction),0.2) / np.power(fraction,0.6)\\n\\n m1= mc* np.power(1+invfraction,0.2) / np.power(invfraction,0.6)\\n return (m1,m2)\",\n \"def dt_avg(self, print_output=True, output_file = \\\"dt.csv\\\"):\\t\\n\\n\\t\\tavg = self.dt.mean(axis=2)\\n\\t\\tif print_output: np.savetxt(output_file, avg, delimiter = \\\",\\\")\\n\\t\\treturn avg\",\n \"def avg(ev):\\n profData = getProfilingData(ev)\\n if profData is not None:\\n return profData.Tavg()\\n return \\\"\\\"\",\n \"def mv_to_typee(mv):\\n tab1 = [\\n 0.0000000E+00,\\n 1.6977288E+01,\\n -4.3514970E-01,\\n -1.5859697E-01,\\n -9.2502871E-02,\\n -2.6084314E-02,\\n -4.1360199E-03,\\n -3.4034030E-04,\\n -1.1564890E-05,\\n 0.0000000E+00,\\n ]\\n\\n tab2 = [\\n 0.0000000E+00,\\n 1.7057035E+01,\\n -2.3301759E-01,\\n 6.5435585E-03,\\n -7.3562749E-05,\\n -1.7896001E-06,\\n 8.4036165E-08,\\n -1.3735879E-09,\\n 1.0629823E-11,\\n -3.2447087E-14,\\n ]\\n\\n if -8.825 <= mv <= 0.0:\\n c = tab1\\n elif 0.0 < mv <= 76.373:\\n c = tab2\\n else:\\n raise ValueError(\\\"Voltage specified is out of range for Type E thermocouple\\\")\\n\\n t = 0.0\\n for p in range(0, len(c)):\\n t += c[p] * math.pow(mv, p)\\n return t\",\n \"def average_seconds(data, board):\\n return str(\\n timedelta(seconds=mean(data[board]))\\n ).split(\\\".\\\")[0]\",\n \"def time_then_chan_avg(inms, tbin, chanbin, outms=\\\"\\\", zaptemp=True,\\n zaporig=False, chanselstr=\\\"\\\", datacolstr='corrected'):\\n casalog.origin('time_then_chan_avg')\\n inms_root = inms.rpartition(\\\".ms\\\")[0]\\n if not inms_root:\\n inms_root = inms\\n inms_root = os.path.basename(inms_root) # Keep outms in local directory.\\n troot = inms_root + '_' + chanselstr + \\\"_timebin\\\" + tbin\\n tms = troot + \\\".ms\\\"\\n\\n funnyshapes = False\\n \\n try:\\n # Do time averaging.\\n if (chanselstr.find(':') > -1) and ((chanselstr.find(',') > -1) or\\n (chanselstr.find(';') > -1)):\\n funnyshapes = True\\n\\n ## print 'tbin =', tbin\\n ## print 'tavspw =', chanselstr\\n ## print 'tavdc =', datacolstr\\n ## print 'inms =', inms\\n casalog.post(\\\"Time averaging to \\\" + tms)\\n split(vis=inms, outputvis=tms, timebin=tbin, spw=chanselstr,\\n datacolumn=datacolstr)\\n ms.open(tms)\\n nrows_aft_tavg = ms.nrow()\\n ms.close()\\n except Exception, e:\\n casalog.post(\\n\\\"\\\"\\\"Error from split(vis='%s', outputvis='%s',\\n timebin='%s', spw='%s', datacolumn='%s').\\\"\\\"\\\" % (inms, tms,\\n tbin,\\n chanselstr,\\n datacolstr),\\n 'SEVERE')\\n if os.path.isdir(tms):\\n casalog.post(\\\"\\\\t%s has been left on disk for your inspection.\\\" % tms,\\n 'SEVERE')\\n raise e\\n\\n if outms == \\\"\\\":\\n outms = \\\"%s_width%d.ms\\\" % (troot, chanbin)\\n try:\\n # Do channel averaging.\\n casalog.post(\\\"Channel averaging to \\\" + outms)\\n if datacolstr.lower() not in ['all', 'float_data', 'lag_data']:\\n datacolstr = 'data'\\n split(vis=tms, outputvis=outms, datacolumn=datacolstr, width=chanbin)\\n tb.open(outms)\\n if funnyshapes:\\n dat = tb.getvarcol('DATA')\\n nrows_aft_cavg = len(dat)\\n shape_aft_cavg = set([d.shape for d in dat.itervalues()])\\n else:\\n dat = tb.getcol('DATA')\\n shape_aft_cavg = dat.shape\\n nrows_aft_cavg = shape_aft_cavg[-1]\\n tb.close()\\n except Exception, e:\\n casalog.post(\\n\\\"\\\"\\\"Error from split(vis='%s', outputvis='%s',\\n datacolumn='data', width=%d, spw='%s').\\\"\\\"\\\" % (tms, outms,\\n chanbin,\\n chanselstr),\\n 'SEVERE')\\n raise e\\n if zaptemp:\\n shutil.rmtree(tms)\\n if zaporig:\\n casalog.post(\\\"Following your instruction to shutil.rmtree(\\\" + inms + \\\")\\\", 'WARN')\\n shutil.rmtree(inms)\\n return nrows_aft_tavg, nrows_aft_cavg, shape_aft_cavg\",\n \"def calccalmean(self,blk):\\n calind=self.getcalind(blk)\\n x=self.spec[calind,:]\\n return np.nanmean(x,axis=0)\",\n \"def get_average_for_month_at_time(self, month, hour, minute, weekend):\\n\\t\\tif weekend:\\n\\t\\t\\treturn self.averages_weekend[month][self.get_list_id(hour, minute)]\\n\\t\\telse:\\n\\t\\t\\treturn self.averages_weekday[month][self.get_list_id(hour, minute)]\",\n \"def average(self, returns):\\r\\n return returns.mean() * self.day\",\n \"def kinetic_energy(v, Mm=1.):\\n speed_squared = v[:, 0] ** 2 + v[:, 1] ** 2\\n # timeit.timeit('vt[:,0]**2+vt[:,1]**2', setup='import numpy as np; vt = np.random.rand(10000,2)', number=1000)\\n KE = 0.5 * sum(Mm * speed_squared)\\n return KE\",\n \"def average_tod(self,d,feed_tod,feed_weights,mask): \\n\\n frequency = d['level1/spectrometer/frequency'][...]\\n # This becomes (nBands, 64) \\n self.frequency = np.mean(np.reshape(frequency,(frequency.shape[0],frequency.shape[1]//16,16)) ,axis=-1)\\n all_tod = np.zeros((8, feed_tod.shape[-1]))\\n all_weights=np.zeros((8, feed_tod.shape[-1]))\\n all_frequency=np.zeros((8))\\n for ichan, (flow,fhigh) in enumerate(zip(np.arange(8)+26,np.arange(8)+27)):\\n sel = ((self.frequency >= flow) & (self.frequency < fhigh))\\n top = np.sum(feed_tod[sel,:]*feed_weights[sel,:],axis=0)\\n bot = np.sum(feed_weights[sel,:],axis=0)\\n all_tod[ichan,:] = top/bot\\n all_weights[ichan,:] = bot\\n all_frequency[ichan] = (fhigh+flow)/2.\\n \\n diff = all_tod[:,mask]\\n N = int(diff.shape[1]//2*2)\\n diff = (diff[:,:N:2]-diff[:,1:N:2])\\n auto = stats.MAD(diff.T)\\n\\n amean_rms = np.sqrt(1./np.nanmedian(all_weights[:,mask],axis=1))\\n\\n # Add the weighted average uncertainties to the auto-rms uncertainties\\n all_weights = 1./(1./all_weights + auto[:,None]**2)\\n\\n return all_tod, all_weights, auto, all_frequency\",\n \"def get_mean(self):\\n mean = np.array(np.zeros((4,8)))\\n for i,c in enumerate(self.cellLines):\\n for j,l in enumerate(self.ligands):\\n mean[i][j] = self.aucs[c][l]['mean']\\n return mean\",\n \"def getMeanRMS (self,arr):\\n print \\\"You are trying get mean rms for a gaussian error with catastrophic errorbar.\\\"\\n print \\\"I refuse to do so, but feel free to give me hard time about it\\\"\\n raise NotImplementedError\",\n \"def dt_avg(self, print_output=True, output_file = \\\"dt_query.csv\\\"):\\t\\n\\n\\t\\tavg = self.dt.mean(axis=2)\\n\\t\\tif print_output: np.savetxt(output_file, avg, delimiter = \\\",\\\")\\n\\t\\treturn avg\",\n \"def reduce2levlat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def _calc_time(time_lines: list) -> np.ndarray:\\n time = [time_to_fraction_hour(line.split()[1]) for line in time_lines]\\n return np.array(time)\",\n \"def get_center_of_masses(self) -> np.array:\\n com = np.average(self.obj[:, :2], weights=self.obj[:, 2], axis=0)\\n return com\",\n \"def get_video_average(video_path):\\n vidcap = cv2.VideoCapture(video_path)\\n\\n width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n num_color_channels = 3\\n\\n avg_frame = np.zeros((height, width, num_color_channels), dtype=np.float64)\\n frames = 0\\n\\n while True:\\n success, img = vidcap.read()\\n if not success:\\n break\\n avg_frame += img\\n frames += 1\\n\\n avg_frame = avg_frame / frames\\n ####avg_frame = cv2.cvtColor(avg_frame, cv2.COLOR_BGR2RGB)\\n avg_frame = avg_frame.astype(np.uint8)\\n cv2.imwrite(\\\"average_frame.png\\\", avg_frame)\",\n \"def obtain_monthly_mean(data=pd.DataFrame()):\\n return data.resample(\\\"MS\\\").mean()\",\n \"def avg_ttm_2y(df):\\n return 0.5 * (df + df.shift(4))\",\n \"def calculateAverage(self): \\n if not self.lastTransferAverage: \\n size=[0,0,0,0]\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n size[i]=self.lastNbrSamplesPerSeg\\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\\n nbrSamp=self.lastNbrSamplesPerSeg\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n nbrSeg=self.lastNbrSegmentsArray[i]\\n for j in range (0,nbrSamp):\\n for k in range(0,nbrSeg): \\n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\\n self.lastAverageArray[i][j]/=nbrSeg\\n self.lastAverageCalculated=True\\n else: print \\\"NOn averaged data are not available\\\"\",\n \"def generate_observed_mdv(self):\\n id_array = []\\n ratio_array = []\\n std_array = []\\n use_array = []\\n raw_data_array = []\\n for time in sorted(self.mdvtc.keys()):\\n ids, mdv_exp_original, mdv_std_original, mdv_use, target_emu_list, rawdata = self.mdvtc[time].generate_observed_mdv()\\n id_array.extend(ids)\\n ratio_array.extend(mdv_exp_original)\\n std_array.extend(mdv_std_original)\\n use_array.extend(mdv_use)\\n raw_data_array.extend(rawdata)\\n\\n\\n return id_array, numpy.array(ratio_array), numpy.array(std_array), use_array, target_emu_list, raw_data_array\",\n \"def calc_mse(data, ax=0):\\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)\",\n \"def Moving_Average_System(signal,M = 10):\\t\\t\\t\\t\\t\\t\\t\\t# Function of Moving Average System using Ideal Delay System\\n\\tp,q,s = M,signal.shape[0]- M,signal.shape[0]\\n\\tsignal_new = np.zeros(s+M)\\n\\t\\n\\tfor i in range(M+1):\\n\\t\\tsignal_new[M-i:M-i+s] += Signal_Ideal_Delay(signal,d=i)[0]\\n\\t\\t\\n\\tsignal_new = signal_new/(M + 1)\\t\\t\\n\\ttime = np.arange(0,s+M)\\n\\t\\n\\treturn signal_new,time\",\n \"def calculate_mean_vec(self,matrix1):\\n mean_vec = []\\n matrix_transposed = matrix1.T\\n for t in matrix_transposed:\\n mean_vec.append(np.mean(t))\\n return mean_vec\",\n \"def calc_10M_average(self, inputs):\\n self.Vm_sum += self.getAtt('Vm', inputs)\\n if self.time % 10 == 0:\\n if self.time == 0:\\n average = self.Vm_sum / 2\\n else:\\n average = self.Vm_sum / 10\\n self.Vm_10M_average = average\\n self.Vm_sum = 0.0\",\n \"def reprojection_error_mean(*args, **kwargs):\\n return np.mean(reprojection_error_vector(*args, **kwargs))\",\n \"def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n if levAxis(mv) is None: return None\\n if latAxis(mv) is None: return None\\n axes = allAxes( mv )\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n\\n axis_names = [ a.id for a in axes if a.id!='lev' and a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def vel2acc(timeseries, dt):\\n return np.diff(np.hstack(([0], timeseries)) * (1.0 / dt))\",\n \"def rtt_avg_ms(self):\\n\\n return represent_seconds_in_milliseconds(self.__rtt_avg)\",\n \"def computeMACD(x, slow=26, fast=12):\\n emaslow = ExpMovingAverage(x, slow)\\n emafast = ExpMovingAverage(x, fast)\\n return emaslow, emafast, emafast - emaslow\",\n \"def timeseriesCVscore(self, params):\\n errors = []\\n\\n # values = series.values\\n values = self.train_ts\\n self.alpha, self.beta, self.gamma = params\\n\\n # set the number of folds for cross-validation\\n tscv = TimeSeriesSplit(n_splits=3)\\n\\n # iterating over folds, train model on each, forecast and calculate error\\n for train, test in tscv.split(values):\\n\\n self.train = values[train]\\n self.test = values[test]\\n self.triple_exponential_smoothing()\\n predictions = self.result[-len(self.test) :]\\n actual = values[test]\\n error = mape(list(actual), predictions)\\n errors.append(error)\\n\\n # print \\\"error: \\\"\\n # print errors\\n return np.mean(np.array(errors))\",\n \"def mean_std_ci(measures, mul=1., tex=False):\\n measures = np.array(measures)*mul\\n ms = np.mean(measures), np.std(measures), half_int(measures)\\n return ms if not tex else r\\\"${:.2f} \\\\pm {:.2f}$\\\".format(ms[0], ms[2])\",\n \"def average_dnu(self):\\n\\n freqs = self.star.ds.mode_id['f0'].as_matrix()\\n f1 = freqs[1:]\\n f2 = freqs[:-1]\\n diff = f1-f2\\n self.dnu = np.mean(diff)\",\n \"def sma(ohlcv, period=10, ohlcv_series=\\\"close\\\"):\\n _ohlcv = ohlcv[[ohlcv_series]].copy(deep=True)\\n indicator_values = _ohlcv[ohlcv_series].rolling(window=period, min_periods=period).mean()\\n\\n return indicator_values\",\n \"def compute_MAE(e):\\n\\n return np.mean(np.abs(e))\",\n \"def get_averaged_ms(ms_name, tbin=None, cbin=None, chunks=None, taql_where='',\\n columns=None, chan=None, corr=None, data_col=None,\\n group_cols=None, iter_axis=None):\\n\\n if chunks is None:\\n chunks = dict(row=10000)\\n\\n # these are the defaults in averager\\n if tbin is None:\\n tbin = 1\\n if cbin is None:\\n cbin = 1\\n\\n # ensure that these are in the selected columns\\n for _ in [\\\"TIME\\\", \\\"ANTENNA1\\\", \\\"ANTENNA2\\\", \\\"INTERVAL\\\", \\\"FLAG\\\", \\\"FLAG_ROW\\\", data_col]:\\n if _ not in columns:\\n columns.append(_)\\n\\n # must be grouped this way because of time averaging\\n ms_obj = xm.xds_from_ms(ms_name,\\n group_cols=[\\\"DATA_DESC_ID\\\",\\n \\\"FIELD_ID\\\", \\\"SCAN_NUMBER\\\"],\\n columns=columns,\\n taql_where=taql_where)\\n\\n # some channels have been selected\\n # corr selection is performed after averaging!!\\n if chan is not None:\\n ms_obj = [_.sel(chan=chan) for _ in ms_obj]\\n\\n logger.info(\\\"Averaging MAIN table\\\")\\n\\n # perform averaging to the MS\\n avg_mss = average_main(main_ds=ms_obj, time_bin_secs=tbin,\\n chan_bin_size=cbin, group_row_chunks=100000,\\n respect_flag_row=False, sel_cols=columns,\\n viscolumn=data_col)\\n n_ams = len(avg_mss)\\n\\n # writes_ms = xm.xds_to_table(avg_mss, \\\"tesxt\\\", \\\"ALL\\\")\\n logger.info(\\\"Creating averaged xarray Dataset\\\")\\n\\n x_datasets = []\\n for _a, ams in enumerate(avg_mss):\\n ams = ams.compute()\\n logger.info(f\\\"Averaging {_a+1} / {n_ams}\\\")\\n\\n datas = {k: (v.dims, v.data, v.attrs)\\n for k, v in ams.data_vars.items() if k != \\\"FLAG_CATEGORY\\\"}\\n\\n new_ds = xr.Dataset(datas, attrs=ams.attrs, coords=ams.coords)\\n new_ds = new_ds.chunk(chunks)\\n\\n x_datasets.append(new_ds)\\n\\n # data will always be grouped by SPW unless iterating over antenna\\n # the most amount of grouping that will occur will be between to columns\\n all_grps = []\\n\\n if len(group_cols) == 0:\\n # return a single dataset\\n subs = xr.combine_nested(x_datasets, concat_dim=\\\"row\\\",\\n compat=\\\"no_conflicts\\\", data_vars=\\\"all\\\",\\n coords=\\\"different\\\", join=\\\"outer\\\")\\n subs.attrs = {}\\n subs = subs.chunk(chunks)\\n all_grps.append(subs)\\n\\n elif (set(group_cols) <= {\\\"DATA_DESC_ID\\\", \\\"ANTENNA1\\\", \\\"ANTENNA2\\\"} or\\n iter_axis == \\\"antenna\\\"):\\n uniques = np.unique([_.attrs[\\\"DATA_DESC_ID\\\"] for _ in x_datasets])\\n uants = np.arange(vu.get_antennas(ms_name).size)\\n\\n for _d in uniques:\\n subs = []\\n for _ in x_datasets:\\n if _.attrs[\\\"DATA_DESC_ID\\\"] == _d:\\n subs.append(_)\\n subs = xr.combine_nested(subs, concat_dim=\\\"row\\\",\\n compat=\\\"no_conflicts\\\", data_vars=\\\"all\\\",\\n coords=\\\"different\\\", join=\\\"outer\\\")\\n subs.attrs = {\\\"DATA_DESC_ID\\\": _d}\\n subs = subs.chunk(chunks)\\n\\n if {\\\"ANTENNA1\\\", \\\"ANTENNA2\\\"} <= set(group_cols):\\n u_bl = combinations(uants, 2)\\n for p, q in u_bl:\\n n_subs = subs.where((subs.ANTENNA1 == p) &\\n (subs.ANTENNA2 == q), drop=True)\\n n_subs.attrs = {\\\"DATA_DESC_ID\\\": _d,\\n \\\"ANTENNA1\\\": p,\\n \\\"ANTENNA2\\\": q}\\n all_grps.append(n_subs)\\n elif \\\"ANTENNA1\\\" in group_cols:\\n for p in uants[:-1]:\\n n_subs = subs.where((subs.ANTENNA1 == p), drop=True)\\n n_subs.attrs = {\\\"DATA_DESC_ID\\\": _d,\\n \\\"ANTENNA1\\\": p}\\n all_grps.append(n_subs)\\n elif \\\"ANTENNA2\\\" in group_cols:\\n for q in uants[:-1] + 1:\\n n_subs = subs.where((subs.ANTENNA2 == q), drop=True)\\n n_subs.attrs = {\\\"DATA_DESC_ID\\\": _d,\\n \\\"ANTENNA2\\\": q}\\n all_grps.append(n_subs)\\n elif iter_axis == \\\"antenna\\\":\\n for p in uants:\\n n_subs = subs.where((subs.ANTENNA1 == p) |\\n (subs.ANTENNA2 == p), drop=True)\\n n_subs.attrs = {\\\"DATA_DESC_ID\\\": _d,\\n \\\"ANTENNA\\\": p}\\n all_grps.append(n_subs)\\n else:\\n all_grps.append(subs)\\n\\n elif set(group_cols) <= {\\\"DATA_DESC_ID\\\", \\\"FIELD_ID\\\", \\\"SCAN_NUMBER\\\"}:\\n grps = {}\\n # must be ddid + something else\\n # if it is something other than fid and scan e.g\\n # by default group by ddid\\n for grp in group_cols:\\n uniques = np.unique([_.attrs[grp] for _ in x_datasets])\\n grps[grp] = uniques\\n # grps.append(uniques)\\n for com in product(*grps.values()):\\n subs = []\\n natt = {k: v for k, v in zip(group_cols, com)}\\n for _ in x_datasets:\\n if set(natt.items()) <= set(_.attrs.items()):\\n subs.append(_)\\n subs = xr.combine_nested(subs, concat_dim=\\\"row\\\",\\n compat=\\\"no_conflicts\\\",\\n data_vars=\\\"all\\\", coords=\\\"different\\\",\\n join=\\\"outer\\\")\\n subs.attrs = natt\\n subs = subs.chunk(chunks)\\n all_grps.append(subs)\\n\\n # select a corr\\n if corr is not None:\\n all_grps = [_.sel(corr=corr) for _ in all_grps]\\n\\n logger.info(\\\"Averaging completed.\\\")\\n\\n return all_grps\",\n \"def mae(t, y):\\n\\treturn mean_absolute_error(t, y)\",\n \"def computeMACD(x, slow=26, fast=12):\\n emaslow = ExpMovingAverage(x, slow)\\n emafast = ExpMovingAverage(x, fast)\\n return (emaslow, emafast, emafast - emaslow)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58772254","0.569831","0.54306823","0.5339006","0.52570695","0.5178657","0.51458687","0.5114982","0.5073207","0.50591934","0.50121516","0.5010453","0.50002575","0.49653572","0.49469918","0.492515","0.492515","0.48782063","0.48579815","0.4835696","0.4835382","0.48226145","0.47899503","0.47412407","0.47096846","0.4691531","0.4691113","0.46892732","0.4682321","0.46681687","0.4660122","0.46382344","0.46093825","0.46066567","0.45924038","0.45674694","0.45646322","0.4563634","0.45574805","0.45547065","0.45509997","0.4545081","0.45444822","0.45444822","0.45444822","0.45426983","0.4538548","0.4528135","0.45176283","0.45117956","0.45037833","0.45013955","0.44909564","0.44816965","0.44725326","0.44642347","0.4458679","0.44574112","0.44534624","0.4444328","0.44396958","0.44344458","0.4433403","0.4432573","0.44291916","0.44237715","0.44160903","0.44146496","0.44124278","0.4410481","0.44057208","0.4404182","0.44027057","0.4396565","0.43856153","0.43681335","0.43669993","0.436548","0.43588737","0.43501583","0.43481258","0.43454906","0.4343072","0.4341062","0.43407863","0.43391287","0.43370768","0.43359178","0.43277562","0.4324292","0.4324069","0.43201438","0.43199864","0.4319653","0.43159026","0.4311064","0.43106893","0.4310102","0.43085095","0.43077785"],"string":"[\n \"0.58772254\",\n \"0.569831\",\n \"0.54306823\",\n \"0.5339006\",\n \"0.52570695\",\n \"0.5178657\",\n \"0.51458687\",\n \"0.5114982\",\n \"0.5073207\",\n \"0.50591934\",\n \"0.50121516\",\n \"0.5010453\",\n \"0.50002575\",\n \"0.49653572\",\n \"0.49469918\",\n \"0.492515\",\n \"0.492515\",\n \"0.48782063\",\n \"0.48579815\",\n \"0.4835696\",\n \"0.4835382\",\n \"0.48226145\",\n \"0.47899503\",\n \"0.47412407\",\n \"0.47096846\",\n \"0.4691531\",\n \"0.4691113\",\n \"0.46892732\",\n \"0.4682321\",\n \"0.46681687\",\n \"0.4660122\",\n \"0.46382344\",\n \"0.46093825\",\n \"0.46066567\",\n \"0.45924038\",\n \"0.45674694\",\n \"0.45646322\",\n \"0.4563634\",\n \"0.45574805\",\n \"0.45547065\",\n \"0.45509997\",\n \"0.4545081\",\n \"0.45444822\",\n \"0.45444822\",\n \"0.45444822\",\n \"0.45426983\",\n \"0.4538548\",\n \"0.4528135\",\n \"0.45176283\",\n \"0.45117956\",\n \"0.45037833\",\n \"0.45013955\",\n \"0.44909564\",\n \"0.44816965\",\n \"0.44725326\",\n \"0.44642347\",\n \"0.4458679\",\n \"0.44574112\",\n \"0.44534624\",\n \"0.4444328\",\n \"0.44396958\",\n \"0.44344458\",\n \"0.4433403\",\n \"0.4432573\",\n \"0.44291916\",\n \"0.44237715\",\n \"0.44160903\",\n \"0.44146496\",\n \"0.44124278\",\n \"0.4410481\",\n \"0.44057208\",\n \"0.4404182\",\n \"0.44027057\",\n \"0.4396565\",\n \"0.43856153\",\n \"0.43681335\",\n \"0.43669993\",\n \"0.436548\",\n \"0.43588737\",\n \"0.43501583\",\n \"0.43481258\",\n \"0.43454906\",\n \"0.4343072\",\n \"0.4341062\",\n \"0.43407863\",\n \"0.43391287\",\n \"0.43370768\",\n \"0.43359178\",\n \"0.43277562\",\n \"0.4324292\",\n \"0.4324069\",\n \"0.43201438\",\n \"0.43199864\",\n \"0.4319653\",\n \"0.43159026\",\n \"0.4311064\",\n \"0.43106893\",\n \"0.4310102\",\n \"0.43085095\",\n \"0.43077785\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5918535"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19889,"cells":{"query":{"kind":"string","value":"returns a TransientVariable containing the minimum and maximum values of all the variables provided as arguments"},"document":{"kind":"string","value":"def minmin_maxmax( *args ):\n rmin = min( [ mv.min() for mv in args ] )\n rmax = max( [ mv.max() for mv in args ] )\n rmv = cdms2.createVariable( [rmin,rmax] )\n return rmv"},"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 get_minimum():\n return [\n convert_variables([0.78547, 0.78547, 0.78547]),\n ]","def __minimum_remaining_values(self, unassigned_vars):\n min_var = None\n for var in unassigned_vars:\n if min_var is None:\n min_var = var\n elif len(var.domain) < len(min_var.domain):\n min_var = var\n return min_var","def variable_range(examples, var):\n if var[1] == 'd':\n range = set()\n for datum in examples:\n range.add(datum[var[0]])\n return range\n else:\n range_min, range_max = 0, 0\n for datum in examples:\n data_val = float(datum[var[0]])\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\n return (range_min, range_max)","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def xminmax ( self ) :\n return self.xvar.minmax()","def get_min_max_x(self, min_x = 1e9, max_x = -1e9, exclude = []): \n \n if self.verbose > 1:\n print(\"MultiLinearSpectra.get_min_max_x()\") \n \n for m in range(len(self.mess)):\n if m not in exclude and self.mess[m][\"class\"] not in exclude:\n min_x, max_x = self.mess[m][\"object\"].get_min_max_x(min_x, max_x)\n \n return min_x, max_x","def getMinMax(self,arr):\n # not implemented for Template SED yet\n return arr[\"z\"], arr[\"z\"]","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def min_values(self, lower, upper): \n if not self.lower_bounds is None:\n return self.lower_bounds\n\n minus = np.clip(self.coeffs,-math.inf,0)\n plus = np.clip(self.coeffs,0,math.inf)\n self.lower_bounds = plus.dot(lower) + minus.dot(upper) + self.const\n \n return self.lower_bounds","def get_min_max(ints):\n if len(ints) <= 0:\n return ()\n min_value = ints[0]\n max_value = ints[0]\n for i in range(len(ints)):\n temp = ints[i]\n if temp <= min_value:\n min_value = temp\n if temp >= max_value:\n max_value = temp\n output = (min_value, max_value)\n# print(\"output: \", output)\n return output\n pass","def _init_special_vars(self, T_start=None, T_end=None):\n self.min_energy = np.min(self.event_list_T[1][T_start:T_end])\n self.max_energy = np.max(self.event_list_T[1][T_start:T_end])\n self.min_time = np.min(self.event_list_T[0][T_start:T_end])\n self.max_time = np.max(self.event_list_T[0][T_start:T_end])","def min_max(xs):\n return min(xs), max(xs)","def get_min_max(ints):\r\n if len(ints) == 0:\r\n return None\r\n max = ints[0]\r\n min = ints[0]\r\n\r\n for int in ints:\r\n if int < min:\r\n min = int\r\n if int > max:\r\n max = int\r\n \r\n return min, max","def min_max(self, data, era):\n return 0, np.max(data)","def get_minmax_stats(dataframe, variable):\n\n print(\"Maximum value of \", variable, \"is: \", dataframe[variable].max())\n print(\"Minimum value of \", variable, \"is: \", dataframe[variable].min())","def get_minmax(self, stmt, slist):\n minel = maxel = None\n for s in slist:\n if s.keyword == \"min-elements\":\n minel = s.arg\n elif s.keyword == \"max-elements\":\n maxel = s.arg\n if minel is None:\n minst = stmt.search_one(\"min_elements\")\n if minst:\n minel = minst.arg\n else:\n minel = \"0\"\n if maxel is None:\n maxst = stmt.search_one(\"max_elements\")\n if maxst:\n maxel = maxst.arg\n return (minel, maxel)","def get_min_max(ints):\n if not ints:\n return None, None\n if len(ints) ==None:\n return None\n min_val = float(\"inf\")\n max_val = -float(\"inf\")\n # for each int in ints if update max_val and min_val accordingly\n for integer in ints:\n if integer > max_val:\n max_val = integer\n\n if integer < min_val:\n min_val = integer\n \n return (min_val, max_val)","def define_variables(m):\r\n\r\n # Non-negative candidate capacity\r\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Solar build limits\r\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Wind build limits\r\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage build limits\r\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\r\n\r\n # Min power output (all generators excluding storage units)\r\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing thermal\r\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate thermal\r\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing wind\r\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate wind\r\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - existing solar\r\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - candidate solar\r\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max power output - hydro\r\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min charging power - storage units\r\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min discharging power - storage_units\r\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - existing storage\r\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max charging power - candidate storage\r\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - existing storage\r\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max discharging power - candidate storage\r\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - storage units\r\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - existing storage units\r\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - candidate storage\r\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min energy - interval end\r\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Max energy - interval end\r\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate up (thermal and hydro generators)\r\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Ramp-rate down (thermal and hydro generators)\r\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Non-negative lost load power\r\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Min powerflow\r\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Max powerflow\r\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\r\n\r\n # Storage energy transition\r\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\r\n\r\n # Power balance (locational marginal price)\r\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\r\n\r\n return m","def zminmax ( self ) :\n return self.zvar.minmax()","def vmnmx ( self , var , vmin , vmax ) :\n if var.xminmax() :\n vmn , vmx = var.xminmax ()\n if is_good_number ( vmin ) : vmin = max ( vmin , vmn )\n else : vmin = vmn\n if is_good_number ( vmax ) : vmax = min ( vmax , vmx )\n else : vmax = vmx\n\n assert is_good_number ( vmin ), 'Invalid type of ``min'' %s/%s' % ( vmin , type ( vmin ) )\n assert is_good_number ( vmax ), 'Invalid type of ``max'' %s/%s' % ( vmin , type ( vmin ) )\n assert vmin < vmax, 'Invalid min/max range: %s/%s' % ( vmin , vmax )\n \n return vmin , vmax","def _full_value_range(self):\n min_value, max_value = self._raw_data.data_range\n return max_value - min_value","def minMaxFonc(liste):\n\n return min(liste), max(liste)","def __init__(__self__, *,\n max: pulumi.Input[int],\n min: pulumi.Input[int]):\n pulumi.set(__self__, \"max\", max)\n pulumi.set(__self__, \"min\", min)","def __init__(__self__, *,\n max: pulumi.Input[int],\n min: pulumi.Input[int]):\n pulumi.set(__self__, \"max\", max)\n pulumi.set(__self__, \"min\", min)","def get_variables(self):\n return [self.g_t, self.m_t]","def min_max(items):\n return min(items), max(items)","def get_range(self, field, deep=False, axis=None):\n variables = list(self.vars(deep, with_name=field))\n\n if not variables:\n raise KeyError(\"No variable named '%s' was found!\" % field)\n\n start = [np.nanmin(self[var], axis).item(0) for var in variables]\n end = [np.nanmax(self[var], axis).item(0) for var in variables]\n return min(start), max(end)","def __init__(self, min: float, max: float):\n super().__init__()\n\n # store input parameters\n self.min = min\n self.max = max","def get_state_observed_min(self):\n minValues = numpy.zeros(self.get_num_variables())\n i = 0\n for v in self.variables:\n minValues[i] = v.get_min_value()\n i += 1\n return minValues","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units} )\n return latmv","def minmax(self):\r\n vx = [v[0] for v in self.vl]\r\n vy = [v[1] for v in self.vl]\r\n self.xmax, self.xmin = max(vx), min(vx)\r\n self.ymax, self.ymin = max(vy), min(vy)","def get_minmax(self):\n x_minmax = [np.min(self.grid['x']), np.max(self.grid['x'].max())]\n z_minmax = [np.min(self.grid['z']), np.max(self.grid['z'].max())]\n return x_minmax, z_minmax","def minmax ( self , nshoots = 100000 ) :\n ## try to get minmax directly from pdf/function \n if self.tricks and hasattr ( self.pdf , 'function' ) :\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \n f = self.pdf.function()\n if hasattr ( f , 'minmax' ) :\n try :\n mn , mx = f.minmax()\n if 0<= mn and mn <= mx and 0 < mx : \n return mn , mx\n except :\n pass\n if hasattr ( f , 'max' ) :\n try :\n mx = f.max()\n if 0 < mx : return 0 , mx\n except :\n pass\n\n ## check RooAbsReal functionality\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\n if 0 < code :\n mx = self.pdf.maxVal ( code )\n if 0 < mx : return 0 , mx\n \n ## not try to use random\n \n mn , mx = -1 , -10\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\n \n if not self.xminmax() : return ()\n if not self.yminmax() : return ()\n \n mn , mx = -1 , -10\n xmn , xmx = self.xminmax()\n ymn , ymx = self.yminmax()\n for i in range ( nshoots ) : \n xx = random.uniform ( xmn , xmx )\n yy = random.uniform ( ymn , ymx )\n with SETVAR ( self.xvar ) :\n with SETVAR ( self.yvar ) :\n self.xvar.setVal ( xx )\n self.yvar.setVal ( yy )\n vv = self.pdf.getVal()\n if mn < 0 or vv < mn : mn = vv\n if mx < 0 or vv > mx : mx = vv\n \n return mn , mx","def atvar(a,limits=None,inclusive=(1,1)):\r\n a = a.astype(N.float_)\r\n if limits == None or limits == [None,None]:\r\n return avar(a)\r\n assert type(limits) in [ListType,TupleType,N.ndarray], \"Wrong type for limits in atvar\"\r\n if inclusive[0]: lowerfcn = N.greater_equal\r\n else: lowerfcn = N.greater\r\n if inclusive[1]: upperfcn = N.less_equal\r\n else: upperfcn = N.less\r\n if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):\r\n raise ValueError, \"No array values within given limits (atvar).\"\r\n elif limits[0]==None and limits[1]<>None:\r\n mask = upperfcn(a,limits[1])\r\n elif limits[0]<>None and limits[1]==None:\r\n mask = lowerfcn(a,limits[0])\r\n elif limits[0]<>None and limits[1]<>None:\r\n mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])\r\n\r\n a = N.compress(mask,a) # squish out excluded values\r\n return avar(a)","def get_minx_maxx(self, normalized=True):\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\n\n for idx, feature_name in enumerate(self.continuous_feature_names):\n max_value = self.train_df[feature_name].max()\n min_value = self.train_df[feature_name].min()\n\n if normalized:\n minx[0][idx] = (self.permitted_range[feature_name]\n [0] - min_value) / (max_value - min_value)\n maxx[0][idx] = (self.permitted_range[feature_name]\n [1] - min_value) / (max_value - min_value)\n else:\n minx[0][idx] = self.permitted_range[feature_name][0]\n maxx[0][idx] = self.permitted_range[feature_name][1]\n return minx, maxx","def get_min_max(ints):\n if ints is None or len(ints) == 0:\n return None\n \n min_value = ints[0]\n max_value = ints[0]\n\n for value in ints:\n if value < min_value:\n min_value = value\n\n if value > max_value:\n max_value = value\n\n return (min_value, max_value)","def __init__(self, min_val, max_val):\n self.values = (min_val, max_val)","def __init__(self, min_val, max_val):\n self.values = (min_val, max_val)","def __init__(self, min_val, max_val):\n self.values = (min_val, max_val)","def __init__(self, min_val, max_val):\n self.values = (min_val, max_val)","def minmax(xs):\n min_val = None\n max_val = None\n for x in xs:\n if min_val is None or x < min_val:\n min_val = x\n if max_val is None or x > max_val:\n max_val = x\n return (min_val, max_val)","def local_max_to_min(node):\r\n if node.op == T.neg and node.inputs[0].owner:\r\n max = node.inputs[0]\r\n if (max.owner and\r\n isinstance(max.owner.op, CAReduce)\r\n and max.owner.op.scalar_op == scal.maximum):\r\n neg = max.owner.inputs[0]\r\n if neg.owner and neg.owner.op == T.neg:\r\n return [CAReduce(scal.minimum,\r\n max.owner.op.axis)(neg.owner.inputs[0])]\r\n\r\n return False","def get_parameters_min(self):\n minValues = numpy.zeros(self.get_num_parameters())\n i = 0\n for p in self.parameters:\n minValues[i] = p.get_min_value()\n i += 1\n return minValues","def findmaxmin(input_file):\n\tE_list = sub.check_output(\"check_maxmin.py {}\".format(input_file), shell=True).decode(\"utf-8\")\n\tEmax = float(re.search(r\"Maximum\\s*:\\s*(([+-]|\\s)\\d*\\.\\d+)\", E_list).group(1))\n\tEmin = float(re.search(r\"Minimum\\s*:\\s*(([+-]|\\s)\\d*\\.\\d+)\", E_list).group(1))\n\treturn Emax, Emin","def extreme_values(self, extreme):\n\n\t\tif extreme.lower() == 'min':\n\t\t\treturn data.min()\n\t\telif extreme.lower() == 'max':\n\t\t\treturn data.max()\n\t\telse:\n\t\t\tassert 'Invalid Parameter !'","def set_physical_minmax(self, min, max):\n # This allows you to set the min and the max of the quantity that you want the MLP to measure. \n # Once you set this, you can pass in a physical number to get_mlp_value() and it will be mapped to an MLP value and returned\n pass\n \n # Maybe we should let the holder of the MLP determine these values and do the mapping? ","def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units} )\n return lonmv","def parameters(self):\n temp = list(_flatten(self.params))\n temp_val = [self.check_domain(x.val, True) if isinstance(x, Variable) else x for x in temp]\n return _unflatten(temp_val, self.params)[0]","def max_values(self, lower, upper):\n if not self.upper_bounds is None:\n return self.upper_bounds\n\n minus = np.clip(self.coeffs,-math.inf,0)\n plus = np.clip(self.coeffs,0,math.inf)\n self.upper_bounds = plus.dot(upper) + minus.dot(lower) + self.const\n \n return self.upper_bounds","def __findMinMaxVal(self, min_or_max, exp, var_names, val_table, up_sign=1):\n\n # numerical expression\n if isinstance(exp, ast.NumLitExp):\n return exp\n\n # string expression\n elif isinstance(exp, ast.StringLitExp):\n err(\n \"orio.module.ortil.transformation: OrTil: invalid string expression found in loop bound expression: %s\"\n % exp\n )\n\n # identifier expression\n elif isinstance(exp, ast.IdentExp):\n\n # do nothing if the identifier is not in the given list of variables to be replaced\n if exp.name not in var_names:\n return exp\n\n # replace the identifier with its apropriate value (depending on min/max, and upper sign)\n lval, uval = val_table[exp.name]\n if min_or_max == \"max\":\n if up_sign == 1:\n val = ast.ParenthExp(uval.replicate())\n else:\n val = ast.ParenthExp(lval.replicate())\n elif min_or_max == \"min\":\n if up_sign == 1:\n val = ast.ParenthExp(lval.replicate())\n else:\n val = ast.ParenthExp(uval.replicate())\n else:\n err(\n \"orio.module.ortil.transformation internal error: unrecognized min/max argument value\"\n )\n\n # return the obtained min/max value\n return val\n\n # array reference expression\n elif isinstance(exp, ast.ArrayRefExp):\n err(\n \"orio.module.ortil.transformation: invalid array-reference expression found in loop bound \"\n + \"expression: %s\" % exp\n )\n\n # function call expression\n elif isinstance(exp, ast.FunCallExp):\n\n # check the function name\n if (not isinstance(exp.exp, ast.IdentExp)) or exp.exp.name not in (\n \"min\",\n \"max\",\n ):\n err(\n (\n \"orio.module.ortil.transformation: function name found in loop bound expression must be \"\n + \"min/max, obtained: %s\"\n )\n % exp.exp\n )\n\n # recursion on each function argument\n exp.args = []\n for a in exp.args:\n exp.args.append(\n self.__findMinMaxVal(min_or_max, a, var_names, val_table, up_sign)\n )\n\n # return the computed expression\n return exp\n\n # unary operation expression\n elif isinstance(exp, ast.UnaryExp):\n\n # check the unary operation\n if exp.op_type not in (ast.UnaryExp.PLUS, ast.UnaryExp.MINUS):\n err(\n (\n \"orio.module.ortil.transformation: unary operation found in loop bound expression must \"\n + \"be +/-, obtained: %s\"\n )\n % exp.exp\n )\n\n # update the sign, and do recursion on the inner expression\n if exp.op_type == ast.UnaryExp.MINUS:\n up_sign *= -1\n exp.exp = self.__findMinMaxVal(\n min_or_max, exp.exp, var_names, val_table, up_sign\n )\n\n # return the computed expression\n return exp\n\n # binary operation expression\n elif isinstance(exp, ast.BinOpExp):\n\n # check the binary operation\n if exp.op_type not in (\n ast.BinOpExp.ADD,\n ast.BinOpExp.SUB,\n ast.BinOpExp.MUL,\n ):\n err(\n (\n \"orio.module.ortil.transformation: binary operation found in loop bound expression must \"\n + \"be +/-/*, obtained: %s\"\n )\n % exp\n )\n\n # do recursion on both operands\n exp.lhs = self.__findMinMaxVal(\n min_or_max, exp.lhs, var_names, val_table, up_sign\n )\n if exp.op_type == ast.BinOpExp.SUB:\n up_sign *= -1\n exp.rhs = self.__findMinMaxVal(\n min_or_max, exp.rhs, var_names, val_table, up_sign\n )\n\n # return the computed expression\n return exp\n\n # parenthesized expression\n elif isinstance(exp, ast.ParenthExp):\n parenth_before = isinstance(exp.exp, ast.ParenthExp)\n exp.exp = self.__findMinMaxVal(\n min_or_max, exp.exp, var_names, val_table, up_sign\n )\n parenth_after = isinstance(exp.exp, ast.ParenthExp)\n if (not parenth_before) and parenth_after:\n return exp.exp\n return exp\n\n # unrecognized expression\n else:\n err(\n \"orio.module.ortil.transformation internal error: unknown type of expression: %s\"\n % exp.__class__.__name__\n )","def __new__(cls, minx, miny, minz, maxx, maxy, maxz):\n # Coerce bounds to floats, and nones to infs\n kwargs = locals()\n for b, inf in zip(('min', 'max'),\n (-np.inf, np.inf)):\n for axis in 'xyz':\n bound = b + axis\n value = kwargs[bound]\n kwargs[bound] = inf if value is None else float(value)\n \n kwargs.pop('cls') # must be passed positionally\n return super(cls, cls).__new__(cls, **kwargs)","def calculate_avg_min_max(temps):\n\n temp_average = sum(temps) / len(temps)\n return temp_average, min(temps), max(temps)","def get_min_max(ints):\n if not ints:\n return\n max = ints[0]\n min = ints[0]\n\n\n for i in ints:\n if i > max:\n max = i\n if i < min:\n min = i\n return (min, max)","def __define_variable_time(self, initial_guess, minimum, maximum):\n i = 0\n for nlp in self.nlp:\n if isinstance(nlp[\"tf\"], self.CX):\n time_bounds = Bounds(minimum[i], maximum[i], interpolation=InterpolationType.CONSTANT)\n time_init = InitialConditions(initial_guess[i])\n Parameters._add_to_v(self, \"time\", 1, None, time_bounds, time_init, nlp[\"tf\"])\n i += 1","def apply_bound(x, var_min, var_max):\n x.position = np.maximum(x.position, var_min)\n x.position = np.minimum(x.position, var_max)","def _set_min_max_values(self):\n\n p_1, p_2 = self.points[0], self.points[1]\n nb_dim = len(p_1.values)\n self._min_values = []\n self._max_values = []\n for d in range(nb_dim):\n d_min = min(p_1[d], p_2[d])\n d_max = max(p_2[d], p_2[d])\n self._min_values.append(d_min)\n self._max_values.append(d_max)","def get_max_temp(self):\n self.max_temp = self.domain[1] * 2","def minMaxBoucle(liste):\n minimum = float(\"inf\")\n maximum = -float(\"inf\")\n\n for index in range(0, 5):\n liste[index] = int(liste[index])\n if liste[index] > maximum:\n maximum = liste[index]\n if liste[index] < minimum:\n minimum = liste[index]\n return minimum, maximum","def __init__(self, min: int, max: int):\n super().__init__()\n\n # store input parameters\n self.min = min\n self.max = max","def min_max_date(self, min, max, date):\n\t\tif not min or min > date:\n\t\t\tmin = date\n\n\t\tif not max or max < date:\n\t\t\tmax = date\n\n\t\treturn min, max","def get_min_max(ints):\n current_max = None\n current_min = None\n\n if (len(ints) == 0) or (ints is None):\n return tuple([current_min, current_max])\n\n for i, n in enumerate(ints):\n if i == 0:\n current_max = n\n current_min = n\n else:\n if n > current_max:\n current_max = n\n elif n < current_min:\n current_min = n\n\n return tuple([current_min, current_max])","def _get_extremes(self, attr='values'):\n # calculate the maximum and minimum for all series\n series_max = [0]\n series_min = [0]\n for s in self:\n if s is not None:\n series_max.append(s.max(attr))\n series_min.append(s.min(attr))\n return min(series_min), max(series_max)","def min_max(arr: StaticArray) -> ():\n minimum = arr.get(0) # sets min to first element\n maximum = arr.get(0) # sets max to first element\n # iterate over the elements in the array to check for < or >\n for index in range(arr.size()):\n if arr[index] < minimum: # if element is less than the current min, min = new element\n minimum = arr[index]\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\n maximum = arr[index]\n return minimum, maximum","def __init__(self, values=None, min_value=None, max_value=None):\n if values is not None:\n # If list if provided, use it to determine min and max values\n self.min = min(values)\n self.max = max(values)\n\n else:\n self.min = min_value\n self.max = max_value","def generate_var_ranges(self):\n\n var_ranges = {}\n for var in self.variables:\n min_to_max = list(range(int(var['min']), int(var['max']) + 1))\n if (var['zero_ok'] == False and 0 in min_to_max):\n min_to_max.remove(0)\n\n var_ranges[var['variable']] = min_to_max\n\n return var_ranges","def cpfclamp(f, min_, max_):\n return min(max(f, min_), max_)","def return_parameter_bounds(maximum_luminosity=20):\n return [(maximum_luminosity, maximum_luminosity + 3),\n (3 * 10 ** -4, 8 * 10 ** -3), (2., 350), (-8., -0.2),\n (-400, 400)]","def force_bounds(self):\n return self._min_force, self._max_force","def get_extremum(x):\n min_val = x.min()\n argmin = x.argmin()\n max_val = x.max()\n argmax = x.argmax()\n extremum = min_val\n argextremum = argmin\n if abs(min_val) < abs(max_val):\n extremum = max_val\n argextremum = argmax\n\n return extremum, argextremum","def view_limits(self, vmin, vmax):\n return vmin, vmax\n # return nonsingular(vmin, vmax)","def constrain(small, value, big):\n return min(max(value, small), big)","def _check_tmin_tmax(inst, tmin, tmax):\n _check_type(tmin, (None, \"numeric\"), item_name=\"tmin\")\n _check_type(tmax, (None, \"numeric\"), item_name=\"tmax\")\n\n # check positiveness for tmin, tmax\n for name, arg in ((\"tmin\", tmin), (\"tmax\", tmax)):\n if arg is None:\n continue\n if arg < 0:\n raise ValueError(\n f\"Argument '{name}' must be positive. \" f\"Provided '{arg}'.\"\n )\n # check tmax is shorter than instance\n if tmax is not None and inst.times[-1] < tmax:\n raise ValueError(\n \"Argument 'tmax' must be shorter than the instance \"\n f\"length. Provided: '{tmax}', larger than \"\n f\"{inst.times[-1]}s instance.\"\n )\n # check that tmax is larger than tmin\n if tmax is not None and tmin is not None and tmax <= tmin:\n raise ValueError(\n \"Argument 'tmax' must be strictly larger than 'tmin'. \"\n f\"Provided 'tmin' -> '{tmin}' and 'tmax' -> '{tmax}'.\"\n )\n # check that tmin is shorter than instance\n if tmin is not None and inst.times[-1] <= tmin:\n raise ValueError(\n \"Argument 'tmin' must be shorter than the instance \"\n f\"length. Provided: '{tmin}', larger than \"\n f\"{inst.times[-1]}s instance.\"\n )\n return tmin, tmax","def find_varying(params, nvmax):\n print('Finding variable parameters')\n if nvmax < 0:\n raise ValueError(f'nvmax ({nvmax}) must be positive')\n\n var = []\n cnt = 0\n for p in params:\n if len(params[p]) == 2:\n if (params[p][1] - params[p][0]) < 0:\n raise ValueError(f'range is inverted for param: {p}')\n elif cnt >= nvmax:\n raise ValueError(f'too many param ranges were given. Expected {nvmax}')\n else:\n var.append(p)\n cnt += 1\n return var","def yminmax ( self ) :\n return self.yvar.minmax()","def min_max(lst):\r\n my_min = None\r\n my_max = None\r\n for num in lst:\r\n if (my_min and my_max) is not None:\r\n # recalculate running min and max:\r\n if num < my_min:\r\n my_min = num\r\n continue\r\n if num > my_max:\r\n my_max = num\r\n else:\r\n my_min = num\r\n my_max = num\r\n ans = (my_min, my_max)\r\n return ans","def get_min_max(ints):\n if ints == None or len(ints) == 0:\n return None\n if len(ints) == 1:\n return (ints[0],ints[0])\n \n max = ints[0]\n min = ints[0]\n for i in range(1, len(ints)):\n if ints[i] > max:\n max = ints[i]\n if ints[i] < min:\n min = ints[i]\n return (min,max)","def get_min_max(self) -> tuple:\r\n\r\n minimum = float(\"inf\")\r\n maximum = float(\"-inf\")\r\n\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n for name, data in self.trees_data.items():\r\n if self.trees[name][\"point_helper\"] is None:\r\n mapping = self.trees[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n return minimum, maximum","def get_min_max(ints):\n\n if len(ints) == 0:\n return (None,None)\n min = ints[0]\n max = ints[0]\n for x in range(1,len(ints)):\n if ints[x] > max:\n max=ints[x]\n elif ints[x] < min:\n min = ints[x]\n return (min,max)","def initializeVariables(F_n):\n bounds = [(-100, 100), (-10, 10), (-100, 100), (-100, 100), (-30, 30),\n (-100, 100), (-1.28, 1.28), (-500, 500), (-5.12, 5.12),\n (-32, 32), (-600, 600), (-50, 50), (-50, 50)]\n\n if F_n == 8:\n objectiveValue = -12569.5\n else:\n objectiveValue = 1e-8\n\n (lower, upper) = bounds[F_n - 1]\n return (lower, upper, objectiveValue)","def input_bounds(self):\n return self._min_input, self._max_input","def __init__(self, valuesArray1, valuesArray2):\n\n self.valuesArray1 = np.array(valuesArray1).flatten()\n self.valuesArray2 = np.array(valuesArray2).flatten()\n\n self.min1 = self.valuesArray1.min()\n self.max1 = self.valuesArray1.max()\n self.min2 = self.valuesArray2.min()\n self.max2 = self.valuesArray2.max()","def subset_var(df, min_var, max_var, var):\n var_max = df[var] < max_var\n var_min = df[var] > min_var\n return df[var_min & var_max]","def get_min_max(self, groups, key):\n group = groups.get_group(key)\n min = group.loc[group[\"dif\"].idxmin()]\n max = group.loc[group[\"dif\"].idxmax()]\n minmax = {\"min\": min, \"max\": max}\n return minmax","def data_range(x):\n return max(x)-min(x)","def get_model_parameter_bounds():\n minf = float(\"-inf\")\n inf = float(\"inf\")\n params = dict(mu=(minf,inf), rho=(0.0 ,inf))\n return params","def state_limits(self) -> Tuple[torch.Tensor, torch.Tensor]:\n # define upper and lower limits based around the nominal equilibrium input\n upper_limit = torch.ones(self.n_dims)\n upper_limit[TurtleBot2D.X] = 2.0\n upper_limit[TurtleBot2D.Y] = 2.0\n upper_limit[TurtleBot2D.THETA] = 2 * np.pi\n\n lower_limit = -1.0 * upper_limit\n\n return (upper_limit, lower_limit)","def tenant(Cs):\n xs = [variable() for i in xrange(4)]\n constraints = []\n def _(blah):\n constraints.append(blah)\n for x in xs:\n _(geq(x, 0))\n _(leq(xs[0] + xs[1], Cs[0]))\n _(leq(xs[0], Cs[3]))\n _(leq(xs[1], Cs[4]))\n _(leq(xs[2], Cs[1]))\n _(leq(xs[3], Cs[2]))\n _(leq(xs[2] + xs[3], Cs[5]))\n\n p = program(maximize(U(xs)), constraints)\n config(p)\n #p.show()\n p.solve(quiet=True)\n\n return [x.value for x in xs]","def values(self):\n lower = float(self.lowerSpnbx.value())\n upper = float(self.upperSpnbx.value())\n return lower, upper","def set_period_limits(self): # function[Tmin, Tmax] = setTlim(obj)\n\n x_min = self.tf.minimum_period\n x_max = self.tf.maximum_period\n\n Tmin = 10 ** (np.floor(np.log10(x_min) * 2) / 2)\n if (np.log10(x_min) - np.log10(Tmin)) < 0.15:\n Tmin = 10 ** (np.log10(Tmin) - 0.3)\n\n Tmax = 10 ** (np.ceil(np.log10(x_max) * 2) / 2)\n if (np.log10(Tmax) - np.log10(x_max)) < 0.15:\n Tmax = 10 ** (np.log10(Tmax) + 0.3)\n return Tmin, Tmax","def min_max(my_list):\n print(\"Min = \",min(my_list,key = abs))\n print(\"Max = \",max(my_list,key = abs))","def standardize_x(\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\n):\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\n raise ValueError(\n \"Either *both* or *neither* of x_min, x_max need to be supplied!\"\n )\n if x_min is None:\n x_min = torch.min(x, 0)[0]\n x_max = torch.max(x, 0)[0]\n x = (x - x_min) / (x_max - x_min)\n return x, x_min, x_max","def min_max_id()->(int, int):\n stmt = sqlalchemy.select([sqlalchemy.func.min(_READING_TABLE.c.id), \n sqlalchemy.func.max(_READING_TABLE.c.id)]).select_from(_READING_TABLE)\n result = execute_command(stmt).fetchall()[0]\n return result[0], result[1]","def get_tmin_tmax(self, models: List[Model] = None) -> DataFrame:\n if models is None:\n models = self.models\n\n tmintmax = DataFrame(columns=[\"tmin\", \"tmax\"], dtype=\"datetime64[ns]\")\n for ml in models:\n tmintmax.loc[ml.name, [\"tmin\", \"tmax\"]] = [\n ml.get_tmin(),\n ml.get_tmax(),\n ]\n\n return tmintmax","def getValues(self):\n return [self.scale_min, self.scale_max]","def get_min_max(ints):\n print(f\"input arr is {ints}\")\n max=0\n min=len(ints)-1\n for i in range(1,len(ints)):\n if ints[i]>ints[max]:\n temp=ints[i]\n ints[i]=ints[max]\n ints[max]=temp\n if ints[i]<ints[min]:\n temp=ints[i]\n ints[i]=ints[min]\n ints[min]=temp\n #print(f\"max value is {ints[max]}\")\n #print(f\"min value is {ints[min]}\")\n return(ints[min],ints[max])","def get_variable(self, InSet_g, InSet_l, InSet_gx, InSet_lx, InSet_a, InSet_size,\n InSet_dim, InSet_area, InSet_c, BdSet_nlength, BdSet_nr, BdSet_nl, BdSet_ng):\n self.InSet_size = InSet_size\n self.InSet_dim = InSet_dim\n self.InSet_area = InSet_area\n self.BdSet_nlength = BdSet_nlength\n\n self.InSet_g = Parameter(\n Tensor(InSet_g, mstype.float32), name=\"InSet_g\", requires_grad=False)\n self.InSet_l = Parameter(\n Tensor(InSet_l, mstype.float32), name=\"InSet_l\", requires_grad=False)\n self.InSet_gx = Parameter(\n Tensor(InSet_gx, mstype.float32), name=\"InSet_gx\", requires_grad=False)\n self.InSet_lx = Parameter(\n Tensor(InSet_lx, mstype.float32), name=\"InSet_lx\", requires_grad=False)\n self.InSet_a = Parameter(\n Tensor(InSet_a, mstype.float32), name=\"InSet_a\", requires_grad=False)\n self.InSet_c = Parameter(\n Tensor(InSet_c, mstype.float32), name=\"InSet_c\", requires_grad=False)\n self.BdSet_nr = Parameter(\n Tensor(BdSet_nr, mstype.float32), name=\"BdSet_nr\", requires_grad=False)\n self.BdSet_nl = Parameter(\n Tensor(BdSet_nl, mstype.float32), name=\"BdSet_nl\", requires_grad=False)\n self.BdSet_ng = Parameter(\n Tensor(BdSet_ng, mstype.float32), name=\"BdSet_ng\", requires_grad=False)","def getValidRatingInputs(self):\n min = self.minRatingInput.get()\n max = self.maxRatingInput.get()\n\n try:\n min = int(min)\n except ValueError:\n min = 0\n\n try:\n max = int(max)\n except ValueError:\n max = 100\n\n return min, max","def range(series):\n return min(series), max(series)","def get_variable_values(self, vars):\n raise NotImplementedError()"],"string":"[\n \"def get_minimum():\\n return [\\n convert_variables([0.78547, 0.78547, 0.78547]),\\n ]\",\n \"def __minimum_remaining_values(self, unassigned_vars):\\n min_var = None\\n for var in unassigned_vars:\\n if min_var is None:\\n min_var = var\\n elif len(var.domain) < len(min_var.domain):\\n min_var = var\\n return min_var\",\n \"def variable_range(examples, var):\\n if var[1] == 'd':\\n range = set()\\n for datum in examples:\\n range.add(datum[var[0]])\\n return range\\n else:\\n range_min, range_max = 0, 0\\n for datum in examples:\\n data_val = float(datum[var[0]])\\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\\n return (range_min, range_max)\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def xminmax ( self ) :\\n return self.xvar.minmax()\",\n \"def get_min_max_x(self, min_x = 1e9, max_x = -1e9, exclude = []): \\n \\n if self.verbose > 1:\\n print(\\\"MultiLinearSpectra.get_min_max_x()\\\") \\n \\n for m in range(len(self.mess)):\\n if m not in exclude and self.mess[m][\\\"class\\\"] not in exclude:\\n min_x, max_x = self.mess[m][\\\"object\\\"].get_min_max_x(min_x, max_x)\\n \\n return min_x, max_x\",\n \"def getMinMax(self,arr):\\n # not implemented for Template SED yet\\n return arr[\\\"z\\\"], arr[\\\"z\\\"]\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def min_values(self, lower, upper): \\n if not self.lower_bounds is None:\\n return self.lower_bounds\\n\\n minus = np.clip(self.coeffs,-math.inf,0)\\n plus = np.clip(self.coeffs,0,math.inf)\\n self.lower_bounds = plus.dot(lower) + minus.dot(upper) + self.const\\n \\n return self.lower_bounds\",\n \"def get_min_max(ints):\\n if len(ints) <= 0:\\n return ()\\n min_value = ints[0]\\n max_value = ints[0]\\n for i in range(len(ints)):\\n temp = ints[i]\\n if temp <= min_value:\\n min_value = temp\\n if temp >= max_value:\\n max_value = temp\\n output = (min_value, max_value)\\n# print(\\\"output: \\\", output)\\n return output\\n pass\",\n \"def _init_special_vars(self, T_start=None, T_end=None):\\n self.min_energy = np.min(self.event_list_T[1][T_start:T_end])\\n self.max_energy = np.max(self.event_list_T[1][T_start:T_end])\\n self.min_time = np.min(self.event_list_T[0][T_start:T_end])\\n self.max_time = np.max(self.event_list_T[0][T_start:T_end])\",\n \"def min_max(xs):\\n return min(xs), max(xs)\",\n \"def get_min_max(ints):\\r\\n if len(ints) == 0:\\r\\n return None\\r\\n max = ints[0]\\r\\n min = ints[0]\\r\\n\\r\\n for int in ints:\\r\\n if int < min:\\r\\n min = int\\r\\n if int > max:\\r\\n max = int\\r\\n \\r\\n return min, max\",\n \"def min_max(self, data, era):\\n return 0, np.max(data)\",\n \"def get_minmax_stats(dataframe, variable):\\n\\n print(\\\"Maximum value of \\\", variable, \\\"is: \\\", dataframe[variable].max())\\n print(\\\"Minimum value of \\\", variable, \\\"is: \\\", dataframe[variable].min())\",\n \"def get_minmax(self, stmt, slist):\\n minel = maxel = None\\n for s in slist:\\n if s.keyword == \\\"min-elements\\\":\\n minel = s.arg\\n elif s.keyword == \\\"max-elements\\\":\\n maxel = s.arg\\n if minel is None:\\n minst = stmt.search_one(\\\"min_elements\\\")\\n if minst:\\n minel = minst.arg\\n else:\\n minel = \\\"0\\\"\\n if maxel is None:\\n maxst = stmt.search_one(\\\"max_elements\\\")\\n if maxst:\\n maxel = maxst.arg\\n return (minel, maxel)\",\n \"def get_min_max(ints):\\n if not ints:\\n return None, None\\n if len(ints) ==None:\\n return None\\n min_val = float(\\\"inf\\\")\\n max_val = -float(\\\"inf\\\")\\n # for each int in ints if update max_val and min_val accordingly\\n for integer in ints:\\n if integer > max_val:\\n max_val = integer\\n\\n if integer < min_val:\\n min_val = integer\\n \\n return (min_val, max_val)\",\n \"def define_variables(m):\\r\\n\\r\\n # Non-negative candidate capacity\\r\\n m.mu_1 = Var(m.G_C, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Solar build limits\\r\\n m.mu_2 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Wind build limits\\r\\n m.mu_3 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage build limits\\r\\n m.mu_4 = Var(m.Z, m.Y, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min power output (all generators excluding storage units)\\r\\n m.sigma_1 = Var(m.G.difference(m.G_STORAGE), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing thermal\\r\\n m.sigma_2 = Var(m.G_E_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate thermal\\r\\n m.sigma_3 = Var(m.G_C_THERM, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing wind\\r\\n m.sigma_4 = Var(m.G_E_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate wind\\r\\n m.sigma_5 = Var(m.G_C_WIND, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - existing solar\\r\\n m.sigma_6 = Var(m.G_E_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - candidate solar\\r\\n m.sigma_7 = Var(m.G_C_SOLAR, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max power output - hydro\\r\\n m.sigma_8 = Var(m.G_E_HYDRO, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min charging power - storage units\\r\\n m.sigma_9 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min discharging power - storage_units\\r\\n m.sigma_10 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - existing storage\\r\\n m.sigma_11 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max charging power - candidate storage\\r\\n m.sigma_12 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - existing storage\\r\\n m.sigma_13 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max discharging power - candidate storage\\r\\n m.sigma_14 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - storage units\\r\\n m.sigma_15 = Var(m.G_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - existing storage units\\r\\n m.sigma_16 = Var(m.G_E_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - candidate storage\\r\\n m.sigma_17 = Var(m.G_C_STORAGE, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min energy - interval end\\r\\n m.sigma_18 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max energy - interval end\\r\\n m.sigma_19 = Var(m.G_STORAGE, m.Y, m.S, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate up (thermal and hydro generators)\\r\\n m.sigma_20 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Ramp-rate down (thermal and hydro generators)\\r\\n m.sigma_23 = Var(m.G_THERM.union(m.G_E_HYDRO), m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Non-negative lost load power\\r\\n m.sigma_26 = Var(m.Z, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Min powerflow\\r\\n m.sigma_27 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Max powerflow\\r\\n m.sigma_28 = Var(m.L, m.Y, m.S, m.T, within=NonNegativeReals, initialize=0)\\r\\n\\r\\n # Storage energy transition\\r\\n m.zeta_1 = Var(m.G_STORAGE, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n # Power balance (locational marginal price)\\r\\n m.lamb = Var(m.Z, m.Y, m.S, m.T, initialize=0)\\r\\n\\r\\n return m\",\n \"def zminmax ( self ) :\\n return self.zvar.minmax()\",\n \"def vmnmx ( self , var , vmin , vmax ) :\\n if var.xminmax() :\\n vmn , vmx = var.xminmax ()\\n if is_good_number ( vmin ) : vmin = max ( vmin , vmn )\\n else : vmin = vmn\\n if is_good_number ( vmax ) : vmax = min ( vmax , vmx )\\n else : vmax = vmx\\n\\n assert is_good_number ( vmin ), 'Invalid type of ``min'' %s/%s' % ( vmin , type ( vmin ) )\\n assert is_good_number ( vmax ), 'Invalid type of ``max'' %s/%s' % ( vmin , type ( vmin ) )\\n assert vmin < vmax, 'Invalid min/max range: %s/%s' % ( vmin , vmax )\\n \\n return vmin , vmax\",\n \"def _full_value_range(self):\\n min_value, max_value = self._raw_data.data_range\\n return max_value - min_value\",\n \"def minMaxFonc(liste):\\n\\n return min(liste), max(liste)\",\n \"def __init__(__self__, *,\\n max: pulumi.Input[int],\\n min: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"max\\\", max)\\n pulumi.set(__self__, \\\"min\\\", min)\",\n \"def __init__(__self__, *,\\n max: pulumi.Input[int],\\n min: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"max\\\", max)\\n pulumi.set(__self__, \\\"min\\\", min)\",\n \"def get_variables(self):\\n return [self.g_t, self.m_t]\",\n \"def min_max(items):\\n return min(items), max(items)\",\n \"def get_range(self, field, deep=False, axis=None):\\n variables = list(self.vars(deep, with_name=field))\\n\\n if not variables:\\n raise KeyError(\\\"No variable named '%s' was found!\\\" % field)\\n\\n start = [np.nanmin(self[var], axis).item(0) for var in variables]\\n end = [np.nanmax(self[var], axis).item(0) for var in variables]\\n return min(start), max(end)\",\n \"def __init__(self, min: float, max: float):\\n super().__init__()\\n\\n # store input parameters\\n self.min = min\\n self.max = max\",\n \"def get_state_observed_min(self):\\n minValues = numpy.zeros(self.get_num_variables())\\n i = 0\\n for v in self.variables:\\n minValues[i] = v.get_min_value()\\n i += 1\\n return minValues\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def latvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lat_axis1 = latAxis(mv1)\\n lat_axis2 = latAxis(mv2)\\n if len(lat_axis1)<=len(lat_axis2):\\n lat_axis = lat_axis1\\n mv = mv1\\n else:\\n lat_axis = lat_axis2\\n mv = mv2\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units} )\\n return latmv\",\n \"def minmax(self):\\r\\n vx = [v[0] for v in self.vl]\\r\\n vy = [v[1] for v in self.vl]\\r\\n self.xmax, self.xmin = max(vx), min(vx)\\r\\n self.ymax, self.ymin = max(vy), min(vy)\",\n \"def get_minmax(self):\\n x_minmax = [np.min(self.grid['x']), np.max(self.grid['x'].max())]\\n z_minmax = [np.min(self.grid['z']), np.max(self.grid['z'].max())]\\n return x_minmax, z_minmax\",\n \"def minmax ( self , nshoots = 100000 ) :\\n ## try to get minmax directly from pdf/function \\n if self.tricks and hasattr ( self.pdf , 'function' ) :\\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \\n f = self.pdf.function()\\n if hasattr ( f , 'minmax' ) :\\n try :\\n mn , mx = f.minmax()\\n if 0<= mn and mn <= mx and 0 < mx : \\n return mn , mx\\n except :\\n pass\\n if hasattr ( f , 'max' ) :\\n try :\\n mx = f.max()\\n if 0 < mx : return 0 , mx\\n except :\\n pass\\n\\n ## check RooAbsReal functionality\\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\\n if 0 < code :\\n mx = self.pdf.maxVal ( code )\\n if 0 < mx : return 0 , mx\\n \\n ## not try to use random\\n \\n mn , mx = -1 , -10\\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\\n \\n if not self.xminmax() : return ()\\n if not self.yminmax() : return ()\\n \\n mn , mx = -1 , -10\\n xmn , xmx = self.xminmax()\\n ymn , ymx = self.yminmax()\\n for i in range ( nshoots ) : \\n xx = random.uniform ( xmn , xmx )\\n yy = random.uniform ( ymn , ymx )\\n with SETVAR ( self.xvar ) :\\n with SETVAR ( self.yvar ) :\\n self.xvar.setVal ( xx )\\n self.yvar.setVal ( yy )\\n vv = self.pdf.getVal()\\n if mn < 0 or vv < mn : mn = vv\\n if mx < 0 or vv > mx : mx = vv\\n \\n return mn , mx\",\n \"def atvar(a,limits=None,inclusive=(1,1)):\\r\\n a = a.astype(N.float_)\\r\\n if limits == None or limits == [None,None]:\\r\\n return avar(a)\\r\\n assert type(limits) in [ListType,TupleType,N.ndarray], \\\"Wrong type for limits in atvar\\\"\\r\\n if inclusive[0]: lowerfcn = N.greater_equal\\r\\n else: lowerfcn = N.greater\\r\\n if inclusive[1]: upperfcn = N.less_equal\\r\\n else: upperfcn = N.less\\r\\n if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):\\r\\n raise ValueError, \\\"No array values within given limits (atvar).\\\"\\r\\n elif limits[0]==None and limits[1]<>None:\\r\\n mask = upperfcn(a,limits[1])\\r\\n elif limits[0]<>None and limits[1]==None:\\r\\n mask = lowerfcn(a,limits[0])\\r\\n elif limits[0]<>None and limits[1]<>None:\\r\\n mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])\\r\\n\\r\\n a = N.compress(mask,a) # squish out excluded values\\r\\n return avar(a)\",\n \"def get_minx_maxx(self, normalized=True):\\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\\n\\n for idx, feature_name in enumerate(self.continuous_feature_names):\\n max_value = self.train_df[feature_name].max()\\n min_value = self.train_df[feature_name].min()\\n\\n if normalized:\\n minx[0][idx] = (self.permitted_range[feature_name]\\n [0] - min_value) / (max_value - min_value)\\n maxx[0][idx] = (self.permitted_range[feature_name]\\n [1] - min_value) / (max_value - min_value)\\n else:\\n minx[0][idx] = self.permitted_range[feature_name][0]\\n maxx[0][idx] = self.permitted_range[feature_name][1]\\n return minx, maxx\",\n \"def get_min_max(ints):\\n if ints is None or len(ints) == 0:\\n return None\\n \\n min_value = ints[0]\\n max_value = ints[0]\\n\\n for value in ints:\\n if value < min_value:\\n min_value = value\\n\\n if value > max_value:\\n max_value = value\\n\\n return (min_value, max_value)\",\n \"def __init__(self, min_val, max_val):\\n self.values = (min_val, max_val)\",\n \"def __init__(self, min_val, max_val):\\n self.values = (min_val, max_val)\",\n \"def __init__(self, min_val, max_val):\\n self.values = (min_val, max_val)\",\n \"def __init__(self, min_val, max_val):\\n self.values = (min_val, max_val)\",\n \"def minmax(xs):\\n min_val = None\\n max_val = None\\n for x in xs:\\n if min_val is None or x < min_val:\\n min_val = x\\n if max_val is None or x > max_val:\\n max_val = x\\n return (min_val, max_val)\",\n \"def local_max_to_min(node):\\r\\n if node.op == T.neg and node.inputs[0].owner:\\r\\n max = node.inputs[0]\\r\\n if (max.owner and\\r\\n isinstance(max.owner.op, CAReduce)\\r\\n and max.owner.op.scalar_op == scal.maximum):\\r\\n neg = max.owner.inputs[0]\\r\\n if neg.owner and neg.owner.op == T.neg:\\r\\n return [CAReduce(scal.minimum,\\r\\n max.owner.op.axis)(neg.owner.inputs[0])]\\r\\n\\r\\n return False\",\n \"def get_parameters_min(self):\\n minValues = numpy.zeros(self.get_num_parameters())\\n i = 0\\n for p in self.parameters:\\n minValues[i] = p.get_min_value()\\n i += 1\\n return minValues\",\n \"def findmaxmin(input_file):\\n\\tE_list = sub.check_output(\\\"check_maxmin.py {}\\\".format(input_file), shell=True).decode(\\\"utf-8\\\")\\n\\tEmax = float(re.search(r\\\"Maximum\\\\s*:\\\\s*(([+-]|\\\\s)\\\\d*\\\\.\\\\d+)\\\", E_list).group(1))\\n\\tEmin = float(re.search(r\\\"Minimum\\\\s*:\\\\s*(([+-]|\\\\s)\\\\d*\\\\.\\\\d+)\\\", E_list).group(1))\\n\\treturn Emax, Emin\",\n \"def extreme_values(self, extreme):\\n\\n\\t\\tif extreme.lower() == 'min':\\n\\t\\t\\treturn data.min()\\n\\t\\telif extreme.lower() == 'max':\\n\\t\\t\\treturn data.max()\\n\\t\\telse:\\n\\t\\t\\tassert 'Invalid Parameter !'\",\n \"def set_physical_minmax(self, min, max):\\n # This allows you to set the min and the max of the quantity that you want the MLP to measure. \\n # Once you set this, you can pass in a physical number to get_mlp_value() and it will be mapped to an MLP value and returned\\n pass\\n \\n # Maybe we should let the holder of the MLP determine these values and do the mapping? \",\n \"def lonvar_min( mv1, mv2 ):\\n if mv1 is None: return None\\n if mv2 is None: return None\\n lon_axis1 = lonAxis(mv1)\\n lon_axis2 = lonAxis(mv2)\\n if len(lon_axis1)<=len(lon_axis2):\\n lon_axis = lon_axis1\\n mv = mv1\\n else:\\n lon_axis = lon_axis2\\n mv = mv2\\n lonmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units} )\\n return lonmv\",\n \"def parameters(self):\\n temp = list(_flatten(self.params))\\n temp_val = [self.check_domain(x.val, True) if isinstance(x, Variable) else x for x in temp]\\n return _unflatten(temp_val, self.params)[0]\",\n \"def max_values(self, lower, upper):\\n if not self.upper_bounds is None:\\n return self.upper_bounds\\n\\n minus = np.clip(self.coeffs,-math.inf,0)\\n plus = np.clip(self.coeffs,0,math.inf)\\n self.upper_bounds = plus.dot(upper) + minus.dot(lower) + self.const\\n \\n return self.upper_bounds\",\n \"def __findMinMaxVal(self, min_or_max, exp, var_names, val_table, up_sign=1):\\n\\n # numerical expression\\n if isinstance(exp, ast.NumLitExp):\\n return exp\\n\\n # string expression\\n elif isinstance(exp, ast.StringLitExp):\\n err(\\n \\\"orio.module.ortil.transformation: OrTil: invalid string expression found in loop bound expression: %s\\\"\\n % exp\\n )\\n\\n # identifier expression\\n elif isinstance(exp, ast.IdentExp):\\n\\n # do nothing if the identifier is not in the given list of variables to be replaced\\n if exp.name not in var_names:\\n return exp\\n\\n # replace the identifier with its apropriate value (depending on min/max, and upper sign)\\n lval, uval = val_table[exp.name]\\n if min_or_max == \\\"max\\\":\\n if up_sign == 1:\\n val = ast.ParenthExp(uval.replicate())\\n else:\\n val = ast.ParenthExp(lval.replicate())\\n elif min_or_max == \\\"min\\\":\\n if up_sign == 1:\\n val = ast.ParenthExp(lval.replicate())\\n else:\\n val = ast.ParenthExp(uval.replicate())\\n else:\\n err(\\n \\\"orio.module.ortil.transformation internal error: unrecognized min/max argument value\\\"\\n )\\n\\n # return the obtained min/max value\\n return val\\n\\n # array reference expression\\n elif isinstance(exp, ast.ArrayRefExp):\\n err(\\n \\\"orio.module.ortil.transformation: invalid array-reference expression found in loop bound \\\"\\n + \\\"expression: %s\\\" % exp\\n )\\n\\n # function call expression\\n elif isinstance(exp, ast.FunCallExp):\\n\\n # check the function name\\n if (not isinstance(exp.exp, ast.IdentExp)) or exp.exp.name not in (\\n \\\"min\\\",\\n \\\"max\\\",\\n ):\\n err(\\n (\\n \\\"orio.module.ortil.transformation: function name found in loop bound expression must be \\\"\\n + \\\"min/max, obtained: %s\\\"\\n )\\n % exp.exp\\n )\\n\\n # recursion on each function argument\\n exp.args = []\\n for a in exp.args:\\n exp.args.append(\\n self.__findMinMaxVal(min_or_max, a, var_names, val_table, up_sign)\\n )\\n\\n # return the computed expression\\n return exp\\n\\n # unary operation expression\\n elif isinstance(exp, ast.UnaryExp):\\n\\n # check the unary operation\\n if exp.op_type not in (ast.UnaryExp.PLUS, ast.UnaryExp.MINUS):\\n err(\\n (\\n \\\"orio.module.ortil.transformation: unary operation found in loop bound expression must \\\"\\n + \\\"be +/-, obtained: %s\\\"\\n )\\n % exp.exp\\n )\\n\\n # update the sign, and do recursion on the inner expression\\n if exp.op_type == ast.UnaryExp.MINUS:\\n up_sign *= -1\\n exp.exp = self.__findMinMaxVal(\\n min_or_max, exp.exp, var_names, val_table, up_sign\\n )\\n\\n # return the computed expression\\n return exp\\n\\n # binary operation expression\\n elif isinstance(exp, ast.BinOpExp):\\n\\n # check the binary operation\\n if exp.op_type not in (\\n ast.BinOpExp.ADD,\\n ast.BinOpExp.SUB,\\n ast.BinOpExp.MUL,\\n ):\\n err(\\n (\\n \\\"orio.module.ortil.transformation: binary operation found in loop bound expression must \\\"\\n + \\\"be +/-/*, obtained: %s\\\"\\n )\\n % exp\\n )\\n\\n # do recursion on both operands\\n exp.lhs = self.__findMinMaxVal(\\n min_or_max, exp.lhs, var_names, val_table, up_sign\\n )\\n if exp.op_type == ast.BinOpExp.SUB:\\n up_sign *= -1\\n exp.rhs = self.__findMinMaxVal(\\n min_or_max, exp.rhs, var_names, val_table, up_sign\\n )\\n\\n # return the computed expression\\n return exp\\n\\n # parenthesized expression\\n elif isinstance(exp, ast.ParenthExp):\\n parenth_before = isinstance(exp.exp, ast.ParenthExp)\\n exp.exp = self.__findMinMaxVal(\\n min_or_max, exp.exp, var_names, val_table, up_sign\\n )\\n parenth_after = isinstance(exp.exp, ast.ParenthExp)\\n if (not parenth_before) and parenth_after:\\n return exp.exp\\n return exp\\n\\n # unrecognized expression\\n else:\\n err(\\n \\\"orio.module.ortil.transformation internal error: unknown type of expression: %s\\\"\\n % exp.__class__.__name__\\n )\",\n \"def __new__(cls, minx, miny, minz, maxx, maxy, maxz):\\n # Coerce bounds to floats, and nones to infs\\n kwargs = locals()\\n for b, inf in zip(('min', 'max'),\\n (-np.inf, np.inf)):\\n for axis in 'xyz':\\n bound = b + axis\\n value = kwargs[bound]\\n kwargs[bound] = inf if value is None else float(value)\\n \\n kwargs.pop('cls') # must be passed positionally\\n return super(cls, cls).__new__(cls, **kwargs)\",\n \"def calculate_avg_min_max(temps):\\n\\n temp_average = sum(temps) / len(temps)\\n return temp_average, min(temps), max(temps)\",\n \"def get_min_max(ints):\\n if not ints:\\n return\\n max = ints[0]\\n min = ints[0]\\n\\n\\n for i in ints:\\n if i > max:\\n max = i\\n if i < min:\\n min = i\\n return (min, max)\",\n \"def __define_variable_time(self, initial_guess, minimum, maximum):\\n i = 0\\n for nlp in self.nlp:\\n if isinstance(nlp[\\\"tf\\\"], self.CX):\\n time_bounds = Bounds(minimum[i], maximum[i], interpolation=InterpolationType.CONSTANT)\\n time_init = InitialConditions(initial_guess[i])\\n Parameters._add_to_v(self, \\\"time\\\", 1, None, time_bounds, time_init, nlp[\\\"tf\\\"])\\n i += 1\",\n \"def apply_bound(x, var_min, var_max):\\n x.position = np.maximum(x.position, var_min)\\n x.position = np.minimum(x.position, var_max)\",\n \"def _set_min_max_values(self):\\n\\n p_1, p_2 = self.points[0], self.points[1]\\n nb_dim = len(p_1.values)\\n self._min_values = []\\n self._max_values = []\\n for d in range(nb_dim):\\n d_min = min(p_1[d], p_2[d])\\n d_max = max(p_2[d], p_2[d])\\n self._min_values.append(d_min)\\n self._max_values.append(d_max)\",\n \"def get_max_temp(self):\\n self.max_temp = self.domain[1] * 2\",\n \"def minMaxBoucle(liste):\\n minimum = float(\\\"inf\\\")\\n maximum = -float(\\\"inf\\\")\\n\\n for index in range(0, 5):\\n liste[index] = int(liste[index])\\n if liste[index] > maximum:\\n maximum = liste[index]\\n if liste[index] < minimum:\\n minimum = liste[index]\\n return minimum, maximum\",\n \"def __init__(self, min: int, max: int):\\n super().__init__()\\n\\n # store input parameters\\n self.min = min\\n self.max = max\",\n \"def min_max_date(self, min, max, date):\\n\\t\\tif not min or min > date:\\n\\t\\t\\tmin = date\\n\\n\\t\\tif not max or max < date:\\n\\t\\t\\tmax = date\\n\\n\\t\\treturn min, max\",\n \"def get_min_max(ints):\\n current_max = None\\n current_min = None\\n\\n if (len(ints) == 0) or (ints is None):\\n return tuple([current_min, current_max])\\n\\n for i, n in enumerate(ints):\\n if i == 0:\\n current_max = n\\n current_min = n\\n else:\\n if n > current_max:\\n current_max = n\\n elif n < current_min:\\n current_min = n\\n\\n return tuple([current_min, current_max])\",\n \"def _get_extremes(self, attr='values'):\\n # calculate the maximum and minimum for all series\\n series_max = [0]\\n series_min = [0]\\n for s in self:\\n if s is not None:\\n series_max.append(s.max(attr))\\n series_min.append(s.min(attr))\\n return min(series_min), max(series_max)\",\n \"def min_max(arr: StaticArray) -> ():\\n minimum = arr.get(0) # sets min to first element\\n maximum = arr.get(0) # sets max to first element\\n # iterate over the elements in the array to check for < or >\\n for index in range(arr.size()):\\n if arr[index] < minimum: # if element is less than the current min, min = new element\\n minimum = arr[index]\\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\\n maximum = arr[index]\\n return minimum, maximum\",\n \"def __init__(self, values=None, min_value=None, max_value=None):\\n if values is not None:\\n # If list if provided, use it to determine min and max values\\n self.min = min(values)\\n self.max = max(values)\\n\\n else:\\n self.min = min_value\\n self.max = max_value\",\n \"def generate_var_ranges(self):\\n\\n var_ranges = {}\\n for var in self.variables:\\n min_to_max = list(range(int(var['min']), int(var['max']) + 1))\\n if (var['zero_ok'] == False and 0 in min_to_max):\\n min_to_max.remove(0)\\n\\n var_ranges[var['variable']] = min_to_max\\n\\n return var_ranges\",\n \"def cpfclamp(f, min_, max_):\\n return min(max(f, min_), max_)\",\n \"def return_parameter_bounds(maximum_luminosity=20):\\n return [(maximum_luminosity, maximum_luminosity + 3),\\n (3 * 10 ** -4, 8 * 10 ** -3), (2., 350), (-8., -0.2),\\n (-400, 400)]\",\n \"def force_bounds(self):\\n return self._min_force, self._max_force\",\n \"def get_extremum(x):\\n min_val = x.min()\\n argmin = x.argmin()\\n max_val = x.max()\\n argmax = x.argmax()\\n extremum = min_val\\n argextremum = argmin\\n if abs(min_val) < abs(max_val):\\n extremum = max_val\\n argextremum = argmax\\n\\n return extremum, argextremum\",\n \"def view_limits(self, vmin, vmax):\\n return vmin, vmax\\n # return nonsingular(vmin, vmax)\",\n \"def constrain(small, value, big):\\n return min(max(value, small), big)\",\n \"def _check_tmin_tmax(inst, tmin, tmax):\\n _check_type(tmin, (None, \\\"numeric\\\"), item_name=\\\"tmin\\\")\\n _check_type(tmax, (None, \\\"numeric\\\"), item_name=\\\"tmax\\\")\\n\\n # check positiveness for tmin, tmax\\n for name, arg in ((\\\"tmin\\\", tmin), (\\\"tmax\\\", tmax)):\\n if arg is None:\\n continue\\n if arg < 0:\\n raise ValueError(\\n f\\\"Argument '{name}' must be positive. \\\" f\\\"Provided '{arg}'.\\\"\\n )\\n # check tmax is shorter than instance\\n if tmax is not None and inst.times[-1] < tmax:\\n raise ValueError(\\n \\\"Argument 'tmax' must be shorter than the instance \\\"\\n f\\\"length. Provided: '{tmax}', larger than \\\"\\n f\\\"{inst.times[-1]}s instance.\\\"\\n )\\n # check that tmax is larger than tmin\\n if tmax is not None and tmin is not None and tmax <= tmin:\\n raise ValueError(\\n \\\"Argument 'tmax' must be strictly larger than 'tmin'. \\\"\\n f\\\"Provided 'tmin' -> '{tmin}' and 'tmax' -> '{tmax}'.\\\"\\n )\\n # check that tmin is shorter than instance\\n if tmin is not None and inst.times[-1] <= tmin:\\n raise ValueError(\\n \\\"Argument 'tmin' must be shorter than the instance \\\"\\n f\\\"length. Provided: '{tmin}', larger than \\\"\\n f\\\"{inst.times[-1]}s instance.\\\"\\n )\\n return tmin, tmax\",\n \"def find_varying(params, nvmax):\\n print('Finding variable parameters')\\n if nvmax < 0:\\n raise ValueError(f'nvmax ({nvmax}) must be positive')\\n\\n var = []\\n cnt = 0\\n for p in params:\\n if len(params[p]) == 2:\\n if (params[p][1] - params[p][0]) < 0:\\n raise ValueError(f'range is inverted for param: {p}')\\n elif cnt >= nvmax:\\n raise ValueError(f'too many param ranges were given. Expected {nvmax}')\\n else:\\n var.append(p)\\n cnt += 1\\n return var\",\n \"def yminmax ( self ) :\\n return self.yvar.minmax()\",\n \"def min_max(lst):\\r\\n my_min = None\\r\\n my_max = None\\r\\n for num in lst:\\r\\n if (my_min and my_max) is not None:\\r\\n # recalculate running min and max:\\r\\n if num < my_min:\\r\\n my_min = num\\r\\n continue\\r\\n if num > my_max:\\r\\n my_max = num\\r\\n else:\\r\\n my_min = num\\r\\n my_max = num\\r\\n ans = (my_min, my_max)\\r\\n return ans\",\n \"def get_min_max(ints):\\n if ints == None or len(ints) == 0:\\n return None\\n if len(ints) == 1:\\n return (ints[0],ints[0])\\n \\n max = ints[0]\\n min = ints[0]\\n for i in range(1, len(ints)):\\n if ints[i] > max:\\n max = ints[i]\\n if ints[i] < min:\\n min = ints[i]\\n return (min,max)\",\n \"def get_min_max(self) -> tuple:\\r\\n\\r\\n minimum = float(\\\"inf\\\")\\r\\n maximum = float(\\\"-inf\\\")\\r\\n\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n if self.trees[name][\\\"point_helper\\\"] is None:\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n return minimum, maximum\",\n \"def get_min_max(ints):\\n\\n if len(ints) == 0:\\n return (None,None)\\n min = ints[0]\\n max = ints[0]\\n for x in range(1,len(ints)):\\n if ints[x] > max:\\n max=ints[x]\\n elif ints[x] < min:\\n min = ints[x]\\n return (min,max)\",\n \"def initializeVariables(F_n):\\n bounds = [(-100, 100), (-10, 10), (-100, 100), (-100, 100), (-30, 30),\\n (-100, 100), (-1.28, 1.28), (-500, 500), (-5.12, 5.12),\\n (-32, 32), (-600, 600), (-50, 50), (-50, 50)]\\n\\n if F_n == 8:\\n objectiveValue = -12569.5\\n else:\\n objectiveValue = 1e-8\\n\\n (lower, upper) = bounds[F_n - 1]\\n return (lower, upper, objectiveValue)\",\n \"def input_bounds(self):\\n return self._min_input, self._max_input\",\n \"def __init__(self, valuesArray1, valuesArray2):\\n\\n self.valuesArray1 = np.array(valuesArray1).flatten()\\n self.valuesArray2 = np.array(valuesArray2).flatten()\\n\\n self.min1 = self.valuesArray1.min()\\n self.max1 = self.valuesArray1.max()\\n self.min2 = self.valuesArray2.min()\\n self.max2 = self.valuesArray2.max()\",\n \"def subset_var(df, min_var, max_var, var):\\n var_max = df[var] < max_var\\n var_min = df[var] > min_var\\n return df[var_min & var_max]\",\n \"def get_min_max(self, groups, key):\\n group = groups.get_group(key)\\n min = group.loc[group[\\\"dif\\\"].idxmin()]\\n max = group.loc[group[\\\"dif\\\"].idxmax()]\\n minmax = {\\\"min\\\": min, \\\"max\\\": max}\\n return minmax\",\n \"def data_range(x):\\n return max(x)-min(x)\",\n \"def get_model_parameter_bounds():\\n minf = float(\\\"-inf\\\")\\n inf = float(\\\"inf\\\")\\n params = dict(mu=(minf,inf), rho=(0.0 ,inf))\\n return params\",\n \"def state_limits(self) -> Tuple[torch.Tensor, torch.Tensor]:\\n # define upper and lower limits based around the nominal equilibrium input\\n upper_limit = torch.ones(self.n_dims)\\n upper_limit[TurtleBot2D.X] = 2.0\\n upper_limit[TurtleBot2D.Y] = 2.0\\n upper_limit[TurtleBot2D.THETA] = 2 * np.pi\\n\\n lower_limit = -1.0 * upper_limit\\n\\n return (upper_limit, lower_limit)\",\n \"def tenant(Cs):\\n xs = [variable() for i in xrange(4)]\\n constraints = []\\n def _(blah):\\n constraints.append(blah)\\n for x in xs:\\n _(geq(x, 0))\\n _(leq(xs[0] + xs[1], Cs[0]))\\n _(leq(xs[0], Cs[3]))\\n _(leq(xs[1], Cs[4]))\\n _(leq(xs[2], Cs[1]))\\n _(leq(xs[3], Cs[2]))\\n _(leq(xs[2] + xs[3], Cs[5]))\\n\\n p = program(maximize(U(xs)), constraints)\\n config(p)\\n #p.show()\\n p.solve(quiet=True)\\n\\n return [x.value for x in xs]\",\n \"def values(self):\\n lower = float(self.lowerSpnbx.value())\\n upper = float(self.upperSpnbx.value())\\n return lower, upper\",\n \"def set_period_limits(self): # function[Tmin, Tmax] = setTlim(obj)\\n\\n x_min = self.tf.minimum_period\\n x_max = self.tf.maximum_period\\n\\n Tmin = 10 ** (np.floor(np.log10(x_min) * 2) / 2)\\n if (np.log10(x_min) - np.log10(Tmin)) < 0.15:\\n Tmin = 10 ** (np.log10(Tmin) - 0.3)\\n\\n Tmax = 10 ** (np.ceil(np.log10(x_max) * 2) / 2)\\n if (np.log10(Tmax) - np.log10(x_max)) < 0.15:\\n Tmax = 10 ** (np.log10(Tmax) + 0.3)\\n return Tmin, Tmax\",\n \"def min_max(my_list):\\n print(\\\"Min = \\\",min(my_list,key = abs))\\n print(\\\"Max = \\\",max(my_list,key = abs))\",\n \"def standardize_x(\\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\\n):\\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\\n raise ValueError(\\n \\\"Either *both* or *neither* of x_min, x_max need to be supplied!\\\"\\n )\\n if x_min is None:\\n x_min = torch.min(x, 0)[0]\\n x_max = torch.max(x, 0)[0]\\n x = (x - x_min) / (x_max - x_min)\\n return x, x_min, x_max\",\n \"def min_max_id()->(int, int):\\n stmt = sqlalchemy.select([sqlalchemy.func.min(_READING_TABLE.c.id), \\n sqlalchemy.func.max(_READING_TABLE.c.id)]).select_from(_READING_TABLE)\\n result = execute_command(stmt).fetchall()[0]\\n return result[0], result[1]\",\n \"def get_tmin_tmax(self, models: List[Model] = None) -> DataFrame:\\n if models is None:\\n models = self.models\\n\\n tmintmax = DataFrame(columns=[\\\"tmin\\\", \\\"tmax\\\"], dtype=\\\"datetime64[ns]\\\")\\n for ml in models:\\n tmintmax.loc[ml.name, [\\\"tmin\\\", \\\"tmax\\\"]] = [\\n ml.get_tmin(),\\n ml.get_tmax(),\\n ]\\n\\n return tmintmax\",\n \"def getValues(self):\\n return [self.scale_min, self.scale_max]\",\n \"def get_min_max(ints):\\n print(f\\\"input arr is {ints}\\\")\\n max=0\\n min=len(ints)-1\\n for i in range(1,len(ints)):\\n if ints[i]>ints[max]:\\n temp=ints[i]\\n ints[i]=ints[max]\\n ints[max]=temp\\n if ints[i]<ints[min]:\\n temp=ints[i]\\n ints[i]=ints[min]\\n ints[min]=temp\\n #print(f\\\"max value is {ints[max]}\\\")\\n #print(f\\\"min value is {ints[min]}\\\")\\n return(ints[min],ints[max])\",\n \"def get_variable(self, InSet_g, InSet_l, InSet_gx, InSet_lx, InSet_a, InSet_size,\\n InSet_dim, InSet_area, InSet_c, BdSet_nlength, BdSet_nr, BdSet_nl, BdSet_ng):\\n self.InSet_size = InSet_size\\n self.InSet_dim = InSet_dim\\n self.InSet_area = InSet_area\\n self.BdSet_nlength = BdSet_nlength\\n\\n self.InSet_g = Parameter(\\n Tensor(InSet_g, mstype.float32), name=\\\"InSet_g\\\", requires_grad=False)\\n self.InSet_l = Parameter(\\n Tensor(InSet_l, mstype.float32), name=\\\"InSet_l\\\", requires_grad=False)\\n self.InSet_gx = Parameter(\\n Tensor(InSet_gx, mstype.float32), name=\\\"InSet_gx\\\", requires_grad=False)\\n self.InSet_lx = Parameter(\\n Tensor(InSet_lx, mstype.float32), name=\\\"InSet_lx\\\", requires_grad=False)\\n self.InSet_a = Parameter(\\n Tensor(InSet_a, mstype.float32), name=\\\"InSet_a\\\", requires_grad=False)\\n self.InSet_c = Parameter(\\n Tensor(InSet_c, mstype.float32), name=\\\"InSet_c\\\", requires_grad=False)\\n self.BdSet_nr = Parameter(\\n Tensor(BdSet_nr, mstype.float32), name=\\\"BdSet_nr\\\", requires_grad=False)\\n self.BdSet_nl = Parameter(\\n Tensor(BdSet_nl, mstype.float32), name=\\\"BdSet_nl\\\", requires_grad=False)\\n self.BdSet_ng = Parameter(\\n Tensor(BdSet_ng, mstype.float32), name=\\\"BdSet_ng\\\", requires_grad=False)\",\n \"def getValidRatingInputs(self):\\n min = self.minRatingInput.get()\\n max = self.maxRatingInput.get()\\n\\n try:\\n min = int(min)\\n except ValueError:\\n min = 0\\n\\n try:\\n max = int(max)\\n except ValueError:\\n max = 100\\n\\n return min, max\",\n \"def range(series):\\n return min(series), max(series)\",\n \"def get_variable_values(self, vars):\\n raise NotImplementedError()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6460465","0.61516154","0.603381","0.5994661","0.5891523","0.5836747","0.58244497","0.57395023","0.5681477","0.5667921","0.56678796","0.5662136","0.56610906","0.5639008","0.562747","0.5615644","0.5598546","0.55895096","0.5584579","0.5576427","0.5575043","0.55732083","0.5564093","0.5564093","0.5563893","0.5562986","0.55533534","0.55489796","0.5524373","0.5512893","0.55108225","0.5510314","0.5503059","0.5497987","0.5480172","0.54701","0.5467407","0.5459686","0.5459686","0.5459686","0.5459686","0.54508704","0.54439765","0.54397714","0.5409303","0.540528","0.54041255","0.54026306","0.5401623","0.53919506","0.53894085","0.5382388","0.5368249","0.5354883","0.53484267","0.53415906","0.5335744","0.53344935","0.5328858","0.5327344","0.53149045","0.53136677","0.5307095","0.5293615","0.529191","0.52860636","0.52847934","0.5283331","0.52728367","0.52629685","0.5257513","0.525401","0.52509433","0.52389324","0.5238492","0.5236258","0.5223835","0.52207255","0.5211048","0.5207034","0.5205382","0.52027994","0.5190882","0.5184471","0.51831704","0.51828426","0.5179619","0.51789826","0.51783633","0.5174543","0.5171087","0.51632667","0.51534975","0.5153057","0.51443547","0.5138262","0.5137239","0.51356906","0.5133429","0.51329815"],"string":"[\n \"0.6460465\",\n \"0.61516154\",\n \"0.603381\",\n \"0.5994661\",\n \"0.5891523\",\n \"0.5836747\",\n \"0.58244497\",\n \"0.57395023\",\n \"0.5681477\",\n \"0.5667921\",\n \"0.56678796\",\n \"0.5662136\",\n \"0.56610906\",\n \"0.5639008\",\n \"0.562747\",\n \"0.5615644\",\n \"0.5598546\",\n \"0.55895096\",\n \"0.5584579\",\n \"0.5576427\",\n \"0.5575043\",\n \"0.55732083\",\n \"0.5564093\",\n \"0.5564093\",\n \"0.5563893\",\n \"0.5562986\",\n \"0.55533534\",\n \"0.55489796\",\n \"0.5524373\",\n \"0.5512893\",\n \"0.55108225\",\n \"0.5510314\",\n \"0.5503059\",\n \"0.5497987\",\n \"0.5480172\",\n \"0.54701\",\n \"0.5467407\",\n \"0.5459686\",\n \"0.5459686\",\n \"0.5459686\",\n \"0.5459686\",\n \"0.54508704\",\n \"0.54439765\",\n \"0.54397714\",\n \"0.5409303\",\n \"0.540528\",\n \"0.54041255\",\n \"0.54026306\",\n \"0.5401623\",\n \"0.53919506\",\n \"0.53894085\",\n \"0.5382388\",\n \"0.5368249\",\n \"0.5354883\",\n \"0.53484267\",\n \"0.53415906\",\n \"0.5335744\",\n \"0.53344935\",\n \"0.5328858\",\n \"0.5327344\",\n \"0.53149045\",\n \"0.53136677\",\n \"0.5307095\",\n \"0.5293615\",\n \"0.529191\",\n \"0.52860636\",\n \"0.52847934\",\n \"0.5283331\",\n \"0.52728367\",\n \"0.52629685\",\n \"0.5257513\",\n \"0.525401\",\n \"0.52509433\",\n \"0.52389324\",\n \"0.5238492\",\n \"0.5236258\",\n \"0.5223835\",\n \"0.52207255\",\n \"0.5211048\",\n \"0.5207034\",\n \"0.5205382\",\n \"0.52027994\",\n \"0.5190882\",\n \"0.5184471\",\n \"0.51831704\",\n \"0.51828426\",\n \"0.5179619\",\n \"0.51789826\",\n \"0.51783633\",\n \"0.5174543\",\n \"0.5171087\",\n \"0.51632667\",\n \"0.51534975\",\n \"0.5153057\",\n \"0.51443547\",\n \"0.5138262\",\n \"0.5137239\",\n \"0.51356906\",\n \"0.5133429\",\n \"0.51329815\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7315337"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19890,"cells":{"query":{"kind":"string","value":"If mv depends on an axis with just one value, create a copy of mv without that axis, and without the corresponding data dimension. Normally this happens when time has been averaged out, but there is still a onevalued time axis left (thus one would normally use id='time'). You can specify the axis id if there might be more than one singleton."},"document":{"kind":"string","value":"def delete_singleton_axis( mv, vid=None ):\n axes = allAxes(mv)\n saxis = None\n si = None\n for i in range(len(axes)):\n if len(axes[i])==1 and (vid==None or axes[i].id==vid):\n saxis = axes[i]\n si = i\n del axes[si]\n break\n if saxis==None: return mv\n data = ma.copy( mv.data )\n if numpy.version.version >= '1.7.0':\n data = ma.squeeze( data, axis=si )\n else:\n data = ma.squeeze( data ) # let's hope that there's only one singleton!\n mvnew = cdms2.createVariable ( data, axes=axes, id=mv.id )\n if hasattr(mv,'units'): mvnew.units = mv.units\n return mvnew"},"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 reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string)>2:\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n avmv = averager( mv, axis=axes_string )\n else:\n avmv = mv\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )","def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax is None:\n print \"WARNING- no time axis in\",mv.id\n return None\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n print \"WARNING- cannot compute climatology for\",mv.id,seasons.seasons\n print \"...probably there is no data for times in the requested season.\"\n return None\n avmv = mvseas\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def reset_time_dim(ds):\n return ds.assign_coords(Time=pd.to_datetime(ds.XTIME.values))","def timeave_old( mv ):\n # I haven't thought yet about how missing values would work with this...\n # If time intervals be unequal, this will have to be changed...\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\n n = sh[0]\n # BTW, this is the size of everything else:\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\n mvta = numpy.sum( mv.__array__(), axis=0 )\n mvta /= n\n return mvta","def squeeze(self, axis=None):\n # print 'input axis:', axis\n sh = self.data.shape\n if axis is None:\n axis = [a for i, a in enumerate(self.axes_names) if sh[i] == 1]\n else:\n assert self.has_axes(axis)\n ssh = np.array([sh[self.get_axis_id(a)] for a in axis])\n if (ssh != 1).all():\n raise Exception('Subset axes to squeeze (%s) '\n 'are not all one-length: %s'\n % (str(axis), str(ssh)))\n\n axis_ids = tuple(self.get_axis_id(a) for a in axis)\n # print 'axes to squeeze', axis\n # print 'ids :', axis_ids\n\n # select axes to keep:\n axes_names = [a for a in self.axes_names if a not in axis]\n\n axes_domains = dict((a, self.axes_domains[a]) for a in axes_names)\n\n if parse_version(np.__version__) >= parse_version('1.7'):\n data = self.data.squeeze(axis=axis_ids)\n else:\n sm = [':'] * len(sh)\n for i in axis_ids:\n sm[i] = '0'\n # print 'sm:', sm\n data = eval('self.data[%s]' % ','.join(sm))\n\n return xndarray(data, axes_names, axes_domains,\n self.value_label, self.meta_data)","def test_reset_temporal_axis(PM_ds_control_3d_full):\r\n smooth = 10\r\n tsmooth_kws = {\"time\": smooth}\r\n first_ori = PM_ds_control_3d_full.time[0].values\r\n first_actual = _reset_temporal_axis(\r\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\"time\"\r\n ).time.values[0]\r\n first_expected = f\"{first_ori}-{first_ori+smooth*1-1}\"\r\n assert first_actual == first_expected","def reduce2scalar( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def get_mds_axis(obj,index,strict=True):\n ax=obj.dim_of(index)\n if type(ax)!=mds.treenode.TreeNode:\n try:\n ax=ax.getAxis()\n except:\n if strict:\n raise Exception(\"Axis %s is not a treenode\"%(ax))\n return ax","def moveaxis(self, tensor, source, destination):\n\n axes = list(range(self.ndim(tensor)))\n if source < 0:\n source = axes[source]\n if destination < 0:\n destination = axes[destination]\n try:\n axes.pop(source)\n except IndexError:\n raise ValueError(\n \"Source should verify 0 <= source < tensor.ndim\" \"Got %d\" % source\n )\n try:\n axes.insert(destination, source)\n except IndexError:\n raise ValueError(\n \"Destination should verify 0 <= destination < tensor.ndim\"\n \"Got %d\" % destination\n )\n return self.transpose(tensor, axes)","def observation(self, obs):\n\n# import pdb;pdb.set_trace()\n return np.moveaxis(obs, 2, 0)","def add_timedim(data, date=\"1970-01-01\"):\n if isinstance(data, xr.DataArray):\n if \"time\" in data.dims:\n raise ValueError(\n \"You trying to add time dimension to the DataArray that already have it. \\\nThe reason migh be that you trying to use 2d variable (e.g. `a_ice`) \\\nin a function that accepts only 3d variables (e.g. `hovm_data`)\"\n )\n timestamp = [np.array(np.datetime64(date, \"ns\"))]\n data = data.expand_dims({\"time\": timestamp}, axis=0)\n return data\n else:\n data = np.expand_dims(data, axis=0)\n return data","def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\n width_axis.name = \"time\"\n assert len(conv1d_placeholder.axes.find_by_name(\"time\")) == 1\n\n conv_layer = Convolution((3, output_size), lambda x: 1)\n with pytest.raises(IncompatibleAxesError):\n conv_layer(conv1d_placeholder)\n # As a dictionary\n output = conv_layer(conv1d_placeholder, spatial_axes={\"W\": \"time\"})\n assert output.axes == conv1d_placeholder.axes\n # As a tuple\n output = conv_layer(conv1d_placeholder, spatial_axes=(\"D\", \"H\", \"time\"))\n assert output.axes == conv1d_placeholder.axes","def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def collapse_time(cube, ntimes, timestep):\n\n if timestep == None:\n print('Averaging over the %s time points' %(str(ntimes)))\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\n else:\n assert new_cube.coords()[0] == 'time'\n new_cube = cube[timestep, :, :]\n\n return new_cube","def makeKeepDims(x, y, axis):\r\n x = as_tensor_variable(x)\r\n y = as_tensor_variable(y)\r\n\r\n if axis is None:\r\n axis = range(x.type.ndim)\r\n elif isinstance(axis, (int, numpy.integer)):\r\n axis = [axis]\r\n elif isinstance(axis, numpy.ndarray) and axis.ndim == 0:\r\n axis = [int(axis)]\r\n else:\r\n axis = [int(a) for a in axis]\r\n newaxis = []\r\n for a in axis:\r\n if not isinstance(a, int):\r\n raise ValueError(\"keepdims option can be used only with constant axis\")\r\n if a < 0:\r\n a += x.type.ndim\r\n newaxis.append(a)\r\n i = 0\r\n new_dims = []\r\n for j, _ in enumerate(x.type.broadcastable):\r\n if j in newaxis:\r\n new_dims.append('x')\r\n else:\r\n new_dims.append(i)\r\n i += 1\r\n return DimShuffle(y.type.broadcastable, new_dims)(y)","def _create_squeeze(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axes', list(op.axis)),\n ])\n return node","def onAxisLogScaleChanged(self, axis_name, on):\n if axis_name in self.axes:\n # take the old axis and replace it with the new one\n old_axis = self.axes[axis_name]\n if on:\n new_axis = QtChart.QLogValueAxis()\n else:\n new_axis = QtChart.QValueAxis()\n\n # copy the values from old_axis into new_axis\n new_axis.setRange(old_axis.min(), old_axis.max())\n new_axis.setVisible(old_axis.isVisible())\n new_axis.setGridLineVisible(old_axis.isGridLineVisible())\n new_axis.setTitleText(old_axis.titleText())\n self.axes[axis_name] = new_axis\n\n # swap the old axis for the new one in chart and all series\n # attached to old_axis\n self.chart().addAxis(self.axes[axis_name],\n self.axis_alignment[axis_name])\n for unused_name, series in self.series.items():\n if old_axis in series.attachedAxes():\n series.detachAxis(old_axis)\n series.attachAxis(new_axis)\n self.chart().removeAxis(old_axis)","def addExtraAxis(slab,newaxis=None,axis=0,verbose=False):\n\n import cdms2 as cdms\n import MV2 as MV\n\n if newaxis is None:\n newaxis=cdms.createAxis([1,])\n newaxis.units=''\n\n # add new axis to axis list of input <slab>\n axislist=slab.getAxisList()\n axislist.insert(axis,newaxis)\n\n #----------------Reshape----------------\n shape=list(slab.shape)\n shape.insert(axis,len(newaxis))\n slab2=MV.reshape(slab,shape)\n\n #------------Create variable------------\n att_dict=attribute_obj2dict(slab)\n slab2=cdms.createVariable(slab2,axes=axislist,attributes=att_dict,\\\n typecode='f')\n slab2.id=slab.id\n\n if verbose:\n print('\\n# <addExtraAxis>: Originial variable shape:',slab.shape)\n print('# <addExtraAxis>: New variable shape:',slab2.shape)\n\n return slab2","def _data_with_axis(self, axis):\n shpl = list(self.data.shape)\n \n if len(shpl) == 2:\n shpl[1] += 1\n shp = tuple(shpl)\n data = numpy.zeros(shp,dtype=self.data.dtype)\n data[:,1:] = self.data\n data[:,0] = axis.data \n elif len(shpl) == 1:\n shpl.append(2)\n shp = tuple(shpl)\n data = numpy.zeros(shp,dtype=self.data.dtype)\n data[:,1] = self.data\n data[:,0] = axis.data\n else:\n raise Exception(\"Other shapes than (N,) and (N,M) not implemented\")\n return data","def common_time_axis(dismr, verbose=True):\n # generate the time axis\n Nt = len(dismr)\n time = [dt.datetime(850, 1, 15)]\n for i in range(1, len(dismr)):\n y = time[i - 1].year\n m = time[i - 1].month\n if m == 12:\n y += 1\n m = 0\n time.append(dt.datetime(y, m + 1, 15))\n time = np.array(time)\n\n return time","def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\n\n ps = phase_space[:, (id_begin-1):id_end, :]\n # print(np.shape(ps))\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\n\n x = ps[0, :, :]\n px = ps[1, :, :]\n y = ps[2, :, :]\n py = ps[3, :, :]\n\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\n\n for n in range(int(id_end-id_begin+1)):\n x_this = x[n, :]\n px_this = px[n, :]\n y_this = y[n, :]\n py_this = py[n, :]\n\n # Remove all NAN elements in the phase space array\n x_this = x_this[np.logical_not(np.isnan(x_this))]\n px_this = px_this[np.logical_not(np.isnan(px_this))]\n y_this = y_this[np.logical_not(np.isnan(y_this))]\n py_this = py_this[np.logical_not(np.isnan(py_this))]\n\n ## Plot X\n plt.subplot(2, 2, 1)\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\n plt.ylabel('Position in X/ $\\mu$m', fontsize=10)\n\n ## Plot Y\n plt.subplot(2, 2, 2)\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\n plt.ylabel('Position in Y/ $\\mu$m', fontsize=10)\n\n ## Plot px\n plt.subplot(2, 2, 3)\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\n plt.ylabel('Angle in X', fontsize=10)\n\n ## Plot py\n plt.subplot(2, 2, 4)\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\n plt.ylabel('Angle in Y', fontsize=10)\n\n\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\mu$m')\n # plt.title('First Undulator Section')\n # plt.title('Second Undulator Section')\n # plt.title('Third Undulator Section')\n\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\n\n fig = plt.gcf()\n fig.set_size_inches(13.5, 9)\n ax = plt.gca()\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\n fig.savefig('phase_space_U3_new.png', dpi=100)\n plt.show()\n\n\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\n\n return id_on_axis, s_on_axis","def _replace_dim(da, olddim, newdim, drop=True):\n\n da_new = da.rename({olddim: newdim.name})\n # note that alignment along a dimension is skipped when you are overriding\n # the relevant coordinate values\n da_new .coords[newdim.name] = newdim\n da_new = da_new.reset_coords(drop=drop)\n return da_new","def uncollapse_time_from_batch(hparams, x):\n return tf.reshape(x, [hparams.batch_size, -1] + x.shape.as_list()[1:])","def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb","def remove_temporal_mean(self):\n if not hasattr(self, 'detrended_data'):\n self.detrend_data()\n self.mean_removed_data = self.detrended_data - \\\n np.mean(self.detrended_data, axis=-1, keepdims=True)","def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\n attributes={'units':lat_axis.units},\n copy=True )\n return latmv","def uncollapse_freq_into_time(hparams, x):\n if x.shape.ndims == 3:\n return tf.reshape(x, [x.shape[0], hparams.ntimebins, constants.nfreqbins, -1])\n return tf.reshape(x, [x.shape[0], hparams.ntimebins, constants.nfreqbins])","def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # compute it with lat_bnds, lon_bnds etc.\n # If I base another reduction function on this one, it's important to note that an average\n # in the lat direction will unavoidably need weights, because of the geometry.\n\n if vid==None:\n vid = 'reduced_'+mv.id\n time_axis, lat_axis, lon_axis = tllAxes( mv )\n\n mvta = timeave_old( mv )\n\n zm = numpy.zeros( mvta.shape[0] )\n for i in range(len(lat_axis)):\n for j in range(len(lon_axis)):\n zm[i] += mvta[i,j]\n zm[i] /= len(lon_axis)\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\n return zmv","def test_axis_preservation(conv1d_placeholder, output_size):\n conv_layer = Convolution((3, output_size), lambda x: 1)\n output = conv_layer(conv1d_placeholder)\n assert output.axes == conv1d_placeholder.axes, (\"Output axes are not the same as input axes: \"\n \"{} != {}\").format(output.axes,\n conv1d_placeholder.axes)","def replace_axis(self, dim:NamedIndex,\n mapping_or_old:'Union[Mapping[NamedIndex, NamedIndex], NamedIndex]',\n new:'Optional[NamedIndex]'=None):\n\n axes = self[dim] # disable idx_dim access\n # axes = self.get(dim) or self._dim_axes[dim] # dim:'Union[int, NamedIndex]'\n is_tuple_axes = is_namedtuple(axes)\n assert isinstance(axes, dict) or is_tuple_axes, (\n f'unnamed dim({dim!r}) cannot be renamed')\n\n axes_keys = axes._fields if is_tuple_axes else axes.keys()\n axes_iter = iter(zip(axes._fields, axes)) if is_tuple_axes else axes.items()\n axes_ = OrderedDict()\n\n if new is None:\n assert isinstance(mapping_or_old, dict), (\n f\"'mapping_or_old'({type(mapping_or_old)}) is expected to be a dict \"\n \"when 'new' is None\")\n\n mapping = mapping_or_old\n for axis, index in axes_iter:\n axis = mapping.get(axis, axis)\n assert axis not in axes_, f'axis {axis!r} in mapping is conflicted'\n\n axes_[axis] = index\n else:\n assert new not in axes_keys, f'new axis({new!r}) is confilicted'\n\n old = mapping_or_old\n for axis, index in axes_iter:\n axes_[new if axis == old else axis] = index\n\n axes_ = namedtuple(dim, axes_.keys())(**axes_) if is_tuple_axes else type(axes)(axes_)\n ret = OrderedDict()\n for dim_, axes in self.items():\n ret[dim_] = axes_ if dim_ == dim else axes\n\n return type(self)(ret)","def test_default_axis_nxdata(self, nexus_base):\n assert isinstance(nexus_base.default_axis, np.ndarray)","def effect(self):\n AxisType = self.options.AxisType\n AxisDescription = self.options.AxisDescription\n AxisUnit = self.options.AxisUnit\n AxisLabel = self.options.AxisLabel\n AxisMaxValue = self.options.AxisMaxValue\n AxisMinValue = self.options.AxisMinValue\n AxisScale = self.options.AxisScale\n \n \n for id, node in self.selected.iteritems():\n axis = node #TODO: This selection should be further tested\n axis.set(inkex.addNS(\"Type\",\"TimeAnalysis\"), \"Axis\")\n axis.set(inkex.addNS(\"AxisType\",\"TimeAnalysis\"), AxisType)\n axis.set(inkex.addNS(\"AxisDescription\",\"TimeAnalysis\"), AxisDescription)\n #TODO: The label should be unique.\n axis.set(inkex.addNS(\"AxisLabel\",\"TimeAnalysis\"), AxisLabel) \n axis.set(inkex.addNS(\"AxisUnit\",\"TimeAnalysis\"), AxisUnit)\n axis.set(inkex.addNS(\"AxisMaxValue\",\"TimeAnalysis\"), AxisMaxValue)\n axis.set(inkex.addNS(\"AxisMinValue\",\"TimeAnalysis\"), AxisMinValue)\n axis.set(inkex.addNS(\"AxisScale\",\"TimeAnalysis\"), AxisScale)\n # sys.stderr.write(\"The max value of the axis is: \" + str(axis.get(inkex.addNS(\"AxisMaxValue\",\"TimeAnalysis\"))))","def test_newaxis(self):\r\n newaxis = numpy.newaxis\r\n\r\n n = self.shared(numpy.arange(24, dtype=self.dtype).reshape((2, 3, 4)))\r\n assert n.ndim == 3\r\n\r\n n4 = n[newaxis, :, :, :]\r\n assert n4.broadcastable == (True, False, False, False), n4\r\n\r\n n4 = n[:, newaxis, :, :]\r\n assert n4.broadcastable == (False, True, False, False), n4\r\n\r\n n4 = n[:, :, newaxis, :]\r\n assert n4.broadcastable == (False, False, True, False), n4\r\n\r\n n4 = n[:, :, :, newaxis]\r\n assert n4.broadcastable == (False, False, False, True), n4\r\n\r\n n3 = n.flatten()[newaxis, :, newaxis]\r\n assert n3.broadcastable == (True, False, True), n3\r\n\r\n s = cscalar()\r\n s1 = s[newaxis]\r\n assert s1.broadcastable == (True,), s1\r\n\r\n vs1, vn3, vn4 = theano.function([s], [s1, n3, n4])(-2.0)\r\n\r\n assert numpy.all(vs1 == [-2.0])\r\n assert numpy.all(vn3\r\n == numpy.arange(24)[newaxis, :, newaxis])\r\n assert numpy.all(vn4\r\n == numpy.arange(24).reshape((2, 3, 4))[:, :, :, newaxis])","def squeeze_time_dim(d, fs, twin, keepdims=False):\n\n idx = np.arange(int(fs * twin[0]), int(fs * twin[1]))\n if twin[0] == twin[1]:\n idx = [int(twin[0] * fs)]\n\n for k in d.keys():\n if type(d[k]) is dict:\n # do for est / val set\n for i in range(0, len(d[k]['est'])):\n d[k]['est'][i] = d[k]['est'][i][:, :, idx].mean(axis=-1, keepdims=True)\n d[k]['val'][i] = d[k]['val'][i][:, :, idx].mean(axis=-1, keepdims=True)\n else: \n # no est / val data\n d[k] = d[k][:, :, idx].mean(axis=-1, keepdims=keepdims)\n\n return d","def _moveaxis(self, arr, source, dest):\n try:\n source = list(source)\n except TypeError:\n source = [source]\n try:\n dest = list(dest)\n except TypeError:\n dest = [dest]\n\n source = [a + arr.ndim if a < 0 else a for a in source]\n dest = [a + arr.ndim if a < 0 else a for a in dest]\n\n order = [n for n in range(arr.ndim) if n not in source]\n\n for dest, src in sorted(zip(dest, source)):\n order.insert(dest, src)\n\n return arr.transpose(order)","def replace_dim(self, old:NamedIndex, new:NamedIndex):\n\n assert new not in self, f'new dim({new!r}) is confilicted'\n\n ret = OrderedDict()\n for dim, axes in self.items():\n if dim == old:\n if is_namedtuple(axes):\n axes = namedtuple(new, axes._fields)(*axes)\n ret[new] = axes\n else:\n ret[old] = axes\n\n return type(self)(ret)","def test_time_shifted_model():\n uneven_indices = np.delete(np.arange(len(t)), np.arange(1000)[1::2])\n uneven_indices = uneven_indices[:-1]\n\n Z_uneven_1 = Z[:, uneven_indices]\n Z_uneven_2 = Z[:, uneven_indices + 1]\n\n dmd = DMD(svd_rank=2)\n dmd.fit(X=Z)\n\n dmd_xy = DMD(svd_rank=2)\n dmd_xy.fit(X=Z_uneven_1, Y=Z_uneven_2)\n\n assert_equal_models(dmd_xy, dmd, rtol=0.01)","def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n for ax in mv.getAxisList():\n if ax.getBounds() is None:\n ax._bounds_ = ax.genGenericBounds()\n timeax = timeAxis(mv)\n if timeax.units=='months':\n # Special check necessary for LEGATES obs data, because\n # climatology() won't accept this incomplete specification\n timeax.units = 'months since 0001-01-01'\n mvseas = seasons.climatology(mv)\n if mvseas is None:\n # Among other cases, this can happen if mv has all missing values.\n return None\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n avmv.id = vid\n\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def promote_empty_dims(ds):\n ds = ds.copy()\n for di in ds.dims:\n if di not in ds.coords:\n ds.coords[di] = ds[di]\n return ds","def map_axis(axis, dimension, units):\n if axis.isTime() and units is not None:\n axis = axis.clone()\n\n axis.toRelativeTime(str(units))\n\n if dimension is None or dimension.crs == cwt.INDICES:\n selector = map_axis_indices(axis, dimension)\n elif dimension.crs == cwt.VALUES:\n selector = map_axis_values(axis, dimension)\n elif dimension.crs == cwt.TIMESTAMPS:\n selector = map_axis_timestamps(axis, dimension)\n else:\n raise WPSError('Unknown CRS {!r}', dimension.crs)\n\n return selector","def __init__(self, axis=-1):\n self.axis = axis","def reflect(self, axis):\n if axis == \"x\":\n self.y = - self.y\n elif axis == \"y\":\n self.x = - self.x\n else:\n print(\"The argument axis only accepts values 'x' and 'y'!\")","def test_dimension_size_override(self, nt=100):\n i, j, k = dimify('i j k')\n a = TimeData(name='a', dimensions=(i, j, k))\n one = symbol(name='one', dimensions=(i, j, k), value=1.)\n op = Operator(Eq(a.forward, a + one))\n\n # Test dimension override via the buffered dimenions\n a.data[0] = 0.\n op(a=a, t=6)\n assert(np.allclose(a.data[1], 5.))\n\n # Test dimension override via the parent dimenions\n a.data[0] = 0.\n op(a=a, time=5)\n assert(np.allclose(a.data[0], 4.))","def _update_axes(self):\n data_shape = self.data.shape\n if len(self.axes) < self.data.ndim + 1:\n self._axes.append(Axis())\n for index in range(self.data.ndim):\n if len(self.axes[index].values) != data_shape[index]:\n self.axes[index].values = np.arange(data_shape[index],\n dtype=np.float64)","def dd_axis(axis, ambient_dim, operand):\n d = Derivative()\n\n unit_vector = np.zeros(ambient_dim)\n unit_vector[axis] = 1\n\n unit_mvector = MultiVector(unit_vector)\n\n return d.resolve(\n (unit_mvector.scalar_product(d.dnabla(ambient_dim)))\n * d(operand))","def squeeze(self, axis: Optional[AxisLike] = None):\n\n if axis is None:\n axis = range(self.shape.shape[0])\n elif axis == -1:\n axis = self.shape.shape[0]\n if not isinstance(axis, Iterable):\n axis = [axis]\n axis = [ax for ax in axis if (self.shape[ax] == 1).all(axis=0)]\n self.shape = np.delete(self.shape, axis, axis=0)\n return self","def get_axis(self, axis):\n return self.index if axis == 0 else self.columns","def onSetToCustDims(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(0)\n\t\t\n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(1)\n\t\ttry:\n\t\t\trx = int(self.newDimX.GetValue())\n\t\t\try = int(self.newDimY.GetValue())\n\t\t\trz = int(self.newDimZ.GetValue())\n\t\t\tself.currSize = (rx, ry, rz)\n\t\texcept:\n\t\t\tpass","def mirror_axis(self, axis_index=0, reverse=False):\n self.smd3.mirror(axis_index=axis_index, reverse=reverse)\n self.logic.mirror(axis_index=axis_index, reverse=reverse)\n min_vector, max_vector = self.smd3.get_min_max_vector()\n self.header.set_box(min_vector, max_vector)\n self.header.update(self.smd3)\n self.logic.update(self.smd3)\n # self.meta.mirror(axis_index=axis_index, reverse=reverse)","def is_temporal(axis):\n return (axis.lower() in temporal_axes)","def lonvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lon_axis = lonAxis(mv)\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\n attributes={'units':lon_axis.units},\n copy=True )\n return latmv","def pop_aspect(name):\n\t_aspects[name].pop()","def _reshape_trailing(argument, factor):\n space = factor._space if isinstance(factor, RiemannianMetric) else factor\n\n if space.default_coords_type == \"vector\":\n return argument\n leading_shape = argument.shape[:-1]\n trailing_shape = space.shape\n new_shape = leading_shape + trailing_shape\n return gs.reshape(argument, new_shape)","def _lazy_axis(self):\n raise NotImplementedError","def _time_reduce(self, arr, reduction):\n if self.dtype_in_time == 'av':\n return arr\n reductions = {\n 'None': lambda xarr: xarr,\n 'ts': lambda xarr: xarr,\n 'av': lambda xarr: xarr.mean(internal_names.YEAR_STR),\n 'std': lambda xarr: xarr.std(internal_names.YEAR_STR),\n }\n try:\n return reductions[reduction](arr)\n except KeyError:\n raise ValueError(\"Specified time-reduction method '{}' is not \"\n \"supported\".format(reduction))","def rebuild_param(self,vec,**kwargs):\n from collections import OrderedDict\n tmp = OrderedDict([('lengthscale',None),( 'variance',None),( 'gstds',None)])\n for key,val in kwargs.items():\n assert val!=None, \"Can't have None as fixed values\"\n tmp[key]=val\n for key,val in tmp.items():\n if val==None:\n tmp[key]=vec[0]\n vec = np.delete(vec,0)\n return np.array([tmp[key] for key in tmp])","def _increment_dims_left(self, axis: int = None):\n if axis is None:\n axis = self.last_used\n self.set_current_step(axis, self.current_step[axis] - 1)","def __rmul__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.gmt_func(other.value, self.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return other*obj\n newValue = other*self.value\n\n return self._newMV(newValue)","def moveaxis(a, source, destination):\n a = astensor(a)\n\n source = normalize_axis_tuple(source, a.ndim, \"source\")\n destination = normalize_axis_tuple(destination, a.ndim, \"destination\")\n if len(source) != len(destination):\n raise ValueError(\n \"`source` and `destination` arguments must have \"\n \"the same number of elements\"\n )\n\n order = [n for n in range(a.ndim) if n not in source]\n\n for dest, src in sorted(zip(destination, source)):\n order.insert(dest, src)\n\n return transpose(a, order)","def reset_spatial_dims_attrs(self):\n if self.crs is None:\n raise ValueError(\"CRS is missing. Use set_crs function to resolve.\")\n _da = self._obj\n x_dim, y_dim, x_attrs, y_attrs = gis_utils.axes_attrs(self.crs)\n if x_dim != self.x_dim or y_dim != self.y_dim:\n _da = _da.rename({self.x_dim: x_dim, self.y_dim: y_dim})\n _da[x_dim].attrs.update(x_attrs)\n _da[y_dim].attrs.update(y_attrs)\n _da.raster.set_spatial_dims(x_dim=x_dim, y_dim=y_dim)\n return _da","def on_data_vars_change(self, change):\n if change['type'] == 'change' and change['name'] == 'value':\n self.left_ds = getattr(self.ts.data, change['new'])\n if self.mask is None:\n self.right_ds = self.left_ds.copy(deep=True)\n else:\n self.right_ds = self.left_ds * self.mask\n\n self.left_imshow.set_data(self.left_ds.data[0])\n self.right_imshow.set_data(self.right_ds.data[0])","def __init__(self, x_dimname='lon', y_dimname='lat', time_dimname='time'):\n self.x_dimname = x_dimname\n self.y_dimname = y_dimname\n self.time_dimname = time_dimname","def _swap_axis(input_tensor, dim_index, last_index, name=None):\n return array_ops.transpose(\n input_tensor,\n array_ops.concat([\n math_ops.range(dim_index), [last_index],\n math_ops.range(dim_index + 1, last_index), [dim_index]\n ], 0),\n name=name)","def remove_different_category_time(self):\n if self._isCollection:\n self.time_series_data.remove_different_time_index()\n else:\n warnings.warn('Setup mainCategoryCol is necessary for this function')\n return self","def moveaxis(tensor: tf.Tensor, source: int, destination: int) -> tf.Tensor:\n ndim = len(tensor.shape)\n source = _normalize_axis(source, ndim)\n destination = _normalize_axis(destination, ndim)\n order = [n for n in range(ndim) if n != source]\n order.insert(destination, source)\n return tf.transpose(tensor, order)","def allAxes( mv ):\n if mv is None: return None\n return mv.getAxisList()","def reshape_mat(self, data):\n if len(data['x'][0]) < self.num_ofdim:\n x = data['x']\n x_plus = np.zeros([len(x), self.num_ofdim - len(x[0])])\n data['x'] = np.append(x, x_plus, axis=1)\n return data","def adjust_axes(axes):\n # TODO: Uncomment & decide for each subplot!\n for ax in axes.itervalues():\n core.hide_axis(ax)\n\n for k in [\n \"placeholder\",\n \"placeholder1\",\n \"placeholder2\",\n \"spikes_stim\",\n \"spikes_stim1\",\n \"spikes_stim2\",\n \"spikes_post\",\n \"stimulation_schema\"\n ]:\n axes[k].set_frame_on(False)","def reduce2latlon( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\n axes_string = '('+')('.join(axis_names)+')'\n for ax in axes:\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\n ax.setBounds( ax.genGenericBounds() )\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def test_reset_temporal_axis_lead(PM_ds_initialized_3d_full):\r\n smooth = 10\r\n dim = \"lead\"\r\n tsmooth_kws = {dim: smooth}\r\n first_ori = PM_ds_initialized_3d_full.lead[0].values\r\n first_actual = _reset_temporal_axis(\r\n PM_ds_initialized_3d_full, tsmooth_kws=tsmooth_kws\r\n )[dim].values[0]\r\n first_expected = f\"{first_ori}-{first_ori+smooth*1-1}\"\r\n assert first_actual == first_expected","def remove_mean(self, axes=None):\n axes = self._get_axes_numbers(axes)\n out = self\n if 0 in axes:\n out = self - self.mean(0)\n if 1 in axes:\n out = (self.T - self.mean(1)).T\n return out","def _share_short_axis(self, share, side, level):\n if share is None or self._panel_side: # not None\n return\n s = side[0]\n axis = 'x' if s in 'lr' else 'y'\n caxs = getattr(self, '_' + s + 'panels')\n paxs = getattr(share, '_' + s + 'panels')\n caxs = [pax for pax in caxs if not pax._panel_filled]\n paxs = [pax for pax in paxs if not pax._panel_filled]\n for cax, pax in zip(caxs, paxs): # may be uneven\n getattr(cax, '_share' + axis + '_setup')(pax, level)","def add_axes(x, num=1, pos='left'):\n if is_theano_object(x):\n if pos in ['left', 'before', 'begin', 'first']:\n shuffle_pattern = ['x']*num\n shuffle_pattern.extend(range(x.ndim))\n elif pos in ['right', 'after', 'end', 'last']:\n shuffle_pattern = list(range(x.ndim))\n shuffle_pattern.extend( ['x']*num )\n elif pos == 'before last':\n shuffle_pattern = list(range(x.ndim))\n shuffle_pattern = shuffle_pattern[:-1] + ['x']*num + shuffle_pattern[-1:]\n else:\n try:\n shuffle_pattern = list(range(x.ndim))\n shuffle_pattern = shuffle_pattern[:pos] + ['x']*num + shuffle_pattern[pos:]\n except TypeError:\n raise ValueError(\"Unrecognized argument `{}` for pos.\".format(pos))\n return x.dimshuffle(shuffle_pattern)\n else:\n x = np.asarray(x)\n if pos in ['left', 'before', 'begin', 'first']:\n return x.reshape( (1,)*num + x.shape )\n elif pos in ['right', 'after', 'end', 'last']:\n return x.reshape( x.shape + (1,)*num )\n elif pos == 'before last':\n return x.reshape( x.shape[:-1] + (1,)*num + x.shape[-1:] )\n else:\n try:\n return x.reshape( x.shape[:pos] + (1,)*num + x.shape[pos:] )\n except TypeError:\n raise ValueError(\"Unrecognized argument {} for pos.\".format(pos))","def common_axis( axis1, axis2 ):\n if hasattr( axis1, 'units' ):\n units1 = axis1.units.lower().replace(' ','_')\n if axis1.isTime():\n axis1.toRelativeTime( units1 ) #probably will change input argument\n else:\n units1 = None\n if hasattr( axis2, 'units' ):\n units2 = axis2.units.lower().replace(' ','_')\n else:\n units2 = None\n if units1!=None and units2!=None and units1 != units2:\n if axis1.isTime() and axis2.isTime():\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\n else:\n print \"ERROR. common_axis does not yet support differing units\",axis1.units,\" and \",axis2.units\n return None\n if axis1.isTime() or axis2.isTime():\n if not axis2.isTime() or not axis1.isTime():\n print \"ERROR. In common_axis, one axis is time, not the other\"\n return None\n if not axis1.calendar==axis2.calendar:\n print \"ERROR. common_axis does not yet support differing calendars.\"\n if len(axis1)==1 and len(axis2)==1:\n # There's just one time value, probably from averaging over time. The time value is meaningless\n # but it would be messy to have two.\n return (axis1,[0],[0])\n\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\n # units and calendar attributes should always be transferred if present.\n # Also to do: use bounds if available\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\n a1indexina3 = a12indexina3[0:len(axis1)]\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\n\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\n vid = axis1.id\n else:\n vid = None\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\n axis3.units = units1\n return (axis3,a1indexina3,a2indexina3)","def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\n attributes={'units':lev_axis.units},\n copy=True )\n return levmv","def fixdims(var):\n\t\n\tfor ii in var.dims:\n\t\tkk=ii[:3].lower()\n\t\t\n\t\tif kk == 'lat':\n\t\t\tvar=var.rename({ii:'lat'})\n\t\t\t\n\t\tif kk == 'lon':\n\t\t\tvar=var.rename({ii:'lon'})\n\t\t\t\n\t\tif kk == 'lev' or kk == 'ple' or kk == 'pre':\n\t\t\tvar=var.rename({ii:'level'})\n\n\t\tif kk == 'tim':\n\t\t\tvar=var.rename({ii:'time'})\n\n\treturn var","def moment_update(model, model_ema, m):\r\n for p1, p2 in zip(model.parameters(), model_ema.parameters()):\r\n p2.data.mul_(m).add_(1 - m, p1.detach().data)\r\n # p2.data.mul_(m).add_(1 - m, p1.data)","def __init__(self, incoming, axis=-1, name='MultiplicativeNoiseLayer'):\n super(ArgMaxOneHot, self).__init__()\n \n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n \n self.axis = axis\n self.out = None\n self.name = name","def _set_and_permute_time_axis(tensor, sequence_length, axis=-3):\n shape = tensor.shape.as_list()\n shape[0] = sequence_length\n tensor.set_shape(shape)\n\n # in the original tensor the first axis is always the time axis.\n permutation = list(range(tensor.shape.ndims))\n permutation[0] = permutation[axis]\n permutation[axis] = 0\n return tf.transpose(tensor, permutation)","def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals","def common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n axes3.append(common_axis( axes1[i], axes2[i] ))\n return axes3","def _finalize_axis(self, key, **kwargs):\n axis = self.handles['axis']\n self.handles['fig'].set_frameon(False)\n axis.grid(self.show_grid)\n axis.view_init(elev=self.elevation, azim=self.azimuth)\n try:\n axis._dist = self.distance\n except Exception:\n # axis.dist is deprecated see here:\n # https://github.com/matplotlib/matplotlib/pull/22084\n axis.dist = self.distance\n\n if self.xaxis is None:\n axis.w_xaxis.line.set_lw(0.)\n axis.w_xaxis.label.set_text('')\n if self.yaxis is None:\n axis.w_yaxis.line.set_lw(0.)\n axis.w_yaxis.label.set_text('')\n if self.zaxis is None:\n axis.w_zaxis.line.set_lw(0.)\n axis.w_zaxis.label.set_text('')\n if self.disable_axes:\n axis.set_axis_off()\n\n if mpl_version <= Version('1.5.9'):\n axis.set_axis_bgcolor(self.bgcolor)\n else:\n axis.set_facecolor(self.bgcolor)\n return super()._finalize_axis(key, **kwargs)","def x(self, index=np.nan, alter='', xyValue=None, errorIfxyMix=False, neutral=False):\n if alter != '':\n if alter == 'nmeV':\n # invert order of xyValue, to help for graph xlim and ylim\n if xyValue is not None:\n xyValue = np.array(xyValue)\n if len(xyValue.shape) > 1:\n xyValue = [xyValue[0, ::-1], xyValue[1, ::-1]]\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n return Curve.NMTOEV / self.x(index, xyValue=xyValue)\n elif alter == 'nmcm-1':\n # invert order of xyValue, to help for graph xlim and ylim\n if xyValue is not None:\n xyValue = np.array(xyValue)\n if len(xyValue.shape) > 1:\n xyValue = [xyValue[0, ::-1], xyValue[1, ::-1]]\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n return 1e7 / self.x(index, xyValue=xyValue)\n elif alter == 'MCAkeV':\n offset = self.attr('_MCA_CtokeV_offset', default=0)\n mult = self.attr('_MCA_CtokeV_mult', default=1)\n return mult * (self.x(index, xyValue=xyValue) + offset)\n elif alter == 'SIMSdepth':\n offset = self.attr('_SIMSdepth_offset', default=0)\n mult = self.attr('_SIMSdepth_mult', default=1)\n return mult * (self.x(index, xyValue=xyValue) + offset)\n elif alter == 'y':\n try:\n xyValue = xyValue[::-1]\n except TypeError:\n pass\n # print('x xyValue', xyValue, self.y(index, xyValue=xyValue))\n return self.y(index, xyValue=xyValue)\n elif alter != '':\n split = alter.split('.')\n if len(split) == 2:\n module_name = 'grapa.datatypes.' + split[0][0].lower() + split[0][1:]\n import importlib\n try:\n mod = importlib.import_module(module_name)\n met = getattr(getattr(mod, split[0]), split[1])\n return met(self, index=index, xyValue=xyValue)\n except ImportError as e:\n print('ERROR Curve.x Exception raised during module',\n 'import', module_name, ':')\n print(e)\n else:\n print('Error Curve.x: cannot identify alter keyword ('\n + alter + ').')\n\n # alter might be used by subclasses\n val = self.data if xyValue is None else np.array(xyValue)\n if len(val.shape) > 1:\n if np.isnan(index).any():\n return val[0, :]\n return val[0, index]\n return val[0]","def _configure_axis(self, source, title):\n conf = source.conf[title]\n if source.data_type[title] == 'image':\n self.plot.getView().invertY(True)\n else:\n self.plot.getView().invertY(False)\n if(self.settingsWidget.ui.flipy.currentText() == 'Yes' or\n (self.settingsWidget.ui.flipy.currentText() == 'Auto' and\n \"flipy\" in conf and conf['flipy'] == True)):\n self.plot.getView().invertY(not self.plot.getView().getViewBox().yInverted())\n if(self.settingsWidget.ui.flipx.currentText() == 'Yes' or\n (self.settingsWidget.ui.flipx.currentText() == 'Auto' and\n \"flipx\" in conf and conf['flipx'] == True)):\n self.plot.getView().invertX(not self.plot.getView().getViewBox().xInverted())\n\n # Tranpose images to make x (last dimension) horizontal\n axis_labels = ['left', 'bottom']\n xlabel_index = 0\n ylabel_index = 1\n if (source.data_type[title] == 'image') or (source.data_type[title] == 'triple'):\n xlabel_index = (xlabel_index+1)%2\n ylabel_index = (ylabel_index+1)%2\n\n if(self.settingsWidget.ui.transpose.currentText() == 'Yes' or\n (self.settingsWidget.ui.transpose.currentText() == 'Auto' \n and \"transpose\" in conf)):\n xlabel_index = (xlabel_index+1)%2\n ylabel_index = (ylabel_index+1)%2\n\n self.x_axis_name = axis_labels[xlabel_index]\n self.y_axis_name = axis_labels[ylabel_index]\n if(self.actionX_axis.isChecked()):\n if(self.settingsWidget.ui.x_label_auto.isChecked() and \n \"xlabel\" in conf):\n self.plot.getView().setLabel(axis_labels[xlabel_index], conf['xlabel']) #pylint: disable=no-member\n else:\n self.plot.getView().setLabel(axis_labels[xlabel_index], self.settingsWidget.ui.x_label.text()) #pylint: disable=no-member\n\n if(self.actionY_axis.isChecked()):\n if(self.settingsWidget.ui.y_label_auto.isChecked() and \n \"ylabel\" in conf):\n self.plot.getView().setLabel(axis_labels[ylabel_index], conf['ylabel']) #pylint: disable=no-member\n else:\n self.plot.getView().setLabel(axis_labels[ylabel_index], self.settingsWidget.ui.y_label.text()) #pylint: disable=no-member","def update_svq_time_metric(ml_channel_id, ml_channel_name):\n result = []\n entry = [\"MediaLive\", \"SvqTime\", \"ChannelId\", ml_channel_id, \"Pipeline\", \"0\", {\"label\": ml_channel_name + \"-0\"}]\n result.append(entry)\n entry = [\"MediaLive\", \"SvqTime\", \"ChannelId\", ml_channel_id, \"Pipeline\", \"1\", {\"yAxis\": \"right\",\n \"label\": ml_channel_name + \"-1\"}]\n result.append(entry)\n return result","def updateDims(self, key=\"\", val=None):\n self.setDimension(key, val)\n self.setDimension(\n \"outer_radius\",\n self.getDimension(\"inner_radius\")\n + self.getDimension(\"radius_differential\"),\n )\n self.setDimension(\n \"outer_axial\",\n self.getDimension(\"inner_axial\") + self.getDimension(\"height\"),\n )\n self.setDimension(\n \"outer_theta\",\n self.getDimension(\"inner_theta\")\n + self.getDimension(\"azimuthal_differential\"),\n )","def diff_1(value, axis=0, name=None):\n with tf.name_scope(name or 'diff_1'):\n value = tf.convert_to_tensor(value)\n a = array.slice_from_axis(value, end=-1, axis=axis)\n b = array.slice_from_axis(value, begin=1, axis=axis)\n diff_tensor = b - a\n return diff_tensor","def get_axis_name(self, axis_id):\n if isinstance(axis_id, str):\n if axis_id in self.axes_names:\n return axis_id\n else:\n return None\n assert np.isreal(axis_id) and np.round(axis_id) == axis_id\n if axis_id >= 0 and axis_id < self.get_ndims():\n return self.axes_names[axis_id]\n else:\n return None","def _newMV(self, newValue=None, *, dtype: np.dtype = None) -> 'MultiVector':\n if newValue is None and dtype is None:\n raise TypeError(\"Must specify either a type or value\")\n\n return self.__class__(self.layout, newValue, dtype=dtype)","def copy_and_append_time_dimension_to_netcdf_dataset(self,dataset_in,dataset_out):\n\n for dim_name,dim_obj in list(dataset_in.dimensions.items()):\n dataset_out.createDimension(dim_name,len(dim_obj)\n if not dim_obj.isunlimited() else None)\n dataset_out.createDimension('time',None)\n times = dataset_out.createVariable(\"time\",'f8',(\"time\",))\n times.units = \"years since 0001-01-01 00:00:00.0\"\n times.calendar = \"proleptic_gregorian\"\n times[0] = np.array([0.0])\n for var_name, var_obj in list(dataset_in.variables.items()):\n new_var = dataset_out.createVariable(var_name,var_obj.datatype,var_obj.dimensions\n if (len(var_obj.dimensions) <= 1\n or var_name == 'AREA') else\n [\"time\"] + list(var_obj.dimensions))\n if len(var_obj.dimensions) <= 1 or var_name == 'AREA':\n new_var[:] = var_obj[:]\n else:\n new_var[0,:] = var_obj[:]\n new_var.setncatts({attr_name: var_obj.getncattr(attr_name) for attr_name in var_obj.ncattrs()})","def _create_reduceOp(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axes', list(op.axes)),\n helper.make_attribute('keepdims', op.keepdims),\n ])\n return node","def axisinfo(self, unit, axis):\n majloc = AstropyTimeLocator(self)\n majfmt = AstropyTimeFormatter(self)\n return units.AxisInfo(\n majfmt=majfmt, majloc=majloc, label=f\"Time ({self.scale})\"\n )","def upAxis(*args, axis: Union[AnyStr, bool]=\"\", rotateView: bool=True, q=True, query=True,\n **kwargs)->Union[None, Any]:\n pass","def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( mv, axis=axes_string )\n avmv.id = vid\n avmv.units = mv.units\n\n return avmv","def _log_moments_every_epoch(self, x: tf.Tensor, axes: List[int], name: str) -> None:\n effective_batch_size = FLAGS.physical_batch_size * FLAGS.virtual_batch_size_factor\n steps_per_epoch = TinyImageNetPipeline.num_train_samples // effective_batch_size\n mean, stddev = tf.nn.moments(x, axes)\n\n if len(mean.shape) != len(axes):\n # normalize over the other dimensions\n mean = tf.reduce_mean(mean)\n stddev = tf.reduce_mean(stddev)\n\n self.logger_factory.add_scalar('mean_{}'.format(name), mean, log_frequency=steps_per_epoch)\n self.logger_factory.add_scalar('stddev_{}'.format(name), stddev, log_frequency=steps_per_epoch)","def _metadata_changed(self, old, new):\n\n #self.cross_plot.value_range.low = self.minz\n #self.cross_plot.value_range.high = self.maxz\n #self.cross_plot2.value_range.low = self.minz\n #self.cross_plot2.value_range.high = self.maxz\n if self._imag_index.metadata.has_key(\"selections\"):\n x_ndx, y_ndx = self._imag_index.metadata[\"selections\"]\n if y_ndx and x_ndx:\n# xdata, ydata = self._image_index.get_data()\n# xdata, ydata = xdata.get_data(), ydata.get_data()\n self.pd_horiz.set_data(\"horiz\", self._image_value.data[y_ndx,:])\n self.pd_vert.set_data(\"vert\", self._image_value.data[:,x_ndx])","def test_reduce_default_dtype(self):\r\n # We try multiple axis combinations even though axis should not matter.\r\n for method in self.methods:\r\n for idx, dtype in enumerate(imap(str, theano.scalar.all_types)):\r\n axis = self.axes[idx % len(self.axes)]\r\n x = tensor.matrix(dtype=dtype)\r\n s = getattr(x, method)(axis=axis)\r\n assert s.dtype == dict(\r\n int8='int64',\r\n int16='int64',\r\n int32='int64',\r\n uint8='uint64',\r\n uint16='uint64',\r\n uint32='uint64',\r\n ).get(dtype, dtype)\r\n f = theano.function([x], s, mode=self.mode)\r\n topo = f.maker.fgraph.toposort()\r\n assert [n for n in topo if isinstance(n.op, self.op)], (topo, dtype)\r\n data = numpy.random.rand(3, 4) * 10\r\n data = data.astype(dtype)\r\n f(data)","def nd_shape_checking(x, y, mvaxis, traxis):\n assert x.ndim == y.ndim\n dims = np.delete(np.arange(x.ndim), -2)\n assert all([x.shape[k] == y.shape[k] for k in dims])","def _ureduce(a, func, **kwargs):\n a = np.asanyarray(a)\n axis = kwargs.get('axis', None)\n if axis is not None:\n keepdim = list(a.shape)\n nd = a.ndim\n axis = _nx.normalize_axis_tuple(axis, nd)\n\n for ax in axis:\n keepdim[ax] = 1\n\n if len(axis) == 1:\n kwargs['axis'] = axis[0]\n else:\n keep = set(range(nd)) - set(axis)\n nkeep = len(keep)\n # swap axis that should not be reduced to front\n for i, s in enumerate(sorted(keep)):\n a = a.swapaxes(i, s)\n # merge reduced axis\n a = a.reshape(a.shape[:nkeep] + (-1,))\n kwargs['axis'] = -1\n keepdim = tuple(keepdim)\n else:\n keepdim = (1,) * a.ndim\n\n r = func(a, **kwargs)\n return r, keepdim"],"string":"[\n \"def reduce_time( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id=='time' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n if len(axes_string)>2:\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n avmv = averager( mv, axis=axes_string )\\n else:\\n avmv = mv\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def convert_axis( mv, axisold, axisindnew ):\\n (axisnew, indexina3) = axisindnew\\n axes = allAxes(mv)\\n kold = None\\n for k in range(len(axes)):\\n if axes[k]==axisold: kold=k\\n if kold==None:\\n print \\\"ERROR. convert_axis cannot find axis\\\",axisold,\\\" in variable\\\",mv\\n if len(axisold)==len(axisnew):\\n mv.setAxis( kold, axisnew )\\n return\\n # Here's what we would do in 1-D:\\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # for i in range(len(axisold)):\\n # newdata[ indexina3[i] ] = ma[i]\\n # newmv = cdms2.createVariable( newdata, id=mv.id )\\n # >1-D is the same idea, but more dimensions are coming along for the ride,\\n # making it more complicated...\\n shape0 = mv.shape\\n shape0[kold] = len(axisnew)\\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\\n # There seems to be nothing in numpy for treating one axis differently from the rest\\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\\n # The following will do the job. It would be very slow for an array with many big dimensions,\\n # but the arrays here have already been reduced for graphics; the index sets will be small or\\n # empty...\\n ranges = map( range, shape0[0:kold] )\\n for i in range(len(axisold)):\\n for idx in apply(itertools.product,ranges):\\n idx = idx + [indexina3(i)] + [Ellipsis]\\n idxo = idx + [i] + [Ellipsis]\\n newdata[ tuple(idx) ] = mv[idxo]\\n newmv = cdms2.createVariable( newdata, id=mv.id )\",\n \"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax is None:\\n print \\\"WARNING- no time axis in\\\",mv.id\\n return None\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n print \\\"WARNING- cannot compute climatology for\\\",mv.id,seasons.seasons\\n print \\\"...probably there is no data for times in the requested season.\\\"\\n return None\\n avmv = mvseas\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def reset_time_dim(ds):\\n return ds.assign_coords(Time=pd.to_datetime(ds.XTIME.values))\",\n \"def timeave_old( mv ):\\n # I haven't thought yet about how missing values would work with this...\\n # If time intervals be unequal, this will have to be changed...\\n sh = mv.shape # e.g. [312,90,144] for t,lat,lon\\n n = sh[0]\\n # BTW, this is the size of everything else:\\n # n2 = reduce( operator.mul, sh[1:] ) # e.g. 90*144=12960\\n mvta = numpy.sum( mv.__array__(), axis=0 )\\n mvta /= n\\n return mvta\",\n \"def squeeze(self, axis=None):\\n # print 'input axis:', axis\\n sh = self.data.shape\\n if axis is None:\\n axis = [a for i, a in enumerate(self.axes_names) if sh[i] == 1]\\n else:\\n assert self.has_axes(axis)\\n ssh = np.array([sh[self.get_axis_id(a)] for a in axis])\\n if (ssh != 1).all():\\n raise Exception('Subset axes to squeeze (%s) '\\n 'are not all one-length: %s'\\n % (str(axis), str(ssh)))\\n\\n axis_ids = tuple(self.get_axis_id(a) for a in axis)\\n # print 'axes to squeeze', axis\\n # print 'ids :', axis_ids\\n\\n # select axes to keep:\\n axes_names = [a for a in self.axes_names if a not in axis]\\n\\n axes_domains = dict((a, self.axes_domains[a]) for a in axes_names)\\n\\n if parse_version(np.__version__) >= parse_version('1.7'):\\n data = self.data.squeeze(axis=axis_ids)\\n else:\\n sm = [':'] * len(sh)\\n for i in axis_ids:\\n sm[i] = '0'\\n # print 'sm:', sm\\n data = eval('self.data[%s]' % ','.join(sm))\\n\\n return xndarray(data, axes_names, axes_domains,\\n self.value_label, self.meta_data)\",\n \"def test_reset_temporal_axis(PM_ds_control_3d_full):\\r\\n smooth = 10\\r\\n tsmooth_kws = {\\\"time\\\": smooth}\\r\\n first_ori = PM_ds_control_3d_full.time[0].values\\r\\n first_actual = _reset_temporal_axis(\\r\\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\\\"time\\\"\\r\\n ).time.values[0]\\r\\n first_expected = f\\\"{first_ori}-{first_ori+smooth*1-1}\\\"\\r\\n assert first_actual == first_expected\",\n \"def reduce2scalar( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def get_mds_axis(obj,index,strict=True):\\n ax=obj.dim_of(index)\\n if type(ax)!=mds.treenode.TreeNode:\\n try:\\n ax=ax.getAxis()\\n except:\\n if strict:\\n raise Exception(\\\"Axis %s is not a treenode\\\"%(ax))\\n return ax\",\n \"def moveaxis(self, tensor, source, destination):\\n\\n axes = list(range(self.ndim(tensor)))\\n if source < 0:\\n source = axes[source]\\n if destination < 0:\\n destination = axes[destination]\\n try:\\n axes.pop(source)\\n except IndexError:\\n raise ValueError(\\n \\\"Source should verify 0 <= source < tensor.ndim\\\" \\\"Got %d\\\" % source\\n )\\n try:\\n axes.insert(destination, source)\\n except IndexError:\\n raise ValueError(\\n \\\"Destination should verify 0 <= destination < tensor.ndim\\\"\\n \\\"Got %d\\\" % destination\\n )\\n return self.transpose(tensor, axes)\",\n \"def observation(self, obs):\\n\\n# import pdb;pdb.set_trace()\\n return np.moveaxis(obs, 2, 0)\",\n \"def add_timedim(data, date=\\\"1970-01-01\\\"):\\n if isinstance(data, xr.DataArray):\\n if \\\"time\\\" in data.dims:\\n raise ValueError(\\n \\\"You trying to add time dimension to the DataArray that already have it. \\\\\\nThe reason migh be that you trying to use 2d variable (e.g. `a_ice`) \\\\\\nin a function that accepts only 3d variables (e.g. `hovm_data`)\\\"\\n )\\n timestamp = [np.array(np.datetime64(date, \\\"ns\\\"))]\\n data = data.expand_dims({\\\"time\\\": timestamp}, axis=0)\\n return data\\n else:\\n data = np.expand_dims(data, axis=0)\\n return data\",\n \"def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\\n width_axis.name = \\\"time\\\"\\n assert len(conv1d_placeholder.axes.find_by_name(\\\"time\\\")) == 1\\n\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n with pytest.raises(IncompatibleAxesError):\\n conv_layer(conv1d_placeholder)\\n # As a dictionary\\n output = conv_layer(conv1d_placeholder, spatial_axes={\\\"W\\\": \\\"time\\\"})\\n assert output.axes == conv1d_placeholder.axes\\n # As a tuple\\n output = conv_layer(conv1d_placeholder, spatial_axes=(\\\"D\\\", \\\"H\\\", \\\"time\\\"))\\n assert output.axes == conv1d_placeholder.axes\",\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def collapse_time(cube, ntimes, timestep):\\n\\n if timestep == None:\\n print('Averaging over the %s time points' %(str(ntimes)))\\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\\n else:\\n assert new_cube.coords()[0] == 'time'\\n new_cube = cube[timestep, :, :]\\n\\n return new_cube\",\n \"def makeKeepDims(x, y, axis):\\r\\n x = as_tensor_variable(x)\\r\\n y = as_tensor_variable(y)\\r\\n\\r\\n if axis is None:\\r\\n axis = range(x.type.ndim)\\r\\n elif isinstance(axis, (int, numpy.integer)):\\r\\n axis = [axis]\\r\\n elif isinstance(axis, numpy.ndarray) and axis.ndim == 0:\\r\\n axis = [int(axis)]\\r\\n else:\\r\\n axis = [int(a) for a in axis]\\r\\n newaxis = []\\r\\n for a in axis:\\r\\n if not isinstance(a, int):\\r\\n raise ValueError(\\\"keepdims option can be used only with constant axis\\\")\\r\\n if a < 0:\\r\\n a += x.type.ndim\\r\\n newaxis.append(a)\\r\\n i = 0\\r\\n new_dims = []\\r\\n for j, _ in enumerate(x.type.broadcastable):\\r\\n if j in newaxis:\\r\\n new_dims.append('x')\\r\\n else:\\r\\n new_dims.append(i)\\r\\n i += 1\\r\\n return DimShuffle(y.type.broadcastable, new_dims)(y)\",\n \"def _create_squeeze(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n\\n node.attribute.extend([\\n helper.make_attribute('axes', list(op.axis)),\\n ])\\n return node\",\n \"def onAxisLogScaleChanged(self, axis_name, on):\\n if axis_name in self.axes:\\n # take the old axis and replace it with the new one\\n old_axis = self.axes[axis_name]\\n if on:\\n new_axis = QtChart.QLogValueAxis()\\n else:\\n new_axis = QtChart.QValueAxis()\\n\\n # copy the values from old_axis into new_axis\\n new_axis.setRange(old_axis.min(), old_axis.max())\\n new_axis.setVisible(old_axis.isVisible())\\n new_axis.setGridLineVisible(old_axis.isGridLineVisible())\\n new_axis.setTitleText(old_axis.titleText())\\n self.axes[axis_name] = new_axis\\n\\n # swap the old axis for the new one in chart and all series\\n # attached to old_axis\\n self.chart().addAxis(self.axes[axis_name],\\n self.axis_alignment[axis_name])\\n for unused_name, series in self.series.items():\\n if old_axis in series.attachedAxes():\\n series.detachAxis(old_axis)\\n series.attachAxis(new_axis)\\n self.chart().removeAxis(old_axis)\",\n \"def addExtraAxis(slab,newaxis=None,axis=0,verbose=False):\\n\\n import cdms2 as cdms\\n import MV2 as MV\\n\\n if newaxis is None:\\n newaxis=cdms.createAxis([1,])\\n newaxis.units=''\\n\\n # add new axis to axis list of input <slab>\\n axislist=slab.getAxisList()\\n axislist.insert(axis,newaxis)\\n\\n #----------------Reshape----------------\\n shape=list(slab.shape)\\n shape.insert(axis,len(newaxis))\\n slab2=MV.reshape(slab,shape)\\n\\n #------------Create variable------------\\n att_dict=attribute_obj2dict(slab)\\n slab2=cdms.createVariable(slab2,axes=axislist,attributes=att_dict,\\\\\\n typecode='f')\\n slab2.id=slab.id\\n\\n if verbose:\\n print('\\\\n# <addExtraAxis>: Originial variable shape:',slab.shape)\\n print('# <addExtraAxis>: New variable shape:',slab2.shape)\\n\\n return slab2\",\n \"def _data_with_axis(self, axis):\\n shpl = list(self.data.shape)\\n \\n if len(shpl) == 2:\\n shpl[1] += 1\\n shp = tuple(shpl)\\n data = numpy.zeros(shp,dtype=self.data.dtype)\\n data[:,1:] = self.data\\n data[:,0] = axis.data \\n elif len(shpl) == 1:\\n shpl.append(2)\\n shp = tuple(shpl)\\n data = numpy.zeros(shp,dtype=self.data.dtype)\\n data[:,1] = self.data\\n data[:,0] = axis.data\\n else:\\n raise Exception(\\\"Other shapes than (N,) and (N,M) not implemented\\\")\\n return data\",\n \"def common_time_axis(dismr, verbose=True):\\n # generate the time axis\\n Nt = len(dismr)\\n time = [dt.datetime(850, 1, 15)]\\n for i in range(1, len(dismr)):\\n y = time[i - 1].year\\n m = time[i - 1].month\\n if m == 12:\\n y += 1\\n m = 0\\n time.append(dt.datetime(y, m + 1, 15))\\n time = np.array(time)\\n\\n return time\",\n \"def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\\n\\n ps = phase_space[:, (id_begin-1):id_end, :]\\n # print(np.shape(ps))\\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\\n\\n x = ps[0, :, :]\\n px = ps[1, :, :]\\n y = ps[2, :, :]\\n py = ps[3, :, :]\\n\\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\\n\\n for n in range(int(id_end-id_begin+1)):\\n x_this = x[n, :]\\n px_this = px[n, :]\\n y_this = y[n, :]\\n py_this = py[n, :]\\n\\n # Remove all NAN elements in the phase space array\\n x_this = x_this[np.logical_not(np.isnan(x_this))]\\n px_this = px_this[np.logical_not(np.isnan(px_this))]\\n y_this = y_this[np.logical_not(np.isnan(y_this))]\\n py_this = py_this[np.logical_not(np.isnan(py_this))]\\n\\n ## Plot X\\n plt.subplot(2, 2, 1)\\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\\n plt.ylabel('Position in X/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot Y\\n plt.subplot(2, 2, 2)\\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\\n plt.ylabel('Position in Y/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot px\\n plt.subplot(2, 2, 3)\\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\\n plt.ylabel('Angle in X', fontsize=10)\\n\\n ## Plot py\\n plt.subplot(2, 2, 4)\\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\\n plt.ylabel('Angle in Y', fontsize=10)\\n\\n\\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\\\mu$m')\\n # plt.title('First Undulator Section')\\n # plt.title('Second Undulator Section')\\n # plt.title('Third Undulator Section')\\n\\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\\n\\n fig = plt.gcf()\\n fig.set_size_inches(13.5, 9)\\n ax = plt.gca()\\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\\n fig.savefig('phase_space_U3_new.png', dpi=100)\\n plt.show()\\n\\n\\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\\n\\n return id_on_axis, s_on_axis\",\n \"def _replace_dim(da, olddim, newdim, drop=True):\\n\\n da_new = da.rename({olddim: newdim.name})\\n # note that alignment along a dimension is skipped when you are overriding\\n # the relevant coordinate values\\n da_new .coords[newdim.name] = newdim\\n da_new = da_new.reset_coords(drop=drop)\\n return da_new\",\n \"def uncollapse_time_from_batch(hparams, x):\\n return tf.reshape(x, [hparams.batch_size, -1] + x.shape.as_list()[1:])\",\n \"def aminusb_1ax( mv1, mv2 ):\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARNING: aminusb_1ax1 is subtracting variables with different units!\\\",mv1,mv1\\n if mv1 is None or mv2 is None: return None\\n missing = mv1.get_fill_value()\\n axis1 = allAxes(mv1)[0]\\n axis2 = allAxes(mv2)[0]\\n if len(axis1)<=len(axis2):\\n a = mv1\\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\\n else:\\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\\n b = mv2\\n aminusb = a - b\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def remove_temporal_mean(self):\\n if not hasattr(self, 'detrended_data'):\\n self.detrend_data()\\n self.mean_removed_data = self.detrended_data - \\\\\\n np.mean(self.detrended_data, axis=-1, keepdims=True)\",\n \"def latvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lat_axis = latAxis(mv)\\n #latmv = mv.clone() # good if mv has only a lat axis\\n #latmv[:] = lat_axis[:]\\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',\\n attributes={'units':lat_axis.units},\\n copy=True )\\n return latmv\",\n \"def uncollapse_freq_into_time(hparams, x):\\n if x.shape.ndims == 3:\\n return tf.reshape(x, [x.shape[0], hparams.ntimebins, constants.nfreqbins, -1])\\n return tf.reshape(x, [x.shape[0], hparams.ntimebins, constants.nfreqbins])\",\n \"def reduce2lat_old( mv, vid=None ):\\n # >>> For now, I'm assuming that the only axes are time,lat,lon\\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\\n # compute it with lat_bnds, lon_bnds etc.\\n # If I base another reduction function on this one, it's important to note that an average\\n # in the lat direction will unavoidably need weights, because of the geometry.\\n\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n time_axis, lat_axis, lon_axis = tllAxes( mv )\\n\\n mvta = timeave_old( mv )\\n\\n zm = numpy.zeros( mvta.shape[0] )\\n for i in range(len(lat_axis)):\\n for j in range(len(lon_axis)):\\n zm[i] += mvta[i,j]\\n zm[i] /= len(lon_axis)\\n zmv = cdms2.createVariable( zm, axes=[lat_axis], id=vid )\\n return zmv\",\n \"def test_axis_preservation(conv1d_placeholder, output_size):\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n output = conv_layer(conv1d_placeholder)\\n assert output.axes == conv1d_placeholder.axes, (\\\"Output axes are not the same as input axes: \\\"\\n \\\"{} != {}\\\").format(output.axes,\\n conv1d_placeholder.axes)\",\n \"def replace_axis(self, dim:NamedIndex,\\n mapping_or_old:'Union[Mapping[NamedIndex, NamedIndex], NamedIndex]',\\n new:'Optional[NamedIndex]'=None):\\n\\n axes = self[dim] # disable idx_dim access\\n # axes = self.get(dim) or self._dim_axes[dim] # dim:'Union[int, NamedIndex]'\\n is_tuple_axes = is_namedtuple(axes)\\n assert isinstance(axes, dict) or is_tuple_axes, (\\n f'unnamed dim({dim!r}) cannot be renamed')\\n\\n axes_keys = axes._fields if is_tuple_axes else axes.keys()\\n axes_iter = iter(zip(axes._fields, axes)) if is_tuple_axes else axes.items()\\n axes_ = OrderedDict()\\n\\n if new is None:\\n assert isinstance(mapping_or_old, dict), (\\n f\\\"'mapping_or_old'({type(mapping_or_old)}) is expected to be a dict \\\"\\n \\\"when 'new' is None\\\")\\n\\n mapping = mapping_or_old\\n for axis, index in axes_iter:\\n axis = mapping.get(axis, axis)\\n assert axis not in axes_, f'axis {axis!r} in mapping is conflicted'\\n\\n axes_[axis] = index\\n else:\\n assert new not in axes_keys, f'new axis({new!r}) is confilicted'\\n\\n old = mapping_or_old\\n for axis, index in axes_iter:\\n axes_[new if axis == old else axis] = index\\n\\n axes_ = namedtuple(dim, axes_.keys())(**axes_) if is_tuple_axes else type(axes)(axes_)\\n ret = OrderedDict()\\n for dim_, axes in self.items():\\n ret[dim_] = axes_ if dim_ == dim else axes\\n\\n return type(self)(ret)\",\n \"def test_default_axis_nxdata(self, nexus_base):\\n assert isinstance(nexus_base.default_axis, np.ndarray)\",\n \"def effect(self):\\n AxisType = self.options.AxisType\\n AxisDescription = self.options.AxisDescription\\n AxisUnit = self.options.AxisUnit\\n AxisLabel = self.options.AxisLabel\\n AxisMaxValue = self.options.AxisMaxValue\\n AxisMinValue = self.options.AxisMinValue\\n AxisScale = self.options.AxisScale\\n \\n \\n for id, node in self.selected.iteritems():\\n axis = node #TODO: This selection should be further tested\\n axis.set(inkex.addNS(\\\"Type\\\",\\\"TimeAnalysis\\\"), \\\"Axis\\\")\\n axis.set(inkex.addNS(\\\"AxisType\\\",\\\"TimeAnalysis\\\"), AxisType)\\n axis.set(inkex.addNS(\\\"AxisDescription\\\",\\\"TimeAnalysis\\\"), AxisDescription)\\n #TODO: The label should be unique.\\n axis.set(inkex.addNS(\\\"AxisLabel\\\",\\\"TimeAnalysis\\\"), AxisLabel) \\n axis.set(inkex.addNS(\\\"AxisUnit\\\",\\\"TimeAnalysis\\\"), AxisUnit)\\n axis.set(inkex.addNS(\\\"AxisMaxValue\\\",\\\"TimeAnalysis\\\"), AxisMaxValue)\\n axis.set(inkex.addNS(\\\"AxisMinValue\\\",\\\"TimeAnalysis\\\"), AxisMinValue)\\n axis.set(inkex.addNS(\\\"AxisScale\\\",\\\"TimeAnalysis\\\"), AxisScale)\\n # sys.stderr.write(\\\"The max value of the axis is: \\\" + str(axis.get(inkex.addNS(\\\"AxisMaxValue\\\",\\\"TimeAnalysis\\\"))))\",\n \"def test_newaxis(self):\\r\\n newaxis = numpy.newaxis\\r\\n\\r\\n n = self.shared(numpy.arange(24, dtype=self.dtype).reshape((2, 3, 4)))\\r\\n assert n.ndim == 3\\r\\n\\r\\n n4 = n[newaxis, :, :, :]\\r\\n assert n4.broadcastable == (True, False, False, False), n4\\r\\n\\r\\n n4 = n[:, newaxis, :, :]\\r\\n assert n4.broadcastable == (False, True, False, False), n4\\r\\n\\r\\n n4 = n[:, :, newaxis, :]\\r\\n assert n4.broadcastable == (False, False, True, False), n4\\r\\n\\r\\n n4 = n[:, :, :, newaxis]\\r\\n assert n4.broadcastable == (False, False, False, True), n4\\r\\n\\r\\n n3 = n.flatten()[newaxis, :, newaxis]\\r\\n assert n3.broadcastable == (True, False, True), n3\\r\\n\\r\\n s = cscalar()\\r\\n s1 = s[newaxis]\\r\\n assert s1.broadcastable == (True,), s1\\r\\n\\r\\n vs1, vn3, vn4 = theano.function([s], [s1, n3, n4])(-2.0)\\r\\n\\r\\n assert numpy.all(vs1 == [-2.0])\\r\\n assert numpy.all(vn3\\r\\n == numpy.arange(24)[newaxis, :, newaxis])\\r\\n assert numpy.all(vn4\\r\\n == numpy.arange(24).reshape((2, 3, 4))[:, :, :, newaxis])\",\n \"def squeeze_time_dim(d, fs, twin, keepdims=False):\\n\\n idx = np.arange(int(fs * twin[0]), int(fs * twin[1]))\\n if twin[0] == twin[1]:\\n idx = [int(twin[0] * fs)]\\n\\n for k in d.keys():\\n if type(d[k]) is dict:\\n # do for est / val set\\n for i in range(0, len(d[k]['est'])):\\n d[k]['est'][i] = d[k]['est'][i][:, :, idx].mean(axis=-1, keepdims=True)\\n d[k]['val'][i] = d[k]['val'][i][:, :, idx].mean(axis=-1, keepdims=True)\\n else: \\n # no est / val data\\n d[k] = d[k][:, :, idx].mean(axis=-1, keepdims=keepdims)\\n\\n return d\",\n \"def _moveaxis(self, arr, source, dest):\\n try:\\n source = list(source)\\n except TypeError:\\n source = [source]\\n try:\\n dest = list(dest)\\n except TypeError:\\n dest = [dest]\\n\\n source = [a + arr.ndim if a < 0 else a for a in source]\\n dest = [a + arr.ndim if a < 0 else a for a in dest]\\n\\n order = [n for n in range(arr.ndim) if n not in source]\\n\\n for dest, src in sorted(zip(dest, source)):\\n order.insert(dest, src)\\n\\n return arr.transpose(order)\",\n \"def replace_dim(self, old:NamedIndex, new:NamedIndex):\\n\\n assert new not in self, f'new dim({new!r}) is confilicted'\\n\\n ret = OrderedDict()\\n for dim, axes in self.items():\\n if dim == old:\\n if is_namedtuple(axes):\\n axes = namedtuple(new, axes._fields)(*axes)\\n ret[new] = axes\\n else:\\n ret[old] = axes\\n\\n return type(self)(ret)\",\n \"def test_time_shifted_model():\\n uneven_indices = np.delete(np.arange(len(t)), np.arange(1000)[1::2])\\n uneven_indices = uneven_indices[:-1]\\n\\n Z_uneven_1 = Z[:, uneven_indices]\\n Z_uneven_2 = Z[:, uneven_indices + 1]\\n\\n dmd = DMD(svd_rank=2)\\n dmd.fit(X=Z)\\n\\n dmd_xy = DMD(svd_rank=2)\\n dmd_xy.fit(X=Z_uneven_1, Y=Z_uneven_2)\\n\\n assert_equal_models(dmd_xy, dmd, rtol=0.01)\",\n \"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n for ax in mv.getAxisList():\\n if ax.getBounds() is None:\\n ax._bounds_ = ax.genGenericBounds()\\n timeax = timeAxis(mv)\\n if timeax.units=='months':\\n # Special check necessary for LEGATES obs data, because\\n # climatology() won't accept this incomplete specification\\n timeax.units = 'months since 0001-01-01'\\n mvseas = seasons.climatology(mv)\\n if mvseas is None:\\n # Among other cases, this can happen if mv has all missing values.\\n return None\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n avmv.id = vid\\n\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def promote_empty_dims(ds):\\n ds = ds.copy()\\n for di in ds.dims:\\n if di not in ds.coords:\\n ds.coords[di] = ds[di]\\n return ds\",\n \"def map_axis(axis, dimension, units):\\n if axis.isTime() and units is not None:\\n axis = axis.clone()\\n\\n axis.toRelativeTime(str(units))\\n\\n if dimension is None or dimension.crs == cwt.INDICES:\\n selector = map_axis_indices(axis, dimension)\\n elif dimension.crs == cwt.VALUES:\\n selector = map_axis_values(axis, dimension)\\n elif dimension.crs == cwt.TIMESTAMPS:\\n selector = map_axis_timestamps(axis, dimension)\\n else:\\n raise WPSError('Unknown CRS {!r}', dimension.crs)\\n\\n return selector\",\n \"def __init__(self, axis=-1):\\n self.axis = axis\",\n \"def reflect(self, axis):\\n if axis == \\\"x\\\":\\n self.y = - self.y\\n elif axis == \\\"y\\\":\\n self.x = - self.x\\n else:\\n print(\\\"The argument axis only accepts values 'x' and 'y'!\\\")\",\n \"def test_dimension_size_override(self, nt=100):\\n i, j, k = dimify('i j k')\\n a = TimeData(name='a', dimensions=(i, j, k))\\n one = symbol(name='one', dimensions=(i, j, k), value=1.)\\n op = Operator(Eq(a.forward, a + one))\\n\\n # Test dimension override via the buffered dimenions\\n a.data[0] = 0.\\n op(a=a, t=6)\\n assert(np.allclose(a.data[1], 5.))\\n\\n # Test dimension override via the parent dimenions\\n a.data[0] = 0.\\n op(a=a, time=5)\\n assert(np.allclose(a.data[0], 4.))\",\n \"def _update_axes(self):\\n data_shape = self.data.shape\\n if len(self.axes) < self.data.ndim + 1:\\n self._axes.append(Axis())\\n for index in range(self.data.ndim):\\n if len(self.axes[index].values) != data_shape[index]:\\n self.axes[index].values = np.arange(data_shape[index],\\n dtype=np.float64)\",\n \"def dd_axis(axis, ambient_dim, operand):\\n d = Derivative()\\n\\n unit_vector = np.zeros(ambient_dim)\\n unit_vector[axis] = 1\\n\\n unit_mvector = MultiVector(unit_vector)\\n\\n return d.resolve(\\n (unit_mvector.scalar_product(d.dnabla(ambient_dim)))\\n * d(operand))\",\n \"def squeeze(self, axis: Optional[AxisLike] = None):\\n\\n if axis is None:\\n axis = range(self.shape.shape[0])\\n elif axis == -1:\\n axis = self.shape.shape[0]\\n if not isinstance(axis, Iterable):\\n axis = [axis]\\n axis = [ax for ax in axis if (self.shape[ax] == 1).all(axis=0)]\\n self.shape = np.delete(self.shape, axis, axis=0)\\n return self\",\n \"def get_axis(self, axis):\\n return self.index if axis == 0 else self.columns\",\n \"def onSetToCustDims(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(0)\\n\\t\\t\\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(1)\\n\\t\\ttry:\\n\\t\\t\\trx = int(self.newDimX.GetValue())\\n\\t\\t\\try = int(self.newDimY.GetValue())\\n\\t\\t\\trz = int(self.newDimZ.GetValue())\\n\\t\\t\\tself.currSize = (rx, ry, rz)\\n\\t\\texcept:\\n\\t\\t\\tpass\",\n \"def mirror_axis(self, axis_index=0, reverse=False):\\n self.smd3.mirror(axis_index=axis_index, reverse=reverse)\\n self.logic.mirror(axis_index=axis_index, reverse=reverse)\\n min_vector, max_vector = self.smd3.get_min_max_vector()\\n self.header.set_box(min_vector, max_vector)\\n self.header.update(self.smd3)\\n self.logic.update(self.smd3)\\n # self.meta.mirror(axis_index=axis_index, reverse=reverse)\",\n \"def is_temporal(axis):\\n return (axis.lower() in temporal_axes)\",\n \"def lonvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lon_axis = lonAxis(mv)\\n latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',\\n attributes={'units':lon_axis.units},\\n copy=True )\\n return latmv\",\n \"def pop_aspect(name):\\n\\t_aspects[name].pop()\",\n \"def _reshape_trailing(argument, factor):\\n space = factor._space if isinstance(factor, RiemannianMetric) else factor\\n\\n if space.default_coords_type == \\\"vector\\\":\\n return argument\\n leading_shape = argument.shape[:-1]\\n trailing_shape = space.shape\\n new_shape = leading_shape + trailing_shape\\n return gs.reshape(argument, new_shape)\",\n \"def _lazy_axis(self):\\n raise NotImplementedError\",\n \"def _time_reduce(self, arr, reduction):\\n if self.dtype_in_time == 'av':\\n return arr\\n reductions = {\\n 'None': lambda xarr: xarr,\\n 'ts': lambda xarr: xarr,\\n 'av': lambda xarr: xarr.mean(internal_names.YEAR_STR),\\n 'std': lambda xarr: xarr.std(internal_names.YEAR_STR),\\n }\\n try:\\n return reductions[reduction](arr)\\n except KeyError:\\n raise ValueError(\\\"Specified time-reduction method '{}' is not \\\"\\n \\\"supported\\\".format(reduction))\",\n \"def rebuild_param(self,vec,**kwargs):\\n from collections import OrderedDict\\n tmp = OrderedDict([('lengthscale',None),( 'variance',None),( 'gstds',None)])\\n for key,val in kwargs.items():\\n assert val!=None, \\\"Can't have None as fixed values\\\"\\n tmp[key]=val\\n for key,val in tmp.items():\\n if val==None:\\n tmp[key]=vec[0]\\n vec = np.delete(vec,0)\\n return np.array([tmp[key] for key in tmp])\",\n \"def _increment_dims_left(self, axis: int = None):\\n if axis is None:\\n axis = self.last_used\\n self.set_current_step(axis, self.current_step[axis] - 1)\",\n \"def __rmul__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.gmt_func(other.value, self.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return other*obj\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def moveaxis(a, source, destination):\\n a = astensor(a)\\n\\n source = normalize_axis_tuple(source, a.ndim, \\\"source\\\")\\n destination = normalize_axis_tuple(destination, a.ndim, \\\"destination\\\")\\n if len(source) != len(destination):\\n raise ValueError(\\n \\\"`source` and `destination` arguments must have \\\"\\n \\\"the same number of elements\\\"\\n )\\n\\n order = [n for n in range(a.ndim) if n not in source]\\n\\n for dest, src in sorted(zip(destination, source)):\\n order.insert(dest, src)\\n\\n return transpose(a, order)\",\n \"def reset_spatial_dims_attrs(self):\\n if self.crs is None:\\n raise ValueError(\\\"CRS is missing. Use set_crs function to resolve.\\\")\\n _da = self._obj\\n x_dim, y_dim, x_attrs, y_attrs = gis_utils.axes_attrs(self.crs)\\n if x_dim != self.x_dim or y_dim != self.y_dim:\\n _da = _da.rename({self.x_dim: x_dim, self.y_dim: y_dim})\\n _da[x_dim].attrs.update(x_attrs)\\n _da[y_dim].attrs.update(y_attrs)\\n _da.raster.set_spatial_dims(x_dim=x_dim, y_dim=y_dim)\\n return _da\",\n \"def on_data_vars_change(self, change):\\n if change['type'] == 'change' and change['name'] == 'value':\\n self.left_ds = getattr(self.ts.data, change['new'])\\n if self.mask is None:\\n self.right_ds = self.left_ds.copy(deep=True)\\n else:\\n self.right_ds = self.left_ds * self.mask\\n\\n self.left_imshow.set_data(self.left_ds.data[0])\\n self.right_imshow.set_data(self.right_ds.data[0])\",\n \"def __init__(self, x_dimname='lon', y_dimname='lat', time_dimname='time'):\\n self.x_dimname = x_dimname\\n self.y_dimname = y_dimname\\n self.time_dimname = time_dimname\",\n \"def _swap_axis(input_tensor, dim_index, last_index, name=None):\\n return array_ops.transpose(\\n input_tensor,\\n array_ops.concat([\\n math_ops.range(dim_index), [last_index],\\n math_ops.range(dim_index + 1, last_index), [dim_index]\\n ], 0),\\n name=name)\",\n \"def remove_different_category_time(self):\\n if self._isCollection:\\n self.time_series_data.remove_different_time_index()\\n else:\\n warnings.warn('Setup mainCategoryCol is necessary for this function')\\n return self\",\n \"def moveaxis(tensor: tf.Tensor, source: int, destination: int) -> tf.Tensor:\\n ndim = len(tensor.shape)\\n source = _normalize_axis(source, ndim)\\n destination = _normalize_axis(destination, ndim)\\n order = [n for n in range(ndim) if n != source]\\n order.insert(destination, source)\\n return tf.transpose(tensor, order)\",\n \"def allAxes( mv ):\\n if mv is None: return None\\n return mv.getAxisList()\",\n \"def reshape_mat(self, data):\\n if len(data['x'][0]) < self.num_ofdim:\\n x = data['x']\\n x_plus = np.zeros([len(x), self.num_ofdim - len(x[0])])\\n data['x'] = np.append(x, x_plus, axis=1)\\n return data\",\n \"def adjust_axes(axes):\\n # TODO: Uncomment & decide for each subplot!\\n for ax in axes.itervalues():\\n core.hide_axis(ax)\\n\\n for k in [\\n \\\"placeholder\\\",\\n \\\"placeholder1\\\",\\n \\\"placeholder2\\\",\\n \\\"spikes_stim\\\",\\n \\\"spikes_stim1\\\",\\n \\\"spikes_stim2\\\",\\n \\\"spikes_post\\\",\\n \\\"stimulation_schema\\\"\\n ]:\\n axes[k].set_frame_on(False)\",\n \"def reduce2latlon( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n for ax in axes:\\n # The averager insists on bounds. Sometimes they don't exist, especially for obs.\\n if ax.id!='lat' and ax.id!='lon' and not hasattr( ax, 'bounds' ):\\n ax.setBounds( ax.genGenericBounds() )\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def test_reset_temporal_axis_lead(PM_ds_initialized_3d_full):\\r\\n smooth = 10\\r\\n dim = \\\"lead\\\"\\r\\n tsmooth_kws = {dim: smooth}\\r\\n first_ori = PM_ds_initialized_3d_full.lead[0].values\\r\\n first_actual = _reset_temporal_axis(\\r\\n PM_ds_initialized_3d_full, tsmooth_kws=tsmooth_kws\\r\\n )[dim].values[0]\\r\\n first_expected = f\\\"{first_ori}-{first_ori+smooth*1-1}\\\"\\r\\n assert first_actual == first_expected\",\n \"def remove_mean(self, axes=None):\\n axes = self._get_axes_numbers(axes)\\n out = self\\n if 0 in axes:\\n out = self - self.mean(0)\\n if 1 in axes:\\n out = (self.T - self.mean(1)).T\\n return out\",\n \"def _share_short_axis(self, share, side, level):\\n if share is None or self._panel_side: # not None\\n return\\n s = side[0]\\n axis = 'x' if s in 'lr' else 'y'\\n caxs = getattr(self, '_' + s + 'panels')\\n paxs = getattr(share, '_' + s + 'panels')\\n caxs = [pax for pax in caxs if not pax._panel_filled]\\n paxs = [pax for pax in paxs if not pax._panel_filled]\\n for cax, pax in zip(caxs, paxs): # may be uneven\\n getattr(cax, '_share' + axis + '_setup')(pax, level)\",\n \"def add_axes(x, num=1, pos='left'):\\n if is_theano_object(x):\\n if pos in ['left', 'before', 'begin', 'first']:\\n shuffle_pattern = ['x']*num\\n shuffle_pattern.extend(range(x.ndim))\\n elif pos in ['right', 'after', 'end', 'last']:\\n shuffle_pattern = list(range(x.ndim))\\n shuffle_pattern.extend( ['x']*num )\\n elif pos == 'before last':\\n shuffle_pattern = list(range(x.ndim))\\n shuffle_pattern = shuffle_pattern[:-1] + ['x']*num + shuffle_pattern[-1:]\\n else:\\n try:\\n shuffle_pattern = list(range(x.ndim))\\n shuffle_pattern = shuffle_pattern[:pos] + ['x']*num + shuffle_pattern[pos:]\\n except TypeError:\\n raise ValueError(\\\"Unrecognized argument `{}` for pos.\\\".format(pos))\\n return x.dimshuffle(shuffle_pattern)\\n else:\\n x = np.asarray(x)\\n if pos in ['left', 'before', 'begin', 'first']:\\n return x.reshape( (1,)*num + x.shape )\\n elif pos in ['right', 'after', 'end', 'last']:\\n return x.reshape( x.shape + (1,)*num )\\n elif pos == 'before last':\\n return x.reshape( x.shape[:-1] + (1,)*num + x.shape[-1:] )\\n else:\\n try:\\n return x.reshape( x.shape[:pos] + (1,)*num + x.shape[pos:] )\\n except TypeError:\\n raise ValueError(\\\"Unrecognized argument {} for pos.\\\".format(pos))\",\n \"def common_axis( axis1, axis2 ):\\n if hasattr( axis1, 'units' ):\\n units1 = axis1.units.lower().replace(' ','_')\\n if axis1.isTime():\\n axis1.toRelativeTime( units1 ) #probably will change input argument\\n else:\\n units1 = None\\n if hasattr( axis2, 'units' ):\\n units2 = axis2.units.lower().replace(' ','_')\\n else:\\n units2 = None\\n if units1!=None and units2!=None and units1 != units2:\\n if axis1.isTime() and axis2.isTime():\\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\\n else:\\n print \\\"ERROR. common_axis does not yet support differing units\\\",axis1.units,\\\" and \\\",axis2.units\\n return None\\n if axis1.isTime() or axis2.isTime():\\n if not axis2.isTime() or not axis1.isTime():\\n print \\\"ERROR. In common_axis, one axis is time, not the other\\\"\\n return None\\n if not axis1.calendar==axis2.calendar:\\n print \\\"ERROR. common_axis does not yet support differing calendars.\\\"\\n if len(axis1)==1 and len(axis2)==1:\\n # There's just one time value, probably from averaging over time. The time value is meaningless\\n # but it would be messy to have two.\\n return (axis1,[0],[0])\\n\\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\\n # units and calendar attributes should always be transferred if present.\\n # Also to do: use bounds if available\\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\\n a1indexina3 = a12indexina3[0:len(axis1)]\\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\\n\\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\\n vid = axis1.id\\n else:\\n vid = None\\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\\n axis3.units = units1\\n return (axis3,a1indexina3,a2indexina3)\",\n \"def levvar( mv ):\\n # First get the axis. This is probably not as general as we'll need...\\n if mv is None: return None\\n lev_axis = levAxis(mv)\\n #levmv = mv.clone() # good if mv has only a lev axis\\n #levmv[:] = lev_axis[:]\\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',\\n attributes={'units':lev_axis.units},\\n copy=True )\\n return levmv\",\n \"def fixdims(var):\\n\\t\\n\\tfor ii in var.dims:\\n\\t\\tkk=ii[:3].lower()\\n\\t\\t\\n\\t\\tif kk == 'lat':\\n\\t\\t\\tvar=var.rename({ii:'lat'})\\n\\t\\t\\t\\n\\t\\tif kk == 'lon':\\n\\t\\t\\tvar=var.rename({ii:'lon'})\\n\\t\\t\\t\\n\\t\\tif kk == 'lev' or kk == 'ple' or kk == 'pre':\\n\\t\\t\\tvar=var.rename({ii:'level'})\\n\\n\\t\\tif kk == 'tim':\\n\\t\\t\\tvar=var.rename({ii:'time'})\\n\\n\\treturn var\",\n \"def moment_update(model, model_ema, m):\\r\\n for p1, p2 in zip(model.parameters(), model_ema.parameters()):\\r\\n p2.data.mul_(m).add_(1 - m, p1.detach().data)\\r\\n # p2.data.mul_(m).add_(1 - m, p1.data)\",\n \"def __init__(self, incoming, axis=-1, name='MultiplicativeNoiseLayer'):\\n super(ArgMaxOneHot, self).__init__()\\n \\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n \\n self.axis = axis\\n self.out = None\\n self.name = name\",\n \"def _set_and_permute_time_axis(tensor, sequence_length, axis=-3):\\n shape = tensor.shape.as_list()\\n shape[0] = sequence_length\\n tensor.set_shape(shape)\\n\\n # in the original tensor the first axis is always the time axis.\\n permutation = list(range(tensor.shape.ndims))\\n permutation[0] = permutation[axis]\\n permutation[axis] = 0\\n return tf.transpose(tensor, permutation)\",\n \"def interp2( newaxis1, mv ):\\n missing = mv.get_fill_value()\\n axes = allAxes(mv)\\n if len(newaxis1[:])>len(axes[1][:]): return mv\\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\\n for i in range(len( axes[0] )):\\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\\n # the mask - which numpy.interp treats False as 0, True as 1:\\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\\n right=missing ) )>0\\n return new_vals\",\n \"def common_axes( mv1, mv2 ):\\n axes1 = [a[0] for a in mv1.getDomain()]\\n axes2 = [a[0] for a in mv2.getDomain()]\\n if len(axes1)!=len(axes2):\\n print \\\"ERROR. common_axes requires same number of axes in\\\",mv1,\\\" and\\\",mv2\\n return None\\n axes3 = []\\n for i in range(len(axes1)):\\n axes3.append(common_axis( axes1[i], axes2[i] ))\\n return axes3\",\n \"def _finalize_axis(self, key, **kwargs):\\n axis = self.handles['axis']\\n self.handles['fig'].set_frameon(False)\\n axis.grid(self.show_grid)\\n axis.view_init(elev=self.elevation, azim=self.azimuth)\\n try:\\n axis._dist = self.distance\\n except Exception:\\n # axis.dist is deprecated see here:\\n # https://github.com/matplotlib/matplotlib/pull/22084\\n axis.dist = self.distance\\n\\n if self.xaxis is None:\\n axis.w_xaxis.line.set_lw(0.)\\n axis.w_xaxis.label.set_text('')\\n if self.yaxis is None:\\n axis.w_yaxis.line.set_lw(0.)\\n axis.w_yaxis.label.set_text('')\\n if self.zaxis is None:\\n axis.w_zaxis.line.set_lw(0.)\\n axis.w_zaxis.label.set_text('')\\n if self.disable_axes:\\n axis.set_axis_off()\\n\\n if mpl_version <= Version('1.5.9'):\\n axis.set_axis_bgcolor(self.bgcolor)\\n else:\\n axis.set_facecolor(self.bgcolor)\\n return super()._finalize_axis(key, **kwargs)\",\n \"def x(self, index=np.nan, alter='', xyValue=None, errorIfxyMix=False, neutral=False):\\n if alter != '':\\n if alter == 'nmeV':\\n # invert order of xyValue, to help for graph xlim and ylim\\n if xyValue is not None:\\n xyValue = np.array(xyValue)\\n if len(xyValue.shape) > 1:\\n xyValue = [xyValue[0, ::-1], xyValue[1, ::-1]]\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n return Curve.NMTOEV / self.x(index, xyValue=xyValue)\\n elif alter == 'nmcm-1':\\n # invert order of xyValue, to help for graph xlim and ylim\\n if xyValue is not None:\\n xyValue = np.array(xyValue)\\n if len(xyValue.shape) > 1:\\n xyValue = [xyValue[0, ::-1], xyValue[1, ::-1]]\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n return 1e7 / self.x(index, xyValue=xyValue)\\n elif alter == 'MCAkeV':\\n offset = self.attr('_MCA_CtokeV_offset', default=0)\\n mult = self.attr('_MCA_CtokeV_mult', default=1)\\n return mult * (self.x(index, xyValue=xyValue) + offset)\\n elif alter == 'SIMSdepth':\\n offset = self.attr('_SIMSdepth_offset', default=0)\\n mult = self.attr('_SIMSdepth_mult', default=1)\\n return mult * (self.x(index, xyValue=xyValue) + offset)\\n elif alter == 'y':\\n try:\\n xyValue = xyValue[::-1]\\n except TypeError:\\n pass\\n # print('x xyValue', xyValue, self.y(index, xyValue=xyValue))\\n return self.y(index, xyValue=xyValue)\\n elif alter != '':\\n split = alter.split('.')\\n if len(split) == 2:\\n module_name = 'grapa.datatypes.' + split[0][0].lower() + split[0][1:]\\n import importlib\\n try:\\n mod = importlib.import_module(module_name)\\n met = getattr(getattr(mod, split[0]), split[1])\\n return met(self, index=index, xyValue=xyValue)\\n except ImportError as e:\\n print('ERROR Curve.x Exception raised during module',\\n 'import', module_name, ':')\\n print(e)\\n else:\\n print('Error Curve.x: cannot identify alter keyword ('\\n + alter + ').')\\n\\n # alter might be used by subclasses\\n val = self.data if xyValue is None else np.array(xyValue)\\n if len(val.shape) > 1:\\n if np.isnan(index).any():\\n return val[0, :]\\n return val[0, index]\\n return val[0]\",\n \"def _configure_axis(self, source, title):\\n conf = source.conf[title]\\n if source.data_type[title] == 'image':\\n self.plot.getView().invertY(True)\\n else:\\n self.plot.getView().invertY(False)\\n if(self.settingsWidget.ui.flipy.currentText() == 'Yes' or\\n (self.settingsWidget.ui.flipy.currentText() == 'Auto' and\\n \\\"flipy\\\" in conf and conf['flipy'] == True)):\\n self.plot.getView().invertY(not self.plot.getView().getViewBox().yInverted())\\n if(self.settingsWidget.ui.flipx.currentText() == 'Yes' or\\n (self.settingsWidget.ui.flipx.currentText() == 'Auto' and\\n \\\"flipx\\\" in conf and conf['flipx'] == True)):\\n self.plot.getView().invertX(not self.plot.getView().getViewBox().xInverted())\\n\\n # Tranpose images to make x (last dimension) horizontal\\n axis_labels = ['left', 'bottom']\\n xlabel_index = 0\\n ylabel_index = 1\\n if (source.data_type[title] == 'image') or (source.data_type[title] == 'triple'):\\n xlabel_index = (xlabel_index+1)%2\\n ylabel_index = (ylabel_index+1)%2\\n\\n if(self.settingsWidget.ui.transpose.currentText() == 'Yes' or\\n (self.settingsWidget.ui.transpose.currentText() == 'Auto' \\n and \\\"transpose\\\" in conf)):\\n xlabel_index = (xlabel_index+1)%2\\n ylabel_index = (ylabel_index+1)%2\\n\\n self.x_axis_name = axis_labels[xlabel_index]\\n self.y_axis_name = axis_labels[ylabel_index]\\n if(self.actionX_axis.isChecked()):\\n if(self.settingsWidget.ui.x_label_auto.isChecked() and \\n \\\"xlabel\\\" in conf):\\n self.plot.getView().setLabel(axis_labels[xlabel_index], conf['xlabel']) #pylint: disable=no-member\\n else:\\n self.plot.getView().setLabel(axis_labels[xlabel_index], self.settingsWidget.ui.x_label.text()) #pylint: disable=no-member\\n\\n if(self.actionY_axis.isChecked()):\\n if(self.settingsWidget.ui.y_label_auto.isChecked() and \\n \\\"ylabel\\\" in conf):\\n self.plot.getView().setLabel(axis_labels[ylabel_index], conf['ylabel']) #pylint: disable=no-member\\n else:\\n self.plot.getView().setLabel(axis_labels[ylabel_index], self.settingsWidget.ui.y_label.text()) #pylint: disable=no-member\",\n \"def update_svq_time_metric(ml_channel_id, ml_channel_name):\\n result = []\\n entry = [\\\"MediaLive\\\", \\\"SvqTime\\\", \\\"ChannelId\\\", ml_channel_id, \\\"Pipeline\\\", \\\"0\\\", {\\\"label\\\": ml_channel_name + \\\"-0\\\"}]\\n result.append(entry)\\n entry = [\\\"MediaLive\\\", \\\"SvqTime\\\", \\\"ChannelId\\\", ml_channel_id, \\\"Pipeline\\\", \\\"1\\\", {\\\"yAxis\\\": \\\"right\\\",\\n \\\"label\\\": ml_channel_name + \\\"-1\\\"}]\\n result.append(entry)\\n return result\",\n \"def updateDims(self, key=\\\"\\\", val=None):\\n self.setDimension(key, val)\\n self.setDimension(\\n \\\"outer_radius\\\",\\n self.getDimension(\\\"inner_radius\\\")\\n + self.getDimension(\\\"radius_differential\\\"),\\n )\\n self.setDimension(\\n \\\"outer_axial\\\",\\n self.getDimension(\\\"inner_axial\\\") + self.getDimension(\\\"height\\\"),\\n )\\n self.setDimension(\\n \\\"outer_theta\\\",\\n self.getDimension(\\\"inner_theta\\\")\\n + self.getDimension(\\\"azimuthal_differential\\\"),\\n )\",\n \"def diff_1(value, axis=0, name=None):\\n with tf.name_scope(name or 'diff_1'):\\n value = tf.convert_to_tensor(value)\\n a = array.slice_from_axis(value, end=-1, axis=axis)\\n b = array.slice_from_axis(value, begin=1, axis=axis)\\n diff_tensor = b - a\\n return diff_tensor\",\n \"def get_axis_name(self, axis_id):\\n if isinstance(axis_id, str):\\n if axis_id in self.axes_names:\\n return axis_id\\n else:\\n return None\\n assert np.isreal(axis_id) and np.round(axis_id) == axis_id\\n if axis_id >= 0 and axis_id < self.get_ndims():\\n return self.axes_names[axis_id]\\n else:\\n return None\",\n \"def _newMV(self, newValue=None, *, dtype: np.dtype = None) -> 'MultiVector':\\n if newValue is None and dtype is None:\\n raise TypeError(\\\"Must specify either a type or value\\\")\\n\\n return self.__class__(self.layout, newValue, dtype=dtype)\",\n \"def copy_and_append_time_dimension_to_netcdf_dataset(self,dataset_in,dataset_out):\\n\\n for dim_name,dim_obj in list(dataset_in.dimensions.items()):\\n dataset_out.createDimension(dim_name,len(dim_obj)\\n if not dim_obj.isunlimited() else None)\\n dataset_out.createDimension('time',None)\\n times = dataset_out.createVariable(\\\"time\\\",'f8',(\\\"time\\\",))\\n times.units = \\\"years since 0001-01-01 00:00:00.0\\\"\\n times.calendar = \\\"proleptic_gregorian\\\"\\n times[0] = np.array([0.0])\\n for var_name, var_obj in list(dataset_in.variables.items()):\\n new_var = dataset_out.createVariable(var_name,var_obj.datatype,var_obj.dimensions\\n if (len(var_obj.dimensions) <= 1\\n or var_name == 'AREA') else\\n [\\\"time\\\"] + list(var_obj.dimensions))\\n if len(var_obj.dimensions) <= 1 or var_name == 'AREA':\\n new_var[:] = var_obj[:]\\n else:\\n new_var[0,:] = var_obj[:]\\n new_var.setncatts({attr_name: var_obj.getncattr(attr_name) for attr_name in var_obj.ncattrs()})\",\n \"def _create_reduceOp(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n\\n node.attribute.extend([\\n helper.make_attribute('axes', list(op.axes)),\\n helper.make_attribute('keepdims', op.keepdims),\\n ])\\n return node\",\n \"def axisinfo(self, unit, axis):\\n majloc = AstropyTimeLocator(self)\\n majfmt = AstropyTimeFormatter(self)\\n return units.AxisInfo(\\n majfmt=majfmt, majloc=majloc, label=f\\\"Time ({self.scale})\\\"\\n )\",\n \"def upAxis(*args, axis: Union[AnyStr, bool]=\\\"\\\", rotateView: bool=True, q=True, query=True,\\n **kwargs)->Union[None, Any]:\\n pass\",\n \"def reduce2lat( mv, vid=None ):\\n if vid==None: # Note that the averager function returns a variable with meaningless id.\\n vid = 'reduced_'+mv.id\\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' ]\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n avmv = averager( mv, axis=axes_string )\\n avmv.id = vid\\n avmv.units = mv.units\\n\\n return avmv\",\n \"def _log_moments_every_epoch(self, x: tf.Tensor, axes: List[int], name: str) -> None:\\n effective_batch_size = FLAGS.physical_batch_size * FLAGS.virtual_batch_size_factor\\n steps_per_epoch = TinyImageNetPipeline.num_train_samples // effective_batch_size\\n mean, stddev = tf.nn.moments(x, axes)\\n\\n if len(mean.shape) != len(axes):\\n # normalize over the other dimensions\\n mean = tf.reduce_mean(mean)\\n stddev = tf.reduce_mean(stddev)\\n\\n self.logger_factory.add_scalar('mean_{}'.format(name), mean, log_frequency=steps_per_epoch)\\n self.logger_factory.add_scalar('stddev_{}'.format(name), stddev, log_frequency=steps_per_epoch)\",\n \"def _metadata_changed(self, old, new):\\n\\n #self.cross_plot.value_range.low = self.minz\\n #self.cross_plot.value_range.high = self.maxz\\n #self.cross_plot2.value_range.low = self.minz\\n #self.cross_plot2.value_range.high = self.maxz\\n if self._imag_index.metadata.has_key(\\\"selections\\\"):\\n x_ndx, y_ndx = self._imag_index.metadata[\\\"selections\\\"]\\n if y_ndx and x_ndx:\\n# xdata, ydata = self._image_index.get_data()\\n# xdata, ydata = xdata.get_data(), ydata.get_data()\\n self.pd_horiz.set_data(\\\"horiz\\\", self._image_value.data[y_ndx,:])\\n self.pd_vert.set_data(\\\"vert\\\", self._image_value.data[:,x_ndx])\",\n \"def test_reduce_default_dtype(self):\\r\\n # We try multiple axis combinations even though axis should not matter.\\r\\n for method in self.methods:\\r\\n for idx, dtype in enumerate(imap(str, theano.scalar.all_types)):\\r\\n axis = self.axes[idx % len(self.axes)]\\r\\n x = tensor.matrix(dtype=dtype)\\r\\n s = getattr(x, method)(axis=axis)\\r\\n assert s.dtype == dict(\\r\\n int8='int64',\\r\\n int16='int64',\\r\\n int32='int64',\\r\\n uint8='uint64',\\r\\n uint16='uint64',\\r\\n uint32='uint64',\\r\\n ).get(dtype, dtype)\\r\\n f = theano.function([x], s, mode=self.mode)\\r\\n topo = f.maker.fgraph.toposort()\\r\\n assert [n for n in topo if isinstance(n.op, self.op)], (topo, dtype)\\r\\n data = numpy.random.rand(3, 4) * 10\\r\\n data = data.astype(dtype)\\r\\n f(data)\",\n \"def nd_shape_checking(x, y, mvaxis, traxis):\\n assert x.ndim == y.ndim\\n dims = np.delete(np.arange(x.ndim), -2)\\n assert all([x.shape[k] == y.shape[k] for k in dims])\",\n \"def _ureduce(a, func, **kwargs):\\n a = np.asanyarray(a)\\n axis = kwargs.get('axis', None)\\n if axis is not None:\\n keepdim = list(a.shape)\\n nd = a.ndim\\n axis = _nx.normalize_axis_tuple(axis, nd)\\n\\n for ax in axis:\\n keepdim[ax] = 1\\n\\n if len(axis) == 1:\\n kwargs['axis'] = axis[0]\\n else:\\n keep = set(range(nd)) - set(axis)\\n nkeep = len(keep)\\n # swap axis that should not be reduced to front\\n for i, s in enumerate(sorted(keep)):\\n a = a.swapaxes(i, s)\\n # merge reduced axis\\n a = a.reshape(a.shape[:nkeep] + (-1,))\\n kwargs['axis'] = -1\\n keepdim = tuple(keepdim)\\n else:\\n keepdim = (1,) * a.ndim\\n\\n r = func(a, **kwargs)\\n return r, keepdim\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6247364","0.59301597","0.55981517","0.55702573","0.53490317","0.5049275","0.49913675","0.49404666","0.48569542","0.4843272","0.4835321","0.47630703","0.47483668","0.47441968","0.47385386","0.46919236","0.46870866","0.4654426","0.46510515","0.46408376","0.46343154","0.4608973","0.4606408","0.45731387","0.45673314","0.45604137","0.45567515","0.4555424","0.45495102","0.45459738","0.45418134","0.45417315","0.45290983","0.4512956","0.45121592","0.45114994","0.449926","0.44978964","0.4497437","0.44892782","0.44867548","0.44836813","0.44783175","0.44714865","0.44583887","0.445766","0.44391355","0.44372028","0.44326982","0.4422764","0.44176686","0.4417246","0.44133043","0.44057035","0.44039848","0.4380091","0.43774855","0.43710938","0.4354254","0.435285","0.43480936","0.4343263","0.43413207","0.43365073","0.4333775","0.43259653","0.4316119","0.43155003","0.43151152","0.43056893","0.4305594","0.43036327","0.42999315","0.4286424","0.4281934","0.42818296","0.42707255","0.42680702","0.42613843","0.42596862","0.4258441","0.42482919","0.42476624","0.42475906","0.42459136","0.42454824","0.4241476","0.4241343","0.42366642","0.423588","0.42282477","0.42241243","0.42204067","0.42165783","0.42156208","0.42120305","0.42110115","0.42104927","0.42071763","0.42071378"],"string":"[\n \"0.6247364\",\n \"0.59301597\",\n \"0.55981517\",\n \"0.55702573\",\n \"0.53490317\",\n \"0.5049275\",\n \"0.49913675\",\n \"0.49404666\",\n \"0.48569542\",\n \"0.4843272\",\n \"0.4835321\",\n \"0.47630703\",\n \"0.47483668\",\n \"0.47441968\",\n \"0.47385386\",\n \"0.46919236\",\n \"0.46870866\",\n \"0.4654426\",\n \"0.46510515\",\n \"0.46408376\",\n \"0.46343154\",\n \"0.4608973\",\n \"0.4606408\",\n \"0.45731387\",\n \"0.45673314\",\n \"0.45604137\",\n \"0.45567515\",\n \"0.4555424\",\n \"0.45495102\",\n \"0.45459738\",\n \"0.45418134\",\n \"0.45417315\",\n \"0.45290983\",\n \"0.4512956\",\n \"0.45121592\",\n \"0.45114994\",\n \"0.449926\",\n \"0.44978964\",\n \"0.4497437\",\n \"0.44892782\",\n \"0.44867548\",\n \"0.44836813\",\n \"0.44783175\",\n \"0.44714865\",\n \"0.44583887\",\n \"0.445766\",\n \"0.44391355\",\n \"0.44372028\",\n \"0.44326982\",\n \"0.4422764\",\n \"0.44176686\",\n \"0.4417246\",\n \"0.44133043\",\n \"0.44057035\",\n \"0.44039848\",\n \"0.4380091\",\n \"0.43774855\",\n \"0.43710938\",\n \"0.4354254\",\n \"0.435285\",\n \"0.43480936\",\n \"0.4343263\",\n \"0.43413207\",\n \"0.43365073\",\n \"0.4333775\",\n \"0.43259653\",\n \"0.4316119\",\n \"0.43155003\",\n \"0.43151152\",\n \"0.43056893\",\n \"0.4305594\",\n \"0.43036327\",\n \"0.42999315\",\n \"0.4286424\",\n \"0.4281934\",\n \"0.42818296\",\n \"0.42707255\",\n \"0.42680702\",\n \"0.42613843\",\n \"0.42596862\",\n \"0.4258441\",\n \"0.42482919\",\n \"0.42476624\",\n \"0.42475906\",\n \"0.42459136\",\n \"0.42454824\",\n \"0.4241476\",\n \"0.4241343\",\n \"0.42366642\",\n \"0.423588\",\n \"0.42282477\",\n \"0.42241243\",\n \"0.42204067\",\n \"0.42165783\",\n \"0.42156208\",\n \"0.42120305\",\n \"0.42110115\",\n \"0.42104927\",\n \"0.42071763\",\n \"0.42071378\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71518254"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19891,"cells":{"query":{"kind":"string","value":"Not much tested I decided against doing overlapping line plots this way. The input arguments are two variables (cdms2 MVs, normally TransientVariables), with whatever compatibility is needed for this function to work. New axes are computed which can be used for both variables. These axes are returned as a list of tuples, each containing one new axis and index information."},"document":{"kind":"string","value":"def common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n axes3.append(common_axis( axes1[i], axes2[i] ))\n return axes3"},"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 setup_axes(self):\n fig = plt.figure(1)\n axs = fig.add_subplot(1, 1, 1)\n fig.clf()\n axs = plt.subplots(1, 2)\n ax1 : plt.axis = axs[0]\n ax2 : plt.axis = axs[1]\n fig.canvas.draw()\n \n line1_t, = ax1.plot([], label='train')\n line1_v, = ax1.plot([], label='val')\n\n ax1.set_title('Loss vs Iterations')\n ax1.set_xlabel('Iterations')\n ax1.set_ylabel('Loss')\n ax1.grid(True)\n ax1.autoscale()\n # ax1.legend()\n\n line2_t, = ax2.plot([], label='train')\n line2_v, = ax2.plot([], label='val')\n\n ax2.set_title('Accuracy vs Iterations')\n ax2.set_xlabel('Time')\n ax2.set_ylabel('Percent Accuracy')\n ax2.grid(True)\n ax2.autoscale()\n # ax2.legend()\n\n lines = [line1_t, line1_v, line2_t, line2_v]\n\n return fig, ax1, ax2, lines","def plot_results_2d(p_1, p_2, d_1 = 'X', d_2 = 'Y'):\n plt.figure(figsize = (10, 10))\n ax = plt.axes() \n\n color=iter(cm.rainbow(np.linspace(0,1,p_1.shape[0]))) # (1)\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_1.shape[0], step = 1)]\n\n for p in np.arange(0, p_1.shape[0], step = 1): \n c = next(color) # (c)\n for t in np.arange(0, p_1.shape[1], step = 1): \n plt.plot(p_1[p, t], p_2[p, t], 'x', c = c, label = labels[p])\n legend_without_duplicate_labels(ax)\n ax.grid(b = 'True', which = 'major')\n ax.set_xlabel(d_1) \n ax.set_ylabel(d_2)\n ax.set_title('2D particle trajectories')","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 plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices['E_tot1'])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\n \n plt.ylabel('Energy [kWh]')\n plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(24)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\n\n plt.ylabel('Energy Difference [kWh]')\n plt.legend()\n\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n return fig","def _get_lines(self) -> tuple[VGroup, VGroup]:\n x_axis = self.get_x_axis()\n y_axis = self.get_y_axis()\n\n x_lines1, x_lines2 = self._get_lines_parallel_to_axis(\n x_axis,\n y_axis,\n self.y_axis.x_range[2],\n self.faded_line_ratio,\n )\n\n y_lines1, y_lines2 = self._get_lines_parallel_to_axis(\n y_axis,\n x_axis,\n self.x_axis.x_range[2],\n self.faded_line_ratio,\n )\n\n # TODO this was added so that we can run tests on NumberPlane\n # In the future these attributes will be tacked onto self.background_lines\n self.x_lines = x_lines1\n self.y_lines = y_lines1\n lines1 = VGroup(*x_lines1, *y_lines1)\n lines2 = VGroup(*x_lines2, *y_lines2)\n\n return lines1, lines2","def _make_twin_axes(self, *args, **kwargs):\n # Typically, SubplotBase._make_twin_axes is called instead of this.\n # There is also an override in axes_grid1/axes_divider.py.\n if 'sharex' in kwargs and 'sharey' in kwargs:\n raise ValueError('Twinned Axes may share only one axis.')\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\n self.set_adjustable('datalim')\n ax2.set_adjustable('datalim')\n self._twinned_axes.join(self, ax2)\n return ax2","def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb","def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\n\n ps = phase_space[:, (id_begin-1):id_end, :]\n # print(np.shape(ps))\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\n\n x = ps[0, :, :]\n px = ps[1, :, :]\n y = ps[2, :, :]\n py = ps[3, :, :]\n\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\n\n for n in range(int(id_end-id_begin+1)):\n x_this = x[n, :]\n px_this = px[n, :]\n y_this = y[n, :]\n py_this = py[n, :]\n\n # Remove all NAN elements in the phase space array\n x_this = x_this[np.logical_not(np.isnan(x_this))]\n px_this = px_this[np.logical_not(np.isnan(px_this))]\n y_this = y_this[np.logical_not(np.isnan(y_this))]\n py_this = py_this[np.logical_not(np.isnan(py_this))]\n\n ## Plot X\n plt.subplot(2, 2, 1)\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\n plt.ylabel('Position in X/ $\\mu$m', fontsize=10)\n\n ## Plot Y\n plt.subplot(2, 2, 2)\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\n plt.ylabel('Position in Y/ $\\mu$m', fontsize=10)\n\n ## Plot px\n plt.subplot(2, 2, 3)\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\n plt.ylabel('Angle in X', fontsize=10)\n\n ## Plot py\n plt.subplot(2, 2, 4)\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\n plt.ylabel('Angle in Y', fontsize=10)\n\n\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\mu$m')\n # plt.title('First Undulator Section')\n # plt.title('Second Undulator Section')\n # plt.title('Third Undulator Section')\n\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\n\n fig = plt.gcf()\n fig.set_size_inches(13.5, 9)\n ax = plt.gca()\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\n fig.savefig('phase_space_U3_new.png', dpi=100)\n plt.show()\n\n\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\n\n return id_on_axis, s_on_axis","def axes_subplots():\n # gerenate data\n x = np.arange(0, 6 * np.pi+0.2, 0.2)\n y_1 = np.cos(x)\n y_2 = np.sin(2*x)\n y_3 = y_1 + y_2\n\n # display multiple\n fig, axs = plt.subplots(3, 1, sharex=True)\n fig.suptitle('Subplots w/ shared axes')\n axs[0].plot(x, y_1)\n axs[1].plot(x, y_2)\n axs[2].plot(x, y_3)\n axs[0].set_ylabel('$y$')\n axs[1].set_ylabel('$y$')\n axs[2].set_ylabel('$y$')\n\n plt.show()\n\n return None","def TwoOrOneValuePlot(no_of_sets, Xax, Ydat1, Ydat2, Label1, Label2,\n xmin, xmax, ymin_1, ymax_1, ymin_2, ymax_2,\n XLab, YLab_1, YLab_2, SupTitle, Title, FileName,\n currentDate, currentTime, Software_version):\n\n rc('font', size=6, weight='bold')\n if no_of_sets == 1:\n fig = plt.figure(figsize=(9, 5))\n ax1 = fig.add_subplot(111)\n elif no_of_sets == 2:\n fig = plt.figure(figsize=(9, 9))\n ax1 = fig.add_subplot(211)\n else:\n print(' ERROR !!!')\n if no_of_sets == 2:\n ax1.plot(Xax, Ydat2, color=u'#ff7f0e', linestyle='-', alpha=0.4, linewidth='1.00')\n ax1.plot(Xax, Ydat1, color=u'#1f77b4', linestyle='-', alpha=1.0, linewidth='1.00', label=Label1)\n ax1.legend(loc='upper right', fontsize=6)\n ax1.grid(visible=True, which='both', color='silver', linestyle='-')\n ax1.axis([xmin, xmax, ymin_1, ymax_1])\n ax1.set_ylabel(YLab_1, fontsize=6, fontweight='bold')\n ax1.set_title(Title, fontsize=6)\n if no_of_sets == 2:\n ax1.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False)\n ax2 = fig.add_subplot(212)\n if no_of_sets == 2:\n ax2.plot(Xax, Ydat1, color=u'#1f77b4', linestyle='-', alpha=0.4, linewidth='1.00')\n ax2.plot(Xax, Ydat2, color=u'#ff7f0e', linestyle='-', alpha=1.0, linewidth='1.00', label=Label2)\n ax2.legend(loc='upper right', fontsize=6)\n ax2.grid(visible=True, which='both', color='silver', linestyle='-')\n ax2.axis([xmin, xmax, ymin_2, ymax_2])\n ax2.set_xlabel(XLab, fontsize=6, fontweight='bold')\n ax2.set_ylabel(YLab_2, fontsize=6, fontweight='bold')\n fig.subplots_adjust(hspace=0.05, top=0.94)\n elif no_of_sets == 1:\n ax1.set_xlabel(XLab, fontsize=6, fontweight='bold')\n fig.subplots_adjust(top=0.92)\n else:\n print(' ERROR !!!')\n fig.suptitle(SupTitle, fontsize = 8, fontweight='bold')\n if no_of_sets == 2:\n fig.text(0.73, 0.06, 'Processed ' + currentDate + ' at ' + currentTime,\n fontsize=4, transform=plt.gcf().transFigure)\n fig.text(0.09, 0.06, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\n fontsize=4, transform=plt.gcf().transFigure)\n elif no_of_sets == 1:\n fig.text(0.73, 0.03, 'Processed ' + currentDate + ' at '+currentTime,\n fontsize=4, transform=plt.gcf().transFigure)\n fig.text(0.09, 0.03, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\n fontsize=4, transform=plt.gcf().transFigure)\n else:\n print(' ERROR !!!')\n pylab.savefig(FileName, bbox_inches='tight', dpi=160)\n plt.close('all')\n return","def plot_2d_topomap_intra(ax):\n\n # plot first Head \n N = 300 # number of points for interpolation\n xy_center = [-0.178,0] # center of the plot\n radius = 0.1 # radius\n\n # draw a circle\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n # add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon) \n \n\n # Plot second Head \n x2y2_center = [0.178,0] # center of the plot\n radius2 = 0.1 # radius\n \n # draw a circle\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n ## add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon)","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def multiPlot(self,indexSelect=None,varSelect=None,wrapNumber=5,\n compLines=None, save = None, xlim = None,\n forceYAxisZero = True, colourOverride = None,\n style = None, legend = None, varAsAxis = False,\n xAxisLabel = None, yAxisLabel = None, figsize = (12,10),\n legendLoc = 'lower right'):\n if isinstance(compLines,list):\n compVars = [list(i.columns) for i in compLines]\n dfB = [i.copy() for i in compLines]\n for i in range(len(compLines)):\n if \"Time\" not in compVars[i]:\n dfB[i][\"Time\"]=dfB[i].index\n else:\n compVars[i].remove(\"Time\")\n dfB[i] = pd.melt(dfB[i], id_vars=[\"Time\"],\n value_vars=compVars[i])\n elif compLines is not None:\n compVars=list(compLines.columns)\n dfB = compLines.copy()\n if \"Time\" not in compVars:\n dfB[\"Time\"]=dfB.index\n else:\n compVars.remove(\"Time\")\n dfB = pd.melt(dfB,id_vars=[\"Time\"],\n value_vars=compVars)\n if varSelect is None:\n varSelect=list(self.longData['variable'].unique())\n if indexSelect is None:\n indexSelect=list(self.longData['index'].unique())\n if not isinstance(indexSelect,list):\n indexSelect = [indexSelect]\n if len(varSelect)<wrapNumber:\n #cols = math.floor(math.sqrt(len(varSelect)))\n cols = math.ceil(math.sqrt(len(varSelect)))\n else:\n cols = wrapNumber\n rows = math.ceil(len(varSelect)/cols)\n if style is None:\n myStyle = \"darkgrid\"\n else:\n myStyle = style\n with sns.axes_style(style):\n fig, axs = plt.subplots(rows, cols, sharex=True,\n figsize=figsize)\n if (rows>1):\n axs = trim_axs(axs, len(varSelect))\n elif (cols==1):\n axs = [axs]\n if colourOverride is not None:\n myColorMap = plt.get_cmap(name=\"cool\")\n else:\n myColorMap = plt.get_cmap(name=\"hsv\",\n lut=len(indexSelect)+1)\n for ax, theVar, j in zip(axs, varSelect, range(len(varSelect))):\n if varAsAxis:\n if isinstance(yAxisLabel,list):\n ax.set_ylabel(theVar+\" \"+yAxisLabel[j])\n elif yAxisLabel is not None:\n ax.set_ylabel(theVar+\" \"+yAxisLabel)\n else:\n ax.set_ylabel(theVar)\n else:\n ax.set_title(theVar)\n if isinstance(yAxisLabel,list):\n ax.set_ylabel(yAxisLabel[j])\n elif yAxisLabel is not None:\n ax.set_ylabel(yAxisLabel)\n if xAxisLabel is not None:\n ax.set_xlabel(xAxisLabel)\n df = self.longData\n df = df[df['variable']==theVar]\n if indexSelect is not None:\n for theIndex, i in zip(indexSelect,\n range(len(indexSelect))):\n df2 = df[df['index']==theIndex]\n if colourOverride is not None:\n ax.plot(df2[\"Time\"], df2[\"value\"],\n linestyle='solid',\n color=myColorMap(colourOverride[i]))\n else:\n ax.plot(df2[\"Time\"], df2[\"value\"],\n linestyle='solid',\n color=myColorMap(i))\n if isinstance(compLines,list):\n for i, theIndex in enumerate(indexSelect):\n dfB2 = dfB[theIndex][\n dfB[theIndex]['variable']==theVar]\n if colourOverride is not None:\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"o\",\n color=myColorMap(colourOverride[i]))\n else:\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"o\",\n color=myColorMap(i))\n elif compLines is not None:\n dfB2 = dfB[dfB['variable']==theVar]\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"ko\")\n if xlim is not None:\n ax.set_xlim(xlim)\n if forceYAxisZero:\n ax.set_ylim([0, None])\n if legend is not None:\n if colourOverride is not None:\n custom_lines = [Line2D([0], [0], color=myColorMap(\n colourOverride[i]), lw=4)\n for i in range(len(indexSelect))]\n else:\n custom_lines = [Line2D([0], [0], color=myColorMap(i),\n lw=4)\n for i in range(len(indexSelect))]\n if ((not isinstance(compLines,list)) and\n (compLines is not None)):\n custom_lines.append(Line2D([0], [0], \n color=\"k\", lw=4))\n fig.legend(custom_lines, legend,\n loc = legendLoc)\n fig.tight_layout()\n if save is not None:\n fig.savefig(save)","def make_plots(title, \n chrg_x, csd, \n ele_x, pots, \n csd_x, est_csd, est_pot, \n true_pot=None):\n fig = plt.figure(figsize=(7,10))\n #CSDs\n ax1 = plt.subplot(211)\n if np.array(csd_x).any() != False:\n im1b = ax1.plot(csd_x, est_csd[:,0], 'r', label='kCSD', linewidth=3)\n im1a = ax1.plot(chrg_x, csd, 'g', label = 'CSD', linestyle='--', linewidth=3)\n ax1.plot(ele_x, np.zeros_like(ele_x), 'ko',markersize=2.)\n plt.legend() \n ax1.set_xlim([0.,1.])\n #ax1.set_ylim(ax1.get_ylim()[::-1]) #Zero on the top --ASK?!\n max_csd = np.maximum(max(np.abs(csd)), max(np.abs(est_csd[:,0])))\n max_csd += max_csd*0.2\n ax1.set_ylim([-max_csd, max_csd])\n ax1.set_xlabel('Depth mm')\n ax1.set_ylabel('CSD mA/mm')\n #Potentails\n ax2 = plt.subplot(212)\n ax2.plot( ele_x, np.zeros_like(ele_x),'ko',markersize=2.)\n im2b = ax2.plot(csd_x, est_pot, 'b', label = 'kPOT', linewidth=3)\n im2a = ax2.plot(chrg_x,true_pot, color = 'orange', \n linestyle='--', label='TruePOT', linewidth=3)\n ax2.set_xlim([0.,1.])\n #ax2.set_ylim(ax2.get_ylim()[::-1]) #Zero on the top --ASK?!\n ax2.plot(ele_x, pots, 'kx', markersize=8.)\n max_pots = np.maximum(max(np.abs(true_pot)), max(np.abs(est_pot)))\n max_pots += max_pots*0.2\n ax2.set_xlabel('Depth mm')\n ax2.set_ylabel('Potential mV')\n ax2.set_ylim([-max_pots, max_pots])\n fig.suptitle(title)\n plt.legend()\n plt.show()\n return","def _get_lines(self) -> tuple[VGroup, VGroup]:\n center = self.get_origin()\n ratio_faded_lines = self.faded_line_ratio\n offset = self.azimuth_offset\n\n if ratio_faded_lines == 0: # don't show faded lines\n ratio_faded_lines = 1 # i.e. set ratio to 1\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\n rlines1 = VGroup()\n rlines2 = VGroup()\n alines1 = VGroup()\n alines2 = VGroup()\n\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\n ainput = np.arange(0, TAU, astep)\n\n unit_vector = self.x_axis.get_unit_vector()[0]\n\n for k, x in enumerate(rinput):\n new_line = Circle(radius=x * unit_vector)\n if k % ratio_faded_lines == 0:\n alines1.add(new_line)\n else:\n alines2.add(new_line)\n\n line = Line(center, self.get_x_axis().get_end())\n\n for k, x in enumerate(ainput):\n new_line = line.copy()\n new_line.rotate(x + offset, about_point=center)\n if k % ratio_faded_lines == 0:\n rlines1.add(new_line)\n else:\n rlines2.add(new_line)\n\n lines1 = VGroup(*rlines1, *alines1)\n lines2 = VGroup(*rlines2, *alines2)\n return lines1, lines2","def line_axes (self):\n return self._line_axes","def _timeseries_scatter_plot_lines(axes):\n axes.axvline(\n x=0,\n ymin=-1000,\n ymax=1000,\n color=\"grey\",\n linestyle=\"dotted\",\n alpha=0.6,\n )\n axes.axhline(\n y=0,\n xmin=-1000,\n xmax=1000,\n color=\"grey\",\n linestyle=\"dotted\",\n alpha=0.6,\n )","def plot_2d_topomap_inter(ax):\n\n # plot first Head \n N = 300 # number of points for interpolation\n xy_center = [-0.178,0] # center of the plot\n radius = 0.1 # radius\n\n # draw a circle\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n # add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [-0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [-0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n xy = [[-0.087,-0.027],[-0.087,0.027], [-0.068,0]]\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon) \n \n\n # Plot second Head \n x2y2_center = [0.178,0] # center of the plot\n radius2 = 0.1 # radius\n \n # draw a circle\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n ## add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n x2y2 = [[0.087,-0.027],[0.087,0.027], [0.068,0]]\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon)","def princ_axes(self):\r\n # get coordinates of mesh\r\n coords = BoundaryMesh(self.mesh,\"exterior\",True).coordinates()\r\n\r\n # get distances\r\n dist = np.sqrt(np.einsum('ij->i', np.square(coords)))\r\n\r\n # get maximal value\r\n maxind = np.argmax(dist)\r\n maxdist = dist[maxind]\r\n\r\n # get minimal value\r\n minind = np.argmin(dist)\r\n mindist = dist[minind]\r\n\r\n # find coordinates of maximal and minimal points\r\n maxax = coords[maxind, :]\r\n minax = coords[minind, :]\r\n\r\n # get the cross product of these vectors,\r\n # which is the ideal mid-size axis\r\n idealax = np.cross(maxax,minax)\r\n\r\n # get the dot product of this ideal axis with the coordinates,\r\n # take the absolute value, and find the index of the maximum\r\n secind = np.argmax(np.abs(np.einsum('j,ij->i',idealax,coords)))\r\n\r\n # get the second-axis distance\r\n secdist = dist[secind]\r\n\r\n return([maxdist, secdist, mindist], [\"a\", \"b\", \"c\"])","def _color_twin_axes(ax1, color1, ax2, color2):\n #spines\n ax1.spines['left'].set_color(color1)\n ax1.spines['right'].set_color(color2)\n ax2.spines['left'].set_color(color1)\n ax2.spines['right'].set_color(color2)\n #text\n ax1.yaxis.label.set_color(color1)\n ax2.yaxis.label.set_color(color2)\n #ticks\n ax1.tick_params(axis = 'y', colors = color1)\n ax2.tick_params(axis = 'y', colors = color2)","def make_six_plots(mc, moc1, moc2, moc1name, moc2name, rxn,\n cmin=None, cmax=None, emin=None, emax=None, **kwargs):\n\t# Get reaction rate colorbars\n\t_cmin, _cmax = get_min_and_max((mc, moc1, moc2), positive=True)\n\tif cmin is None:\n\t\tcmin = max(1 - max(1 - _cmin, _cmax - 1), 0)\n\tif cmax is None:\n\t\tcmax = 1 + max(_cmax - 1, 1 - _cmin)\n\t\n\tfig = plt.figure()\n\t# Plot the OpenMC reference solution in the upper left subplot\n\taxa = fig.add_subplot(231)\n\ta = plt.imshow(mc.squeeze(), interpolation=\"none\", cmap=\"jet\")\n\tplt.title(\"OpenMC {} Distribution\".format(rxn))\n\tplt.clim(cmin, cmax)\n\tplt.colorbar(a)\n\t# Plot OpenMOC\"s fission rates in the upper center subplot\n\taxb = fig.add_subplot(232)\n\tb = plt.imshow(moc1.squeeze(), interpolation=\"none\", cmap=\"jet\")\n\tplt.title(\"OpenMOC {} Distribution\\n{}\".format(rxn, moc1name))\n\tplt.clim(cmin, cmax)\n\tplt.colorbar(b)\n\t# Plot different OpenMOC fission rates in the upper right subplot\n\taxc = fig.add_subplot(233)\n\tc = plt.imshow(moc2.squeeze(), interpolation=\"none\", cmap=\"jet\")\n\tplt.title(\"OpenMOC {} Distribution\\n{}\".format(rxn, moc2name))\n\tplt.clim(cmin, cmax)\n\tplt.colorbar(c)\n\t\n\t# Get errors and their colorbars\n\terror11 = np.divide(moc1 - mc, mc / 100)\n\terror25 = np.divide(moc2 - mc, mc / 100)\n\terrorvs = np.divide(moc1 - moc2, moc2 / 100)\n\t\n\t_emin, _emax = get_min_and_max((error11, error25, errorvs))\n\tif emin is None:\n\t\temin = min(_emin, -_emax)\n\tif emax is None:\n\t\temax = max(_emax, -_emin)\n\t\t\n\t# Plot (MOC #1 vs. MOC #2) error in the lower left\n\taxd = fig.add_subplot(234)\n\td = plt.imshow(errorvs.squeeze(), interpolation=\"none\", cmap=\"rainbow\")\n\tplt.title(\"% Relative error of {}\\nvs {}\".format(moc1name, moc2name))\n\tplt.clim(emin, emax)\n\tplt.colorbar(d)\n\t# Plot (MOC #1 vs. Monte Carlo) error in the lower center\n\taxe = fig.add_subplot(235)\n\te = plt.imshow(error11.squeeze(), interpolation=\"none\", cmap=\"rainbow\")\n\tplt.title(\"% Relative error of {}\\nvs openmc\".format(moc1name))\n\tplt.clim(emin, emax)\n\tplt.colorbar(e)\n\t# Plot (MOC #2 vs. Monte Carlo) error in the lower right\n\taxf = fig.add_subplot(236)\n\tf = plt.imshow(error25.squeeze(), interpolation=\"none\", cmap=\"rainbow\")\n\tplt.title(\"% Relative error of {}\\nvs openmc\".format(moc2name))\n\tplt.clim(emin, emax)\n\tplt.colorbar(f)\n\t\n\t# implement mode and the rest later\n\tsix_axes = (axa, axb, axc, axd, axe, axf)\n\treturn fig, six_axes","def cartesian_coordinates(self, *axes):","def ft_ax(ax=None,\n y=1.03,\n yy=1.1,\n title=None,\n subtitle=None,\n source=None,\n add_box=False,\n left_axis=False):\n\n if ax is None:\n ax = plt.gca()\n\n ax.set_axisbelow(True)\n \n if title is not None:\n title = plt.title(title, y=y, loc='left')\n if subtitle is not None:\n plt.annotate(subtitle, xy=title.get_position(),\n xycoords='axes fraction', xytext=(0,-11), \n textcoords='offset points', size='large') \n \n if source is not None:\n src = plt.annotate(source, xy=(0,0), \n xycoords='axes fraction', xytext=(0,-35), \n textcoords='offset points', ha='left', va='top', size='small')\n \n # axes and grid-lines\n plt.grid(axis='y', linewidth=.5)\n sns.despine(left=True)\n if not left_axis:\n ax.yaxis.tick_right()\n ax.yaxis.set_label_position('right')\n ax.yaxis.set_label_coords(1,yy)\n ax.yaxis.get_label().set_rotation(0)\n ax.tick_params('y', length=0)\n \n plt.tight_layout()\n \n if add_box:\n ax2 = plt.axes(ax.get_position().bounds, facecolor=(1,1,1,0))\n ax2.xaxis.set_visible(False)\n ax2.yaxis.set_visible(False)\n x,y = np.array([[.01, 0.15], [y+.12, y+.12]])\n line = matplotlib.lines.Line2D(x, y, lw=6., color='k')\n ax2.add_line(line)\n line.set_clip_on(False)\n \n if add_box and source is not None:\n return (line, src)\n elif not add_box and source is not None:\n return (src,)\n elif add_box and source is None:\n return (line,)\n else:\n return []","def _timeseries_scatter_plot_axlim(axes, var_combination, slope,\n mins_maxs):\n min_lim, max_lim, min_glob, max_glob = mins_maxs\n for box in range(3):\n axes[box].set_ylim(min_lim, max_lim)\n if var_combination == \"pr:tas\":\n min_l = min(min_glob) - (max(max_glob) - min(min_glob)) * 0.1\n max_l = max(max_glob) + (max(max_glob) - min(min_glob)) * 0.1\n axes[box].set_xlim(min_l, max_l)\n else:\n axes[box].set_xlim(min_lim, max_lim)\n\n if (slope[\"cmip5\"] + slope[\"cmip6\"]) >= 0:\n axes[box].plot(\n [-1000, 1000],\n [-1000, 1000],\n color=\"gray\",\n alpha=0.6,\n )\n else:\n axes[box].plot(\n [-1000, 1000],\n [1000, -1000],\n color=\"gray\",\n alpha=0.6,\n )","def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\n\n tr =PolarAxes.PolarTransform()\n pi = np.pi\n\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\n\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\n tick_formatter1 = DictFormatter(dict(angle_ticks))\n\n grid_locator2 = MaxNLocator(4)\n\n grid_helper = floating_axes.GridHelperCurveLinear(\n tr, extremes=(tmax, tmin, zmax, zmin),\n grid_locator1=grid_locator1,\n grid_locator2=grid_locator2,\n tick_formatter1=tick_formatter1,\n tick_formatter2=None)\n\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\n fig.add_subplot(ax1)\n\n # create a parasite axes whose transData in RA, cz\n aux_ax = ax1.get_aux_axes(tr)\n\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\n # drawn twice, and possibly over some other\n # artists. So, we decrease the zorder a bit to\n # prevent this.\n\n return ax1, aux_ax","def common_axis( axis1, axis2 ):\n if hasattr( axis1, 'units' ):\n units1 = axis1.units.lower().replace(' ','_')\n if axis1.isTime():\n axis1.toRelativeTime( units1 ) #probably will change input argument\n else:\n units1 = None\n if hasattr( axis2, 'units' ):\n units2 = axis2.units.lower().replace(' ','_')\n else:\n units2 = None\n if units1!=None and units2!=None and units1 != units2:\n if axis1.isTime() and axis2.isTime():\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\n else:\n print \"ERROR. common_axis does not yet support differing units\",axis1.units,\" and \",axis2.units\n return None\n if axis1.isTime() or axis2.isTime():\n if not axis2.isTime() or not axis1.isTime():\n print \"ERROR. In common_axis, one axis is time, not the other\"\n return None\n if not axis1.calendar==axis2.calendar:\n print \"ERROR. common_axis does not yet support differing calendars.\"\n if len(axis1)==1 and len(axis2)==1:\n # There's just one time value, probably from averaging over time. The time value is meaningless\n # but it would be messy to have two.\n return (axis1,[0],[0])\n\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\n # units and calendar attributes should always be transferred if present.\n # Also to do: use bounds if available\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\n a1indexina3 = a12indexina3[0:len(axis1)]\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\n\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\n vid = axis1.id\n else:\n vid = None\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\n axis3.units = units1\n return (axis3,a1indexina3,a2indexina3)","def make_plot(solution, t, plot_Ts, plot_T1, plot_T2, xaxis, cc, delta_cc, albedo,delta_albedo\\\n , em1, delta_em1, em2, delta_em2):\n\n plt.close('all')\n fig = plt.figure()\n ax1 = fig.add_subplot(111)\n \n if xaxis == 'cloud cover':\n inc_cc = []\n for i in range(len(solution[0,:])):\n inc_cc.append(cc + (i*delta_cc)/calcs_per_timestep)\n\n if plot_Ts == 'On': ax1.plot(inc_cc,solution[0,:],label = 'Surface temperature')\n if plot_T1 == 'On': ax1.plot(inc_cc,solution[1,:], label = 'Lower atmospheric temperature')\n if plot_T2 == 'On': ax1.plot(inc_cc,solution[2,:], label = 'Upper atmospheric temperature')\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\n\n elif xaxis == 'time':\n \n #for i in range(len(solution[0,:])):\n #t.append(i*(timestep/calcs_per_timestep))\n \n if plot_Ts == 'On': ax1.plot(t,solution[0,:],label = 'Surface temperature')\n if plot_T1 == 'On': ax1.plot(t,solution[1,:], label = 'Lower atmospheric temperature')\n if plot_T2 == 'On': ax1.plot(t,solution[2,:], label = 'Upper atmospheric temperature')\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\n \n elif xaxis == 'albedo':\n inc_alb = []\n for i in range(len(solution[0,:])):\n inc_alb.append(albedo+(i*delta_albedo)/calcs_per_timestep)\n \n if plot_Ts == 'On': ax1.plot(inc_alb,solution[0,:],label = 'Surface temperature')\n if plot_T1 == 'On': ax1.plot(inc_alb,solution[1,:], label = 'Lower atmospheric temperature')\n if plot_T2 == 'On': ax1.plot(inc_alb,solution[2,:], label = 'Upper atmospheric temperature')\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\n \n elif xaxis == 'epsilon1':\n inc_em = []\n for i in range(len(solution[0,:])):\n inc_em.append(em1+(i*delta_em1)/calcs_per_timestep)\n \n if plot_Ts == 'On': ax1.plot(inc_em,solution[0,:],label = 'Surface temperature')\n if plot_T1 == 'On': ax1.plot(inc_em,solution[1,:], label = 'Lower atmospheric temperature')\n if plot_T2 == 'On': ax1.plot(inc_em,solution[2,:], label = 'Upper atmospheric temperature')\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\n \n elif xaxis == 'epsilon2':\n inc_em = []\n for i in range(len(solution[0,:])):\n inc_em.append(em2+(i*delta_em2)/calcs_per_timestep)\n \n if plot_Ts == 'On': ax1.plot(inc_em,solution[0,:],label = 'Surface temperature')\n if plot_T1 == 'On': ax1.plot(inc_em,solution[1,:], label = 'Lower atmospheric temperature')\n if plot_T2 == 'On': ax1.plot(inc_em,solution[2,:], label = 'Upper atmospheric temperature')\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\n \n else: raise ValueError('No x axis selected')\n \n fig.suptitle('Global Average Temperature')\n ax1.set_title(f'Final Surface Temperature = {round(solution[0,-1],2)} K')\n ax1.legend()\n\n if xaxis == 'cloud cover': ax1.set_xlabel('Cloud Cover (%)')\n elif xaxis == 'time': ax1.set_xlabel('Time (years)')\n elif xaxis == 'albedo': ax1.set_xlabel('Albedo')\n elif xaxis == 'epsilon1': ax1.set_xlabel(u'\\u03B5\\u2081')\n elif xaxis == 'epsilon2': ax1.set_xlabel(u'\\u03B5\\u2082')\n plt.ylabel('Temerature (K)')\n return fig","def update_cross_sections(self):\n self.get_xcs_panel().update_plot()\n self.get_ycs_panel().update_plot()","def plot_overlay2axes(self, axes) -> None:\n # calculate height (based on leaf analysis ratio)\n upper_point = (\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\n )\n lower_point = (\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\n )\n height = abs(upper_point - lower_point) * 0.8\n\n for idx, line in enumerate(self.marker_lines):\n width = abs(self.error[idx]) * self._image.dpmm\n y = line.center.y\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\n\n if self._orientation == Orientation.UP_DOWN:\n r = Rectangle(width, height, center=(x, y))\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n else:\n r = Rectangle(height, width, center=(x, y))\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n r.plot2axes(\n axes, edgecolor=\"none\", fill=True, alpha=1, facecolor=self.bg_color[idx]\n )","def populate_axes_with_euclidean(pid_series, series_was_shifted_to, axes):\n euclidean_distance(pid_series, series_was_shifted_to).plot(kind='bar', legend=False, ax=axes)","def scatter_plots_col(X, Y, i1, i2, ms=7, X_Labels=[], Y_Label='Y', ax=[]):\r\n\r\n # Options for the graphic\r\n pltfont = {'fontname': 'Bitstream Vera Sans', 'fontsize': 15} # font\r\n # Colorscale\r\n colorscale = 'jet'\r\n #colorscale = 'gray' # black and white plot\r\n\r\n ###########################################################################\r\n # Check inputs\r\n ###########################################################################\r\n if not isinstance(X, np.ndarray):\r\n raise ValueError('\"X\" must be a numpy.array.')\r\n if X.dtype.kind != 'f' and X.dtype.kind != 'i' and X.dtype.kind != 'u':\r\n raise ValueError('\"X\" must contain floats or integers.')\r\n\r\n if not isinstance(Y, np.ndarray):\r\n raise ValueError('\"Y\" must be a numpy.array.')\r\n if Y.dtype.kind != 'f' and Y.dtype.kind != 'i' and Y.dtype.kind != 'u':\r\n raise ValueError('\"Y\" must contain floats or integers.')\r\n\r\n Nx = X.shape\r\n Y = Y.flatten() # shape (N, )\r\n Ny = Y.shape\r\n N = Nx[0]\r\n M = Nx[1]\r\n if Ny[0] != N:\r\n raise ValueError('input \"X\" and \"Y\" must have the same number of rows')\r\n\r\n if not isinstance(i1, (int, np.int8, np.int16, np.int32, np.int64)):\r\n raise ValueError('\"i1\" must be scalar and integer.')\r\n if i1 < 0 or i1 > M-1:\r\n raise ValueError('\"i1\" must be in [0, M-1].')\r\n\r\n if not isinstance(i2, (int, np.int8, np.int16, np.int32, np.int64)):\r\n raise ValueError('\"i2\" must be scalar and integer.')\r\n if i2 < 0 or i2 > M-1:\r\n raise ValueError('\"i2\" must be in [0, M-1].')\r\n\r\n ###########################################################################\r\n # Check optional inputs\r\n ###########################################################################\r\n\r\n if not isinstance(Y_Label, str):\r\n raise ValueError('\"Y_Label\" must be a string.')\r\n\r\n if not X_Labels:\r\n X_Labels = [np.nan]*M\r\n for i in range(M):\r\n X_Labels[i] = 'X' + str(i+1)\r\n else:\r\n if not isinstance(X_Labels, list):\r\n raise ValueError('\"X_Labels\" must be a list with M elements.')\r\n if not all(isinstance(i, str) for i in X_Labels):\r\n raise ValueError('Elements in \"X_Labels\" must be strings.')\r\n if len(X_Labels) != M:\r\n raise ValueError('\"X_Labels\" must have M elements.')\r\n\r\n if not isinstance(ms, (int, np.int8, np.int16, np.int32, np.int64)):\r\n raise ValueError('\"ms\" must be scalar and integer.')\r\n if ms <= 0:\r\n raise ValueError('\"i2\" must be positive.')\r\n\r\n ###########################################################################\r\n # Create plot\r\n ###########################################################################\r\n\r\n # Option 1: plot on curent figure\r\n if plt.get_fignums(): # if there is a figure recover axes of current figure\r\n ax = plt.gca()\r\n else: # else create a new figure\r\n plt.figure()\r\n ax = plt.gca()\r\n # Option 2: create a new figure\r\n #plt.figure()\r\n #ax = plt.gca()\r\n\r\n map_plot = plt.scatter(X[:, i1], X[:, i2], s=ms, c=Y, cmap=colorscale)\r\n plt.xlabel(X_Labels[i1], **pltfont)\r\n plt.ylabel(X_Labels[i2], **pltfont)\r\n plt.xlim((np.min(X[:, i1]), np.max(X[:, i1])))\r\n plt.ylim((np.min(X[:, i2]), np.max(X[:, i2])))\r\n plt.xticks(**pltfont)\r\n plt.yticks(**pltfont)\r\n\r\n # Add colorbar\r\n cb = plt.colorbar(map_plot, ax=ax)\r\n cb.set_label(Y_Label, **pltfont)\r\n cb.Fontname = pltfont['fontname']\r\n cb.ax.tick_params(labelsize=pltfont['fontsize'])","def crossAxes(axl, xyzero=[0.0, 0.0], limits=[None, None, None, None], labels:Union[str, None]=['nA', 'mV']):\n\n axl = _ax_tolist(axl)\n # if type(axl) is not list:\n # axl = [axl]\n for ax in axl:\n if ax is None:\n continue\n # ax.set_title('spines at data (1,2)')\n # ax.plot(x,y)\n ax.spines[\"left\"].set_position((\"data\", xyzero[0]))\n ax.spines[\"right\"].set_color(\"none\")\n ax.spines[\"bottom\"].set_position((\"data\", xyzero[1]))\n ax.spines[\"top\"].set_color(\"none\")\n # ax.spines['left'].set_smart_bounds(True)\n # ax.spines['bottom'].set_smart_bounds(True) # deprecated, not sure what to do\n ax.xaxis.set_ticks_position(\"bottom\")\n ax.yaxis.set_ticks_position(\"left\")\n if limits[0] is not None:\n ax.set_xlim(left=limits[0], right=limits[2])\n ax.set_ylim(bottom=limits[1], top=limits[3])","def plot_2d(self, x1: Union[Iterable, ndarray], x2: Union[Iterable, ndarray],\n color_map: str = 'viridis', ax: Axes = None) -> Axes:\n x1_grid, x2_grid = meshgrid(x1, x2)\n x1_x2 = dstack((x1_grid, x2_grid))\n f = self._method(x1_x2)\n ax = ax or new_axes()\n ax.contourf(x1_grid, x2_grid, f, cmap=color_map)\n ax.set_xlabel('x1')\n ax.set_ylabel('x2')\n return ax","def createCustomXYaxis(origin: Tuple[float, float, float], endPoints: List[Tuple[float, float, float]]) -> List[\n vtkActor]:\n\n output = []\n\n for endPoint in endPoints:\n output.append(createLine(origin, endPoint, color=\"lightgreen\"))\n\n return output","def plotsegs(x1,y1,x2,y2):\n x = np.repeat(np.nan,x1.shape[0]*3)\n y = np.repeat(np.nan,x1.shape[0]*3)\n x[0::3] = x1\n x[1::3] = x2\n y[0::3] = y1\n y[1::3] = y2\n plt.plot(x,y)","def dline_Mgas_array(lines,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig, axs = plt.subplots(len(lines), sharex='col',\\\n figsize=(6,15),facecolor='w',\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\n\n for i,ax in enumerate(axs):\n\n dline_Mgas(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add=True,cb=True)\n dline_Mgas(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add=True,cb=False)\n\n plt.tight_layout()\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/dlines_Mgas_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)","def compute_axes(self):\n mini, maxi = self._get_extremes()\n self.y_axis.min = mini\n self.y_axis.max = maxi\n self.y_axis._max_min()\n\n if not None in [s.xvalues for s in self]:\n mini, maxi = self._get_extremes('xvalues')\n self.x_axis.min = mini\n self.x_axis.max = maxi\n self.x_axis._max_min()","def comp_axes(self, machine, N0=None):\n if self.time is None and N0 is None:\n raise InputError(\"ERROR: time and N0 can't be both None\")\n\n # Get machine pole pair number\n p = machine.get_pole_pair_number()\n\n # Get electrical fundamental frequency\n f_elec = self.comp_felec()\n\n # Airgap radius\n Rag = machine.comp_Rgap_mec()\n\n # Setup normalizations for time and angle axes\n norm_time = {\n \"elec_order\": f_elec,\n \"mech_order\": f_elec / p,\n }\n if N0 is not None:\n norm_time[\"angle_rotor\"] = 1 / (360 * N0 / 60)\n\n norm_angle = {\"space_order\": p, \"distance\": 1 / Rag}\n\n # Create time axis\n if self.time is None:\n # Create time axis as a DataLinspace\n Time = DataLinspace(\n name=\"time\",\n unit=\"s\",\n initial=0,\n final=60 / N0 * self.Nrev,\n number=self.Nt_tot,\n include_endpoint=False,\n normalizations=norm_time,\n )\n else:\n # Load time data\n time = self.time.get_data()\n self.Nt_tot = len(time)\n Time = Data1D(name=\"time\", unit=\"s\", values=time, normalizations=norm_time)\n\n # Create angle axis\n if self.angle is None:\n # Create angle axis as a DataLinspace\n Angle = DataLinspace(\n name=\"angle\",\n unit=\"rad\",\n initial=0,\n final=2 * pi,\n number=self.Na_tot,\n include_endpoint=False,\n normalizations=norm_angle,\n )\n else:\n # Load angle data\n angle = self.angle.get_data()\n self.Na_tot = len(angle)\n Angle = Data1D(\n name=\"angle\", unit=\"rad\", values=angle, normalizations=norm_angle\n )\n\n return Time, Angle","def plot_separate(self):\n f, axes = plt.subplots(2, 3, figsize=(16, 8))\n\n self.decomposition_plot(ax=axes[0, 0], text='Lens light', lens_light_add=True, unconvolved=True)\n self.decomposition_plot(ax=axes[1, 0], text='Lens light convolved', lens_light_add=True)\n self.decomposition_plot(ax=axes[0, 1], text='Source light', source_add=True, unconvolved=True)\n self.decomposition_plot(ax=axes[1, 1], text='Source light convolved', source_add=True)\n self.decomposition_plot(ax=axes[0, 2], text='All components', source_add=True, lens_light_add=True,\n unconvolved=True)\n self.decomposition_plot(ax=axes[1, 2], text='All components convolved', source_add=True,\n lens_light_add=True, point_source_add=True)\n f.tight_layout()\n f.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0., hspace=0.05)\n return f, axes","def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\n steps: int=10):\n \n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n ctr1 = np.nanmean(loc1, 0)\n ctr1[2] -= 0.2\n ctr2 = np.nanmean(loc2, 0)\n ctr2[2] -= 0.2\n\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\n Cmax1=np.nanmax(C1[:])\n Cmax2=np.nanmax(C2[:])\n Cmax=[]\n Cmax=[Cmax1, Cmax2]\n vmax=np.nanmax(Cmax)\n Cmin1=np.nanmin(C1[:])\n Cmin2=np.nanmin(C2[:])\n Cmin=[]\n Cmin=[Cmin1, Cmin2]\n vmin=np.min(Cmin)\n\n # Calculate automatic threshold\n if threshold == 'auto':\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\n else:\n threshold = threshold\n\n # Define colormap for both participant\n cmap_p = matplotlib.cm.get_cmap('Reds')\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\n\n for e1 in range(len(loc1)):\n x1 = loc1[e1, 0]\n y1 = loc1[e1, 1]\n z1 = loc1[e1, 2]\n for e2 in range(len(loc1)):\n x2 = loc1[e2, 0]\n y2 = loc1[e2, 1]\n z2 = loc1[e2, 2]\n if C1[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C1[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)\n \n for e1 in range(len(loc2)):\n x1 = loc2[e1, 0]\n y1 = loc2[e1, 1]\n z1 = loc2[e1, 2]\n for e2 in range(len(loc2)):\n x2 = loc2[e2, 0]\n y2 = loc2[e2, 1]\n z2 = loc2[e2, 2]\n if C2[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C2[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)","def intersection(self, axis2):","def plot(self) -> List[matplotlib.figure.Figure]:\n figs = []\n\n # Figure 1, position in 3 subplots\n pos_fig_sub = self.plot_subplots(0, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed)\n figs.append(pos_fig_sub)\n\n # Figure 2, orientation in 3 subplots\n eul_fig_sub = self.plot_subplots(1, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed)\n figs.append(eul_fig_sub)\n\n # Figure 3, position in one axes\n pos_fig_one = self.plot_one_axes(2, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed,\n {'labeled': 'Labeled (X)', 'filled': 'Filled (Y)', 'smoothed': 'Smoothed (Z)'})\n figs.append(pos_fig_one)\n\n # Figure 3, position in one axes\n eul_fig_one = self.plot_one_axes(3, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed,\n {'labeled': 'Labeled (Flex/Ext)', 'filled': 'Filled (Lat Flex)',\n 'smoothed': 'Smoothed (Axial)'})\n figs.append(eul_fig_one)\n\n return figs","def discrete_scatter(x1, x2, y=None, markers=None, s=10, ax=None,\n labels=None, padding=.2, alpha=1, c=None, markeredgewidth=None):\n if ax is None:\n ax = plt.gca()\n\n if y is None:\n y = np.zeros(len(x1))\n\n unique_y = np.unique(y)\n\n if markers is None:\n markers = ['o', '^', 'v', 'D', 's', '*', 'p', 'h', 'H', '8', '<', '>'] * 10\n\n if len(markers) == 1:\n markers = markers * len(unique_y)\n\n if labels is None:\n labels = unique_y\n\n # lines in the matplotlib sense, not actual lines\n lines = []\n\n current_cycler = mpl.rcParams['axes.prop_cycle']\n\n for i, (yy, cycle) in enumerate(zip(unique_y, current_cycler())):\n mask = y == yy\n # if c is none, use color cycle\n if c is None:\n color = cycle['color']\n elif len(c) > 1:\n color = c[i]\n else:\n color = c\n # use light edge for dark markers\n if np.mean(colorConverter.to_rgb(color)) < .4:\n markeredgecolor = \"grey\"\n else:\n markeredgecolor = \"black\"\n\n lines.append(ax.plot(x1[mask], x2[mask], markers[i], markersize=s,\n label=labels[i], alpha=alpha, c=color,\n markeredgewidth=markeredgewidth,\n markeredgecolor=markeredgecolor)[0])\n\n if padding != 0:\n pad1 = x1.std() * padding\n pad2 = x2.std() * padding\n xlim = ax.get_xlim()\n ylim = ax.get_ylim()\n ax.set_xlim(min(x1.min() - pad1, xlim[0]), max(x1.max() + pad1, xlim[1]))\n ax.set_ylim(min(x2.min() - pad2, ylim[0]), max(x2.max() + pad2, ylim[1]))\n\n return lines","def _axes_domain(self, *args, **kwargs):\n # See _add_gridline_label for detials\n lon_0 = self.axes.projection.proj4_params.get('lon_0', 0)\n x_range, y_range = type(self)._axes_domain(self, *args, **kwargs)\n x_range = np.asarray(x_range) + lon_0\n return x_range, y_range","def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def plot_output_3axes(axes, name, color):\n\tout = vice.output(name)\n\taxes[0].plot(out.history[\"time\"][1:], out.history[\"ifr\"][1:],\n\t\tc = visuals.colors()[color], linestyle = '--')\n\taxes[0].plot(out.history[\"time\"], out.history[\"sfr\"],\n\t\tc = visuals.colors()[color], linestyle = '-')\n\taxes[1].plot(out.history[\"[Fe/H]\"], out.history[\"[O/Fe]\"],\n\t\tc = visuals.colors()[color])\n\taxes[2].plot(list(map(lambda x, y: (x + y) / 2., out.mdf[\"bin_edge_left\"],\n\t\tout.mdf[\"bin_edge_right\"])), out.mdf[\"dn/d[O/Fe]\"],\n\t\tc = visuals.colors()[color])","def plotScopes12p(day,shot):\n axs = []\n for p in range(4):\n if p == 0:\n ax = plt.subplot(4,3,3*p+1)\n plt.title(\"day %d, shot %d, scope 1\"%(day,shot))\n else:\n plt.subplot(4,3,3*p+1,sharex=ax)\n\n x = findReadData(day,1,p+1,shot)\n plt.plot(x.Time,x.Ampl)\n plt.ylabel(\"channel %d\"%(p+1))\n fudgePlotLimits(x.Time,x.Ampl)\n if p==3:\n plt.xlabel(\"time ($\\mu$s)\")\n\n plt.subplot(4,3,3*p+2,sharex=ax)\n if p == 0:\n plt.title(\"day %d, shot %d, scope 2\"%(day,shot))\n x = findReadData(day,2,p+1,shot)\n plt.plot(x.Time,x.Ampl)\n plt.ylabel(\"channel %d\"%(p+1))\n fudgePlotLimits(x.Time,x.Ampl)\n if p==3:\n plt.xlabel(\"time ($\\mu$s)\")\n\n plt.subplot(4,3,3*p+3,sharex=ax)\n if p == 0:\n plt.title(\"day %d, shot %d, scope 3\"%(day,shot))\n x = findReadData(day,3,p+1,shot)\n plt.plot(x.Time,x.Ampl)\n plt.ylabel(\"channel %d\"%(p+1))\n fudgePlotLimits(x.Time,x.Ampl)\n if p==3:\n plt.xlabel(\"time ($\\mu$s)\")","def figures(self):\n if np.size(self.iceicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n if self.site1.archive == 'icecore':\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\n else:\n mpl.xlabel(self.site1.label+' age (yr b1950)')\n if self.site2.archive == 'icecore':\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\n else:\n mpl.ylabel(self.site2.label+' age (yr b1950)')\n if np.size(self.iceicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceicehorizons_depth1),\n self.site2.fct_age_init(self.iceicehorizons_depth2),\n color=pccfg.color_init, linestyle='', marker='o', markersize=2,\n label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceicehorizons_depth1),\n self.site2.fct_age_model(self.iceicehorizons_depth2),\n color=pccfg.color_mod, linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceicehorizons_depth1),\n self.site2.fct_age(self.iceicehorizons_depth2), color=pccfg.color_opt,\n xerr=np.zeros(np.size(self.iceicehorizons_depth1)),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_age(self.iceicehorizons_depth1)-self.iceicehorizons_sigma/2\n ystart = self.site2.fct_age(self.iceicehorizons_depth2)+self.iceicehorizons_sigma/2\n for i in range(np.size(self.iceicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceicehorizons_sigma[i],\n -self.iceicehorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement', zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_ice_synchro.pdf')\n elif self.site1.archive == 'icecore' or self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n if np.size(self.airairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\n if np.size(self.airairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airairhorizons_depth1),\n self.site2.fct_airage_init(self.airairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airairhorizons_depth1),\n self.site2.fct_airage_model(self.airairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airairhorizons_depth1),\n self.site2.fct_airage(self.airairhorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.airairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_airage(self.airairhorizons_depth1)-\\\n self.airairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.airairhorizons_depth2)+\\\n self.airairhorizons_sigma/2\n for i in range(np.size(self.airairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airairhorizons_sigma[i],\n -self.airairhorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site2.archive == 'icecore':\n if np.size(self.iceairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n if self.site1.archive == 'icecore':\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\n else:\n mpl.xlabel(self.site1.label+' age (yr b1950)')\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\n if np.size(self.iceairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceairhorizons_depth1),\n self.site2.fct_airage_init(self.iceairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceairhorizons_depth1),\n self.site2.fct_airage_model(self.iceairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceairhorizons_depth1),\n self.site2.fct_airage(self.iceairhorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.iceairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_age(self.iceairhorizons_depth1)-\\\n self.iceairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.iceairhorizons_depth2)+\\\n self.iceairhorizons_sigma/2\n for i in range(np.size(self.iceairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceairhorizons_sigma[i],\n -self.iceairhorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0) \n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site1.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_air_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore':\n if np.size(self.airicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\n if self.site2.archive == 'icecore':\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\n else:\n mpl.ylabel(self.site2.label+' age (yr b1950)')\n if np.size(self.airicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airicehorizons_depth1),\n self.site2.fct_age_init(self.airicehorizons_depth2),\n color=pccfg.color_init,\n linestyle='', marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airicehorizons_depth1),\n self.site2.fct_age_model(self.airicehorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airicehorizons_depth1),\n self.site2.fct_age(self.airicehorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.airicehorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_airage(self.airicehorizons_depth1)-\\\n self.airicehorizons_sigma/2\n ystart = self.site2.fct_age(self.airicehorizons_depth2)+\\\n self.airicehorizons_sigma/2\n for i in range(np.size(self.airicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airicehorizons_sigma[i],\n -self.airicehorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement')\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_ice_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()","def plot_box(ax, p1, p2, *args, **kwargs):\n x1, y1, z1 = p1\n x2, y2, z2 = p2\n\n plot_line(ax, (x1, y1, z1), (x2, y1, z1), *args, **kwargs)\n plot_line(ax, (x1, y2, z1), (x2, y2, z1), *args, **kwargs)\n plot_line(ax, (x1, y1, z2), (x2, y1, z2), *args, **kwargs)\n plot_line(ax, (x1, y2, z2), (x2, y2, z2), *args, **kwargs)\n\n plot_line(ax, (x1, y1, z1), (x1, y2, z1), *args, **kwargs)\n plot_line(ax, (x2, y1, z1), (x2, y2, z1), *args, **kwargs)\n plot_line(ax, (x1, y1, z2), (x1, y2, z2), *args, **kwargs)\n plot_line(ax, (x2, y1, z2), (x2, y2, z2), *args, **kwargs)\n\n plot_line(ax, (x1, y1, z1), (x1, y1, z2), *args, **kwargs)\n plot_line(ax, (x2, y1, z1), (x2, y1, z2), *args, **kwargs)\n plot_line(ax, (x1, y2, z1), (x1, y2, z2), *args, **kwargs)\n plot_line(ax, (x2, y2, z1), (x2, y2, z2), *args, **kwargs)","def plot_3outputs(X, gp,xlim):\r\n fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(15, 8))\r\n slices = GPy.util.multioutput.get_slices([X, X, X])\r\n #Output 1\r\n ax1.set_xlim(xlim)\r\n ax1.set_title('X')\r\n gp.plot(plot_limits=xlim, ax=ax1, fixed_inputs=[(1,0)], which_data_rows=slices[0])\r\n # ax1.plot(X1,Y1,'r,',mew=1.5)\r\n #Output 2\r\n ax2.set_xlim(xlim)\r\n ax2.set_title('Y')\r\n gp.plot(plot_limits=xlim, ax=ax2, fixed_inputs=[(1,1)], which_data_rows=slices[1])\r\n # ax2.plot(X2,Y2,'r,',mew=1.5)\r\n # Output 3\r\n ax3.set_xlim(xlim)\r\n ax3.set_title('Z')\r\n gp.plot(plot_limits=xlim, ax=ax3, fixed_inputs=[(1,2)], which_data_rows=slices[2])\r\n # ax3.plot(X3, Y3, 'r,', mew=1.5)\r\n return","def plot_line(ax, p1, p2, *args, **kwargs):\n ax.plot(*zip(p1, p2), *args, **kwargs)","def axis2D(xlow,xhigh,xfirst,xstep,ylow,yhigh,yfirst,ystep):\n dislin.graf(xlow,xhigh,xfirst,xstep,\\\n ylow,yhigh,yfirst,ystep)","def from_cartesian(self, coordinates, *axes):","def _format_twin_axes(*args):\n if(len(args) > 1):\n #get minimum y limit\n ylow, yhigh = 0., 0.\n for ax in args:\n yl = ax.get_ylim()\n if(yl[0] < ylow):\n ylow = yl[0]\n yhigh = yl[1]\n #scale all axes identically so that they overlap at y = 0\n if(yhigh != 0):\n frac = ylow/yhigh\n for ax in args:\n yl = ax.get_ylim()\n ax.set_ylim(frac*yl[1], yl[1])","def calcPositions_xy(self):\n vA, cA = self.valueAxis, self.categoryAxis\n vA.setPosition(self.x, self.y, self.height)\n if vA: vA.joinAxis = cA\n if cA: cA.joinAxis = vA\n vA.configure(self.data)\n # If zero is in chart, put x axis there, otherwise\n # use bottom.\n xAxisCrossesAt = vA.scale(0)\n if ((xAxisCrossesAt > self.y + self.height) or (xAxisCrossesAt < self.y)):\n y = self.y\n else:\n y = xAxisCrossesAt\n cA.setPosition(self.x, y, self.width)\n cA.configure(self.data)\n\n self._seriesCount = len(self.data)\n self._rowLength = max(map(len,self.data))\n if self.useAbsolute:\n # Dimensions are absolute.\n normFactor = 1.0\n else:\n # Dimensions are normalized to fit.\n normWidth = self.groupSpacing\n availWidth = self.categoryAxis.scale(0)[1]\n normFactor = availWidth / normWidth\n \n self._positions = []\n for rowNo in range(len(self.data)):\n lineRow = []\n for colNo in range(len(self.data[rowNo])):\n datum = self.data[rowNo][colNo]\n if datum is not None:\n (groupX, groupWidth) = self.categoryAxis.scale(colNo)\n x = groupX + (0.5 * self.groupSpacing * normFactor)\n y = self.valueAxis.scale(0)\n height = self.valueAxis.scale(datum) - y\n lineRow.append((x, y+height))\n self._positions.append(lineRow)\n return self._positions","def plot_events(ax, MD):\n\n coord_vars = ['CT_at_HB', 'CT_out_HB']\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\n all_vars = coord_vars + ingestion_vars\n\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\n \n names = ['M', 'M', 'F', 'F', 'W', 'W']\n idx = [2, 0, 0, 1, 0, 1]\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\n\n offsets = [-3, -5, -9, -11, -14, -16]\n height = 1.\n \n print \"plotting events..\"\n\n\n for c, name in enumerate(all_vars):\n\n # load\n if not hasattr(MD, name):\n MD.load(name)\n\n events = getattr(MD, name) / 3600. - 7 \n\n offset = offsets[c]\n color = colors[c]\n label = str(events.shape[0]) + ' ' + labels[c]\n\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\n label += ' events'\n\n if name in coord_vars:\n \n ax.scatter(\n events, offset * np.ones(events.shape[0]),\n c=color,\n marker='|',\n linewidths=1,\n edgecolors=None\n )\n \n\n elif name in ingestion_vars:\n\n for x in events: \n event_patch = patches.Rectangle(\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\n linewidth=0.001,\n fc=color, \n ec=color\n ) \n ax.add_patch(event_patch) \n\n # event descritpion\n ax.text(31, offset, label, color=color, \n fontsize=7, ha='left', va='bottom'\n )","def plot_msd(msd, h_exp):\n fig, ax = plt.subplots(1, 2, figsize = (10, 10))\n av_msd = np.mean(msd, axis = 0)\n\n for p in np.arange(0, msd.shape[0], step = 1):\n for t in np.arange(0, msd.shape[1], step = 1): \n ax[0].plot(t, msd[p, t], 'bx')\n ax[1].plot(t, av_msd[t], 'ro')\n ax[0].set_xlabel('Time lag (number of steps)')\n ax[0].set_ylabel('MSD (pix^2)')\n ax[0].set_title('Individual TAMSDs: H = ' + str(h_exp))\n ax[1].set_xlabel('Time lag (number of steps)')\n ax[1].set_ylabel('MSD (pix^2)')\n ax[1].set_title('Averaged TAMSDs: H = ' + str(h_exp)) \n ax[0].set_xlim([0, np.max(t)])\n ax[1].set_xlim([0, np.max(t)])\n ax[0].set_ylim([0, np.max(msd)]) \n ax[1].set_ylim([0, np.max(av_msd)])","def _get_lines_parallel_to_axis(\n self,\n axis_parallel_to: NumberLine,\n axis_perpendicular_to: NumberLine,\n freq: float,\n ratio_faded_lines: int,\n ) -> tuple[VGroup, VGroup]:\n\n line = Line(axis_parallel_to.get_start(), axis_parallel_to.get_end())\n if ratio_faded_lines == 0: # don't show faded lines\n ratio_faded_lines = 1 # i.e. set ratio to 1\n step = (1 / ratio_faded_lines) * freq\n lines1 = VGroup()\n lines2 = VGroup()\n unit_vector_axis_perp_to = axis_perpendicular_to.get_unit_vector()\n\n # need to unpack all three values\n x_min, x_max, _ = axis_perpendicular_to.x_range\n\n # account for different axis scalings (logarithmic), where\n # negative values do not exist and [-2 , 4] should output lines\n # similar to [0, 6]\n if axis_perpendicular_to.x_min > 0 and x_min < 0:\n x_min, x_max = (0, np.abs(x_min) + np.abs(x_max))\n\n # min/max used in case range does not include 0. i.e. if (2,6):\n # the range becomes (0,4), not (0,6).\n ranges = (\n [0],\n np.arange(step, min(x_max - x_min, x_max), step),\n np.arange(-step, max(x_min - x_max, x_min), -step),\n )\n\n for inputs in ranges:\n for k, x in enumerate(inputs):\n new_line = line.copy()\n new_line.shift(unit_vector_axis_perp_to * x)\n if (k + 1) % ratio_faded_lines == 0:\n lines1.add(new_line)\n else:\n lines2.add(new_line)\n return lines1, lines2","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 _find_axes(cls, input_data, explicit_x=None):\n\n if isinstance(input_data, pd.Series):\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a pandas Series\")\n\n return input_data.index, input_data.values\n elif isinstance(input_data, pd.DataFrame):\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a pandas DataFrame\")\n\n return input_data.index, input_data.values[:, 0]\n elif isinstance(input_data, np.ndarray):\n if len(input_data.shape) == 2 and input_data.shape[0] == 2:\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a 2D array of input data\")\n\n return input_data[:, 0], input_data[:, 1]\n elif len(input_data.shape) == 1:\n if explicit_x is not None:\n if len(explicit_x) != len(input_data):\n raise ArgumentError(\"Your explicit x data has a different length that your y data\", x_length=len(explicit_x), y_length=len(input_data))\n\n return explicit_x, input_data\n else:\n return np.linspace(0, len(input_data) - 1, len(input_data)), input_data\n elif explicit_x is not None:\n return np.array(explicit_x), np.array(explicit_x)\n\n return np.linspace(0, len(input_data) - 1, len(input_data)), np.array(input_data)","def get_tick_iterators(self, axes):\n\n lat_levs, lat_n, lat_factor = self._grid_info[\"lat_info\"]\n yy0 = lat_levs / lat_factor\n\n lon_levs, lon_n, lon_factor = self._grid_info[\"lon_info\"]\n xx0 = lon_levs / lon_factor\n\n e0, e1 = self._extremes\n\n def trf_xy(x, y):\n trf = self.grid_helper.grid_finder.get_transform() + axes.transData\n return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T\n\n # find angles\n if self.nth_coord == 0:\n mask = (e0 <= yy0) & (yy0 <= e1)\n (xx1, yy1), (dxx1, dyy1), (dxx2, dyy2) = _value_and_jacobian(\n trf_xy, self.value, yy0[mask], (-np.inf, np.inf), (e0, e1))\n labels = self._grid_info[\"lat_labels\"]\n\n elif self.nth_coord == 1:\n mask = (e0 <= xx0) & (xx0 <= e1)\n (xx1, yy1), (dxx2, dyy2), (dxx1, dyy1) = _value_and_jacobian(\n trf_xy, xx0[mask], self.value, (-np.inf, np.inf), (e0, e1))\n labels = self._grid_info[\"lon_labels\"]\n\n labels = [l for l, m in zip(labels, mask) if m]\n\n angle_normal = np.arctan2(dyy1, dxx1)\n angle_tangent = np.arctan2(dyy2, dxx2)\n mm = (dyy1 == 0) & (dxx1 == 0) # points with degenerate normal\n angle_normal[mm] = angle_tangent[mm] + np.pi / 2\n\n tick_to_axes = self.get_tick_transform(axes) - axes.transAxes\n in_01 = functools.partial(\n mpl.transforms._interval_contains_close, (0, 1))\n\n def f1():\n for x, y, normal, tangent, lab \\\n in zip(xx1, yy1, angle_normal, angle_tangent, labels):\n c2 = tick_to_axes.transform((x, y))\n if in_01(c2[0]) and in_01(c2[1]):\n yield [x, y], *np.rad2deg([normal, tangent]), lab\n\n return f1(), iter([])","def populate_plot_axis(self,plot,ax='x'):\n\n fig=plt.gcf()\n\n extra_ax=[]\n\n if ax=='x':\n\n ticks=plot.get_xticks()\n\n lim=plot.get_xlim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['bottom'].set_position(('outward',10))\n\n axn.spines['bottom'].set_visible(True)\n\n else:\n\n dy_fig=0.08\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0,\\\n prev_ax_position.y0-2*dy_fig,\\\n prev_ax_position.width,\\\n 0),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.yaxis.set_visible(False)\n\n for side in axn.spines.keys():\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_xticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_xticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n xlab=axn.set_xlabel(self.names[i])\n\n xlab.set_fontsize(10)\n\n axn.tick_params(axis='x',labelsize=10)\n\n axn.set_xlim(lim)\n\n\n\n elif ax=='y':\n\n ticks=plot.get_yticks()\n\n lim=plot.get_ylim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['left'].set_position(('outward',10))\n\n axn.spines['left'].set_visible(True)\n\n else:\n\n dx_fig=0.08\n\n plot_position=plot.get_position()\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0-2*dx_fig,\\\n prev_ax_position.y0,\\\n 0,\\\n prev_ax_position.height),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.xaxis.set_visible(False) # hide the yaxis\n\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_yticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_yticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n ylab=axn.set_ylabel(self.names[i])\n\n ylab.set_fontsize(10)\n\n axn.tick_params(axis='y',labelsize=10)\n\n axn.set_ylim(lim)\n\n else:\n\n raise ValueError(\"Axis can be 'x' or 'y'\")","def get_2d_axes(xmin, xmax, ymin, ymax,\n axis_style='r-style',\n xscale=1.0, xbase=0.0, yscale=1.0, ybase=0.0,\n xticks=[], yticks=[],\n xtick_labels=None, ytick_labels=None,\n tick_font='normalsize', tick_size='semithick',\n label_font='Large', xlabel='x', ylabel='y',\n xlabel_offset=0.1, ylabel_offset=0.15,\n axis_size='thick', axis_color='gray',\n tick_frac=0.05, ):\n\n # Find the tick size\n tick_dim = min(tick_frac*(ymax - ymin)*yscale,\n tick_frac*(xmax - xmin)*xscale)\n\n # Draw the axes\n s = ''\n if axis_style == 'r-style':\n if len(xticks) >= 2:\n s += '\\\\draw[%s, color=%s] (%f, %f) -- (%f,%f) -- (%f,%f) -- (%f, %f);'%(\n axis_size, axis_color,\n xscale*(xticks[0] - xbase),\n yscale*(ymin - ybase) - tick_dim,\n xscale*(xticks[0] - xbase), yscale*(ymin - ybase),\n xscale*(xticks[-1] - xbase), yscale*(ymin - ybase),\n xscale*(xticks[-1] - xbase), yscale*(ymin - ybase) - tick_dim)\n if len(yticks) >= 2:\n s += '\\\\draw[%s, color=%s] (%f, %f) -- (%f,%f) -- (%f,%f) -- (%f, %f);'%(\n axis_size, axis_color,\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[0] - ybase),\n xscale*(xmin - xbase), yscale*(yticks[0] - ybase),\n xscale*(xmin - xbase), yscale*(yticks[-1] - ybase),\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[-1] - ybase))\n else:\n s += '\\\\draw[%s, color=%s] (%f,%f) -- (%f,%f);'%(\n axis_size, axis_color,\n xscale*(xmin - xbase), yscale*(ymin - ybase),\n xscale*(xmax - xbase), yscale*(ymin - ybase))\n s += '\\\\draw[%s, color=%s] (%f,%f) -- (%f,%f);'%(\n axis_size, axis_color,\n xscale*(xmin - xbase), yscale*(ymin - ybase),\n xscale*(xmin - xbase), yscale*(ymax - ybase))\n\n # Draw the x-label\n if xlabel is not None:\n s += '\\\\draw[font=\\\\%s] (%f, %f) node[below] {%s};'%(\n label_font, 0.5*xscale*(xmin + xmax - xbase),\n yscale*(ymin - xlabel_offset*(ymax - ymin) - ybase),\n xlabel)\n\n # Draw the y-label\n if ylabel is not None:\n s += '\\\\draw[font=\\\\%s] (%f, %f) node[rotate=90] {%s};'%(\n label_font, xscale*(xmin - ylabel_offset*(xmax - xmin) - xbase),\n 0.5*yscale*(ymin + ymax - ybase),\n ylabel)\n\n # Draw the ticks on the graph\n if axis_style == 'r-style':\n if xtick_labels is None:\n for i in range(len(xticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[below] {%g};\\n'%(\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) - tick_dim,\n xticks[i])\n else:\n for i in range(len(xticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[below] {%s};\\n'%(\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) - tick_dim,\n xtick_labels[i])\n\n # Draw the ticks on the graph\n if ytick_labels is None:\n for i in range(len(yticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[left] {%g};\\n'%(\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[i] - ybase),\n yticks[i])\n else:\n for i in range(len(yticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[left] {%s};\\n'%(\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[i] - ybase),\n ytick_labels[i])\n else:\n if xtick_labels is None:\n for i in range(len(xticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[below] {%g};\\n'%(\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) + tick_dim,\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\n xticks[i])\n else:\n for i in range(len(xticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[below] {%s};\\n'%(\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) + tick_dim,\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\n xtick_labels[i])\n\n # Draw the ticks on the graph\n if ytick_labels is None:\n for i in range(len(yticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[left] {%g};\\n'%(\n xscale*(xmin - xbase) + tick_dim, yscale*(yticks[i] - ybase),\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\n yticks[i])\n else:\n for i in range(len(yticks)):\n s += '\\\\draw[font=\\\\%s, %s, color=%s, text=black] '%(\n tick_font, tick_size, axis_color)\n s += '(%f, %f) -- (%f, %f) node[left] {%s};\\n'%(\n xscale*(xmin - xbase) + tick_dim, yscale*(yticks[i] - ybase),\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\n ytick_labels[i])\n\n return s","def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors ('x' for bads)\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","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 convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )","def _set_axes(self):\n self += helper.line(stroke=\"black\", x1=self.__dict__['x'], x2=self.__dict__['x'], y1=0, y2=self.__dict__['y']*2)\n self += helper.line(stroke=\"black\", x1=0, x2=self.__dict__['x']*2, y1=self.__dict__['y'], y2=self.__dict__['y'])","def plot_data_matplotlib(df_data):\n # creating the figure and subplots as two rows and one column\n fig, ax = plt.subplots(2, 1)\n # defining the colours used for the plots and y axes\n red = \"#DA2525\"\n blue = \"#003A78\"\n # setting up the subplots to share the x axis\n # ax02 is the second y axis of the first subplot\n ax02 = ax[0].twinx()\n # ax12 is the second y axis of the second subplot\n ax12 = ax[1].twinx()\n # the global co2 line plot\n line1 = ax[0].plot(\n df_data.index,\n df_data[\"global_co2\"],\n label=\"Global $CO_2$ Emissions\",\n color=blue\n )\n # the global temperature line plot\n line2 = ax02.plot(\n df_data.index,\n df_data[\"global_temp\"],\n label=\"Global Temperature Anomaly\",\n color=red\n )\n # the uk co2 line plot\n line3 = ax[1].plot(\n df_data.index,\n df_data[\"uk_co2\"],\n label=\"UK $CO_2$ Emissions\",\n color=blue\n )\n # the uk temperature line plot\n line4 = ax12.plot(\n df_data.index,\n df_data[\"uk_temp\"],\n label=\"UK Surface Temperature\",\n color=red\n )\n # the next three dataframes are used to indicate where there are gaps in\n # the data, which I will use to produce a shaded region to highlight this\n # fact\n # for the global temperature data\n global_temp_nan = df_data[pd.isna(df_data[\"global_temp\"])]\n # for the UK temperature data\n uk_temp_nan = df_data[pd.isna(df_data[\"uk_temp\"])][:-1]\n # for the UK co2 emissions data\n uk_co2_nan = df_data[pd.isna(df_data[\"uk_co2\"])][:-2]\n # creating a shaded region to show the missing global temperature data\n ax[0].axvspan(\n global_temp_nan.index[0],\n global_temp_nan.index[-1],\n alpha=0.1,\n color=\"black\"\n )\n # creating a shaded region to show the missing UK co2 data\n ax[1].axvspan(\n uk_temp_nan.index[0],\n uk_co2_nan.index[-1],\n alpha=0.1,\n color=\"black\"\n )\n # creating a shaded region to show the missing UK temperature data\n ax[1].axvspan(\n uk_co2_nan.index[-1],\n uk_temp_nan.index[-1],\n alpha=0.05,\n color=\"black\"\n )\n # setting titles for the figure and subplots\n ax[0].set_title(\"{}{}{}\".format(\n \"Global and UK \",\n \"$CO_2$ Emissions and Surface Temperature over Time\",\n \"\\n\\nGlobal\"))\n ax[1].set_title(\"UK\")\n # setting axes labels\n ax[1].set_xlabel(\"Time (years)\")\n ax[0].set_ylabel(\"$CO_2$ Emissions (Tg)\", color=blue)\n ax02.set_ylabel(\"Temperature Anomaly (°C)\", color=red)\n ax[1].set_ylabel(\"$CO_2$ Emissions (Tg)\", color=blue)\n ax12.set_ylabel(\"Temperature (°C)\", color=red)\n # setting x axes limits so both subplots are over the same range\n ax[0].set_xlim((df_data.index[0], df_data.index[-1]))\n ax[1].set_xlim((df_data.index[0], df_data.index[-1]))\n # setting the x axes tick values\n ax[0].set_xticks([d for d in df_data.index if d.year % 20 == 0])\n ax[1].set_xticks([d for d in df_data.index if d.year % 20 == 0])\n # setting y axes colours to match the line plots\n ax[0].tick_params(\"y\", colors=blue)\n ax02.tick_params(\"y\", colors=red)\n ax[1].tick_params(\"y\", colors=blue)\n ax12.tick_params(\"y\", colors=red)\n # annotating the shaded regions\n ax[0].annotate(\n \"No temperature data available\",\n (\"1760-01-01\", 4000)\n )\n ax[1].annotate(\n \"No data available\",\n (\"1760-01-01\", 300)\n )\n ax[1].annotate(\n \"No temperature data available\",\n (\"1850-01-01\", 500)\n )\n # setting the legends \n ax[0].legend(\n line1 + line2,\n [\n line1[0].get_label(),\n line2[0].get_label(),\n ],\n loc=2\n )\n ax[1].legend(\n line3 + line4,\n [\n line3[0].get_label(),\n line4[0].get_label()\n ],\n loc=2\n )\n plt.show()\n return","def TwoDynSpectraPlot(Data_Ch_A, Data_Ch_B, VminA, VmaxA, VminB, VmaxB, Suptitle,\n CBarLabelA, CBarLabelB, no_of_spectra,\n TimeFigureScale, TimeScale, frequency,\n FreqPointsNum, colormap, TitleA, TitleB, fig_file_name,\n currentDate, currentTime, Software_version, customDPI):\n fig, axarr = plt.subplots(2, 1, figsize=(16.0, 9.0))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.08)\n im0 = axarr[0].imshow(np.flipud(Data_Ch_A), aspect='auto', vmin=VminA, vmax=VmaxA,\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\n rc('font', size=8, weight='bold')\n\n ticks_loc = axarr[0].get_yticks().tolist() # <---- Added to suppress warning\n axarr[0].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[0].set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\n axarr[0].set_yticklabels(axarr[0].get_yticks(), fontsize=8, fontweight='bold')\n cbar = fig.colorbar(im0, ax=axarr[0], pad=0.005)\n cbar.ax.tick_params(labelsize=8)\n cbar.set_label(CBarLabelA, fontsize=9, fontweight='bold')\n text = axarr[0].get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = ' '\n\n ticks_loc = axarr[0].get_xticks().tolist() # <---- Added to suppress warning\n axarr[0].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[0].set_xticklabels(text)\n axis_copy = axarr[0].twiny()\n axis_copy.set_xlim(0, no_of_spectra)\n text = axis_copy.get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeFigureScale[k]\n\n ticks_loc = axis_copy.get_xticks().tolist() # <---- Added to suppress warning\n axis_copy.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axis_copy.set_xticklabels(text, fontsize=8, fontweight='bold')\n axarr[0].set_title(TitleA, fontsize=10, fontweight='bold', style='italic', y=1.05)\n im1 = axarr[1].imshow(np.flipud(Data_Ch_B), aspect='auto', vmin=VminB, vmax=VmaxB,\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\n # frequency[FreqPointsNum-1]\n\n ticks_loc = axarr[1].get_xticks().tolist() # <---- Added to suppress warning\n axarr[1].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n ticks_loc = axarr[1].get_yticks().tolist() # <---- Added to suppress warning\n axarr[1].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[1].set_xlabel('UTC Time, HH:MM:SS.msec', fontsize=10, fontweight='bold')\n axarr[1].set_ylabel('Frequency, MHz', fontsize=10, fontweight='bold')\n cbar = fig.colorbar(im1, ax=axarr[1], pad=0.005)\n cbar.set_label(CBarLabelB, fontsize=9, fontweight='bold')\n cbar.ax.tick_params(labelsize=8)\n text = axarr[1].get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeScale[k]\n axarr[1].set_xticklabels(text, fontsize=8, fontweight='bold')\n axarr[1].set_yticklabels(axarr[1].get_yticks(), fontsize=8, fontweight='bold')\n axarr[1].set_title(TitleB, fontsize=10, fontweight='bold', style='italic', y=1.00)\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=1.01)\n fig.subplots_adjust(top=0.91)\n fig.text(0.72, 0.065, 'Processed ' + currentDate + ' at ' + currentTime,\n fontsize=6, transform=plt.gcf().transFigure)\n fig.text(0.1, 0.065, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\n fontsize=6, transform=plt.gcf().transFigure)\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\n plt.close('all')\n return 0","def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\n if log:\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\n else:\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)","def line_SFR_array(lines,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig, axs = plt.subplots(len(lines), sharex='col',\\\n figsize=(6,15),facecolor='w',\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\n\n for i,ax in enumerate(axs):\n\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\n line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=False,add=True,cb=False)\n\n # Only 1 galaxy\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=True,add=True,cb=False)\n\n\n plt.tight_layout()\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/lines_SFR_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)","def axes_maker(rows, cols):\n fig = plt.figure()\n current_subplot = [1] # Use list in order to modify\n def next_axes(**kwargs):\n current_subplot[0] += 1\n axes = fig.add_subplot(rows, cols, current_subplot[0] - 1, **kwargs)\n return axes\n return next_axes","def scatter_plots_interaction(X, Y, ms=7, X_Labels=[], Y_Label='Y'):\r\n\r\n # Options for the graphic\r\n pltfont = {'fontname': 'Bitstream Vera Sans', 'fontsize': 15} # font\r\n # Colorscale\r\n colorscale = 'jet'\r\n #colorscale = 'gray' # black and white plot\r\n\r\n ###########################################################################\r\n # Check inputs\r\n ###########################################################################\r\n if not isinstance(X, np.ndarray):\r\n raise ValueError('\"X\" must be a numpy.array.')\r\n if X.dtype.kind != 'f' and X.dtype.kind != 'i' and X.dtype.kind != 'u':\r\n raise ValueError('\"X\" must contain floats or integers.')\r\n\r\n if not isinstance(Y, np.ndarray):\r\n raise ValueError('\"Y\" must be a numpy.array.')\r\n if Y.dtype.kind != 'f' and Y.dtype.kind != 'i' and Y.dtype.kind != 'u':\r\n raise ValueError('\"Y\" must contain floats or integers.')\r\n\r\n Nx = X.shape\r\n Y = Y.flatten() # shape (N, )\r\n Ny = Y.shape\r\n N = Nx[0]\r\n M = Nx[1]\r\n if Ny[0] != N:\r\n raise ValueError('input \"X\" and \"Y\" must have the same number of rows')\r\n\r\n ###########################################################################\r\n # Check optional inputs\r\n ###########################################################################\r\n\r\n if not isinstance(Y_Label, str):\r\n raise ValueError('\"Y_Label\" must be a string.')\r\n\r\n if not X_Labels:\r\n X_Labels = [np.nan]*M\r\n for i in range(M):\r\n X_Labels[i] = 'X' + str(i+1)\r\n else:\r\n if not isinstance(X_Labels, list):\r\n raise ValueError('\"X_Labels\" must be a list with M elements.')\r\n if not all(isinstance(i, str) for i in X_Labels):\r\n raise ValueError('Elements in \"X_Labels\" must be strings.')\r\n if len(X_Labels) != M:\r\n raise ValueError('\"X_Labels\" must have M elements.')\r\n\r\n if not isinstance(ms, (int, np.int8, np.int16, np.int32, np.int64)):\r\n raise ValueError('\"ms\" must be scalar and integer.')\r\n if ms <= 0:\r\n raise ValueError('\"i2\" must be positive.')\r\n\r\n ###########################################################################\r\n # Create plot\r\n ###########################################################################\r\n\r\n fig = plt.figure()\r\n\r\n k = 1\r\n for i in range(M-1):\r\n for j in range(i+1, M, 1):\r\n plt.subplot(M-1, M-1, k)\r\n map_plot = plt.scatter(X[:, i], X[:, j], s=ms, c=Y, cmap=colorscale)\r\n plt.title(X_Labels[i] + ' vs ' + X_Labels[j], **pltfont)\r\n plt.xlim((np.min(X[:, i]), np.max(X[:, i])))\r\n plt.ylim((np.min(X[:, j]), np.max(X[:, j])))\r\n plt.xticks([])\r\n plt.yticks([])\r\n k = k + 1\r\n k = k + i\r\n\r\n # Create colorbar\r\n cax = fig.add_axes([0.92, 0.05, 0.02, 0.8]) # Add axes for the colorbar\r\n cb = plt.colorbar(map_plot, ax=cax, fraction=1, extendfrac=1, extendrect=True)\r\n cb.set_label(Y_Label, **pltfont)\r\n cb.Fontname = pltfont['fontname']\r\n cb.ax.tick_params(labelsize=pltfont['fontsize'])\r\n # Make axes of the colorbar invisible\r\n cax.set_visible(False)","def hov_difference(x, y, climits=None, dlimits=None, data_cmap='jet', nclasses=15, cticks=None, cticks_dif=None, ax1=None, ax2=None, ax3=None, rescaley=6, grid=True, rescalex=1, clabel=None, **kwargs):\n\n if climits is None:\n sys.exit('Please specify climits for hovmoeller')\n if dlimits is None:\n sys.exit('Please specify dlimits for hovmoeller')\n\n fig = plt.figure()\n if ax1 is None:\n ax1 = fig.add_subplot(311)\n if ax2 is None:\n ax2 = fig.add_subplot(312)\n if ax3 is None:\n ax3 = fig.add_subplot(313)\n\n #set all invalid data to NAN\n xdata = x.data\n ydata = y.data\n\n hov1 = hovmoeller(x.num2date(x.time), xdata, rescaley=rescaley, lat=x.lat, rescalex=rescalex)\n hov2 = hovmoeller(y.num2date(y.time), ydata, rescaley=rescaley, lat=y.lat, rescalex=rescalex)\n\n hov1.time_to_lat(**kwargs)\n hov2.time_to_lat(**kwargs)\n\n cmap = plt.cm.get_cmap(data_cmap, nclasses)\n\n hov1.plot(title=x._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap, ax=ax1, showcolorbar=False, climits=climits, grid=grid)\n hov2.plot(title=y._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap, ax=ax2, showcolorbar=False, climits=climits, grid=grid)\n\n add_nice_legend(ax1, hov1.im, cmap, cticks=cticks, label=clabel)\n add_nice_legend(ax2, hov2.im, cmap, cticks=cticks, label=clabel)\n\n if x.data.shape == y.data.shape:\n hov3 = hovmoeller(y.num2date(y.time), x.data - y.data, rescaley=rescaley, lat=y.lat, rescalex=rescalex)\n hov3.time_to_lat(**kwargs)\n cmap_diff = plt.cm.get_cmap('RdBu', nclasses)\n hov3.plot(title=x._get_label() + ' - ' + y._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap_diff, ax=ax3, showcolorbar=False, climits=dlimits, grid=grid)\n add_nice_legend(ax3, hov3.im, cmap_diff, cticks=cticks_dif, label=clabel)\n else:\n msg = 'Difference plot not possible as data has different shape'\n ax3.text(0.5, 0.5, msg,\n horizontalalignment='center',\n verticalalignment='center') # ,\n #transform = ax.transAxes)\n ax3.set_xticks([])\n ax3.set_yticks([])\n\n return fig, hov1, hov2","def plot_2nd(self, mod = 'F'):\n if not mpl: raise \"Problem with matplotib: Plotting not possible.\"\n f = plt.figure(figsize=(5,4), dpi=100)\n \n A2 = []\n \n strainList= self.__structures.items()[0][1].strainList\n \n if len(strainList)<=5:\n kk=1\n ll=len(strainList)\n grid=[ll]\n elif len(strainList)%5 == 0:\n kk=len(strainList)/5\n ll=5\n grid=[5 for i in range(kk)]\n else:\n kk=len(strainList)/5+1\n ll=5\n grid=[5 for i in range(kk)]\n grid[-1]=len(strainList)%5\n \n \n n=1\n m=1\n for stype in strainList:\n atoms = self.get_atomsByStraintype(stype)\n self.__V0 = atoms[0].V0\n strainList = atoms[0].strainList\n if self.__thermodyn and mod == 'F':\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\n elif self.__thermodyn and mod=='E0':\n energy = [i.gsenergy for i in atoms]\n elif self.__thermodyn and mod=='Fvib':\n energy = [i.phenergy[-1] for i in atoms]\n else:\n energy = [i.gsenergy for i in atoms]\n \n strain = [i.eta for i in atoms]\n \n spl = '1'+str(len(strainList))+str(n)\n #plt.subplot(int(spl))\n #a = f.add_subplot(int(spl))\n if (n-1)%5==0: m=0\n \n \n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\n #print (kk,ll), ((n-1)/5,m)\n j = 0\n for i in [2,4,6]:\n ans = Energy()\n ans.energy = energy\n ans.strain = strain\n ans.V0 = self.__V0\n \n fitorder = i\n ans.set_2nd(fitorder)\n A2.append(ans.get_2nd())\n \n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\n \n try:\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\n except:\n continue\n a.plot(strains, dE, label=str(fitorder))\n a.set_title(stype)\n a.set_xlabel('strain')\n a.set_ylabel(r'$\\frac{d^2E}{d\\epsilon^2}$ in eV')\n \n j+=1\n \n n+=1\n m+=1\n \n a.legend(title='Order of fit')\n return f","def plotZM(data, x, y, plotOpt=None, modelLevels=None, surfacePressure=None):\n # explanation of axes:\n # ax1: primary coordinate system latitude vs. pressure (left ticks on y axis)\n # ax2: twinned axes for altitude coordinates on right y axis\n # axm: small side panel with shared y axis from ax2 for display of model levels\n # right y ticks and y label will be drawn on axr if modelLevels are given, else on ax2\n # axr: pointer to \"right axis\", either ax2 or axm\n\n if plotOpt is None: plotOpt = {}\n labelFontSize = \"small\"\n # create figure and axes\n fig = plt.figure()\n ax1 = fig.add_subplot(111)\n # scale data if requested\n scale_factor = plotOpt.get('scale_factor', 1.0)\n pdata = data * scale_factor\n # determine contour levels to be used; default: linear spacing, 20 levels\n clevs = plotOpt.get('levels', np.linspace(data.min(), data.max(), 20))\n # map contour values to colors\n norm=matplotlib.colors.BoundaryNorm(clevs, ncolors=256, clip=False)\n # draw the (filled) contours\n contour = ax1.contourf(x, y, pdata, levels=clevs, norm=norm) \n # mask out surface pressure if given\n if not surfacePressure is None: \n ax1.fill_between(x, surfacePressure, surfacePressure.max(), color=\"white\") \n # add a title\n title = plotOpt.get('title', 'Vertical cross section')\n ax1.set_title(title)\n # add colorbar\n # Note: use of the ticks keyword forces colorbar to draw all labels\n fmt = matplotlib.ticker.FormatStrFormatter(\"%g\")\n cbar = fig.colorbar(contour, ax=ax1, orientation='horizontal', shrink=0.8,\n ticks=clevs, format=fmt)\n cbar.set_label(plotOpt.get('units', ''))\n for t in cbar.ax.get_xticklabels():\n t.set_fontsize(labelFontSize)\n # set up y axes: log pressure labels on the left y axis, altitude labels\n # according to model levels on the right y axis\n ax1.set_ylabel(\"Pressure [hPa]\")\n ax1.set_yscale('log')\n ax1.set_ylim(10.*np.ceil(y.max()/10.), y.min()) # avoid truncation of 1000 hPa\n subs = [1,2,5]\n if y.max()/y.min() < 30.:\n subs = [1,2,3,4,5,6,7,8,9]\n y1loc = matplotlib.ticker.LogLocator(base=10., subs=subs)\n ax1.yaxis.set_major_locator(y1loc)\n fmt = matplotlib.ticker.FormatStrFormatter(\"%g\")\n ax1.yaxis.set_major_formatter(fmt)\n for t in ax1.get_yticklabels():\n t.set_fontsize(labelFontSize)\n # calculate altitudes from pressure values (use fixed scale height)\n z0 = 8.400 # scale height for pressure_to_altitude conversion [km]\n altitude = z0 * np.log(1015.23/y)\n # add second y axis for altitude scale \n ax2 = ax1.twinx()\n # change values and font size of x labels\n ax1.set_xlabel('Latitude [degrees]')\n xloc = matplotlib.ticker.FixedLocator(np.arange(-90.,91.,30.))\n ax1.xaxis.set_major_locator(xloc)\n for t in ax1.get_xticklabels():\n t.set_fontsize(labelFontSize)\n # draw horizontal lines to the right to indicate model levels\n if not modelLevels is None:\n pos = ax1.get_position()\n axm = fig.add_axes([pos.x1,pos.y0,0.02,pos.height], sharey=ax2)\n axm.set_xlim(0., 1.)\n axm.xaxis.set_visible(False)\n modelLev = axm.hlines(altitude, 0., 1., color='0.5')\n axr = axm # specify y axis for right tick marks and labels\n # turn off tick labels of ax2\n for t in ax2.get_yticklabels():\n t.set_visible(False)\n label_xcoor = 3.7\n else:\n axr = ax2\n label_xcoor = 1.05\n axr.set_ylabel(\"Altitude [km]\")\n axr.yaxis.set_label_coords(label_xcoor, 0.5)\n axr.set_ylim(altitude.min(), altitude.max())\n yrloc = matplotlib.ticker.MaxNLocator(steps=[1,2,5,10])\n axr.yaxis.set_major_locator(yrloc)\n axr.yaxis.tick_right()\n for t in axr.yaxis.get_majorticklines():\n t.set_visible(False)\n for t in axr.get_yticklabels():\n t.set_fontsize(labelFontSize)\n # show plot\n plt.show()","def simPlots_comb(loadFile, axes, drug1, drug2):\n # Read model\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=False)\n\n drug1 += r\" ($\\mu$M)\"\n drug2 += r\" ($\\mu$M)\"\n\n dfplot = pd.DataFrame()\n dfplot[\"confl\"] = M.phase.flatten()\n dfplot[\"death\"] = M.green.flatten()\n dfplot[\"time\"] = np.tile(M.timeV, M.X1.size)\n dfplot[drug1] = np.round(np.repeat(M.X1, M.timeV.size), decimals=1)\n dfplot[drug2] = np.round(np.repeat(M.X2, M.timeV.size), decimals=1)\n\n ddd = dfplot.loc[dfplot[\"time\"] == 72.0, :]\n ddd = ddd.groupby([drug1, drug2, \"time\"]).mean().reset_index()\n confldf = ddd.pivot(drug1, drug2, \"confl\")\n\n sns.heatmap(confldf, ax=axes[0], vmin=0.0, square=True, xticklabels=1)\n axes[0].set_title(\"Phase\")\n sns.heatmap(ddd.pivot(drug1, drug2, \"death\"), ax=axes[3], vmin=0.0, square=True, xticklabels=1)\n axes[3].set_title(\"Annexin V\")\n\n confl = confldf.to_numpy()\n confl /= confl[0, 0]\n confl = 1.0 - confl\n\n assert np.all(confl <= 1.0)\n\n additive = (confl[:, 0][:, None] + confl[0, :][None, :]) - np.outer(confl[:, 0], confl[0, :])\n\n assert np.all(additive <= 1.0)\n\n confldf.iloc[:, :] = confl - additive\n\n sns.heatmap(confldf, ax=axes[1], cmap=\"PiYG\", vmin=-0.5, vmax=0.5, square=True, xticklabels=1)\n axes[1].set_title(\"Just Viability\")\n\n return confldf","def plot_multi_axis(time, axes, labels=None, fname=None):\n fig = plt.figure(figsize=(10, 6))\n if labels:\n for i in range(len(axes)):\n plt.plot(time, axes[i], label=labels[3][i])\n plt.plot(time, vecnorm(*axes), 'k', label=labels[3][len(axes)])\n plt.title(labels[0])\n plt.xlabel(labels[1])\n plt.ylabel(labels[2])\n plt.legend(loc='upper left')\n else:\n for i in range(len(axes)):\n plt.plot(time, axes[i])\n plt.plot(time, vecnorm(axes), 'k')\n if fname:\n with open(fname, 'w') as f:\n mpld3.save_html(fig, f)","def getPlotData(integrated):\n\tglobal normalized\n\tg1 = integrated.split(\"_\")[0]\n\tg2 = integrated.split(\"_\")[1] \n\tcompAxis = []\n\twarmthAxis = []\n\tgetMappingsWarmth = parser.getMappings(normalized)[0]\n\tgetMappingsComp = parser.getMappings(normalized)[1]\n\tintWarmthMap, intCompMap = parser.extractInformation(getMappingsWarmth, getMappingsComp)\n\n\t#using mean and standard deviation computed from 18aug16 data: \n\tcompAxis.append(intCompMap[g1][0]) #group 1\n\tcompAxis.append(intCompMap[g2][0]) #group 2\n\n\tcompAxis.append(intCompMap[integrated][0]) #combined observed\n\t\n\t#using mean and standard deviation computed from 18aug16 data: \n\tcompPrediction = getCombination(float(intCompMap[g1][0]), float(intCompMap[g2][0]), float(intCompMap[g1][1]), float(intCompMap[g2][1]), float(intCompMap[g1][2]), float(intCompMap[g2][2]))\n\t\n\tcompAxis.append(compPrediction[0]) #combined predicted\n\t\n\t#using mean and standard deviation computed from 18aug16 data: \n\twarmthAxis.append(intWarmthMap[g1][0])\n\twarmthAxis.append(intWarmthMap[g2][0])\n\t\n\twarmthAxis.append(intWarmthMap[integrated][0])\n\t\n\t#using mean and standard deviation computed from 18aug16 data: \n\twarmthPrediction = getCombination(float(intWarmthMap[g1][0]), float(intWarmthMap[g2][0]), float(intWarmthMap[g1][1]), float(intWarmthMap[g2][1]), float(intWarmthMap[g1][2]), float(intWarmthMap[g2][2]))\n\t\n\twarmthAxis.append(warmthPrediction[0])\n\treturn warmthAxis, compAxis","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 plot_sensors_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor info and transform loc to fit with headmodel\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 = []\n bads_epo1 = epo1.info['bads']\n bads_epo2 = []\n bads_epo2 = epo2.info['bads']\n\n # plot sensors\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='x', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='o', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n \n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='x', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='o', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def figure_2_combined_cross_sections(crange=CRANGE, koffrange=KOFFRANGE,\n scale_factor=alpha, label_style=0):\n def combined_error_c(ctilde, z, scale_factor=scale_factor):\n c = ctilde * c0\n koff = z * KP\n x = c * KON / koff\n num = 2 * KP * x + koff * KP * T * (1 + x) ** 3 + koff ** 2 * T * x ** 2 * (1 + x) ** 3\n den = koff ** 2 * KP * T ** 2 * x * (1 + x) ** 2\n val = num / den\n return scale_factor * val\n def combined_error_koff(ctilde, z, scale_factor=scale_factor):\n c = ctilde * c0\n koff = z * KP\n x = c * KON / koff\n num = 2 * KP * x + koff * KP * T * (1 + x) ** 3 + koff**2 * T * (1 + x) ** 3\n den = koff ** 2 * KP * T**2 * x * (1 + x) ** 2\n val = num / den\n return scale_factor * val\n\n def cross_section_combined_error_c():\n arr = [combined_error_c(cval, 1) for cval in crange]\n return dict({'xpts': crange, 'ypts':arr})\n def cross_section_combined_error_koff():\n arr = [combined_error_koff(c, 1) for c in crange]\n return dict({'xpts': koffrange, 'ypts':arr})\n\n figname = 'combined_error_cross_sections'\n curve1 = cross_section_combined_error_c()\n curve2 = cross_section_combined_error_koff()\n # plot\n plt.figure(figsize=(3, 3))\n ax1 = plt.gca()\n ax2 = ax1.twiny()\n\n if label_style == 0:\n ln1 = ax1.plot(curve1['xpts'], curve1['ypts'], color=cs['simple_fisher'], label=r'$c$', zorder=1)\n ln2 = ax2.plot(curve2['xpts'], curve2['ypts'], color=cs['heuristic'], label=r'$k_{\\mathrm{off}}$', zorder=1)\n #plt.title('Mode 2: MLE relative error comparison\\n' + r'($\\tilde{c}_0=10$, $\\alpha=1 \\times 10^4$, $k_{p}=10$)')\n\n elif label_style == 1:\n ln1 = ax1.plot(curve1['xpts'], curve1['ypts'], color=cs['simple_fisher'], label=r'$\\delta c^{2}/c^{2}$', zorder=1)\n ln2 = ax2.plot(curve2['xpts'], curve2['ypts'], color=cs['heuristic'],label=r'$\\delta k_{\\mathrm{off}}^{2}/k_{\\mathrm{off}}^{2}$', zorder=1)\n plt.title('Mode 2: MLE relative error comparison\\n' + r'($k_p=10$, $t=100$, $k_{\\mathrm{off}}=k_{\\mathrm{on}}=1$)')\n plt.ylabel(r'$\\langle\\delta (\\cdot)^{2}\\rangle$/$(\\cdot)^{2}$')\n\n # axis\n ax1.set_xlabel(r'$k_{\\mathrm{on}}c/k_{p}$')\n ax1.set_ylabel(r'$k_{p}t \\langle\\delta (\\cdot)^{2}\\rangle$/$(\\cdot)^{2}$')\n #ax2.set_xlabel(r'$k_{\\mathrm{off}}$')\n\n ax1.set_xscale('log')\n ax2.set_xscale('log')\n ax1.set_xlim([1E-2, 1E2])\n ax2.set_xlim([1E-2, 1E2])\n plt.ylim([0, 0.01*alpha])\n\n lns = ln1 + ln2\n labs = [l.get_label() for l in lns]\n ax1.legend(lns, labs)\n\n plt.tight_layout()\n # save figure\n plt.savefig(DIR_OUTPUT + os.sep + figname + '.pdf', transparent=True)\n plt.savefig(DIR_OUTPUT + os.sep + figname + '.eps')","def axes(*x: Iterable[int]):\n return [_ti_core.Axis(i) for i in x]","def plot_subplots(x_list, y_list, z_list):\n # create a line chart with the average rating of the top movies per year\n # min rating = 0 and max = 10\n plot1 = plt.subplot(211)\n plt.plot(x_list, y_list, color = 'lightseagreen')\n plt.axis([START_YEAR, END_YEAR - 1, 0, 10])\n plt.title('Average IMDB Movie Rating per Year', fontsize=12)\n plt.ylabel('Average Rating')\n plt.grid(True)\n\n # make x ticklabels of plot1 invisible\n plt.setp(plot1.get_xticklabels(), visible=False)\n\n # adjust space between subplots\n plt.subplots_adjust(hspace=0.3)\n\n # create a line chart with the average runtime with shared x-axis\n plot2 = plt.subplot(212, sharex=plot1)\n plt.plot(x_list, z_list, color = 'lightseagreen')\n plt.title('Average IMDB Movie Runtime per Year', fontsize=12)\n plt.ylabel('Average Runtime (min)')\n plt.grid(True)\n\n # define axes, with all years (2008 till 2017) on the x-axis\n # min runtime = 0, max runtime = 180\n plt.axis([START_YEAR, END_YEAR - 1, 0, 180])\n plt.xticks(x_list)\n plt.xlabel('Year')\n\n # plot both the subplots\n plt.show()","def CombinedPlotHelper(self,minc=70,maxc=120,num=25):\n levels = np.linspace(minc,maxc,num+1)\n title = textwrap.dedent(\"\"\"\\\n Orography difference between LGM and Modern ICE-5G data\n using {0} meter contour interval\"\"\").format((maxc-minc)/num)\n plt.figure()\n ax = plt.subplot(111)\n contourset = plt.contourf(self.difference_in_ice_5g_orography,\n levels=levels,hold=True)\n cbar = plt.colorbar()\n cbar.ax.set_ylabel('Orography difference in meters')\n plt.contour(self.difference_in_ice_5g_orography,levels=contourset.levels,\n colors='black',hold=True)\n ufcntr = plt.contourf(self.difference_in_ice_5g_orography,\n levels=[np.min(self.difference_in_ice_5g_orography),minc],\n colors='white',\n hatches=['/'],hold=True)\n ofcntr = plt.contourf(self.difference_in_ice_5g_orography,\n levels=[maxc,np.max(self.difference_in_ice_5g_orography)],\n colors='white',\n hatches=['\\\\'],hold=True)\n ufartists,uflabels = ufcntr.legend_elements() #@UnusedVariable\n ofartists,oflabels = ofcntr.legend_elements() #@UnusedVariable\n uflabels=['Difference $\\\\leq {0}$'.format(minc)]\n oflabels=['${0} <$ Difference'.format(maxc)]\n artists = ufartists + ofartists\n labels = uflabels + oflabels\n plt.title(title)\n pts.set_ticks_to_zero()\n axbounds = ax.get_position()\n #Shrink box by 5%\n ax.set_position([axbounds.x0,axbounds.y0 + axbounds.height*0.05,\n axbounds.width,axbounds.height*0.95])\n ax.legend(artists,labels,loc='upper center',\n bbox_to_anchor=(0.5,-0.025),fancybox=True,ncol=2)\n #if self.save:\n #plt.savefig('something')\n print(\"Combined plot created\")","def problemTwo(self):\n # Initialize plot figure\n plot_2 = plt.figure(figsize=(18, 20 ))\n plot_2.subplots_adjust(left=.08, right=.97, top=.97, bottom=.07)\n mv = plot_2.add_subplot(1, 1, 1)\n plt.tick_params(labelsize=20)\n mv.set_xlabel('$\\\\frac{(y-y_o)}{D}$', fontsize=36)\n mv.set_ylabel('$\\\\frac{u(y)}{U_{\\infty}}$', fontsize=36)\n mv.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 self.y_pos = self.data[file]['y pos'].tolist()\n # Calc the v_inf for the 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 # Plot the mean velocity\n mv.plot(y_pos_nondim_hot, hot_nondim, color=self.plot_color[index], label=f'Hotwire @ {file}mm', linewidth=3)\n mv.plot(y_pos_nondim_pitot, pitot_nondim, color=self.plot_color[index], label=f'Pitot @ {file}mm', linestyle='--', linewidth=2)\n mv.legend(loc='lower right', fontsize=22)\n plot_2.savefig(os.path.join(os.getcwd(), r'plots\\prob2'))\n plt.draw()","def get_y_lims(ax, xlims):\n # Assuming that all objects have the same x coordinates\n x = ax.lines[0].get_data()[0]\n\n indexes = get_interval(x, xlims[0], xlims[1])\n xmax = x[indexes[-1]]\n xmin = x[indexes[0]]\n\n ymax_array = []\n ymin_array = []\n\n for function in ax.lines:\n y = function.get_data()[1]\n\n ymin_array.append(np.min(y[indexes]))\n ymax_array.append(np.max(y[indexes]))\n\n ymax = max(ymax_array)\n ymin = min(ymin_array)\n\n return xmin, xmax, ymin, ymax","def pacf_plots(self):\n fig, axes = plt.subplots(3, 2, figsize=(20, 9), sharex=False)\n #\n axes[0, 0].plot(self.ts_df['y'])\n axes[0, 0].set_title('Original Series')\n plot_pacf(self.ts_df['y'], ax=axes[0, 1])\n\n # 1st Differencing\n axes[1, 0].plot(self.ts_df['y'].diff())\n axes[1, 0].set_title('1st Order Differencing')\n # axes[0].set(ylim=(0, 5))\n plot_pacf(self.ts_df['y'].diff().dropna(), ax=axes[1, 1])\n\n # 2nd Differencing\n axes[2, 0].plot(self.ts_df['y'].diff().diff())\n axes[2, 0].set_title('2nd Order Differencing')\n plot_pacf(self.ts_df['y'].diff().diff().dropna(), ax=axes[2, 1])\n\n plt.gcf().autofmt_xdate()\n plt.grid(True)\n plt.show()","def axhlines(ys, xmin=0, xmax=1, **kwargs):\n if \"transform\" in kwargs:\n raise ValueError(\"'transform' is not allowed as a kwarg;\"\n + \"axhlines generates its own transform.\")\n\n # prepare data\n ys = np.array((ys, ) if np.isscalar(ys) else ys, copy=False)\n xmins = np.array((xmin, ) if np.isscalar(xmin) else xmin, copy=False)\n xmaxs = np.array((xmax, ) if np.isscalar(xmax) else xmax, copy=False)\n\n if len(ys) > 1:\n if len(xmins) == 1:\n xmins = np.repeat(xmins, len(ys))\n if len(xmaxs) == 1:\n xmaxs = np.repeat(xmaxs, len(ys))\n\n if len(xmins) != len(xmaxs) or len(xmins) != len(ys):\n raise ValueError(\"Incompatible data\")\n\n # prepare the ax\n ax = kwargs.pop('ax', None)\n if ax is None:\n ax = plt.gca()\n\n # prepare colors\n colors = kwargs.pop('colors', None)\n if colors is None:\n cycle_props = next(ax._get_lines.prop_cycler)\n colors = cycle_props.pop('color', None)\n\n # prepare trans\n trans = ax.get_yaxis_transform(which='grid')\n # prepare lines\n lines = [\n ([xmin, y], [xmax, y])\n for xmin, xmax, y in zip(xmins, xmaxs, ys)\n ]\n lc = LineCollection(lines, transform=trans, colors=colors, **kwargs)\n ax.add_collection(lc)\n ax.autoscale_view(scalex=False, scaley=True)\n\n return lc","def TwoImmedSpectraPlot(Xax, Ydat1, Ydat2, Label1, Label2, xmin, xmax, ymin, ymax,\n XLab, YLab, SupTitle, Title, FileName, currentDate, currentTime, Software_version):\n plt.figure()\n rc('font', size=8, weight='normal')\n plt.plot(Xax, Ydat1, color='r', linestyle='-', linewidth='1.00', label=Label1)\n plt.plot(Xax, Ydat2, color='b', linestyle='-', linewidth='1.00', label=Label2)\n plt.axis([xmin, xmax, ymin, ymax])\n plt.xlabel(XLab)\n plt.ylabel(YLab)\n plt.suptitle(SupTitle, fontsize=9, fontweight='bold')\n plt.title(Title, fontsize=7, x=0.46, y=1.005)\n plt.grid(visible=True, which='both', color='0.00', linestyle='--')\n plt.legend(loc='upper right', fontsize=8)\n plt.text(0.7, 0.03, 'Processed ' + currentDate + ' at ' + currentTime,\n fontsize=5, transform=plt.gcf().transFigure)\n plt.text(0.03, 0.03, 'Software version: ' + Software_version + ' yerin.serge@gmail.com, IRA NASU',\n fontsize=5, transform=plt.gcf().transFigure)\n pylab.savefig(FileName, bbox_inches='tight', dpi=160)\n plt.close('all')\n return 0","def setX(ax1: Union[object, List], ax2: Union[object, List]):\n if type(ax1) is list:\n print(\"PlotHelpers: cannot use list as source to set Y axis\")\n return\n ax2 = _ax_tolist(ax2)\n # if type(ax2) is not list:\n # ax2 = [ax2]\n refx = ax1.get_xlim()\n for ax in ax2:\n ax.set_xlim(refx)","def plot(self, noTLS, path_plots, interactive):\n fig = plt.figure(figsize=(10,12))\n ax1 = fig.add_subplot(4, 1, 1)\n ax2 = fig.add_subplot(4, 1, 2)\n ax3 = fig.add_subplot(4, 2, 5)\n ax4 = fig.add_subplot(4, 2, 6)\n ax5 = fig.add_subplot(4, 2, 7)\n ax6 = fig.add_subplot(4, 2, 8)\n\n # First panel: data from each sector\n colors = self._get_colors(self.nlc)\n for i, lci in enumerate(self.alllc):\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\n ax1.legend(fontsize='small', ncol=4)\n\n # Second panel: Detrended light curve\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\n color='black',\n label='Detrended')\n\n # Third panel: BLS\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\n mean_SR = np.mean(self.BLS.power)\n std_SR = np.std(self.BLS.power)\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\n SDE = (best_power - mean_SR)/std_SR\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\n for n in range(2, 10):\n if n*self.BLS.period_max <= max(self.BLS.period.value):\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n sx, ex = ax3.get_xlim()\n sy, ey = ax3.get_ylim()\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.2f\\nDepth = %.4f\\nDuration = %.2f d\\nSDE = %.3f' %\n (self.BLS.period_max, self.BLS.t0_max,\n self.BLS.depth_max, self.BLS.duration_max, SDE))\n\n\n # Fourth panel: lightcurve folded to the best period from the BLS\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\n marker='.', alpha=0.5)\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\n\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\n duration=self.BLS.duration_max,\n transit_time=self.BLS.t0_max)\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\n ax4.set_xlim(-l, l)\n h = max(lc_model.flux)\n l = min(lc_model.flux)\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\n del lc_model, lc_model_folded, r1, dt1\n\n\n if not noTLS:\n # Fifth panel: TLS periodogram\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\n for n in range(2, 10):\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.set_ylabel(r'SDE')\n ax5.set_xlabel('Period (days)')\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\n ax5.set_xlim(0, max(self.tls.periods))\n\n period_tls = self.tls.period\n T0_tls = self.tls.T0\n depth_tls = self.tls.depth\n duration_tls = self.tls.duration\n FAP_tls = self.tls.FAP\n\n sx, ex = ax5.get_xlim()\n sy, ey = ax5.get_ylim()\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.1f\\nDepth = %.4f\\nDuration = %.2f d\\nFAP = %.4f' %\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\n\n # Sixth panel: folded light curve to the best period from the TLS\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\n alpha=0.5, ls='None', markersize=0.7)\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\n x0=0.0, nbins=nbins, useBinCenter=True)\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\n ax6.set_xlim(0.5-l, 0.5+l)\n h = max(self.tls.model_folded_model)\n l = min(self.tls.model_folded_model)\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\n ax6.set_xlabel('Phase')\n ax6.set_ylabel('Relative flux')\n del r1, dt1\n\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\n if interactive:\n plt.show()\n plt.close('all')\n del fig","def plot():\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\n\n matplotlib.rcParams.update({'font.size': 18})\n fig, axes = plt.subplots(\n 1, 3,\n figsize=(6.25 * 3, 5),\n gridspec_kw={'wspace': 0.3}\n )\n\n ax = axes[0]\n ax.plot(ts, us[:, lin_model.inputs[1]], 'k')\n ax.plot(ts, us[:, lin_model.inputs[0]], 'k--')\n\n ax.set_title(r'Inputs')\n ax.set_ylabel(r'$\\frac{L}{min}$')\n ax.set_xlabel(r't ($min$)')\n ax.legend([r'$F_{m, in}$', r'$F_{G, in}$'])\n ax.set_xlim([0, ts[-1]])\n\n ax = axes[1]\n ax.plot(ts, ys[:, 2], 'k')\n ax.plot(ts, ys[:, 0], 'grey')\n ax.plot(ts, ys[:, 3], 'k--')\n\n ax.set_title(r'Outputs')\n ax.set_ylabel(r'$\\frac{mg}{L}$')\n ax.set_xlabel(r't ($min$)')\n ax.set_xlim([0, ts[-1]])\n ax.legend([r'$C_{FA}$', r'$C_{G}$', r'$C_{E}$'])\n\n ax.axhline(lin_model.yd2n(K.ysp)[1], color='red')\n ax.axhline(lin_model.yd2n(K.ysp)[0], color='red', linestyle='--')\n\n ax = axes[2]\n ax.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 1],\n 'k'\n )\n ax.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 0],\n 'k--'\n )\n ax.legend([r'$C_{FA}$', r'$C_G$'])\n ax.set_title('bias')\n ax.set_ylabel(r'$\\frac{mg}{L}$')\n ax.set_xlabel(r't ($min$)')\n ax.set_xlim([0, ts[-1]])\n\n # plt.suptitle('Closedloop bioreactor without noise')\n # plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n plt.savefig('no_noise.pdf', bbox_inches='tight')\n plt.show()","def llcm_plot():\n x = np.arange(0, 10, 0.5) # x in [0, 10)\n y_1 = 2**x\n y_2 = x**2\n\n plt.figure()\n # specify color, linestyle, and marker w/ keyword argument\n # plt.plot(x, y_1, label='$2^x$', color='g', linestyle='--', marker='o')\n plt.plot(x, y_1, 'g--o', label='$2^x$')\n # plt.plot(x, y_2, label='$x^2$', color='r', linestyle='-', marker='*')\n plt.plot(x, y_2, 'r-*', label='$x^2$')\n plt.xlabel('$x$')\n plt.ylabel('$y$')\n plt.legend(loc='upper left')\n plt.title('Line plots w/ Legend, linestyle, color, and marker')\n plt.show()\n\n\n return None","def emission_vs_depth(filename,**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(); c = 'r'\n if not p.add:\n fig,ax = plt.subplots(figsize=(8,6)); c = 'b'\n st_cols = ['depth','[CII]158','[OI]63','CO(1-0)','CO(2-1)','CO(3-2)']\n st = pd.read_csv(p.d_cloudy.replace('ext/','') + 'NH/' + filename + '.str',sep='\\t',skiprows=1,names=st_cols)\n dx = np.append(0,np.diff(st.depth))\n pc2cm = u.parsec.to(u.cm)\n # Derive mass-luminosity ratio\n import astropy.constants as c\n M = 1e3 * c.m_p.value * st.depth.values.max() / u.M_sun.to(u.kg) \n cloudy_lin_header = ['#lineslist','C 1 609.590m','C 1 370.269m','C 2 157.636m','O 1 63.1679m','O 1 145.495m','O 3 88.3323m','N 2 205.244m','N 2 121.767m','CO 2600.05m','CO 1300.05m','CO 866.727m','CO 650.074m','CO 325.137m','H2 17.0300m','H2 12.2752m','H2 9.66228m','H2 8.02362m','H2 6.90725m','H2 6.10718m','H2 5.50996m','O 4 25.8832m','NE 2 12.8101m','NE 3 15.5509m','S 3 18.7078m','FE 2 25.9811m']\n cloudy_lin = pd.read_csv(p.d_cloudy.replace('ext/','') + 'NH/' + filename + '.lin',\\\n sep='\\t',names=cloudy_lin_header,comment='#').reset_index(drop=True)\n Cloudy_lines_dict = aux.get_Cloudy_lines_dict()\n cloudy_lin = cloudy_lin.rename(columns=Cloudy_lines_dict)\n L = cloudy_lin['CO(1-0)'][0] * u.erg.to('J') / c.L_sun.value\n print(L,M)\n ax.plot(st.depth/pc2cm,dx*st['CO(1-0)'],'-',color='m',label='CO(1-0): %.2e Lsun/Msun' % (L/M))\n L = cloudy_lin['[OI]63'][0] * u.erg.to('J') / c.L_sun.value\n print(L,M)\n ax.plot(st.depth/pc2cm,dx*st['[OI]63'],'g--',label='[OI]63: %.2e Lsun/Msun' % (L/M))\n ax.set_yscale(\"log\")\n ax.set_xscale(\"log\")\n ax.set_xlabel('Depth [pc]')\n ax.set_ylabel('Intensity [ergs/s/cm^2]')\n ax.legend()\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'look-up/'): os.mkdir(p.d_plot + 'look-up/') \n plt.savefig('plots/look-up/emission_%s' % filename,dpi=200)","def drawLine2P(x,y,xlims):\n \n xrange = np.arange(xlims[0],xlims[1],1)\n A = np.vstack([x, np.ones(len(x))]).T\n k, b = np.linalg.lstsq(A, y, rcond=None)[0]\n return [xrange, k*xrange + b]","def scatter_and_line():\n\n # Make random data points around straight line\n random_linear = np.zeros((1000,2))\n random_linear[:,0] = np.random.uniform(0,10,1000)\n random_error = np.random.normal(0.0,2.0,1000)\n random_linear[:,1] = random_linear[:,0]*2.0+1.0+random_error\n\n # Make datasets, order determining line graph on top\n dataset_a = DataSet(random_linear,plot='scatter',order=0,label='Random')\n dataset_b = DataSet(linear,plot='line',colour='black',order=1,label='Linear')\n\n # Colour scatter graph by error\n dataset_a.set_colour(map='coolwarm',colour=random_error)\n\n # Make plot object and add datasets\n plot = Plot()\n plot.set_text(latex=True)\n plot.add_dataset(dataset_a)\n plot.add_dataset(dataset_b)\n plot.set_legend(legend=True)\n\n # Plot graph and display\n plot.plot()\n plot.save(name='./figures/2d_scatter_and_line',fmt='png')\n plot.display()","def plotDataForIndices(monthlyData, indices, usedEfficiencies, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices[energyType])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange], label = 'optimized for H', color='r')\n plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange], label = 'optimized for C', color='b')\n plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange], label = 'optimized for L', color='g')\n plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange], label = 'optimized for PV', color='c')\n plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange], label = 'optimized for HCL', color='m')\n plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange], label = 'optimized for E_tot', color='k')\n plt.plot(multiplier*monthlyData[energyType][indices['PVC'], dummyRange], label = 'optimized for PV and C', color='b', alpha = 0.5)\n if not indices['45']==None:\n plt.plot(multiplier*monthlyData[energyType][indices['45'], :], label = 'fixed at 45 deg', color='y')\n plt.ylabel('Energy [kWh]')\n plt.xlim(0,288)\n\n# plt.legend()\n \n # Shrink current axis by 20%\n box = ax1.get_position()\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n \n # Put a legend to the right of the current axis\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(4)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which=u'major')\n \n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\n\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\n plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\n plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\n plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\n plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\n plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\n plt.plot(multiplier*monthlyData[energyType][indices['PVC'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV and C', color='b', alpha = 0.5)\n if not indices['45']==None:\n plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\n plt.ylabel('Energy Difference [kWh]')\n# plt.legend()\n plt.xlim(0,288)\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which=u'major')\n \n box = ax2.get_position()\n ax2.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n \n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\n\n \n return fig","def plot_failure_function_2D(self, index_x, index_y, range_x, offset_scale=1):\n\n smbl_x = self.symbols[index_x]\n smbl_y = self.symbols[index_y]\n print(\"x = \", smbl_x, \"\\ny = \", smbl_y)\n\n # Determine the y value that belongs to z = 0 and x = variable.\n # substitute the mean values and create a substitution dict.\n mean = list(self.mean)\n symbols = list(self.symbols)\n # The value of y should not be included as it needs te be solved.\n del mean[index_y]\n del symbols[index_y]\n sub = dict(zip(symbols, mean))\n\n # Determine the y values\n y = []\n y_fail = []\n y_no_fail = []\n for x in range_x:\n if x == 0:\n x += 0.01\n # Update x\n sub[smbl_x] = x\n y.append(solve(self.z.subs(sub), smbl_y)[0])\n\n offset = max(y) * offset_scale\n z_fail = self.z + offset\n z_no_fail = self.z - offset\n\n for x in range_x:\n if x == 0:\n x += 0.01\n # Update x\n sub[smbl_x] = x\n y_fail.append(solve(z_fail.subs(sub), smbl_y)[0])\n y_no_fail.append(solve(z_no_fail.subs(sub), smbl_y)[0])\n\n plt.xlabel(\"variable: \" + smbl_x)\n plt.ylabel(\"variable: \" + smbl_y)\n plt.plot(range_x, y, label=\"z = 0\", color=\"blue\")\n plt.plot(range_x, y_fail, label=\"fail_side\", color=\"red\")\n plt.plot(range_x, y_no_fail, label=\"no_fail_side\", color=\"green\")\n plt.legend()\n plt.show()","def viz_2D_topomap_intra (epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray,\n threshold: float=0.95, steps: int=2,\n lab: bool = False):\n\n # defining head model and adding sensors\n fig = plt.figure()\n ax = fig.add_subplot(111, aspect = 1)\n ax.axis(\"off\")\n plot_2d_topomap_intra(ax)\n # bads are represented as squares\n plot_sensors_2d_intra(epo1, epo2, lab = lab)\n # plotting links according to sign (red for positive values,\n # blue for negative) and value (line thickness increases\n # with the strength of connectivity)\n plot_links_2d_intra(epo1, epo2, C1=C1, C2=C2, threshold=threshold, steps=steps)\n plt.tight_layout()\n plt.show()\n\n return (ax)"],"string":"[\n \"def setup_axes(self):\\n fig = plt.figure(1)\\n axs = fig.add_subplot(1, 1, 1)\\n fig.clf()\\n axs = plt.subplots(1, 2)\\n ax1 : plt.axis = axs[0]\\n ax2 : plt.axis = axs[1]\\n fig.canvas.draw()\\n \\n line1_t, = ax1.plot([], label='train')\\n line1_v, = ax1.plot([], label='val')\\n\\n ax1.set_title('Loss vs Iterations')\\n ax1.set_xlabel('Iterations')\\n ax1.set_ylabel('Loss')\\n ax1.grid(True)\\n ax1.autoscale()\\n # ax1.legend()\\n\\n line2_t, = ax2.plot([], label='train')\\n line2_v, = ax2.plot([], label='val')\\n\\n ax2.set_title('Accuracy vs Iterations')\\n ax2.set_xlabel('Time')\\n ax2.set_ylabel('Percent Accuracy')\\n ax2.grid(True)\\n ax2.autoscale()\\n # ax2.legend()\\n\\n lines = [line1_t, line1_v, line2_t, line2_v]\\n\\n return fig, ax1, ax2, lines\",\n \"def plot_results_2d(p_1, p_2, d_1 = 'X', d_2 = 'Y'):\\n plt.figure(figsize = (10, 10))\\n ax = plt.axes() \\n\\n color=iter(cm.rainbow(np.linspace(0,1,p_1.shape[0]))) # (1)\\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_1.shape[0], step = 1)]\\n\\n for p in np.arange(0, p_1.shape[0], step = 1): \\n c = next(color) # (c)\\n for t in np.arange(0, p_1.shape[1], step = 1): \\n plt.plot(p_1[p, t], p_2[p, t], 'x', c = c, label = labels[p])\\n legend_without_duplicate_labels(ax)\\n ax.grid(b = 'True', which = 'major')\\n ax.set_xlabel(d_1) \\n ax.set_ylabel(d_2)\\n ax.set_title('2D particle trajectories')\",\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 plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices['E_tot1'])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\\n \\n plt.ylabel('Energy [kWh]')\\n plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(24)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\\n\\n plt.ylabel('Energy Difference [kWh]')\\n plt.legend()\\n\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n return fig\",\n \"def _get_lines(self) -> tuple[VGroup, VGroup]:\\n x_axis = self.get_x_axis()\\n y_axis = self.get_y_axis()\\n\\n x_lines1, x_lines2 = self._get_lines_parallel_to_axis(\\n x_axis,\\n y_axis,\\n self.y_axis.x_range[2],\\n self.faded_line_ratio,\\n )\\n\\n y_lines1, y_lines2 = self._get_lines_parallel_to_axis(\\n y_axis,\\n x_axis,\\n self.x_axis.x_range[2],\\n self.faded_line_ratio,\\n )\\n\\n # TODO this was added so that we can run tests on NumberPlane\\n # In the future these attributes will be tacked onto self.background_lines\\n self.x_lines = x_lines1\\n self.y_lines = y_lines1\\n lines1 = VGroup(*x_lines1, *y_lines1)\\n lines2 = VGroup(*x_lines2, *y_lines2)\\n\\n return lines1, lines2\",\n \"def _make_twin_axes(self, *args, **kwargs):\\n # Typically, SubplotBase._make_twin_axes is called instead of this.\\n # There is also an override in axes_grid1/axes_divider.py.\\n if 'sharex' in kwargs and 'sharey' in kwargs:\\n raise ValueError('Twinned Axes may share only one axis.')\\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\\n self.set_adjustable('datalim')\\n ax2.set_adjustable('datalim')\\n self._twinned_axes.join(self, ax2)\\n return ax2\",\n \"def aminusb_2ax( mv1, mv2 ):\\n return mv2\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n missing = mv1.get_fill_value()\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n if axes1 is None or axes2 is None: return None\\n if len(axes1)!=2: print \\\"ERROR @1, wrong number of axes for aminusb_2ax\\\",axes1\\n if len(axes2)!=2: print \\\"ERROR @2, wrong number of axes for aminusb_2ax\\\",axes2\\n if len(axes1[0])==len(axes2[0]):\\n # Only axis2 differs, there's a better way...\\n return aminusb_ax2( mv1, mv2 )\\n if len(axes1[0])<=len(axes2[0]):\\n if len(axes1[1])<=len(axes2[1]):\\n mv1new = mv1\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid1 = mv1.getGrid()\\n mv2new = mv2.regrid(grid1)\\n else:\\n # Interpolate mv1 from axis1[1] to axis2[1]\\n # Interpolate mv2 from axis2[0] to axis1[0]\\n print \\\"ERROR @3, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n if len(axes1[1])<=len(axes2[1]):\\n # Interpolate mv1 from axis1[0] to axis2[0]\\n # Interpolate mv2 from axis2[1] to axis1[1]\\n print \\\"ERROR @4, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n mv2new = mv2\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid2 = mv2.getGrid()\\n mv1new = mv1.regrid(grid2)\\n aminusb = mv1new - mv2new\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\\n\\n ps = phase_space[:, (id_begin-1):id_end, :]\\n # print(np.shape(ps))\\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\\n\\n x = ps[0, :, :]\\n px = ps[1, :, :]\\n y = ps[2, :, :]\\n py = ps[3, :, :]\\n\\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\\n\\n for n in range(int(id_end-id_begin+1)):\\n x_this = x[n, :]\\n px_this = px[n, :]\\n y_this = y[n, :]\\n py_this = py[n, :]\\n\\n # Remove all NAN elements in the phase space array\\n x_this = x_this[np.logical_not(np.isnan(x_this))]\\n px_this = px_this[np.logical_not(np.isnan(px_this))]\\n y_this = y_this[np.logical_not(np.isnan(y_this))]\\n py_this = py_this[np.logical_not(np.isnan(py_this))]\\n\\n ## Plot X\\n plt.subplot(2, 2, 1)\\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\\n plt.ylabel('Position in X/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot Y\\n plt.subplot(2, 2, 2)\\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\\n plt.ylabel('Position in Y/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot px\\n plt.subplot(2, 2, 3)\\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\\n plt.ylabel('Angle in X', fontsize=10)\\n\\n ## Plot py\\n plt.subplot(2, 2, 4)\\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\\n plt.ylabel('Angle in Y', fontsize=10)\\n\\n\\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\\\mu$m')\\n # plt.title('First Undulator Section')\\n # plt.title('Second Undulator Section')\\n # plt.title('Third Undulator Section')\\n\\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\\n\\n fig = plt.gcf()\\n fig.set_size_inches(13.5, 9)\\n ax = plt.gca()\\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\\n fig.savefig('phase_space_U3_new.png', dpi=100)\\n plt.show()\\n\\n\\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\\n\\n return id_on_axis, s_on_axis\",\n \"def axes_subplots():\\n # gerenate data\\n x = np.arange(0, 6 * np.pi+0.2, 0.2)\\n y_1 = np.cos(x)\\n y_2 = np.sin(2*x)\\n y_3 = y_1 + y_2\\n\\n # display multiple\\n fig, axs = plt.subplots(3, 1, sharex=True)\\n fig.suptitle('Subplots w/ shared axes')\\n axs[0].plot(x, y_1)\\n axs[1].plot(x, y_2)\\n axs[2].plot(x, y_3)\\n axs[0].set_ylabel('$y$')\\n axs[1].set_ylabel('$y$')\\n axs[2].set_ylabel('$y$')\\n\\n plt.show()\\n\\n return None\",\n \"def TwoOrOneValuePlot(no_of_sets, Xax, Ydat1, Ydat2, Label1, Label2,\\n xmin, xmax, ymin_1, ymax_1, ymin_2, ymax_2,\\n XLab, YLab_1, YLab_2, SupTitle, Title, FileName,\\n currentDate, currentTime, Software_version):\\n\\n rc('font', size=6, weight='bold')\\n if no_of_sets == 1:\\n fig = plt.figure(figsize=(9, 5))\\n ax1 = fig.add_subplot(111)\\n elif no_of_sets == 2:\\n fig = plt.figure(figsize=(9, 9))\\n ax1 = fig.add_subplot(211)\\n else:\\n print(' ERROR !!!')\\n if no_of_sets == 2:\\n ax1.plot(Xax, Ydat2, color=u'#ff7f0e', linestyle='-', alpha=0.4, linewidth='1.00')\\n ax1.plot(Xax, Ydat1, color=u'#1f77b4', linestyle='-', alpha=1.0, linewidth='1.00', label=Label1)\\n ax1.legend(loc='upper right', fontsize=6)\\n ax1.grid(visible=True, which='both', color='silver', linestyle='-')\\n ax1.axis([xmin, xmax, ymin_1, ymax_1])\\n ax1.set_ylabel(YLab_1, fontsize=6, fontweight='bold')\\n ax1.set_title(Title, fontsize=6)\\n if no_of_sets == 2:\\n ax1.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False)\\n ax2 = fig.add_subplot(212)\\n if no_of_sets == 2:\\n ax2.plot(Xax, Ydat1, color=u'#1f77b4', linestyle='-', alpha=0.4, linewidth='1.00')\\n ax2.plot(Xax, Ydat2, color=u'#ff7f0e', linestyle='-', alpha=1.0, linewidth='1.00', label=Label2)\\n ax2.legend(loc='upper right', fontsize=6)\\n ax2.grid(visible=True, which='both', color='silver', linestyle='-')\\n ax2.axis([xmin, xmax, ymin_2, ymax_2])\\n ax2.set_xlabel(XLab, fontsize=6, fontweight='bold')\\n ax2.set_ylabel(YLab_2, fontsize=6, fontweight='bold')\\n fig.subplots_adjust(hspace=0.05, top=0.94)\\n elif no_of_sets == 1:\\n ax1.set_xlabel(XLab, fontsize=6, fontweight='bold')\\n fig.subplots_adjust(top=0.92)\\n else:\\n print(' ERROR !!!')\\n fig.suptitle(SupTitle, fontsize = 8, fontweight='bold')\\n if no_of_sets == 2:\\n fig.text(0.73, 0.06, 'Processed ' + currentDate + ' at ' + currentTime,\\n fontsize=4, transform=plt.gcf().transFigure)\\n fig.text(0.09, 0.06, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\\n fontsize=4, transform=plt.gcf().transFigure)\\n elif no_of_sets == 1:\\n fig.text(0.73, 0.03, 'Processed ' + currentDate + ' at '+currentTime,\\n fontsize=4, transform=plt.gcf().transFigure)\\n fig.text(0.09, 0.03, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\\n fontsize=4, transform=plt.gcf().transFigure)\\n else:\\n print(' ERROR !!!')\\n pylab.savefig(FileName, bbox_inches='tight', dpi=160)\\n plt.close('all')\\n return\",\n \"def plot_2d_topomap_intra(ax):\\n\\n # plot first Head \\n N = 300 # number of points for interpolation\\n xy_center = [-0.178,0] # center of the plot\\n radius = 0.1 # radius\\n\\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n # add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon) \\n \\n\\n # Plot second Head \\n x2y2_center = [0.178,0] # center of the plot\\n radius2 = 0.1 # radius\\n \\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n ## add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon)\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def multiPlot(self,indexSelect=None,varSelect=None,wrapNumber=5,\\n compLines=None, save = None, xlim = None,\\n forceYAxisZero = True, colourOverride = None,\\n style = None, legend = None, varAsAxis = False,\\n xAxisLabel = None, yAxisLabel = None, figsize = (12,10),\\n legendLoc = 'lower right'):\\n if isinstance(compLines,list):\\n compVars = [list(i.columns) for i in compLines]\\n dfB = [i.copy() for i in compLines]\\n for i in range(len(compLines)):\\n if \\\"Time\\\" not in compVars[i]:\\n dfB[i][\\\"Time\\\"]=dfB[i].index\\n else:\\n compVars[i].remove(\\\"Time\\\")\\n dfB[i] = pd.melt(dfB[i], id_vars=[\\\"Time\\\"],\\n value_vars=compVars[i])\\n elif compLines is not None:\\n compVars=list(compLines.columns)\\n dfB = compLines.copy()\\n if \\\"Time\\\" not in compVars:\\n dfB[\\\"Time\\\"]=dfB.index\\n else:\\n compVars.remove(\\\"Time\\\")\\n dfB = pd.melt(dfB,id_vars=[\\\"Time\\\"],\\n value_vars=compVars)\\n if varSelect is None:\\n varSelect=list(self.longData['variable'].unique())\\n if indexSelect is None:\\n indexSelect=list(self.longData['index'].unique())\\n if not isinstance(indexSelect,list):\\n indexSelect = [indexSelect]\\n if len(varSelect)<wrapNumber:\\n #cols = math.floor(math.sqrt(len(varSelect)))\\n cols = math.ceil(math.sqrt(len(varSelect)))\\n else:\\n cols = wrapNumber\\n rows = math.ceil(len(varSelect)/cols)\\n if style is None:\\n myStyle = \\\"darkgrid\\\"\\n else:\\n myStyle = style\\n with sns.axes_style(style):\\n fig, axs = plt.subplots(rows, cols, sharex=True,\\n figsize=figsize)\\n if (rows>1):\\n axs = trim_axs(axs, len(varSelect))\\n elif (cols==1):\\n axs = [axs]\\n if colourOverride is not None:\\n myColorMap = plt.get_cmap(name=\\\"cool\\\")\\n else:\\n myColorMap = plt.get_cmap(name=\\\"hsv\\\",\\n lut=len(indexSelect)+1)\\n for ax, theVar, j in zip(axs, varSelect, range(len(varSelect))):\\n if varAsAxis:\\n if isinstance(yAxisLabel,list):\\n ax.set_ylabel(theVar+\\\" \\\"+yAxisLabel[j])\\n elif yAxisLabel is not None:\\n ax.set_ylabel(theVar+\\\" \\\"+yAxisLabel)\\n else:\\n ax.set_ylabel(theVar)\\n else:\\n ax.set_title(theVar)\\n if isinstance(yAxisLabel,list):\\n ax.set_ylabel(yAxisLabel[j])\\n elif yAxisLabel is not None:\\n ax.set_ylabel(yAxisLabel)\\n if xAxisLabel is not None:\\n ax.set_xlabel(xAxisLabel)\\n df = self.longData\\n df = df[df['variable']==theVar]\\n if indexSelect is not None:\\n for theIndex, i in zip(indexSelect,\\n range(len(indexSelect))):\\n df2 = df[df['index']==theIndex]\\n if colourOverride is not None:\\n ax.plot(df2[\\\"Time\\\"], df2[\\\"value\\\"],\\n linestyle='solid',\\n color=myColorMap(colourOverride[i]))\\n else:\\n ax.plot(df2[\\\"Time\\\"], df2[\\\"value\\\"],\\n linestyle='solid',\\n color=myColorMap(i))\\n if isinstance(compLines,list):\\n for i, theIndex in enumerate(indexSelect):\\n dfB2 = dfB[theIndex][\\n dfB[theIndex]['variable']==theVar]\\n if colourOverride is not None:\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"o\\\",\\n color=myColorMap(colourOverride[i]))\\n else:\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"o\\\",\\n color=myColorMap(i))\\n elif compLines is not None:\\n dfB2 = dfB[dfB['variable']==theVar]\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"ko\\\")\\n if xlim is not None:\\n ax.set_xlim(xlim)\\n if forceYAxisZero:\\n ax.set_ylim([0, None])\\n if legend is not None:\\n if colourOverride is not None:\\n custom_lines = [Line2D([0], [0], color=myColorMap(\\n colourOverride[i]), lw=4)\\n for i in range(len(indexSelect))]\\n else:\\n custom_lines = [Line2D([0], [0], color=myColorMap(i),\\n lw=4)\\n for i in range(len(indexSelect))]\\n if ((not isinstance(compLines,list)) and\\n (compLines is not None)):\\n custom_lines.append(Line2D([0], [0], \\n color=\\\"k\\\", lw=4))\\n fig.legend(custom_lines, legend,\\n loc = legendLoc)\\n fig.tight_layout()\\n if save is not None:\\n fig.savefig(save)\",\n \"def make_plots(title, \\n chrg_x, csd, \\n ele_x, pots, \\n csd_x, est_csd, est_pot, \\n true_pot=None):\\n fig = plt.figure(figsize=(7,10))\\n #CSDs\\n ax1 = plt.subplot(211)\\n if np.array(csd_x).any() != False:\\n im1b = ax1.plot(csd_x, est_csd[:,0], 'r', label='kCSD', linewidth=3)\\n im1a = ax1.plot(chrg_x, csd, 'g', label = 'CSD', linestyle='--', linewidth=3)\\n ax1.plot(ele_x, np.zeros_like(ele_x), 'ko',markersize=2.)\\n plt.legend() \\n ax1.set_xlim([0.,1.])\\n #ax1.set_ylim(ax1.get_ylim()[::-1]) #Zero on the top --ASK?!\\n max_csd = np.maximum(max(np.abs(csd)), max(np.abs(est_csd[:,0])))\\n max_csd += max_csd*0.2\\n ax1.set_ylim([-max_csd, max_csd])\\n ax1.set_xlabel('Depth mm')\\n ax1.set_ylabel('CSD mA/mm')\\n #Potentails\\n ax2 = plt.subplot(212)\\n ax2.plot( ele_x, np.zeros_like(ele_x),'ko',markersize=2.)\\n im2b = ax2.plot(csd_x, est_pot, 'b', label = 'kPOT', linewidth=3)\\n im2a = ax2.plot(chrg_x,true_pot, color = 'orange', \\n linestyle='--', label='TruePOT', linewidth=3)\\n ax2.set_xlim([0.,1.])\\n #ax2.set_ylim(ax2.get_ylim()[::-1]) #Zero on the top --ASK?!\\n ax2.plot(ele_x, pots, 'kx', markersize=8.)\\n max_pots = np.maximum(max(np.abs(true_pot)), max(np.abs(est_pot)))\\n max_pots += max_pots*0.2\\n ax2.set_xlabel('Depth mm')\\n ax2.set_ylabel('Potential mV')\\n ax2.set_ylim([-max_pots, max_pots])\\n fig.suptitle(title)\\n plt.legend()\\n plt.show()\\n return\",\n \"def _get_lines(self) -> tuple[VGroup, VGroup]:\\n center = self.get_origin()\\n ratio_faded_lines = self.faded_line_ratio\\n offset = self.azimuth_offset\\n\\n if ratio_faded_lines == 0: # don't show faded lines\\n ratio_faded_lines = 1 # i.e. set ratio to 1\\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\\n rlines1 = VGroup()\\n rlines2 = VGroup()\\n alines1 = VGroup()\\n alines2 = VGroup()\\n\\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\\n ainput = np.arange(0, TAU, astep)\\n\\n unit_vector = self.x_axis.get_unit_vector()[0]\\n\\n for k, x in enumerate(rinput):\\n new_line = Circle(radius=x * unit_vector)\\n if k % ratio_faded_lines == 0:\\n alines1.add(new_line)\\n else:\\n alines2.add(new_line)\\n\\n line = Line(center, self.get_x_axis().get_end())\\n\\n for k, x in enumerate(ainput):\\n new_line = line.copy()\\n new_line.rotate(x + offset, about_point=center)\\n if k % ratio_faded_lines == 0:\\n rlines1.add(new_line)\\n else:\\n rlines2.add(new_line)\\n\\n lines1 = VGroup(*rlines1, *alines1)\\n lines2 = VGroup(*rlines2, *alines2)\\n return lines1, lines2\",\n \"def line_axes (self):\\n return self._line_axes\",\n \"def _timeseries_scatter_plot_lines(axes):\\n axes.axvline(\\n x=0,\\n ymin=-1000,\\n ymax=1000,\\n color=\\\"grey\\\",\\n linestyle=\\\"dotted\\\",\\n alpha=0.6,\\n )\\n axes.axhline(\\n y=0,\\n xmin=-1000,\\n xmax=1000,\\n color=\\\"grey\\\",\\n linestyle=\\\"dotted\\\",\\n alpha=0.6,\\n )\",\n \"def plot_2d_topomap_inter(ax):\\n\\n # plot first Head \\n N = 300 # number of points for interpolation\\n xy_center = [-0.178,0] # center of the plot\\n radius = 0.1 # radius\\n\\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n # add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [-0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [-0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n xy = [[-0.087,-0.027],[-0.087,0.027], [-0.068,0]]\\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon) \\n \\n\\n # Plot second Head \\n x2y2_center = [0.178,0] # center of the plot\\n radius2 = 0.1 # radius\\n \\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n ## add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n x2y2 = [[0.087,-0.027],[0.087,0.027], [0.068,0]]\\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon)\",\n \"def princ_axes(self):\\r\\n # get coordinates of mesh\\r\\n coords = BoundaryMesh(self.mesh,\\\"exterior\\\",True).coordinates()\\r\\n\\r\\n # get distances\\r\\n dist = np.sqrt(np.einsum('ij->i', np.square(coords)))\\r\\n\\r\\n # get maximal value\\r\\n maxind = np.argmax(dist)\\r\\n maxdist = dist[maxind]\\r\\n\\r\\n # get minimal value\\r\\n minind = np.argmin(dist)\\r\\n mindist = dist[minind]\\r\\n\\r\\n # find coordinates of maximal and minimal points\\r\\n maxax = coords[maxind, :]\\r\\n minax = coords[minind, :]\\r\\n\\r\\n # get the cross product of these vectors,\\r\\n # which is the ideal mid-size axis\\r\\n idealax = np.cross(maxax,minax)\\r\\n\\r\\n # get the dot product of this ideal axis with the coordinates,\\r\\n # take the absolute value, and find the index of the maximum\\r\\n secind = np.argmax(np.abs(np.einsum('j,ij->i',idealax,coords)))\\r\\n\\r\\n # get the second-axis distance\\r\\n secdist = dist[secind]\\r\\n\\r\\n return([maxdist, secdist, mindist], [\\\"a\\\", \\\"b\\\", \\\"c\\\"])\",\n \"def _color_twin_axes(ax1, color1, ax2, color2):\\n #spines\\n ax1.spines['left'].set_color(color1)\\n ax1.spines['right'].set_color(color2)\\n ax2.spines['left'].set_color(color1)\\n ax2.spines['right'].set_color(color2)\\n #text\\n ax1.yaxis.label.set_color(color1)\\n ax2.yaxis.label.set_color(color2)\\n #ticks\\n ax1.tick_params(axis = 'y', colors = color1)\\n ax2.tick_params(axis = 'y', colors = color2)\",\n \"def make_six_plots(mc, moc1, moc2, moc1name, moc2name, rxn,\\n cmin=None, cmax=None, emin=None, emax=None, **kwargs):\\n\\t# Get reaction rate colorbars\\n\\t_cmin, _cmax = get_min_and_max((mc, moc1, moc2), positive=True)\\n\\tif cmin is None:\\n\\t\\tcmin = max(1 - max(1 - _cmin, _cmax - 1), 0)\\n\\tif cmax is None:\\n\\t\\tcmax = 1 + max(_cmax - 1, 1 - _cmin)\\n\\t\\n\\tfig = plt.figure()\\n\\t# Plot the OpenMC reference solution in the upper left subplot\\n\\taxa = fig.add_subplot(231)\\n\\ta = plt.imshow(mc.squeeze(), interpolation=\\\"none\\\", cmap=\\\"jet\\\")\\n\\tplt.title(\\\"OpenMC {} Distribution\\\".format(rxn))\\n\\tplt.clim(cmin, cmax)\\n\\tplt.colorbar(a)\\n\\t# Plot OpenMOC\\\"s fission rates in the upper center subplot\\n\\taxb = fig.add_subplot(232)\\n\\tb = plt.imshow(moc1.squeeze(), interpolation=\\\"none\\\", cmap=\\\"jet\\\")\\n\\tplt.title(\\\"OpenMOC {} Distribution\\\\n{}\\\".format(rxn, moc1name))\\n\\tplt.clim(cmin, cmax)\\n\\tplt.colorbar(b)\\n\\t# Plot different OpenMOC fission rates in the upper right subplot\\n\\taxc = fig.add_subplot(233)\\n\\tc = plt.imshow(moc2.squeeze(), interpolation=\\\"none\\\", cmap=\\\"jet\\\")\\n\\tplt.title(\\\"OpenMOC {} Distribution\\\\n{}\\\".format(rxn, moc2name))\\n\\tplt.clim(cmin, cmax)\\n\\tplt.colorbar(c)\\n\\t\\n\\t# Get errors and their colorbars\\n\\terror11 = np.divide(moc1 - mc, mc / 100)\\n\\terror25 = np.divide(moc2 - mc, mc / 100)\\n\\terrorvs = np.divide(moc1 - moc2, moc2 / 100)\\n\\t\\n\\t_emin, _emax = get_min_and_max((error11, error25, errorvs))\\n\\tif emin is None:\\n\\t\\temin = min(_emin, -_emax)\\n\\tif emax is None:\\n\\t\\temax = max(_emax, -_emin)\\n\\t\\t\\n\\t# Plot (MOC #1 vs. MOC #2) error in the lower left\\n\\taxd = fig.add_subplot(234)\\n\\td = plt.imshow(errorvs.squeeze(), interpolation=\\\"none\\\", cmap=\\\"rainbow\\\")\\n\\tplt.title(\\\"% Relative error of {}\\\\nvs {}\\\".format(moc1name, moc2name))\\n\\tplt.clim(emin, emax)\\n\\tplt.colorbar(d)\\n\\t# Plot (MOC #1 vs. Monte Carlo) error in the lower center\\n\\taxe = fig.add_subplot(235)\\n\\te = plt.imshow(error11.squeeze(), interpolation=\\\"none\\\", cmap=\\\"rainbow\\\")\\n\\tplt.title(\\\"% Relative error of {}\\\\nvs openmc\\\".format(moc1name))\\n\\tplt.clim(emin, emax)\\n\\tplt.colorbar(e)\\n\\t# Plot (MOC #2 vs. Monte Carlo) error in the lower right\\n\\taxf = fig.add_subplot(236)\\n\\tf = plt.imshow(error25.squeeze(), interpolation=\\\"none\\\", cmap=\\\"rainbow\\\")\\n\\tplt.title(\\\"% Relative error of {}\\\\nvs openmc\\\".format(moc2name))\\n\\tplt.clim(emin, emax)\\n\\tplt.colorbar(f)\\n\\t\\n\\t# implement mode and the rest later\\n\\tsix_axes = (axa, axb, axc, axd, axe, axf)\\n\\treturn fig, six_axes\",\n \"def cartesian_coordinates(self, *axes):\",\n \"def ft_ax(ax=None,\\n y=1.03,\\n yy=1.1,\\n title=None,\\n subtitle=None,\\n source=None,\\n add_box=False,\\n left_axis=False):\\n\\n if ax is None:\\n ax = plt.gca()\\n\\n ax.set_axisbelow(True)\\n \\n if title is not None:\\n title = plt.title(title, y=y, loc='left')\\n if subtitle is not None:\\n plt.annotate(subtitle, xy=title.get_position(),\\n xycoords='axes fraction', xytext=(0,-11), \\n textcoords='offset points', size='large') \\n \\n if source is not None:\\n src = plt.annotate(source, xy=(0,0), \\n xycoords='axes fraction', xytext=(0,-35), \\n textcoords='offset points', ha='left', va='top', size='small')\\n \\n # axes and grid-lines\\n plt.grid(axis='y', linewidth=.5)\\n sns.despine(left=True)\\n if not left_axis:\\n ax.yaxis.tick_right()\\n ax.yaxis.set_label_position('right')\\n ax.yaxis.set_label_coords(1,yy)\\n ax.yaxis.get_label().set_rotation(0)\\n ax.tick_params('y', length=0)\\n \\n plt.tight_layout()\\n \\n if add_box:\\n ax2 = plt.axes(ax.get_position().bounds, facecolor=(1,1,1,0))\\n ax2.xaxis.set_visible(False)\\n ax2.yaxis.set_visible(False)\\n x,y = np.array([[.01, 0.15], [y+.12, y+.12]])\\n line = matplotlib.lines.Line2D(x, y, lw=6., color='k')\\n ax2.add_line(line)\\n line.set_clip_on(False)\\n \\n if add_box and source is not None:\\n return (line, src)\\n elif not add_box and source is not None:\\n return (src,)\\n elif add_box and source is None:\\n return (line,)\\n else:\\n return []\",\n \"def _timeseries_scatter_plot_axlim(axes, var_combination, slope,\\n mins_maxs):\\n min_lim, max_lim, min_glob, max_glob = mins_maxs\\n for box in range(3):\\n axes[box].set_ylim(min_lim, max_lim)\\n if var_combination == \\\"pr:tas\\\":\\n min_l = min(min_glob) - (max(max_glob) - min(min_glob)) * 0.1\\n max_l = max(max_glob) + (max(max_glob) - min(min_glob)) * 0.1\\n axes[box].set_xlim(min_l, max_l)\\n else:\\n axes[box].set_xlim(min_lim, max_lim)\\n\\n if (slope[\\\"cmip5\\\"] + slope[\\\"cmip6\\\"]) >= 0:\\n axes[box].plot(\\n [-1000, 1000],\\n [-1000, 1000],\\n color=\\\"gray\\\",\\n alpha=0.6,\\n )\\n else:\\n axes[box].plot(\\n [-1000, 1000],\\n [1000, -1000],\\n color=\\\"gray\\\",\\n alpha=0.6,\\n )\",\n \"def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\\n\\n tr =PolarAxes.PolarTransform()\\n pi = np.pi\\n\\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\\n\\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\\n tick_formatter1 = DictFormatter(dict(angle_ticks))\\n\\n grid_locator2 = MaxNLocator(4)\\n\\n grid_helper = floating_axes.GridHelperCurveLinear(\\n tr, extremes=(tmax, tmin, zmax, zmin),\\n grid_locator1=grid_locator1,\\n grid_locator2=grid_locator2,\\n tick_formatter1=tick_formatter1,\\n tick_formatter2=None)\\n\\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\\n fig.add_subplot(ax1)\\n\\n # create a parasite axes whose transData in RA, cz\\n aux_ax = ax1.get_aux_axes(tr)\\n\\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\\n # drawn twice, and possibly over some other\\n # artists. So, we decrease the zorder a bit to\\n # prevent this.\\n\\n return ax1, aux_ax\",\n \"def common_axis( axis1, axis2 ):\\n if hasattr( axis1, 'units' ):\\n units1 = axis1.units.lower().replace(' ','_')\\n if axis1.isTime():\\n axis1.toRelativeTime( units1 ) #probably will change input argument\\n else:\\n units1 = None\\n if hasattr( axis2, 'units' ):\\n units2 = axis2.units.lower().replace(' ','_')\\n else:\\n units2 = None\\n if units1!=None and units2!=None and units1 != units2:\\n if axis1.isTime() and axis2.isTime():\\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\\n else:\\n print \\\"ERROR. common_axis does not yet support differing units\\\",axis1.units,\\\" and \\\",axis2.units\\n return None\\n if axis1.isTime() or axis2.isTime():\\n if not axis2.isTime() or not axis1.isTime():\\n print \\\"ERROR. In common_axis, one axis is time, not the other\\\"\\n return None\\n if not axis1.calendar==axis2.calendar:\\n print \\\"ERROR. common_axis does not yet support differing calendars.\\\"\\n if len(axis1)==1 and len(axis2)==1:\\n # There's just one time value, probably from averaging over time. The time value is meaningless\\n # but it would be messy to have two.\\n return (axis1,[0],[0])\\n\\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\\n # units and calendar attributes should always be transferred if present.\\n # Also to do: use bounds if available\\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\\n a1indexina3 = a12indexina3[0:len(axis1)]\\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\\n\\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\\n vid = axis1.id\\n else:\\n vid = None\\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\\n axis3.units = units1\\n return (axis3,a1indexina3,a2indexina3)\",\n \"def make_plot(solution, t, plot_Ts, plot_T1, plot_T2, xaxis, cc, delta_cc, albedo,delta_albedo\\\\\\n , em1, delta_em1, em2, delta_em2):\\n\\n plt.close('all')\\n fig = plt.figure()\\n ax1 = fig.add_subplot(111)\\n \\n if xaxis == 'cloud cover':\\n inc_cc = []\\n for i in range(len(solution[0,:])):\\n inc_cc.append(cc + (i*delta_cc)/calcs_per_timestep)\\n\\n if plot_Ts == 'On': ax1.plot(inc_cc,solution[0,:],label = 'Surface temperature')\\n if plot_T1 == 'On': ax1.plot(inc_cc,solution[1,:], label = 'Lower atmospheric temperature')\\n if plot_T2 == 'On': ax1.plot(inc_cc,solution[2,:], label = 'Upper atmospheric temperature')\\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\\n\\n elif xaxis == 'time':\\n \\n #for i in range(len(solution[0,:])):\\n #t.append(i*(timestep/calcs_per_timestep))\\n \\n if plot_Ts == 'On': ax1.plot(t,solution[0,:],label = 'Surface temperature')\\n if plot_T1 == 'On': ax1.plot(t,solution[1,:], label = 'Lower atmospheric temperature')\\n if plot_T2 == 'On': ax1.plot(t,solution[2,:], label = 'Upper atmospheric temperature')\\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\\n \\n elif xaxis == 'albedo':\\n inc_alb = []\\n for i in range(len(solution[0,:])):\\n inc_alb.append(albedo+(i*delta_albedo)/calcs_per_timestep)\\n \\n if plot_Ts == 'On': ax1.plot(inc_alb,solution[0,:],label = 'Surface temperature')\\n if plot_T1 == 'On': ax1.plot(inc_alb,solution[1,:], label = 'Lower atmospheric temperature')\\n if plot_T2 == 'On': ax1.plot(inc_alb,solution[2,:], label = 'Upper atmospheric temperature')\\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\\n \\n elif xaxis == 'epsilon1':\\n inc_em = []\\n for i in range(len(solution[0,:])):\\n inc_em.append(em1+(i*delta_em1)/calcs_per_timestep)\\n \\n if plot_Ts == 'On': ax1.plot(inc_em,solution[0,:],label = 'Surface temperature')\\n if plot_T1 == 'On': ax1.plot(inc_em,solution[1,:], label = 'Lower atmospheric temperature')\\n if plot_T2 == 'On': ax1.plot(inc_em,solution[2,:], label = 'Upper atmospheric temperature')\\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\\n \\n elif xaxis == 'epsilon2':\\n inc_em = []\\n for i in range(len(solution[0,:])):\\n inc_em.append(em2+(i*delta_em2)/calcs_per_timestep)\\n \\n if plot_Ts == 'On': ax1.plot(inc_em,solution[0,:],label = 'Surface temperature')\\n if plot_T1 == 'On': ax1.plot(inc_em,solution[1,:], label = 'Lower atmospheric temperature')\\n if plot_T2 == 'On': ax1.plot(inc_em,solution[2,:], label = 'Upper atmospheric temperature')\\n if plot_Ts == 'Off' and plot_T1 == 'Off' and plot_T2 == 'Off': raise ValueError('No y variable selected')\\n \\n else: raise ValueError('No x axis selected')\\n \\n fig.suptitle('Global Average Temperature')\\n ax1.set_title(f'Final Surface Temperature = {round(solution[0,-1],2)} K')\\n ax1.legend()\\n\\n if xaxis == 'cloud cover': ax1.set_xlabel('Cloud Cover (%)')\\n elif xaxis == 'time': ax1.set_xlabel('Time (years)')\\n elif xaxis == 'albedo': ax1.set_xlabel('Albedo')\\n elif xaxis == 'epsilon1': ax1.set_xlabel(u'\\\\u03B5\\\\u2081')\\n elif xaxis == 'epsilon2': ax1.set_xlabel(u'\\\\u03B5\\\\u2082')\\n plt.ylabel('Temerature (K)')\\n return fig\",\n \"def update_cross_sections(self):\\n self.get_xcs_panel().update_plot()\\n self.get_ycs_panel().update_plot()\",\n \"def plot_overlay2axes(self, axes) -> None:\\n # calculate height (based on leaf analysis ratio)\\n upper_point = (\\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n lower_point = (\\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n height = abs(upper_point - lower_point) * 0.8\\n\\n for idx, line in enumerate(self.marker_lines):\\n width = abs(self.error[idx]) * self._image.dpmm\\n y = line.center.y\\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\\n\\n if self._orientation == Orientation.UP_DOWN:\\n r = Rectangle(width, height, center=(x, y))\\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n else:\\n r = Rectangle(height, width, center=(x, y))\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n r.plot2axes(\\n axes, edgecolor=\\\"none\\\", fill=True, alpha=1, facecolor=self.bg_color[idx]\\n )\",\n \"def populate_axes_with_euclidean(pid_series, series_was_shifted_to, axes):\\n euclidean_distance(pid_series, series_was_shifted_to).plot(kind='bar', legend=False, ax=axes)\",\n \"def scatter_plots_col(X, Y, i1, i2, ms=7, X_Labels=[], Y_Label='Y', ax=[]):\\r\\n\\r\\n # Options for the graphic\\r\\n pltfont = {'fontname': 'Bitstream Vera Sans', 'fontsize': 15} # font\\r\\n # Colorscale\\r\\n colorscale = 'jet'\\r\\n #colorscale = 'gray' # black and white plot\\r\\n\\r\\n ###########################################################################\\r\\n # Check inputs\\r\\n ###########################################################################\\r\\n if not isinstance(X, np.ndarray):\\r\\n raise ValueError('\\\"X\\\" must be a numpy.array.')\\r\\n if X.dtype.kind != 'f' and X.dtype.kind != 'i' and X.dtype.kind != 'u':\\r\\n raise ValueError('\\\"X\\\" must contain floats or integers.')\\r\\n\\r\\n if not isinstance(Y, np.ndarray):\\r\\n raise ValueError('\\\"Y\\\" must be a numpy.array.')\\r\\n if Y.dtype.kind != 'f' and Y.dtype.kind != 'i' and Y.dtype.kind != 'u':\\r\\n raise ValueError('\\\"Y\\\" must contain floats or integers.')\\r\\n\\r\\n Nx = X.shape\\r\\n Y = Y.flatten() # shape (N, )\\r\\n Ny = Y.shape\\r\\n N = Nx[0]\\r\\n M = Nx[1]\\r\\n if Ny[0] != N:\\r\\n raise ValueError('input \\\"X\\\" and \\\"Y\\\" must have the same number of rows')\\r\\n\\r\\n if not isinstance(i1, (int, np.int8, np.int16, np.int32, np.int64)):\\r\\n raise ValueError('\\\"i1\\\" must be scalar and integer.')\\r\\n if i1 < 0 or i1 > M-1:\\r\\n raise ValueError('\\\"i1\\\" must be in [0, M-1].')\\r\\n\\r\\n if not isinstance(i2, (int, np.int8, np.int16, np.int32, np.int64)):\\r\\n raise ValueError('\\\"i2\\\" must be scalar and integer.')\\r\\n if i2 < 0 or i2 > M-1:\\r\\n raise ValueError('\\\"i2\\\" must be in [0, M-1].')\\r\\n\\r\\n ###########################################################################\\r\\n # Check optional inputs\\r\\n ###########################################################################\\r\\n\\r\\n if not isinstance(Y_Label, str):\\r\\n raise ValueError('\\\"Y_Label\\\" must be a string.')\\r\\n\\r\\n if not X_Labels:\\r\\n X_Labels = [np.nan]*M\\r\\n for i in range(M):\\r\\n X_Labels[i] = 'X' + str(i+1)\\r\\n else:\\r\\n if not isinstance(X_Labels, list):\\r\\n raise ValueError('\\\"X_Labels\\\" must be a list with M elements.')\\r\\n if not all(isinstance(i, str) for i in X_Labels):\\r\\n raise ValueError('Elements in \\\"X_Labels\\\" must be strings.')\\r\\n if len(X_Labels) != M:\\r\\n raise ValueError('\\\"X_Labels\\\" must have M elements.')\\r\\n\\r\\n if not isinstance(ms, (int, np.int8, np.int16, np.int32, np.int64)):\\r\\n raise ValueError('\\\"ms\\\" must be scalar and integer.')\\r\\n if ms <= 0:\\r\\n raise ValueError('\\\"i2\\\" must be positive.')\\r\\n\\r\\n ###########################################################################\\r\\n # Create plot\\r\\n ###########################################################################\\r\\n\\r\\n # Option 1: plot on curent figure\\r\\n if plt.get_fignums(): # if there is a figure recover axes of current figure\\r\\n ax = plt.gca()\\r\\n else: # else create a new figure\\r\\n plt.figure()\\r\\n ax = plt.gca()\\r\\n # Option 2: create a new figure\\r\\n #plt.figure()\\r\\n #ax = plt.gca()\\r\\n\\r\\n map_plot = plt.scatter(X[:, i1], X[:, i2], s=ms, c=Y, cmap=colorscale)\\r\\n plt.xlabel(X_Labels[i1], **pltfont)\\r\\n plt.ylabel(X_Labels[i2], **pltfont)\\r\\n plt.xlim((np.min(X[:, i1]), np.max(X[:, i1])))\\r\\n plt.ylim((np.min(X[:, i2]), np.max(X[:, i2])))\\r\\n plt.xticks(**pltfont)\\r\\n plt.yticks(**pltfont)\\r\\n\\r\\n # Add colorbar\\r\\n cb = plt.colorbar(map_plot, ax=ax)\\r\\n cb.set_label(Y_Label, **pltfont)\\r\\n cb.Fontname = pltfont['fontname']\\r\\n cb.ax.tick_params(labelsize=pltfont['fontsize'])\",\n \"def crossAxes(axl, xyzero=[0.0, 0.0], limits=[None, None, None, None], labels:Union[str, None]=['nA', 'mV']):\\n\\n axl = _ax_tolist(axl)\\n # if type(axl) is not list:\\n # axl = [axl]\\n for ax in axl:\\n if ax is None:\\n continue\\n # ax.set_title('spines at data (1,2)')\\n # ax.plot(x,y)\\n ax.spines[\\\"left\\\"].set_position((\\\"data\\\", xyzero[0]))\\n ax.spines[\\\"right\\\"].set_color(\\\"none\\\")\\n ax.spines[\\\"bottom\\\"].set_position((\\\"data\\\", xyzero[1]))\\n ax.spines[\\\"top\\\"].set_color(\\\"none\\\")\\n # ax.spines['left'].set_smart_bounds(True)\\n # ax.spines['bottom'].set_smart_bounds(True) # deprecated, not sure what to do\\n ax.xaxis.set_ticks_position(\\\"bottom\\\")\\n ax.yaxis.set_ticks_position(\\\"left\\\")\\n if limits[0] is not None:\\n ax.set_xlim(left=limits[0], right=limits[2])\\n ax.set_ylim(bottom=limits[1], top=limits[3])\",\n \"def plot_2d(self, x1: Union[Iterable, ndarray], x2: Union[Iterable, ndarray],\\n color_map: str = 'viridis', ax: Axes = None) -> Axes:\\n x1_grid, x2_grid = meshgrid(x1, x2)\\n x1_x2 = dstack((x1_grid, x2_grid))\\n f = self._method(x1_x2)\\n ax = ax or new_axes()\\n ax.contourf(x1_grid, x2_grid, f, cmap=color_map)\\n ax.set_xlabel('x1')\\n ax.set_ylabel('x2')\\n return ax\",\n \"def createCustomXYaxis(origin: Tuple[float, float, float], endPoints: List[Tuple[float, float, float]]) -> List[\\n vtkActor]:\\n\\n output = []\\n\\n for endPoint in endPoints:\\n output.append(createLine(origin, endPoint, color=\\\"lightgreen\\\"))\\n\\n return output\",\n \"def plotsegs(x1,y1,x2,y2):\\n x = np.repeat(np.nan,x1.shape[0]*3)\\n y = np.repeat(np.nan,x1.shape[0]*3)\\n x[0::3] = x1\\n x[1::3] = x2\\n y[0::3] = y1\\n y[1::3] = y2\\n plt.plot(x,y)\",\n \"def dline_Mgas_array(lines,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig, axs = plt.subplots(len(lines), sharex='col',\\\\\\n figsize=(6,15),facecolor='w',\\\\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\\n\\n for i,ax in enumerate(axs):\\n\\n dline_Mgas(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add=True,cb=True)\\n dline_Mgas(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add=True,cb=False)\\n\\n plt.tight_layout()\\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/dlines_Mgas_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)\",\n \"def compute_axes(self):\\n mini, maxi = self._get_extremes()\\n self.y_axis.min = mini\\n self.y_axis.max = maxi\\n self.y_axis._max_min()\\n\\n if not None in [s.xvalues for s in self]:\\n mini, maxi = self._get_extremes('xvalues')\\n self.x_axis.min = mini\\n self.x_axis.max = maxi\\n self.x_axis._max_min()\",\n \"def comp_axes(self, machine, N0=None):\\n if self.time is None and N0 is None:\\n raise InputError(\\\"ERROR: time and N0 can't be both None\\\")\\n\\n # Get machine pole pair number\\n p = machine.get_pole_pair_number()\\n\\n # Get electrical fundamental frequency\\n f_elec = self.comp_felec()\\n\\n # Airgap radius\\n Rag = machine.comp_Rgap_mec()\\n\\n # Setup normalizations for time and angle axes\\n norm_time = {\\n \\\"elec_order\\\": f_elec,\\n \\\"mech_order\\\": f_elec / p,\\n }\\n if N0 is not None:\\n norm_time[\\\"angle_rotor\\\"] = 1 / (360 * N0 / 60)\\n\\n norm_angle = {\\\"space_order\\\": p, \\\"distance\\\": 1 / Rag}\\n\\n # Create time axis\\n if self.time is None:\\n # Create time axis as a DataLinspace\\n Time = DataLinspace(\\n name=\\\"time\\\",\\n unit=\\\"s\\\",\\n initial=0,\\n final=60 / N0 * self.Nrev,\\n number=self.Nt_tot,\\n include_endpoint=False,\\n normalizations=norm_time,\\n )\\n else:\\n # Load time data\\n time = self.time.get_data()\\n self.Nt_tot = len(time)\\n Time = Data1D(name=\\\"time\\\", unit=\\\"s\\\", values=time, normalizations=norm_time)\\n\\n # Create angle axis\\n if self.angle is None:\\n # Create angle axis as a DataLinspace\\n Angle = DataLinspace(\\n name=\\\"angle\\\",\\n unit=\\\"rad\\\",\\n initial=0,\\n final=2 * pi,\\n number=self.Na_tot,\\n include_endpoint=False,\\n normalizations=norm_angle,\\n )\\n else:\\n # Load angle data\\n angle = self.angle.get_data()\\n self.Na_tot = len(angle)\\n Angle = Data1D(\\n name=\\\"angle\\\", unit=\\\"rad\\\", values=angle, normalizations=norm_angle\\n )\\n\\n return Time, Angle\",\n \"def plot_separate(self):\\n f, axes = plt.subplots(2, 3, figsize=(16, 8))\\n\\n self.decomposition_plot(ax=axes[0, 0], text='Lens light', lens_light_add=True, unconvolved=True)\\n self.decomposition_plot(ax=axes[1, 0], text='Lens light convolved', lens_light_add=True)\\n self.decomposition_plot(ax=axes[0, 1], text='Source light', source_add=True, unconvolved=True)\\n self.decomposition_plot(ax=axes[1, 1], text='Source light convolved', source_add=True)\\n self.decomposition_plot(ax=axes[0, 2], text='All components', source_add=True, lens_light_add=True,\\n unconvolved=True)\\n self.decomposition_plot(ax=axes[1, 2], text='All components convolved', source_add=True,\\n lens_light_add=True, point_source_add=True)\\n f.tight_layout()\\n f.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0., hspace=0.05)\\n return f, axes\",\n \"def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\\n steps: int=10):\\n \\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n ctr1 = np.nanmean(loc1, 0)\\n ctr1[2] -= 0.2\\n ctr2 = np.nanmean(loc2, 0)\\n ctr2[2] -= 0.2\\n\\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\\n Cmax1=np.nanmax(C1[:])\\n Cmax2=np.nanmax(C2[:])\\n Cmax=[]\\n Cmax=[Cmax1, Cmax2]\\n vmax=np.nanmax(Cmax)\\n Cmin1=np.nanmin(C1[:])\\n Cmin2=np.nanmin(C2[:])\\n Cmin=[]\\n Cmin=[Cmin1, Cmin2]\\n vmin=np.min(Cmin)\\n\\n # Calculate automatic threshold\\n if threshold == 'auto':\\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\\n else:\\n threshold = threshold\\n\\n # Define colormap for both participant\\n cmap_p = matplotlib.cm.get_cmap('Reds')\\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\\n\\n for e1 in range(len(loc1)):\\n x1 = loc1[e1, 0]\\n y1 = loc1[e1, 1]\\n z1 = loc1[e1, 2]\\n for e2 in range(len(loc1)):\\n x2 = loc1[e2, 0]\\n y2 = loc1[e2, 1]\\n z2 = loc1[e2, 2]\\n if C1[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C1[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\\n \\n for e1 in range(len(loc2)):\\n x1 = loc2[e1, 0]\\n y1 = loc2[e1, 1]\\n z1 = loc2[e1, 2]\\n for e2 in range(len(loc2)):\\n x2 = loc2[e2, 0]\\n y2 = loc2[e2, 1]\\n z2 = loc2[e2, 2]\\n if C2[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C2[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\",\n \"def intersection(self, axis2):\",\n \"def plot(self) -> List[matplotlib.figure.Figure]:\\n figs = []\\n\\n # Figure 1, position in 3 subplots\\n pos_fig_sub = self.plot_subplots(0, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed)\\n figs.append(pos_fig_sub)\\n\\n # Figure 2, orientation in 3 subplots\\n eul_fig_sub = self.plot_subplots(1, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed)\\n figs.append(eul_fig_sub)\\n\\n # Figure 3, position in one axes\\n pos_fig_one = self.plot_one_axes(2, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed,\\n {'labeled': 'Labeled (X)', 'filled': 'Filled (Y)', 'smoothed': 'Smoothed (Z)'})\\n figs.append(pos_fig_one)\\n\\n # Figure 3, position in one axes\\n eul_fig_one = self.plot_one_axes(3, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed,\\n {'labeled': 'Labeled (Flex/Ext)', 'filled': 'Filled (Lat Flex)',\\n 'smoothed': 'Smoothed (Axial)'})\\n figs.append(eul_fig_one)\\n\\n return figs\",\n \"def discrete_scatter(x1, x2, y=None, markers=None, s=10, ax=None,\\n labels=None, padding=.2, alpha=1, c=None, markeredgewidth=None):\\n if ax is None:\\n ax = plt.gca()\\n\\n if y is None:\\n y = np.zeros(len(x1))\\n\\n unique_y = np.unique(y)\\n\\n if markers is None:\\n markers = ['o', '^', 'v', 'D', 's', '*', 'p', 'h', 'H', '8', '<', '>'] * 10\\n\\n if len(markers) == 1:\\n markers = markers * len(unique_y)\\n\\n if labels is None:\\n labels = unique_y\\n\\n # lines in the matplotlib sense, not actual lines\\n lines = []\\n\\n current_cycler = mpl.rcParams['axes.prop_cycle']\\n\\n for i, (yy, cycle) in enumerate(zip(unique_y, current_cycler())):\\n mask = y == yy\\n # if c is none, use color cycle\\n if c is None:\\n color = cycle['color']\\n elif len(c) > 1:\\n color = c[i]\\n else:\\n color = c\\n # use light edge for dark markers\\n if np.mean(colorConverter.to_rgb(color)) < .4:\\n markeredgecolor = \\\"grey\\\"\\n else:\\n markeredgecolor = \\\"black\\\"\\n\\n lines.append(ax.plot(x1[mask], x2[mask], markers[i], markersize=s,\\n label=labels[i], alpha=alpha, c=color,\\n markeredgewidth=markeredgewidth,\\n markeredgecolor=markeredgecolor)[0])\\n\\n if padding != 0:\\n pad1 = x1.std() * padding\\n pad2 = x2.std() * padding\\n xlim = ax.get_xlim()\\n ylim = ax.get_ylim()\\n ax.set_xlim(min(x1.min() - pad1, xlim[0]), max(x1.max() + pad1, xlim[1]))\\n ax.set_ylim(min(x2.min() - pad2, ylim[0]), max(x2.max() + pad2, ylim[1]))\\n\\n return lines\",\n \"def _axes_domain(self, *args, **kwargs):\\n # See _add_gridline_label for detials\\n lon_0 = self.axes.projection.proj4_params.get('lon_0', 0)\\n x_range, y_range = type(self)._axes_domain(self, *args, **kwargs)\\n x_range = np.asarray(x_range) + lon_0\\n return x_range, y_range\",\n \"def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def plot_output_3axes(axes, name, color):\\n\\tout = vice.output(name)\\n\\taxes[0].plot(out.history[\\\"time\\\"][1:], out.history[\\\"ifr\\\"][1:],\\n\\t\\tc = visuals.colors()[color], linestyle = '--')\\n\\taxes[0].plot(out.history[\\\"time\\\"], out.history[\\\"sfr\\\"],\\n\\t\\tc = visuals.colors()[color], linestyle = '-')\\n\\taxes[1].plot(out.history[\\\"[Fe/H]\\\"], out.history[\\\"[O/Fe]\\\"],\\n\\t\\tc = visuals.colors()[color])\\n\\taxes[2].plot(list(map(lambda x, y: (x + y) / 2., out.mdf[\\\"bin_edge_left\\\"],\\n\\t\\tout.mdf[\\\"bin_edge_right\\\"])), out.mdf[\\\"dn/d[O/Fe]\\\"],\\n\\t\\tc = visuals.colors()[color])\",\n \"def plotScopes12p(day,shot):\\n axs = []\\n for p in range(4):\\n if p == 0:\\n ax = plt.subplot(4,3,3*p+1)\\n plt.title(\\\"day %d, shot %d, scope 1\\\"%(day,shot))\\n else:\\n plt.subplot(4,3,3*p+1,sharex=ax)\\n\\n x = findReadData(day,1,p+1,shot)\\n plt.plot(x.Time,x.Ampl)\\n plt.ylabel(\\\"channel %d\\\"%(p+1))\\n fudgePlotLimits(x.Time,x.Ampl)\\n if p==3:\\n plt.xlabel(\\\"time ($\\\\mu$s)\\\")\\n\\n plt.subplot(4,3,3*p+2,sharex=ax)\\n if p == 0:\\n plt.title(\\\"day %d, shot %d, scope 2\\\"%(day,shot))\\n x = findReadData(day,2,p+1,shot)\\n plt.plot(x.Time,x.Ampl)\\n plt.ylabel(\\\"channel %d\\\"%(p+1))\\n fudgePlotLimits(x.Time,x.Ampl)\\n if p==3:\\n plt.xlabel(\\\"time ($\\\\mu$s)\\\")\\n\\n plt.subplot(4,3,3*p+3,sharex=ax)\\n if p == 0:\\n plt.title(\\\"day %d, shot %d, scope 3\\\"%(day,shot))\\n x = findReadData(day,3,p+1,shot)\\n plt.plot(x.Time,x.Ampl)\\n plt.ylabel(\\\"channel %d\\\"%(p+1))\\n fudgePlotLimits(x.Time,x.Ampl)\\n if p==3:\\n plt.xlabel(\\\"time ($\\\\mu$s)\\\")\",\n \"def figures(self):\\n if np.size(self.iceicehorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n if self.site1.archive == 'icecore':\\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\\n else:\\n mpl.xlabel(self.site1.label+' age (yr b1950)')\\n if self.site2.archive == 'icecore':\\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\\n else:\\n mpl.ylabel(self.site2.label+' age (yr b1950)')\\n if np.size(self.iceicehorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_age_init(self.iceicehorizons_depth1),\\n self.site2.fct_age_init(self.iceicehorizons_depth2),\\n color=pccfg.color_init, linestyle='', marker='o', markersize=2,\\n label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_age_model(self.iceicehorizons_depth1),\\n self.site2.fct_age_model(self.iceicehorizons_depth2),\\n color=pccfg.color_mod, linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_age(self.iceicehorizons_depth1),\\n self.site2.fct_age(self.iceicehorizons_depth2), color=pccfg.color_opt,\\n xerr=np.zeros(np.size(self.iceicehorizons_depth1)),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_age(self.iceicehorizons_depth1)-self.iceicehorizons_sigma/2\\n ystart = self.site2.fct_age(self.iceicehorizons_depth2)+self.iceicehorizons_sigma/2\\n for i in range(np.size(self.iceicehorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.iceicehorizons_sigma[i],\\n -self.iceicehorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement', zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_ice_synchro.pdf')\\n elif self.site1.archive == 'icecore' or self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\\n if np.size(self.airairhorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\\n if np.size(self.airairhorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_airage_init(self.airairhorizons_depth1),\\n self.site2.fct_airage_init(self.airairhorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='',\\n marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_airage_model(self.airairhorizons_depth1),\\n self.site2.fct_airage_model(self.airairhorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_airage(self.airairhorizons_depth1),\\n self.site2.fct_airage(self.airairhorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.airairhorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_airage(self.airairhorizons_depth1)-\\\\\\n self.airairhorizons_sigma/2\\n ystart = self.site2.fct_airage(self.airairhorizons_depth2)+\\\\\\n self.airairhorizons_sigma/2\\n for i in range(np.size(self.airairhorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.airairhorizons_sigma[i],\\n -self.airairhorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\\n zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site2.archive == 'icecore':\\n if np.size(self.iceairhorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n if self.site1.archive == 'icecore':\\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\\n else:\\n mpl.xlabel(self.site1.label+' age (yr b1950)')\\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\\n if np.size(self.iceairhorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_age_init(self.iceairhorizons_depth1),\\n self.site2.fct_airage_init(self.iceairhorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='',\\n marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_age_model(self.iceairhorizons_depth1),\\n self.site2.fct_airage_model(self.iceairhorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_age(self.iceairhorizons_depth1),\\n self.site2.fct_airage(self.iceairhorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.iceairhorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_age(self.iceairhorizons_depth1)-\\\\\\n self.iceairhorizons_sigma/2\\n ystart = self.site2.fct_airage(self.iceairhorizons_depth2)+\\\\\\n self.iceairhorizons_sigma/2\\n for i in range(np.size(self.iceairhorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.iceairhorizons_sigma[i],\\n -self.iceairhorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0) \\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\\n zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site1.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_air_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site1.archive == 'icecore':\\n if np.size(self.airicehorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\\n if self.site2.archive == 'icecore':\\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\\n else:\\n mpl.ylabel(self.site2.label+' age (yr b1950)')\\n if np.size(self.airicehorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_airage_init(self.airicehorizons_depth1),\\n self.site2.fct_age_init(self.airicehorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='', marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_airage_model(self.airicehorizons_depth1),\\n self.site2.fct_age_model(self.airicehorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_airage(self.airicehorizons_depth1),\\n self.site2.fct_age(self.airicehorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.airicehorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_airage(self.airicehorizons_depth1)-\\\\\\n self.airicehorizons_sigma/2\\n ystart = self.site2.fct_age(self.airicehorizons_depth2)+\\\\\\n self.airicehorizons_sigma/2\\n for i in range(np.size(self.airicehorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.airicehorizons_sigma[i],\\n -self.airicehorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement')\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_ice_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\",\n \"def plot_box(ax, p1, p2, *args, **kwargs):\\n x1, y1, z1 = p1\\n x2, y2, z2 = p2\\n\\n plot_line(ax, (x1, y1, z1), (x2, y1, z1), *args, **kwargs)\\n plot_line(ax, (x1, y2, z1), (x2, y2, z1), *args, **kwargs)\\n plot_line(ax, (x1, y1, z2), (x2, y1, z2), *args, **kwargs)\\n plot_line(ax, (x1, y2, z2), (x2, y2, z2), *args, **kwargs)\\n\\n plot_line(ax, (x1, y1, z1), (x1, y2, z1), *args, **kwargs)\\n plot_line(ax, (x2, y1, z1), (x2, y2, z1), *args, **kwargs)\\n plot_line(ax, (x1, y1, z2), (x1, y2, z2), *args, **kwargs)\\n plot_line(ax, (x2, y1, z2), (x2, y2, z2), *args, **kwargs)\\n\\n plot_line(ax, (x1, y1, z1), (x1, y1, z2), *args, **kwargs)\\n plot_line(ax, (x2, y1, z1), (x2, y1, z2), *args, **kwargs)\\n plot_line(ax, (x1, y2, z1), (x1, y2, z2), *args, **kwargs)\\n plot_line(ax, (x2, y2, z1), (x2, y2, z2), *args, **kwargs)\",\n \"def plot_3outputs(X, gp,xlim):\\r\\n fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(15, 8))\\r\\n slices = GPy.util.multioutput.get_slices([X, X, X])\\r\\n #Output 1\\r\\n ax1.set_xlim(xlim)\\r\\n ax1.set_title('X')\\r\\n gp.plot(plot_limits=xlim, ax=ax1, fixed_inputs=[(1,0)], which_data_rows=slices[0])\\r\\n # ax1.plot(X1,Y1,'r,',mew=1.5)\\r\\n #Output 2\\r\\n ax2.set_xlim(xlim)\\r\\n ax2.set_title('Y')\\r\\n gp.plot(plot_limits=xlim, ax=ax2, fixed_inputs=[(1,1)], which_data_rows=slices[1])\\r\\n # ax2.plot(X2,Y2,'r,',mew=1.5)\\r\\n # Output 3\\r\\n ax3.set_xlim(xlim)\\r\\n ax3.set_title('Z')\\r\\n gp.plot(plot_limits=xlim, ax=ax3, fixed_inputs=[(1,2)], which_data_rows=slices[2])\\r\\n # ax3.plot(X3, Y3, 'r,', mew=1.5)\\r\\n return\",\n \"def plot_line(ax, p1, p2, *args, **kwargs):\\n ax.plot(*zip(p1, p2), *args, **kwargs)\",\n \"def axis2D(xlow,xhigh,xfirst,xstep,ylow,yhigh,yfirst,ystep):\\n dislin.graf(xlow,xhigh,xfirst,xstep,\\\\\\n ylow,yhigh,yfirst,ystep)\",\n \"def from_cartesian(self, coordinates, *axes):\",\n \"def _format_twin_axes(*args):\\n if(len(args) > 1):\\n #get minimum y limit\\n ylow, yhigh = 0., 0.\\n for ax in args:\\n yl = ax.get_ylim()\\n if(yl[0] < ylow):\\n ylow = yl[0]\\n yhigh = yl[1]\\n #scale all axes identically so that they overlap at y = 0\\n if(yhigh != 0):\\n frac = ylow/yhigh\\n for ax in args:\\n yl = ax.get_ylim()\\n ax.set_ylim(frac*yl[1], yl[1])\",\n \"def calcPositions_xy(self):\\n vA, cA = self.valueAxis, self.categoryAxis\\n vA.setPosition(self.x, self.y, self.height)\\n if vA: vA.joinAxis = cA\\n if cA: cA.joinAxis = vA\\n vA.configure(self.data)\\n # If zero is in chart, put x axis there, otherwise\\n # use bottom.\\n xAxisCrossesAt = vA.scale(0)\\n if ((xAxisCrossesAt > self.y + self.height) or (xAxisCrossesAt < self.y)):\\n y = self.y\\n else:\\n y = xAxisCrossesAt\\n cA.setPosition(self.x, y, self.width)\\n cA.configure(self.data)\\n\\n self._seriesCount = len(self.data)\\n self._rowLength = max(map(len,self.data))\\n if self.useAbsolute:\\n # Dimensions are absolute.\\n normFactor = 1.0\\n else:\\n # Dimensions are normalized to fit.\\n normWidth = self.groupSpacing\\n availWidth = self.categoryAxis.scale(0)[1]\\n normFactor = availWidth / normWidth\\n \\n self._positions = []\\n for rowNo in range(len(self.data)):\\n lineRow = []\\n for colNo in range(len(self.data[rowNo])):\\n datum = self.data[rowNo][colNo]\\n if datum is not None:\\n (groupX, groupWidth) = self.categoryAxis.scale(colNo)\\n x = groupX + (0.5 * self.groupSpacing * normFactor)\\n y = self.valueAxis.scale(0)\\n height = self.valueAxis.scale(datum) - y\\n lineRow.append((x, y+height))\\n self._positions.append(lineRow)\\n return self._positions\",\n \"def plot_events(ax, MD):\\n\\n coord_vars = ['CT_at_HB', 'CT_out_HB']\\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\\n all_vars = coord_vars + ingestion_vars\\n\\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\\n \\n names = ['M', 'M', 'F', 'F', 'W', 'W']\\n idx = [2, 0, 0, 1, 0, 1]\\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\\n\\n offsets = [-3, -5, -9, -11, -14, -16]\\n height = 1.\\n \\n print \\\"plotting events..\\\"\\n\\n\\n for c, name in enumerate(all_vars):\\n\\n # load\\n if not hasattr(MD, name):\\n MD.load(name)\\n\\n events = getattr(MD, name) / 3600. - 7 \\n\\n offset = offsets[c]\\n color = colors[c]\\n label = str(events.shape[0]) + ' ' + labels[c]\\n\\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\\n label += ' events'\\n\\n if name in coord_vars:\\n \\n ax.scatter(\\n events, offset * np.ones(events.shape[0]),\\n c=color,\\n marker='|',\\n linewidths=1,\\n edgecolors=None\\n )\\n \\n\\n elif name in ingestion_vars:\\n\\n for x in events: \\n event_patch = patches.Rectangle(\\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\\n linewidth=0.001,\\n fc=color, \\n ec=color\\n ) \\n ax.add_patch(event_patch) \\n\\n # event descritpion\\n ax.text(31, offset, label, color=color, \\n fontsize=7, ha='left', va='bottom'\\n )\",\n \"def plot_msd(msd, h_exp):\\n fig, ax = plt.subplots(1, 2, figsize = (10, 10))\\n av_msd = np.mean(msd, axis = 0)\\n\\n for p in np.arange(0, msd.shape[0], step = 1):\\n for t in np.arange(0, msd.shape[1], step = 1): \\n ax[0].plot(t, msd[p, t], 'bx')\\n ax[1].plot(t, av_msd[t], 'ro')\\n ax[0].set_xlabel('Time lag (number of steps)')\\n ax[0].set_ylabel('MSD (pix^2)')\\n ax[0].set_title('Individual TAMSDs: H = ' + str(h_exp))\\n ax[1].set_xlabel('Time lag (number of steps)')\\n ax[1].set_ylabel('MSD (pix^2)')\\n ax[1].set_title('Averaged TAMSDs: H = ' + str(h_exp)) \\n ax[0].set_xlim([0, np.max(t)])\\n ax[1].set_xlim([0, np.max(t)])\\n ax[0].set_ylim([0, np.max(msd)]) \\n ax[1].set_ylim([0, np.max(av_msd)])\",\n \"def _get_lines_parallel_to_axis(\\n self,\\n axis_parallel_to: NumberLine,\\n axis_perpendicular_to: NumberLine,\\n freq: float,\\n ratio_faded_lines: int,\\n ) -> tuple[VGroup, VGroup]:\\n\\n line = Line(axis_parallel_to.get_start(), axis_parallel_to.get_end())\\n if ratio_faded_lines == 0: # don't show faded lines\\n ratio_faded_lines = 1 # i.e. set ratio to 1\\n step = (1 / ratio_faded_lines) * freq\\n lines1 = VGroup()\\n lines2 = VGroup()\\n unit_vector_axis_perp_to = axis_perpendicular_to.get_unit_vector()\\n\\n # need to unpack all three values\\n x_min, x_max, _ = axis_perpendicular_to.x_range\\n\\n # account for different axis scalings (logarithmic), where\\n # negative values do not exist and [-2 , 4] should output lines\\n # similar to [0, 6]\\n if axis_perpendicular_to.x_min > 0 and x_min < 0:\\n x_min, x_max = (0, np.abs(x_min) + np.abs(x_max))\\n\\n # min/max used in case range does not include 0. i.e. if (2,6):\\n # the range becomes (0,4), not (0,6).\\n ranges = (\\n [0],\\n np.arange(step, min(x_max - x_min, x_max), step),\\n np.arange(-step, max(x_min - x_max, x_min), -step),\\n )\\n\\n for inputs in ranges:\\n for k, x in enumerate(inputs):\\n new_line = line.copy()\\n new_line.shift(unit_vector_axis_perp_to * x)\\n if (k + 1) % ratio_faded_lines == 0:\\n lines1.add(new_line)\\n else:\\n lines2.add(new_line)\\n return lines1, lines2\",\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 _find_axes(cls, input_data, explicit_x=None):\\n\\n if isinstance(input_data, pd.Series):\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a pandas Series\\\")\\n\\n return input_data.index, input_data.values\\n elif isinstance(input_data, pd.DataFrame):\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a pandas DataFrame\\\")\\n\\n return input_data.index, input_data.values[:, 0]\\n elif isinstance(input_data, np.ndarray):\\n if len(input_data.shape) == 2 and input_data.shape[0] == 2:\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a 2D array of input data\\\")\\n\\n return input_data[:, 0], input_data[:, 1]\\n elif len(input_data.shape) == 1:\\n if explicit_x is not None:\\n if len(explicit_x) != len(input_data):\\n raise ArgumentError(\\\"Your explicit x data has a different length that your y data\\\", x_length=len(explicit_x), y_length=len(input_data))\\n\\n return explicit_x, input_data\\n else:\\n return np.linspace(0, len(input_data) - 1, len(input_data)), input_data\\n elif explicit_x is not None:\\n return np.array(explicit_x), np.array(explicit_x)\\n\\n return np.linspace(0, len(input_data) - 1, len(input_data)), np.array(input_data)\",\n \"def get_tick_iterators(self, axes):\\n\\n lat_levs, lat_n, lat_factor = self._grid_info[\\\"lat_info\\\"]\\n yy0 = lat_levs / lat_factor\\n\\n lon_levs, lon_n, lon_factor = self._grid_info[\\\"lon_info\\\"]\\n xx0 = lon_levs / lon_factor\\n\\n e0, e1 = self._extremes\\n\\n def trf_xy(x, y):\\n trf = self.grid_helper.grid_finder.get_transform() + axes.transData\\n return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T\\n\\n # find angles\\n if self.nth_coord == 0:\\n mask = (e0 <= yy0) & (yy0 <= e1)\\n (xx1, yy1), (dxx1, dyy1), (dxx2, dyy2) = _value_and_jacobian(\\n trf_xy, self.value, yy0[mask], (-np.inf, np.inf), (e0, e1))\\n labels = self._grid_info[\\\"lat_labels\\\"]\\n\\n elif self.nth_coord == 1:\\n mask = (e0 <= xx0) & (xx0 <= e1)\\n (xx1, yy1), (dxx2, dyy2), (dxx1, dyy1) = _value_and_jacobian(\\n trf_xy, xx0[mask], self.value, (-np.inf, np.inf), (e0, e1))\\n labels = self._grid_info[\\\"lon_labels\\\"]\\n\\n labels = [l for l, m in zip(labels, mask) if m]\\n\\n angle_normal = np.arctan2(dyy1, dxx1)\\n angle_tangent = np.arctan2(dyy2, dxx2)\\n mm = (dyy1 == 0) & (dxx1 == 0) # points with degenerate normal\\n angle_normal[mm] = angle_tangent[mm] + np.pi / 2\\n\\n tick_to_axes = self.get_tick_transform(axes) - axes.transAxes\\n in_01 = functools.partial(\\n mpl.transforms._interval_contains_close, (0, 1))\\n\\n def f1():\\n for x, y, normal, tangent, lab \\\\\\n in zip(xx1, yy1, angle_normal, angle_tangent, labels):\\n c2 = tick_to_axes.transform((x, y))\\n if in_01(c2[0]) and in_01(c2[1]):\\n yield [x, y], *np.rad2deg([normal, tangent]), lab\\n\\n return f1(), iter([])\",\n \"def populate_plot_axis(self,plot,ax='x'):\\n\\n fig=plt.gcf()\\n\\n extra_ax=[]\\n\\n if ax=='x':\\n\\n ticks=plot.get_xticks()\\n\\n lim=plot.get_xlim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['bottom'].set_position(('outward',10))\\n\\n axn.spines['bottom'].set_visible(True)\\n\\n else:\\n\\n dy_fig=0.08\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0,\\\\\\n prev_ax_position.y0-2*dy_fig,\\\\\\n prev_ax_position.width,\\\\\\n 0),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.yaxis.set_visible(False)\\n\\n for side in axn.spines.keys():\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_xticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_xticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n xlab=axn.set_xlabel(self.names[i])\\n\\n xlab.set_fontsize(10)\\n\\n axn.tick_params(axis='x',labelsize=10)\\n\\n axn.set_xlim(lim)\\n\\n\\n\\n elif ax=='y':\\n\\n ticks=plot.get_yticks()\\n\\n lim=plot.get_ylim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['left'].set_position(('outward',10))\\n\\n axn.spines['left'].set_visible(True)\\n\\n else:\\n\\n dx_fig=0.08\\n\\n plot_position=plot.get_position()\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0-2*dx_fig,\\\\\\n prev_ax_position.y0,\\\\\\n 0,\\\\\\n prev_ax_position.height),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.xaxis.set_visible(False) # hide the yaxis\\n\\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_yticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_yticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n ylab=axn.set_ylabel(self.names[i])\\n\\n ylab.set_fontsize(10)\\n\\n axn.tick_params(axis='y',labelsize=10)\\n\\n axn.set_ylim(lim)\\n\\n else:\\n\\n raise ValueError(\\\"Axis can be 'x' or 'y'\\\")\",\n \"def get_2d_axes(xmin, xmax, ymin, ymax,\\n axis_style='r-style',\\n xscale=1.0, xbase=0.0, yscale=1.0, ybase=0.0,\\n xticks=[], yticks=[],\\n xtick_labels=None, ytick_labels=None,\\n tick_font='normalsize', tick_size='semithick',\\n label_font='Large', xlabel='x', ylabel='y',\\n xlabel_offset=0.1, ylabel_offset=0.15,\\n axis_size='thick', axis_color='gray',\\n tick_frac=0.05, ):\\n\\n # Find the tick size\\n tick_dim = min(tick_frac*(ymax - ymin)*yscale,\\n tick_frac*(xmax - xmin)*xscale)\\n\\n # Draw the axes\\n s = ''\\n if axis_style == 'r-style':\\n if len(xticks) >= 2:\\n s += '\\\\\\\\draw[%s, color=%s] (%f, %f) -- (%f,%f) -- (%f,%f) -- (%f, %f);'%(\\n axis_size, axis_color,\\n xscale*(xticks[0] - xbase),\\n yscale*(ymin - ybase) - tick_dim,\\n xscale*(xticks[0] - xbase), yscale*(ymin - ybase),\\n xscale*(xticks[-1] - xbase), yscale*(ymin - ybase),\\n xscale*(xticks[-1] - xbase), yscale*(ymin - ybase) - tick_dim)\\n if len(yticks) >= 2:\\n s += '\\\\\\\\draw[%s, color=%s] (%f, %f) -- (%f,%f) -- (%f,%f) -- (%f, %f);'%(\\n axis_size, axis_color,\\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[0] - ybase),\\n xscale*(xmin - xbase), yscale*(yticks[0] - ybase),\\n xscale*(xmin - xbase), yscale*(yticks[-1] - ybase),\\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[-1] - ybase))\\n else:\\n s += '\\\\\\\\draw[%s, color=%s] (%f,%f) -- (%f,%f);'%(\\n axis_size, axis_color,\\n xscale*(xmin - xbase), yscale*(ymin - ybase),\\n xscale*(xmax - xbase), yscale*(ymin - ybase))\\n s += '\\\\\\\\draw[%s, color=%s] (%f,%f) -- (%f,%f);'%(\\n axis_size, axis_color,\\n xscale*(xmin - xbase), yscale*(ymin - ybase),\\n xscale*(xmin - xbase), yscale*(ymax - ybase))\\n\\n # Draw the x-label\\n if xlabel is not None:\\n s += '\\\\\\\\draw[font=\\\\\\\\%s] (%f, %f) node[below] {%s};'%(\\n label_font, 0.5*xscale*(xmin + xmax - xbase),\\n yscale*(ymin - xlabel_offset*(ymax - ymin) - ybase),\\n xlabel)\\n\\n # Draw the y-label\\n if ylabel is not None:\\n s += '\\\\\\\\draw[font=\\\\\\\\%s] (%f, %f) node[rotate=90] {%s};'%(\\n label_font, xscale*(xmin - ylabel_offset*(xmax - xmin) - xbase),\\n 0.5*yscale*(ymin + ymax - ybase),\\n ylabel)\\n\\n # Draw the ticks on the graph\\n if axis_style == 'r-style':\\n if xtick_labels is None:\\n for i in range(len(xticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[below] {%g};\\\\n'%(\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) - tick_dim,\\n xticks[i])\\n else:\\n for i in range(len(xticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[below] {%s};\\\\n'%(\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) - tick_dim,\\n xtick_labels[i])\\n\\n # Draw the ticks on the graph\\n if ytick_labels is None:\\n for i in range(len(yticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[left] {%g};\\\\n'%(\\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[i] - ybase),\\n yticks[i])\\n else:\\n for i in range(len(yticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[left] {%s};\\\\n'%(\\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\\n xscale*(xmin - xbase) - tick_dim, yscale*(yticks[i] - ybase),\\n ytick_labels[i])\\n else:\\n if xtick_labels is None:\\n for i in range(len(xticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[below] {%g};\\\\n'%(\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) + tick_dim,\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\\n xticks[i])\\n else:\\n for i in range(len(xticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[below] {%s};\\\\n'%(\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase) + tick_dim,\\n xscale*(xticks[i] - xbase), yscale*(ymin - ybase),\\n xtick_labels[i])\\n\\n # Draw the ticks on the graph\\n if ytick_labels is None:\\n for i in range(len(yticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[left] {%g};\\\\n'%(\\n xscale*(xmin - xbase) + tick_dim, yscale*(yticks[i] - ybase),\\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\\n yticks[i])\\n else:\\n for i in range(len(yticks)):\\n s += '\\\\\\\\draw[font=\\\\\\\\%s, %s, color=%s, text=black] '%(\\n tick_font, tick_size, axis_color)\\n s += '(%f, %f) -- (%f, %f) node[left] {%s};\\\\n'%(\\n xscale*(xmin - xbase) + tick_dim, yscale*(yticks[i] - ybase),\\n xscale*(xmin - xbase), yscale*(yticks[i] - ybase),\\n ytick_labels[i])\\n\\n return s\",\n \"def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors ('x' for bads)\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\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 convert_axis( mv, axisold, axisindnew ):\\n (axisnew, indexina3) = axisindnew\\n axes = allAxes(mv)\\n kold = None\\n for k in range(len(axes)):\\n if axes[k]==axisold: kold=k\\n if kold==None:\\n print \\\"ERROR. convert_axis cannot find axis\\\",axisold,\\\" in variable\\\",mv\\n if len(axisold)==len(axisnew):\\n mv.setAxis( kold, axisnew )\\n return\\n # Here's what we would do in 1-D:\\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # for i in range(len(axisold)):\\n # newdata[ indexina3[i] ] = ma[i]\\n # newmv = cdms2.createVariable( newdata, id=mv.id )\\n # >1-D is the same idea, but more dimensions are coming along for the ride,\\n # making it more complicated...\\n shape0 = mv.shape\\n shape0[kold] = len(axisnew)\\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\\n # There seems to be nothing in numpy for treating one axis differently from the rest\\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\\n # The following will do the job. It would be very slow for an array with many big dimensions,\\n # but the arrays here have already been reduced for graphics; the index sets will be small or\\n # empty...\\n ranges = map( range, shape0[0:kold] )\\n for i in range(len(axisold)):\\n for idx in apply(itertools.product,ranges):\\n idx = idx + [indexina3(i)] + [Ellipsis]\\n idxo = idx + [i] + [Ellipsis]\\n newdata[ tuple(idx) ] = mv[idxo]\\n newmv = cdms2.createVariable( newdata, id=mv.id )\",\n \"def _set_axes(self):\\n self += helper.line(stroke=\\\"black\\\", x1=self.__dict__['x'], x2=self.__dict__['x'], y1=0, y2=self.__dict__['y']*2)\\n self += helper.line(stroke=\\\"black\\\", x1=0, x2=self.__dict__['x']*2, y1=self.__dict__['y'], y2=self.__dict__['y'])\",\n \"def plot_data_matplotlib(df_data):\\n # creating the figure and subplots as two rows and one column\\n fig, ax = plt.subplots(2, 1)\\n # defining the colours used for the plots and y axes\\n red = \\\"#DA2525\\\"\\n blue = \\\"#003A78\\\"\\n # setting up the subplots to share the x axis\\n # ax02 is the second y axis of the first subplot\\n ax02 = ax[0].twinx()\\n # ax12 is the second y axis of the second subplot\\n ax12 = ax[1].twinx()\\n # the global co2 line plot\\n line1 = ax[0].plot(\\n df_data.index,\\n df_data[\\\"global_co2\\\"],\\n label=\\\"Global $CO_2$ Emissions\\\",\\n color=blue\\n )\\n # the global temperature line plot\\n line2 = ax02.plot(\\n df_data.index,\\n df_data[\\\"global_temp\\\"],\\n label=\\\"Global Temperature Anomaly\\\",\\n color=red\\n )\\n # the uk co2 line plot\\n line3 = ax[1].plot(\\n df_data.index,\\n df_data[\\\"uk_co2\\\"],\\n label=\\\"UK $CO_2$ Emissions\\\",\\n color=blue\\n )\\n # the uk temperature line plot\\n line4 = ax12.plot(\\n df_data.index,\\n df_data[\\\"uk_temp\\\"],\\n label=\\\"UK Surface Temperature\\\",\\n color=red\\n )\\n # the next three dataframes are used to indicate where there are gaps in\\n # the data, which I will use to produce a shaded region to highlight this\\n # fact\\n # for the global temperature data\\n global_temp_nan = df_data[pd.isna(df_data[\\\"global_temp\\\"])]\\n # for the UK temperature data\\n uk_temp_nan = df_data[pd.isna(df_data[\\\"uk_temp\\\"])][:-1]\\n # for the UK co2 emissions data\\n uk_co2_nan = df_data[pd.isna(df_data[\\\"uk_co2\\\"])][:-2]\\n # creating a shaded region to show the missing global temperature data\\n ax[0].axvspan(\\n global_temp_nan.index[0],\\n global_temp_nan.index[-1],\\n alpha=0.1,\\n color=\\\"black\\\"\\n )\\n # creating a shaded region to show the missing UK co2 data\\n ax[1].axvspan(\\n uk_temp_nan.index[0],\\n uk_co2_nan.index[-1],\\n alpha=0.1,\\n color=\\\"black\\\"\\n )\\n # creating a shaded region to show the missing UK temperature data\\n ax[1].axvspan(\\n uk_co2_nan.index[-1],\\n uk_temp_nan.index[-1],\\n alpha=0.05,\\n color=\\\"black\\\"\\n )\\n # setting titles for the figure and subplots\\n ax[0].set_title(\\\"{}{}{}\\\".format(\\n \\\"Global and UK \\\",\\n \\\"$CO_2$ Emissions and Surface Temperature over Time\\\",\\n \\\"\\\\n\\\\nGlobal\\\"))\\n ax[1].set_title(\\\"UK\\\")\\n # setting axes labels\\n ax[1].set_xlabel(\\\"Time (years)\\\")\\n ax[0].set_ylabel(\\\"$CO_2$ Emissions (Tg)\\\", color=blue)\\n ax02.set_ylabel(\\\"Temperature Anomaly (°C)\\\", color=red)\\n ax[1].set_ylabel(\\\"$CO_2$ Emissions (Tg)\\\", color=blue)\\n ax12.set_ylabel(\\\"Temperature (°C)\\\", color=red)\\n # setting x axes limits so both subplots are over the same range\\n ax[0].set_xlim((df_data.index[0], df_data.index[-1]))\\n ax[1].set_xlim((df_data.index[0], df_data.index[-1]))\\n # setting the x axes tick values\\n ax[0].set_xticks([d for d in df_data.index if d.year % 20 == 0])\\n ax[1].set_xticks([d for d in df_data.index if d.year % 20 == 0])\\n # setting y axes colours to match the line plots\\n ax[0].tick_params(\\\"y\\\", colors=blue)\\n ax02.tick_params(\\\"y\\\", colors=red)\\n ax[1].tick_params(\\\"y\\\", colors=blue)\\n ax12.tick_params(\\\"y\\\", colors=red)\\n # annotating the shaded regions\\n ax[0].annotate(\\n \\\"No temperature data available\\\",\\n (\\\"1760-01-01\\\", 4000)\\n )\\n ax[1].annotate(\\n \\\"No data available\\\",\\n (\\\"1760-01-01\\\", 300)\\n )\\n ax[1].annotate(\\n \\\"No temperature data available\\\",\\n (\\\"1850-01-01\\\", 500)\\n )\\n # setting the legends \\n ax[0].legend(\\n line1 + line2,\\n [\\n line1[0].get_label(),\\n line2[0].get_label(),\\n ],\\n loc=2\\n )\\n ax[1].legend(\\n line3 + line4,\\n [\\n line3[0].get_label(),\\n line4[0].get_label()\\n ],\\n loc=2\\n )\\n plt.show()\\n return\",\n \"def TwoDynSpectraPlot(Data_Ch_A, Data_Ch_B, VminA, VmaxA, VminB, VmaxB, Suptitle,\\n CBarLabelA, CBarLabelB, no_of_spectra,\\n TimeFigureScale, TimeScale, frequency,\\n FreqPointsNum, colormap, TitleA, TitleB, fig_file_name,\\n currentDate, currentTime, Software_version, customDPI):\\n fig, axarr = plt.subplots(2, 1, figsize=(16.0, 9.0))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.08)\\n im0 = axarr[0].imshow(np.flipud(Data_Ch_A), aspect='auto', vmin=VminA, vmax=VmaxA,\\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\\n rc('font', size=8, weight='bold')\\n\\n ticks_loc = axarr[0].get_yticks().tolist() # <---- Added to suppress warning\\n axarr[0].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[0].set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\\n axarr[0].set_yticklabels(axarr[0].get_yticks(), fontsize=8, fontweight='bold')\\n cbar = fig.colorbar(im0, ax=axarr[0], pad=0.005)\\n cbar.ax.tick_params(labelsize=8)\\n cbar.set_label(CBarLabelA, fontsize=9, fontweight='bold')\\n text = axarr[0].get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = ' '\\n\\n ticks_loc = axarr[0].get_xticks().tolist() # <---- Added to suppress warning\\n axarr[0].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[0].set_xticklabels(text)\\n axis_copy = axarr[0].twiny()\\n axis_copy.set_xlim(0, no_of_spectra)\\n text = axis_copy.get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeFigureScale[k]\\n\\n ticks_loc = axis_copy.get_xticks().tolist() # <---- Added to suppress warning\\n axis_copy.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axis_copy.set_xticklabels(text, fontsize=8, fontweight='bold')\\n axarr[0].set_title(TitleA, fontsize=10, fontweight='bold', style='italic', y=1.05)\\n im1 = axarr[1].imshow(np.flipud(Data_Ch_B), aspect='auto', vmin=VminB, vmax=VmaxB,\\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\\n # frequency[FreqPointsNum-1]\\n\\n ticks_loc = axarr[1].get_xticks().tolist() # <---- Added to suppress warning\\n axarr[1].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n ticks_loc = axarr[1].get_yticks().tolist() # <---- Added to suppress warning\\n axarr[1].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[1].set_xlabel('UTC Time, HH:MM:SS.msec', fontsize=10, fontweight='bold')\\n axarr[1].set_ylabel('Frequency, MHz', fontsize=10, fontweight='bold')\\n cbar = fig.colorbar(im1, ax=axarr[1], pad=0.005)\\n cbar.set_label(CBarLabelB, fontsize=9, fontweight='bold')\\n cbar.ax.tick_params(labelsize=8)\\n text = axarr[1].get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeScale[k]\\n axarr[1].set_xticklabels(text, fontsize=8, fontweight='bold')\\n axarr[1].set_yticklabels(axarr[1].get_yticks(), fontsize=8, fontweight='bold')\\n axarr[1].set_title(TitleB, fontsize=10, fontweight='bold', style='italic', y=1.00)\\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=1.01)\\n fig.subplots_adjust(top=0.91)\\n fig.text(0.72, 0.065, 'Processed ' + currentDate + ' at ' + currentTime,\\n fontsize=6, transform=plt.gcf().transFigure)\\n fig.text(0.1, 0.065, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\\n fontsize=6, transform=plt.gcf().transFigure)\\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\\n plt.close('all')\\n return 0\",\n \"def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\\n if log:\\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\\n else:\\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)\",\n \"def line_SFR_array(lines,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig, axs = plt.subplots(len(lines), sharex='col',\\\\\\n figsize=(6,15),facecolor='w',\\\\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\\n\\n for i,ax in enumerate(axs):\\n\\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\\n line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=False,add=True,cb=False)\\n\\n # Only 1 galaxy\\n #line_SFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=True,add=True,cb=False)\\n\\n\\n plt.tight_layout()\\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/lines_SFR_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)\",\n \"def axes_maker(rows, cols):\\n fig = plt.figure()\\n current_subplot = [1] # Use list in order to modify\\n def next_axes(**kwargs):\\n current_subplot[0] += 1\\n axes = fig.add_subplot(rows, cols, current_subplot[0] - 1, **kwargs)\\n return axes\\n return next_axes\",\n \"def scatter_plots_interaction(X, Y, ms=7, X_Labels=[], Y_Label='Y'):\\r\\n\\r\\n # Options for the graphic\\r\\n pltfont = {'fontname': 'Bitstream Vera Sans', 'fontsize': 15} # font\\r\\n # Colorscale\\r\\n colorscale = 'jet'\\r\\n #colorscale = 'gray' # black and white plot\\r\\n\\r\\n ###########################################################################\\r\\n # Check inputs\\r\\n ###########################################################################\\r\\n if not isinstance(X, np.ndarray):\\r\\n raise ValueError('\\\"X\\\" must be a numpy.array.')\\r\\n if X.dtype.kind != 'f' and X.dtype.kind != 'i' and X.dtype.kind != 'u':\\r\\n raise ValueError('\\\"X\\\" must contain floats or integers.')\\r\\n\\r\\n if not isinstance(Y, np.ndarray):\\r\\n raise ValueError('\\\"Y\\\" must be a numpy.array.')\\r\\n if Y.dtype.kind != 'f' and Y.dtype.kind != 'i' and Y.dtype.kind != 'u':\\r\\n raise ValueError('\\\"Y\\\" must contain floats or integers.')\\r\\n\\r\\n Nx = X.shape\\r\\n Y = Y.flatten() # shape (N, )\\r\\n Ny = Y.shape\\r\\n N = Nx[0]\\r\\n M = Nx[1]\\r\\n if Ny[0] != N:\\r\\n raise ValueError('input \\\"X\\\" and \\\"Y\\\" must have the same number of rows')\\r\\n\\r\\n ###########################################################################\\r\\n # Check optional inputs\\r\\n ###########################################################################\\r\\n\\r\\n if not isinstance(Y_Label, str):\\r\\n raise ValueError('\\\"Y_Label\\\" must be a string.')\\r\\n\\r\\n if not X_Labels:\\r\\n X_Labels = [np.nan]*M\\r\\n for i in range(M):\\r\\n X_Labels[i] = 'X' + str(i+1)\\r\\n else:\\r\\n if not isinstance(X_Labels, list):\\r\\n raise ValueError('\\\"X_Labels\\\" must be a list with M elements.')\\r\\n if not all(isinstance(i, str) for i in X_Labels):\\r\\n raise ValueError('Elements in \\\"X_Labels\\\" must be strings.')\\r\\n if len(X_Labels) != M:\\r\\n raise ValueError('\\\"X_Labels\\\" must have M elements.')\\r\\n\\r\\n if not isinstance(ms, (int, np.int8, np.int16, np.int32, np.int64)):\\r\\n raise ValueError('\\\"ms\\\" must be scalar and integer.')\\r\\n if ms <= 0:\\r\\n raise ValueError('\\\"i2\\\" must be positive.')\\r\\n\\r\\n ###########################################################################\\r\\n # Create plot\\r\\n ###########################################################################\\r\\n\\r\\n fig = plt.figure()\\r\\n\\r\\n k = 1\\r\\n for i in range(M-1):\\r\\n for j in range(i+1, M, 1):\\r\\n plt.subplot(M-1, M-1, k)\\r\\n map_plot = plt.scatter(X[:, i], X[:, j], s=ms, c=Y, cmap=colorscale)\\r\\n plt.title(X_Labels[i] + ' vs ' + X_Labels[j], **pltfont)\\r\\n plt.xlim((np.min(X[:, i]), np.max(X[:, i])))\\r\\n plt.ylim((np.min(X[:, j]), np.max(X[:, j])))\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n k = k + 1\\r\\n k = k + i\\r\\n\\r\\n # Create colorbar\\r\\n cax = fig.add_axes([0.92, 0.05, 0.02, 0.8]) # Add axes for the colorbar\\r\\n cb = plt.colorbar(map_plot, ax=cax, fraction=1, extendfrac=1, extendrect=True)\\r\\n cb.set_label(Y_Label, **pltfont)\\r\\n cb.Fontname = pltfont['fontname']\\r\\n cb.ax.tick_params(labelsize=pltfont['fontsize'])\\r\\n # Make axes of the colorbar invisible\\r\\n cax.set_visible(False)\",\n \"def hov_difference(x, y, climits=None, dlimits=None, data_cmap='jet', nclasses=15, cticks=None, cticks_dif=None, ax1=None, ax2=None, ax3=None, rescaley=6, grid=True, rescalex=1, clabel=None, **kwargs):\\n\\n if climits is None:\\n sys.exit('Please specify climits for hovmoeller')\\n if dlimits is None:\\n sys.exit('Please specify dlimits for hovmoeller')\\n\\n fig = plt.figure()\\n if ax1 is None:\\n ax1 = fig.add_subplot(311)\\n if ax2 is None:\\n ax2 = fig.add_subplot(312)\\n if ax3 is None:\\n ax3 = fig.add_subplot(313)\\n\\n #set all invalid data to NAN\\n xdata = x.data\\n ydata = y.data\\n\\n hov1 = hovmoeller(x.num2date(x.time), xdata, rescaley=rescaley, lat=x.lat, rescalex=rescalex)\\n hov2 = hovmoeller(y.num2date(y.time), ydata, rescaley=rescaley, lat=y.lat, rescalex=rescalex)\\n\\n hov1.time_to_lat(**kwargs)\\n hov2.time_to_lat(**kwargs)\\n\\n cmap = plt.cm.get_cmap(data_cmap, nclasses)\\n\\n hov1.plot(title=x._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap, ax=ax1, showcolorbar=False, climits=climits, grid=grid)\\n hov2.plot(title=y._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap, ax=ax2, showcolorbar=False, climits=climits, grid=grid)\\n\\n add_nice_legend(ax1, hov1.im, cmap, cticks=cticks, label=clabel)\\n add_nice_legend(ax2, hov2.im, cmap, cticks=cticks, label=clabel)\\n\\n if x.data.shape == y.data.shape:\\n hov3 = hovmoeller(y.num2date(y.time), x.data - y.data, rescaley=rescaley, lat=y.lat, rescalex=rescalex)\\n hov3.time_to_lat(**kwargs)\\n cmap_diff = plt.cm.get_cmap('RdBu', nclasses)\\n hov3.plot(title=x._get_label() + ' - ' + y._get_label(), ylabel='lat', xlabel='time', origin='lower', xtickrotation=30, cmap=cmap_diff, ax=ax3, showcolorbar=False, climits=dlimits, grid=grid)\\n add_nice_legend(ax3, hov3.im, cmap_diff, cticks=cticks_dif, label=clabel)\\n else:\\n msg = 'Difference plot not possible as data has different shape'\\n ax3.text(0.5, 0.5, msg,\\n horizontalalignment='center',\\n verticalalignment='center') # ,\\n #transform = ax.transAxes)\\n ax3.set_xticks([])\\n ax3.set_yticks([])\\n\\n return fig, hov1, hov2\",\n \"def plot_2nd(self, mod = 'F'):\\n if not mpl: raise \\\"Problem with matplotib: Plotting not possible.\\\"\\n f = plt.figure(figsize=(5,4), dpi=100)\\n \\n A2 = []\\n \\n strainList= self.__structures.items()[0][1].strainList\\n \\n if len(strainList)<=5:\\n kk=1\\n ll=len(strainList)\\n grid=[ll]\\n elif len(strainList)%5 == 0:\\n kk=len(strainList)/5\\n ll=5\\n grid=[5 for i in range(kk)]\\n else:\\n kk=len(strainList)/5+1\\n ll=5\\n grid=[5 for i in range(kk)]\\n grid[-1]=len(strainList)%5\\n \\n \\n n=1\\n m=1\\n for stype in strainList:\\n atoms = self.get_atomsByStraintype(stype)\\n self.__V0 = atoms[0].V0\\n strainList = atoms[0].strainList\\n if self.__thermodyn and mod == 'F':\\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\\n elif self.__thermodyn and mod=='E0':\\n energy = [i.gsenergy for i in atoms]\\n elif self.__thermodyn and mod=='Fvib':\\n energy = [i.phenergy[-1] for i in atoms]\\n else:\\n energy = [i.gsenergy for i in atoms]\\n \\n strain = [i.eta for i in atoms]\\n \\n spl = '1'+str(len(strainList))+str(n)\\n #plt.subplot(int(spl))\\n #a = f.add_subplot(int(spl))\\n if (n-1)%5==0: m=0\\n \\n \\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\\n #print (kk,ll), ((n-1)/5,m)\\n j = 0\\n for i in [2,4,6]:\\n ans = Energy()\\n ans.energy = energy\\n ans.strain = strain\\n ans.V0 = self.__V0\\n \\n fitorder = i\\n ans.set_2nd(fitorder)\\n A2.append(ans.get_2nd())\\n \\n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\\n \\n try:\\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\\n except:\\n continue\\n a.plot(strains, dE, label=str(fitorder))\\n a.set_title(stype)\\n a.set_xlabel('strain')\\n a.set_ylabel(r'$\\\\frac{d^2E}{d\\\\epsilon^2}$ in eV')\\n \\n j+=1\\n \\n n+=1\\n m+=1\\n \\n a.legend(title='Order of fit')\\n return f\",\n \"def plotZM(data, x, y, plotOpt=None, modelLevels=None, surfacePressure=None):\\n # explanation of axes:\\n # ax1: primary coordinate system latitude vs. pressure (left ticks on y axis)\\n # ax2: twinned axes for altitude coordinates on right y axis\\n # axm: small side panel with shared y axis from ax2 for display of model levels\\n # right y ticks and y label will be drawn on axr if modelLevels are given, else on ax2\\n # axr: pointer to \\\"right axis\\\", either ax2 or axm\\n\\n if plotOpt is None: plotOpt = {}\\n labelFontSize = \\\"small\\\"\\n # create figure and axes\\n fig = plt.figure()\\n ax1 = fig.add_subplot(111)\\n # scale data if requested\\n scale_factor = plotOpt.get('scale_factor', 1.0)\\n pdata = data * scale_factor\\n # determine contour levels to be used; default: linear spacing, 20 levels\\n clevs = plotOpt.get('levels', np.linspace(data.min(), data.max(), 20))\\n # map contour values to colors\\n norm=matplotlib.colors.BoundaryNorm(clevs, ncolors=256, clip=False)\\n # draw the (filled) contours\\n contour = ax1.contourf(x, y, pdata, levels=clevs, norm=norm) \\n # mask out surface pressure if given\\n if not surfacePressure is None: \\n ax1.fill_between(x, surfacePressure, surfacePressure.max(), color=\\\"white\\\") \\n # add a title\\n title = plotOpt.get('title', 'Vertical cross section')\\n ax1.set_title(title)\\n # add colorbar\\n # Note: use of the ticks keyword forces colorbar to draw all labels\\n fmt = matplotlib.ticker.FormatStrFormatter(\\\"%g\\\")\\n cbar = fig.colorbar(contour, ax=ax1, orientation='horizontal', shrink=0.8,\\n ticks=clevs, format=fmt)\\n cbar.set_label(plotOpt.get('units', ''))\\n for t in cbar.ax.get_xticklabels():\\n t.set_fontsize(labelFontSize)\\n # set up y axes: log pressure labels on the left y axis, altitude labels\\n # according to model levels on the right y axis\\n ax1.set_ylabel(\\\"Pressure [hPa]\\\")\\n ax1.set_yscale('log')\\n ax1.set_ylim(10.*np.ceil(y.max()/10.), y.min()) # avoid truncation of 1000 hPa\\n subs = [1,2,5]\\n if y.max()/y.min() < 30.:\\n subs = [1,2,3,4,5,6,7,8,9]\\n y1loc = matplotlib.ticker.LogLocator(base=10., subs=subs)\\n ax1.yaxis.set_major_locator(y1loc)\\n fmt = matplotlib.ticker.FormatStrFormatter(\\\"%g\\\")\\n ax1.yaxis.set_major_formatter(fmt)\\n for t in ax1.get_yticklabels():\\n t.set_fontsize(labelFontSize)\\n # calculate altitudes from pressure values (use fixed scale height)\\n z0 = 8.400 # scale height for pressure_to_altitude conversion [km]\\n altitude = z0 * np.log(1015.23/y)\\n # add second y axis for altitude scale \\n ax2 = ax1.twinx()\\n # change values and font size of x labels\\n ax1.set_xlabel('Latitude [degrees]')\\n xloc = matplotlib.ticker.FixedLocator(np.arange(-90.,91.,30.))\\n ax1.xaxis.set_major_locator(xloc)\\n for t in ax1.get_xticklabels():\\n t.set_fontsize(labelFontSize)\\n # draw horizontal lines to the right to indicate model levels\\n if not modelLevels is None:\\n pos = ax1.get_position()\\n axm = fig.add_axes([pos.x1,pos.y0,0.02,pos.height], sharey=ax2)\\n axm.set_xlim(0., 1.)\\n axm.xaxis.set_visible(False)\\n modelLev = axm.hlines(altitude, 0., 1., color='0.5')\\n axr = axm # specify y axis for right tick marks and labels\\n # turn off tick labels of ax2\\n for t in ax2.get_yticklabels():\\n t.set_visible(False)\\n label_xcoor = 3.7\\n else:\\n axr = ax2\\n label_xcoor = 1.05\\n axr.set_ylabel(\\\"Altitude [km]\\\")\\n axr.yaxis.set_label_coords(label_xcoor, 0.5)\\n axr.set_ylim(altitude.min(), altitude.max())\\n yrloc = matplotlib.ticker.MaxNLocator(steps=[1,2,5,10])\\n axr.yaxis.set_major_locator(yrloc)\\n axr.yaxis.tick_right()\\n for t in axr.yaxis.get_majorticklines():\\n t.set_visible(False)\\n for t in axr.get_yticklabels():\\n t.set_fontsize(labelFontSize)\\n # show plot\\n plt.show()\",\n \"def simPlots_comb(loadFile, axes, drug1, drug2):\\n # Read model\\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=False)\\n\\n drug1 += r\\\" ($\\\\mu$M)\\\"\\n drug2 += r\\\" ($\\\\mu$M)\\\"\\n\\n dfplot = pd.DataFrame()\\n dfplot[\\\"confl\\\"] = M.phase.flatten()\\n dfplot[\\\"death\\\"] = M.green.flatten()\\n dfplot[\\\"time\\\"] = np.tile(M.timeV, M.X1.size)\\n dfplot[drug1] = np.round(np.repeat(M.X1, M.timeV.size), decimals=1)\\n dfplot[drug2] = np.round(np.repeat(M.X2, M.timeV.size), decimals=1)\\n\\n ddd = dfplot.loc[dfplot[\\\"time\\\"] == 72.0, :]\\n ddd = ddd.groupby([drug1, drug2, \\\"time\\\"]).mean().reset_index()\\n confldf = ddd.pivot(drug1, drug2, \\\"confl\\\")\\n\\n sns.heatmap(confldf, ax=axes[0], vmin=0.0, square=True, xticklabels=1)\\n axes[0].set_title(\\\"Phase\\\")\\n sns.heatmap(ddd.pivot(drug1, drug2, \\\"death\\\"), ax=axes[3], vmin=0.0, square=True, xticklabels=1)\\n axes[3].set_title(\\\"Annexin V\\\")\\n\\n confl = confldf.to_numpy()\\n confl /= confl[0, 0]\\n confl = 1.0 - confl\\n\\n assert np.all(confl <= 1.0)\\n\\n additive = (confl[:, 0][:, None] + confl[0, :][None, :]) - np.outer(confl[:, 0], confl[0, :])\\n\\n assert np.all(additive <= 1.0)\\n\\n confldf.iloc[:, :] = confl - additive\\n\\n sns.heatmap(confldf, ax=axes[1], cmap=\\\"PiYG\\\", vmin=-0.5, vmax=0.5, square=True, xticklabels=1)\\n axes[1].set_title(\\\"Just Viability\\\")\\n\\n return confldf\",\n \"def plot_multi_axis(time, axes, labels=None, fname=None):\\n fig = plt.figure(figsize=(10, 6))\\n if labels:\\n for i in range(len(axes)):\\n plt.plot(time, axes[i], label=labels[3][i])\\n plt.plot(time, vecnorm(*axes), 'k', label=labels[3][len(axes)])\\n plt.title(labels[0])\\n plt.xlabel(labels[1])\\n plt.ylabel(labels[2])\\n plt.legend(loc='upper left')\\n else:\\n for i in range(len(axes)):\\n plt.plot(time, axes[i])\\n plt.plot(time, vecnorm(axes), 'k')\\n if fname:\\n with open(fname, 'w') as f:\\n mpld3.save_html(fig, f)\",\n \"def getPlotData(integrated):\\n\\tglobal normalized\\n\\tg1 = integrated.split(\\\"_\\\")[0]\\n\\tg2 = integrated.split(\\\"_\\\")[1] \\n\\tcompAxis = []\\n\\twarmthAxis = []\\n\\tgetMappingsWarmth = parser.getMappings(normalized)[0]\\n\\tgetMappingsComp = parser.getMappings(normalized)[1]\\n\\tintWarmthMap, intCompMap = parser.extractInformation(getMappingsWarmth, getMappingsComp)\\n\\n\\t#using mean and standard deviation computed from 18aug16 data: \\n\\tcompAxis.append(intCompMap[g1][0]) #group 1\\n\\tcompAxis.append(intCompMap[g2][0]) #group 2\\n\\n\\tcompAxis.append(intCompMap[integrated][0]) #combined observed\\n\\t\\n\\t#using mean and standard deviation computed from 18aug16 data: \\n\\tcompPrediction = getCombination(float(intCompMap[g1][0]), float(intCompMap[g2][0]), float(intCompMap[g1][1]), float(intCompMap[g2][1]), float(intCompMap[g1][2]), float(intCompMap[g2][2]))\\n\\t\\n\\tcompAxis.append(compPrediction[0]) #combined predicted\\n\\t\\n\\t#using mean and standard deviation computed from 18aug16 data: \\n\\twarmthAxis.append(intWarmthMap[g1][0])\\n\\twarmthAxis.append(intWarmthMap[g2][0])\\n\\t\\n\\twarmthAxis.append(intWarmthMap[integrated][0])\\n\\t\\n\\t#using mean and standard deviation computed from 18aug16 data: \\n\\twarmthPrediction = getCombination(float(intWarmthMap[g1][0]), float(intWarmthMap[g2][0]), float(intWarmthMap[g1][1]), float(intWarmthMap[g2][1]), float(intWarmthMap[g1][2]), float(intWarmthMap[g2][2]))\\n\\t\\n\\twarmthAxis.append(warmthPrediction[0])\\n\\treturn warmthAxis, compAxis\",\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 plot_sensors_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor info and transform loc to fit with headmodel\\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 = []\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 = []\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n \\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def figure_2_combined_cross_sections(crange=CRANGE, koffrange=KOFFRANGE,\\n scale_factor=alpha, label_style=0):\\n def combined_error_c(ctilde, z, scale_factor=scale_factor):\\n c = ctilde * c0\\n koff = z * KP\\n x = c * KON / koff\\n num = 2 * KP * x + koff * KP * T * (1 + x) ** 3 + koff ** 2 * T * x ** 2 * (1 + x) ** 3\\n den = koff ** 2 * KP * T ** 2 * x * (1 + x) ** 2\\n val = num / den\\n return scale_factor * val\\n def combined_error_koff(ctilde, z, scale_factor=scale_factor):\\n c = ctilde * c0\\n koff = z * KP\\n x = c * KON / koff\\n num = 2 * KP * x + koff * KP * T * (1 + x) ** 3 + koff**2 * T * (1 + x) ** 3\\n den = koff ** 2 * KP * T**2 * x * (1 + x) ** 2\\n val = num / den\\n return scale_factor * val\\n\\n def cross_section_combined_error_c():\\n arr = [combined_error_c(cval, 1) for cval in crange]\\n return dict({'xpts': crange, 'ypts':arr})\\n def cross_section_combined_error_koff():\\n arr = [combined_error_koff(c, 1) for c in crange]\\n return dict({'xpts': koffrange, 'ypts':arr})\\n\\n figname = 'combined_error_cross_sections'\\n curve1 = cross_section_combined_error_c()\\n curve2 = cross_section_combined_error_koff()\\n # plot\\n plt.figure(figsize=(3, 3))\\n ax1 = plt.gca()\\n ax2 = ax1.twiny()\\n\\n if label_style == 0:\\n ln1 = ax1.plot(curve1['xpts'], curve1['ypts'], color=cs['simple_fisher'], label=r'$c$', zorder=1)\\n ln2 = ax2.plot(curve2['xpts'], curve2['ypts'], color=cs['heuristic'], label=r'$k_{\\\\mathrm{off}}$', zorder=1)\\n #plt.title('Mode 2: MLE relative error comparison\\\\n' + r'($\\\\tilde{c}_0=10$, $\\\\alpha=1 \\\\times 10^4$, $k_{p}=10$)')\\n\\n elif label_style == 1:\\n ln1 = ax1.plot(curve1['xpts'], curve1['ypts'], color=cs['simple_fisher'], label=r'$\\\\delta c^{2}/c^{2}$', zorder=1)\\n ln2 = ax2.plot(curve2['xpts'], curve2['ypts'], color=cs['heuristic'],label=r'$\\\\delta k_{\\\\mathrm{off}}^{2}/k_{\\\\mathrm{off}}^{2}$', zorder=1)\\n plt.title('Mode 2: MLE relative error comparison\\\\n' + r'($k_p=10$, $t=100$, $k_{\\\\mathrm{off}}=k_{\\\\mathrm{on}}=1$)')\\n plt.ylabel(r'$\\\\langle\\\\delta (\\\\cdot)^{2}\\\\rangle$/$(\\\\cdot)^{2}$')\\n\\n # axis\\n ax1.set_xlabel(r'$k_{\\\\mathrm{on}}c/k_{p}$')\\n ax1.set_ylabel(r'$k_{p}t \\\\langle\\\\delta (\\\\cdot)^{2}\\\\rangle$/$(\\\\cdot)^{2}$')\\n #ax2.set_xlabel(r'$k_{\\\\mathrm{off}}$')\\n\\n ax1.set_xscale('log')\\n ax2.set_xscale('log')\\n ax1.set_xlim([1E-2, 1E2])\\n ax2.set_xlim([1E-2, 1E2])\\n plt.ylim([0, 0.01*alpha])\\n\\n lns = ln1 + ln2\\n labs = [l.get_label() for l in lns]\\n ax1.legend(lns, labs)\\n\\n plt.tight_layout()\\n # save figure\\n plt.savefig(DIR_OUTPUT + os.sep + figname + '.pdf', transparent=True)\\n plt.savefig(DIR_OUTPUT + os.sep + figname + '.eps')\",\n \"def axes(*x: Iterable[int]):\\n return [_ti_core.Axis(i) for i in x]\",\n \"def plot_subplots(x_list, y_list, z_list):\\n # create a line chart with the average rating of the top movies per year\\n # min rating = 0 and max = 10\\n plot1 = plt.subplot(211)\\n plt.plot(x_list, y_list, color = 'lightseagreen')\\n plt.axis([START_YEAR, END_YEAR - 1, 0, 10])\\n plt.title('Average IMDB Movie Rating per Year', fontsize=12)\\n plt.ylabel('Average Rating')\\n plt.grid(True)\\n\\n # make x ticklabels of plot1 invisible\\n plt.setp(plot1.get_xticklabels(), visible=False)\\n\\n # adjust space between subplots\\n plt.subplots_adjust(hspace=0.3)\\n\\n # create a line chart with the average runtime with shared x-axis\\n plot2 = plt.subplot(212, sharex=plot1)\\n plt.plot(x_list, z_list, color = 'lightseagreen')\\n plt.title('Average IMDB Movie Runtime per Year', fontsize=12)\\n plt.ylabel('Average Runtime (min)')\\n plt.grid(True)\\n\\n # define axes, with all years (2008 till 2017) on the x-axis\\n # min runtime = 0, max runtime = 180\\n plt.axis([START_YEAR, END_YEAR - 1, 0, 180])\\n plt.xticks(x_list)\\n plt.xlabel('Year')\\n\\n # plot both the subplots\\n plt.show()\",\n \"def CombinedPlotHelper(self,minc=70,maxc=120,num=25):\\n levels = np.linspace(minc,maxc,num+1)\\n title = textwrap.dedent(\\\"\\\"\\\"\\\\\\n Orography difference between LGM and Modern ICE-5G data\\n using {0} meter contour interval\\\"\\\"\\\").format((maxc-minc)/num)\\n plt.figure()\\n ax = plt.subplot(111)\\n contourset = plt.contourf(self.difference_in_ice_5g_orography,\\n levels=levels,hold=True)\\n cbar = plt.colorbar()\\n cbar.ax.set_ylabel('Orography difference in meters')\\n plt.contour(self.difference_in_ice_5g_orography,levels=contourset.levels,\\n colors='black',hold=True)\\n ufcntr = plt.contourf(self.difference_in_ice_5g_orography,\\n levels=[np.min(self.difference_in_ice_5g_orography),minc],\\n colors='white',\\n hatches=['/'],hold=True)\\n ofcntr = plt.contourf(self.difference_in_ice_5g_orography,\\n levels=[maxc,np.max(self.difference_in_ice_5g_orography)],\\n colors='white',\\n hatches=['\\\\\\\\'],hold=True)\\n ufartists,uflabels = ufcntr.legend_elements() #@UnusedVariable\\n ofartists,oflabels = ofcntr.legend_elements() #@UnusedVariable\\n uflabels=['Difference $\\\\\\\\leq {0}$'.format(minc)]\\n oflabels=['${0} <$ Difference'.format(maxc)]\\n artists = ufartists + ofartists\\n labels = uflabels + oflabels\\n plt.title(title)\\n pts.set_ticks_to_zero()\\n axbounds = ax.get_position()\\n #Shrink box by 5%\\n ax.set_position([axbounds.x0,axbounds.y0 + axbounds.height*0.05,\\n axbounds.width,axbounds.height*0.95])\\n ax.legend(artists,labels,loc='upper center',\\n bbox_to_anchor=(0.5,-0.025),fancybox=True,ncol=2)\\n #if self.save:\\n #plt.savefig('something')\\n print(\\\"Combined plot created\\\")\",\n \"def problemTwo(self):\\n # Initialize plot figure\\n plot_2 = plt.figure(figsize=(18, 20 ))\\n plot_2.subplots_adjust(left=.08, right=.97, top=.97, bottom=.07)\\n mv = plot_2.add_subplot(1, 1, 1)\\n plt.tick_params(labelsize=20)\\n mv.set_xlabel('$\\\\\\\\frac{(y-y_o)}{D}$', fontsize=36)\\n mv.set_ylabel('$\\\\\\\\frac{u(y)}{U_{\\\\infty}}$', fontsize=36)\\n mv.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 self.y_pos = self.data[file]['y pos'].tolist()\\n # Calc the v_inf for the 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 # Plot the mean velocity\\n mv.plot(y_pos_nondim_hot, hot_nondim, color=self.plot_color[index], label=f'Hotwire @ {file}mm', linewidth=3)\\n mv.plot(y_pos_nondim_pitot, pitot_nondim, color=self.plot_color[index], label=f'Pitot @ {file}mm', linestyle='--', linewidth=2)\\n mv.legend(loc='lower right', fontsize=22)\\n plot_2.savefig(os.path.join(os.getcwd(), r'plots\\\\prob2'))\\n plt.draw()\",\n \"def get_y_lims(ax, xlims):\\n # Assuming that all objects have the same x coordinates\\n x = ax.lines[0].get_data()[0]\\n\\n indexes = get_interval(x, xlims[0], xlims[1])\\n xmax = x[indexes[-1]]\\n xmin = x[indexes[0]]\\n\\n ymax_array = []\\n ymin_array = []\\n\\n for function in ax.lines:\\n y = function.get_data()[1]\\n\\n ymin_array.append(np.min(y[indexes]))\\n ymax_array.append(np.max(y[indexes]))\\n\\n ymax = max(ymax_array)\\n ymin = min(ymin_array)\\n\\n return xmin, xmax, ymin, ymax\",\n \"def pacf_plots(self):\\n fig, axes = plt.subplots(3, 2, figsize=(20, 9), sharex=False)\\n #\\n axes[0, 0].plot(self.ts_df['y'])\\n axes[0, 0].set_title('Original Series')\\n plot_pacf(self.ts_df['y'], ax=axes[0, 1])\\n\\n # 1st Differencing\\n axes[1, 0].plot(self.ts_df['y'].diff())\\n axes[1, 0].set_title('1st Order Differencing')\\n # axes[0].set(ylim=(0, 5))\\n plot_pacf(self.ts_df['y'].diff().dropna(), ax=axes[1, 1])\\n\\n # 2nd Differencing\\n axes[2, 0].plot(self.ts_df['y'].diff().diff())\\n axes[2, 0].set_title('2nd Order Differencing')\\n plot_pacf(self.ts_df['y'].diff().diff().dropna(), ax=axes[2, 1])\\n\\n plt.gcf().autofmt_xdate()\\n plt.grid(True)\\n plt.show()\",\n \"def axhlines(ys, xmin=0, xmax=1, **kwargs):\\n if \\\"transform\\\" in kwargs:\\n raise ValueError(\\\"'transform' is not allowed as a kwarg;\\\"\\n + \\\"axhlines generates its own transform.\\\")\\n\\n # prepare data\\n ys = np.array((ys, ) if np.isscalar(ys) else ys, copy=False)\\n xmins = np.array((xmin, ) if np.isscalar(xmin) else xmin, copy=False)\\n xmaxs = np.array((xmax, ) if np.isscalar(xmax) else xmax, copy=False)\\n\\n if len(ys) > 1:\\n if len(xmins) == 1:\\n xmins = np.repeat(xmins, len(ys))\\n if len(xmaxs) == 1:\\n xmaxs = np.repeat(xmaxs, len(ys))\\n\\n if len(xmins) != len(xmaxs) or len(xmins) != len(ys):\\n raise ValueError(\\\"Incompatible data\\\")\\n\\n # prepare the ax\\n ax = kwargs.pop('ax', None)\\n if ax is None:\\n ax = plt.gca()\\n\\n # prepare colors\\n colors = kwargs.pop('colors', None)\\n if colors is None:\\n cycle_props = next(ax._get_lines.prop_cycler)\\n colors = cycle_props.pop('color', None)\\n\\n # prepare trans\\n trans = ax.get_yaxis_transform(which='grid')\\n # prepare lines\\n lines = [\\n ([xmin, y], [xmax, y])\\n for xmin, xmax, y in zip(xmins, xmaxs, ys)\\n ]\\n lc = LineCollection(lines, transform=trans, colors=colors, **kwargs)\\n ax.add_collection(lc)\\n ax.autoscale_view(scalex=False, scaley=True)\\n\\n return lc\",\n \"def TwoImmedSpectraPlot(Xax, Ydat1, Ydat2, Label1, Label2, xmin, xmax, ymin, ymax,\\n XLab, YLab, SupTitle, Title, FileName, currentDate, currentTime, Software_version):\\n plt.figure()\\n rc('font', size=8, weight='normal')\\n plt.plot(Xax, Ydat1, color='r', linestyle='-', linewidth='1.00', label=Label1)\\n plt.plot(Xax, Ydat2, color='b', linestyle='-', linewidth='1.00', label=Label2)\\n plt.axis([xmin, xmax, ymin, ymax])\\n plt.xlabel(XLab)\\n plt.ylabel(YLab)\\n plt.suptitle(SupTitle, fontsize=9, fontweight='bold')\\n plt.title(Title, fontsize=7, x=0.46, y=1.005)\\n plt.grid(visible=True, which='both', color='0.00', linestyle='--')\\n plt.legend(loc='upper right', fontsize=8)\\n plt.text(0.7, 0.03, 'Processed ' + currentDate + ' at ' + currentTime,\\n fontsize=5, transform=plt.gcf().transFigure)\\n plt.text(0.03, 0.03, 'Software version: ' + Software_version + ' yerin.serge@gmail.com, IRA NASU',\\n fontsize=5, transform=plt.gcf().transFigure)\\n pylab.savefig(FileName, bbox_inches='tight', dpi=160)\\n plt.close('all')\\n return 0\",\n \"def setX(ax1: Union[object, List], ax2: Union[object, List]):\\n if type(ax1) is list:\\n print(\\\"PlotHelpers: cannot use list as source to set Y axis\\\")\\n return\\n ax2 = _ax_tolist(ax2)\\n # if type(ax2) is not list:\\n # ax2 = [ax2]\\n refx = ax1.get_xlim()\\n for ax in ax2:\\n ax.set_xlim(refx)\",\n \"def plot(self, noTLS, path_plots, interactive):\\n fig = plt.figure(figsize=(10,12))\\n ax1 = fig.add_subplot(4, 1, 1)\\n ax2 = fig.add_subplot(4, 1, 2)\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax4 = fig.add_subplot(4, 2, 6)\\n ax5 = fig.add_subplot(4, 2, 7)\\n ax6 = fig.add_subplot(4, 2, 8)\\n\\n # First panel: data from each sector\\n colors = self._get_colors(self.nlc)\\n for i, lci in enumerate(self.alllc):\\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\\n ax1.legend(fontsize='small', ncol=4)\\n\\n # Second panel: Detrended light curve\\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\\n color='black',\\n label='Detrended')\\n\\n # Third panel: BLS\\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\\n mean_SR = np.mean(self.BLS.power)\\n std_SR = np.std(self.BLS.power)\\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\\n SDE = (best_power - mean_SR)/std_SR\\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\\n for n in range(2, 10):\\n if n*self.BLS.period_max <= max(self.BLS.period.value):\\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n sx, ex = ax3.get_xlim()\\n sy, ey = ax3.get_ylim()\\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.2f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nSDE = %.3f' %\\n (self.BLS.period_max, self.BLS.t0_max,\\n self.BLS.depth_max, self.BLS.duration_max, SDE))\\n\\n\\n # Fourth panel: lightcurve folded to the best period from the BLS\\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\\n marker='.', alpha=0.5)\\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n\\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\\n duration=self.BLS.duration_max,\\n transit_time=self.BLS.t0_max)\\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\\n ax4.set_xlim(-l, l)\\n h = max(lc_model.flux)\\n l = min(lc_model.flux)\\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n del lc_model, lc_model_folded, r1, dt1\\n\\n\\n if not noTLS:\\n # Fifth panel: TLS periodogram\\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\\n for n in range(2, 10):\\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.set_ylabel(r'SDE')\\n ax5.set_xlabel('Period (days)')\\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\\n ax5.set_xlim(0, max(self.tls.periods))\\n\\n period_tls = self.tls.period\\n T0_tls = self.tls.T0\\n depth_tls = self.tls.depth\\n duration_tls = self.tls.duration\\n FAP_tls = self.tls.FAP\\n\\n sx, ex = ax5.get_xlim()\\n sy, ey = ax5.get_ylim()\\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.1f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nFAP = %.4f' %\\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\\n\\n # Sixth panel: folded light curve to the best period from the TLS\\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\\n alpha=0.5, ls='None', markersize=0.7)\\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\\n x0=0.0, nbins=nbins, useBinCenter=True)\\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\\n ax6.set_xlim(0.5-l, 0.5+l)\\n h = max(self.tls.model_folded_model)\\n l = min(self.tls.model_folded_model)\\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n ax6.set_xlabel('Phase')\\n ax6.set_ylabel('Relative flux')\\n del r1, dt1\\n\\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\\n if interactive:\\n plt.show()\\n plt.close('all')\\n del fig\",\n \"def plot():\\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\\n\\n matplotlib.rcParams.update({'font.size': 18})\\n fig, axes = plt.subplots(\\n 1, 3,\\n figsize=(6.25 * 3, 5),\\n gridspec_kw={'wspace': 0.3}\\n )\\n\\n ax = axes[0]\\n ax.plot(ts, us[:, lin_model.inputs[1]], 'k')\\n ax.plot(ts, us[:, lin_model.inputs[0]], 'k--')\\n\\n ax.set_title(r'Inputs')\\n ax.set_ylabel(r'$\\\\frac{L}{min}$')\\n ax.set_xlabel(r't ($min$)')\\n ax.legend([r'$F_{m, in}$', r'$F_{G, in}$'])\\n ax.set_xlim([0, ts[-1]])\\n\\n ax = axes[1]\\n ax.plot(ts, ys[:, 2], 'k')\\n ax.plot(ts, ys[:, 0], 'grey')\\n ax.plot(ts, ys[:, 3], 'k--')\\n\\n ax.set_title(r'Outputs')\\n ax.set_ylabel(r'$\\\\frac{mg}{L}$')\\n ax.set_xlabel(r't ($min$)')\\n ax.set_xlim([0, ts[-1]])\\n ax.legend([r'$C_{FA}$', r'$C_{G}$', r'$C_{E}$'])\\n\\n ax.axhline(lin_model.yd2n(K.ysp)[1], color='red')\\n ax.axhline(lin_model.yd2n(K.ysp)[0], color='red', linestyle='--')\\n\\n ax = axes[2]\\n ax.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 1],\\n 'k'\\n )\\n ax.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 0],\\n 'k--'\\n )\\n ax.legend([r'$C_{FA}$', r'$C_G$'])\\n ax.set_title('bias')\\n ax.set_ylabel(r'$\\\\frac{mg}{L}$')\\n ax.set_xlabel(r't ($min$)')\\n ax.set_xlim([0, ts[-1]])\\n\\n # plt.suptitle('Closedloop bioreactor without noise')\\n # plt.tight_layout(rect=[0, 0.03, 1, 0.95])\\n plt.savefig('no_noise.pdf', bbox_inches='tight')\\n plt.show()\",\n \"def llcm_plot():\\n x = np.arange(0, 10, 0.5) # x in [0, 10)\\n y_1 = 2**x\\n y_2 = x**2\\n\\n plt.figure()\\n # specify color, linestyle, and marker w/ keyword argument\\n # plt.plot(x, y_1, label='$2^x$', color='g', linestyle='--', marker='o')\\n plt.plot(x, y_1, 'g--o', label='$2^x$')\\n # plt.plot(x, y_2, label='$x^2$', color='r', linestyle='-', marker='*')\\n plt.plot(x, y_2, 'r-*', label='$x^2$')\\n plt.xlabel('$x$')\\n plt.ylabel('$y$')\\n plt.legend(loc='upper left')\\n plt.title('Line plots w/ Legend, linestyle, color, and marker')\\n plt.show()\\n\\n\\n return None\",\n \"def emission_vs_depth(filename,**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(); c = 'r'\\n if not p.add:\\n fig,ax = plt.subplots(figsize=(8,6)); c = 'b'\\n st_cols = ['depth','[CII]158','[OI]63','CO(1-0)','CO(2-1)','CO(3-2)']\\n st = pd.read_csv(p.d_cloudy.replace('ext/','') + 'NH/' + filename + '.str',sep='\\\\t',skiprows=1,names=st_cols)\\n dx = np.append(0,np.diff(st.depth))\\n pc2cm = u.parsec.to(u.cm)\\n # Derive mass-luminosity ratio\\n import astropy.constants as c\\n M = 1e3 * c.m_p.value * st.depth.values.max() / u.M_sun.to(u.kg) \\n cloudy_lin_header = ['#lineslist','C 1 609.590m','C 1 370.269m','C 2 157.636m','O 1 63.1679m','O 1 145.495m','O 3 88.3323m','N 2 205.244m','N 2 121.767m','CO 2600.05m','CO 1300.05m','CO 866.727m','CO 650.074m','CO 325.137m','H2 17.0300m','H2 12.2752m','H2 9.66228m','H2 8.02362m','H2 6.90725m','H2 6.10718m','H2 5.50996m','O 4 25.8832m','NE 2 12.8101m','NE 3 15.5509m','S 3 18.7078m','FE 2 25.9811m']\\n cloudy_lin = pd.read_csv(p.d_cloudy.replace('ext/','') + 'NH/' + filename + '.lin',\\\\\\n sep='\\\\t',names=cloudy_lin_header,comment='#').reset_index(drop=True)\\n Cloudy_lines_dict = aux.get_Cloudy_lines_dict()\\n cloudy_lin = cloudy_lin.rename(columns=Cloudy_lines_dict)\\n L = cloudy_lin['CO(1-0)'][0] * u.erg.to('J') / c.L_sun.value\\n print(L,M)\\n ax.plot(st.depth/pc2cm,dx*st['CO(1-0)'],'-',color='m',label='CO(1-0): %.2e Lsun/Msun' % (L/M))\\n L = cloudy_lin['[OI]63'][0] * u.erg.to('J') / c.L_sun.value\\n print(L,M)\\n ax.plot(st.depth/pc2cm,dx*st['[OI]63'],'g--',label='[OI]63: %.2e Lsun/Msun' % (L/M))\\n ax.set_yscale(\\\"log\\\")\\n ax.set_xscale(\\\"log\\\")\\n ax.set_xlabel('Depth [pc]')\\n ax.set_ylabel('Intensity [ergs/s/cm^2]')\\n ax.legend()\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'look-up/'): os.mkdir(p.d_plot + 'look-up/') \\n plt.savefig('plots/look-up/emission_%s' % filename,dpi=200)\",\n \"def drawLine2P(x,y,xlims):\\n \\n xrange = np.arange(xlims[0],xlims[1],1)\\n A = np.vstack([x, np.ones(len(x))]).T\\n k, b = np.linalg.lstsq(A, y, rcond=None)[0]\\n return [xrange, k*xrange + b]\",\n \"def scatter_and_line():\\n\\n # Make random data points around straight line\\n random_linear = np.zeros((1000,2))\\n random_linear[:,0] = np.random.uniform(0,10,1000)\\n random_error = np.random.normal(0.0,2.0,1000)\\n random_linear[:,1] = random_linear[:,0]*2.0+1.0+random_error\\n\\n # Make datasets, order determining line graph on top\\n dataset_a = DataSet(random_linear,plot='scatter',order=0,label='Random')\\n dataset_b = DataSet(linear,plot='line',colour='black',order=1,label='Linear')\\n\\n # Colour scatter graph by error\\n dataset_a.set_colour(map='coolwarm',colour=random_error)\\n\\n # Make plot object and add datasets\\n plot = Plot()\\n plot.set_text(latex=True)\\n plot.add_dataset(dataset_a)\\n plot.add_dataset(dataset_b)\\n plot.set_legend(legend=True)\\n\\n # Plot graph and display\\n plot.plot()\\n plot.save(name='./figures/2d_scatter_and_line',fmt='png')\\n plot.display()\",\n \"def plotDataForIndices(monthlyData, indices, usedEfficiencies, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices[energyType])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange], label = 'optimized for H', color='r')\\n plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange], label = 'optimized for C', color='b')\\n plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange], label = 'optimized for L', color='g')\\n plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange], label = 'optimized for PV', color='c')\\n plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange], label = 'optimized for HCL', color='m')\\n plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange], label = 'optimized for E_tot', color='k')\\n plt.plot(multiplier*monthlyData[energyType][indices['PVC'], dummyRange], label = 'optimized for PV and C', color='b', alpha = 0.5)\\n if not indices['45']==None:\\n plt.plot(multiplier*monthlyData[energyType][indices['45'], :], label = 'fixed at 45 deg', color='y')\\n plt.ylabel('Energy [kWh]')\\n plt.xlim(0,288)\\n\\n# plt.legend()\\n \\n # Shrink current axis by 20%\\n box = ax1.get_position()\\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\\n \\n # Put a legend to the right of the current axis\\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(4)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which=u'major')\\n \\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\\n\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\\n plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\\n plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\\n plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\\n plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\\n plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\\n plt.plot(multiplier*monthlyData[energyType][indices['PVC'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV and C', color='b', alpha = 0.5)\\n if not indices['45']==None:\\n plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\\n plt.ylabel('Energy Difference [kWh]')\\n# plt.legend()\\n plt.xlim(0,288)\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which=u'major')\\n \\n box = ax2.get_position()\\n ax2.set_position([box.x0, box.y0, box.width * 0.8, box.height])\\n \\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\\n\\n \\n return fig\",\n \"def plot_failure_function_2D(self, index_x, index_y, range_x, offset_scale=1):\\n\\n smbl_x = self.symbols[index_x]\\n smbl_y = self.symbols[index_y]\\n print(\\\"x = \\\", smbl_x, \\\"\\\\ny = \\\", smbl_y)\\n\\n # Determine the y value that belongs to z = 0 and x = variable.\\n # substitute the mean values and create a substitution dict.\\n mean = list(self.mean)\\n symbols = list(self.symbols)\\n # The value of y should not be included as it needs te be solved.\\n del mean[index_y]\\n del symbols[index_y]\\n sub = dict(zip(symbols, mean))\\n\\n # Determine the y values\\n y = []\\n y_fail = []\\n y_no_fail = []\\n for x in range_x:\\n if x == 0:\\n x += 0.01\\n # Update x\\n sub[smbl_x] = x\\n y.append(solve(self.z.subs(sub), smbl_y)[0])\\n\\n offset = max(y) * offset_scale\\n z_fail = self.z + offset\\n z_no_fail = self.z - offset\\n\\n for x in range_x:\\n if x == 0:\\n x += 0.01\\n # Update x\\n sub[smbl_x] = x\\n y_fail.append(solve(z_fail.subs(sub), smbl_y)[0])\\n y_no_fail.append(solve(z_no_fail.subs(sub), smbl_y)[0])\\n\\n plt.xlabel(\\\"variable: \\\" + smbl_x)\\n plt.ylabel(\\\"variable: \\\" + smbl_y)\\n plt.plot(range_x, y, label=\\\"z = 0\\\", color=\\\"blue\\\")\\n plt.plot(range_x, y_fail, label=\\\"fail_side\\\", color=\\\"red\\\")\\n plt.plot(range_x, y_no_fail, label=\\\"no_fail_side\\\", color=\\\"green\\\")\\n plt.legend()\\n plt.show()\",\n \"def viz_2D_topomap_intra (epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray,\\n threshold: float=0.95, steps: int=2,\\n lab: bool = False):\\n\\n # defining head model and adding sensors\\n fig = plt.figure()\\n ax = fig.add_subplot(111, aspect = 1)\\n ax.axis(\\\"off\\\")\\n plot_2d_topomap_intra(ax)\\n # bads are represented as squares\\n plot_sensors_2d_intra(epo1, epo2, lab = lab)\\n # plotting links according to sign (red for positive values,\\n # blue for negative) and value (line thickness increases\\n # with the strength of connectivity)\\n plot_links_2d_intra(epo1, epo2, C1=C1, C2=C2, threshold=threshold, steps=steps)\\n plt.tight_layout()\\n plt.show()\\n\\n return (ax)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57410544","0.57360107","0.5571669","0.55329823","0.5515343","0.54836935","0.5431624","0.5425385","0.5408111","0.5307821","0.5279651","0.5267647","0.52437675","0.52202445","0.51879686","0.5187689","0.51863897","0.5173515","0.51703244","0.5135122","0.5129557","0.5126211","0.5114361","0.51135707","0.5112207","0.51084524","0.5105865","0.5095333","0.50933015","0.508934","0.50757","0.5068307","0.50655556","0.50587535","0.50536525","0.5044922","0.5043651","0.50343657","0.5029098","0.50156194","0.5012354","0.4995906","0.49953592","0.49941313","0.49927923","0.49898827","0.49776512","0.49776435","0.49741605","0.4973675","0.4970992","0.49666584","0.49661842","0.49602306","0.4958086","0.49558613","0.49545404","0.49529073","0.4951051","0.49447107","0.4939706","0.49394515","0.49383777","0.49314016","0.49282962","0.49187917","0.49147218","0.4908163","0.48991475","0.48977572","0.48952982","0.48943675","0.48918357","0.48904267","0.48792097","0.48781523","0.48760265","0.4870114","0.48683292","0.48632476","0.4858631","0.48573348","0.48552853","0.48486215","0.48453525","0.48434594","0.4842728","0.48404872","0.4839464","0.4836494","0.48331746","0.48324686","0.4832098","0.48303214","0.48279753","0.48263064","0.482215","0.4820212","0.48189494","0.4818012"],"string":"[\n \"0.57410544\",\n \"0.57360107\",\n \"0.5571669\",\n \"0.55329823\",\n \"0.5515343\",\n \"0.54836935\",\n \"0.5431624\",\n \"0.5425385\",\n \"0.5408111\",\n \"0.5307821\",\n \"0.5279651\",\n \"0.5267647\",\n \"0.52437675\",\n \"0.52202445\",\n \"0.51879686\",\n \"0.5187689\",\n \"0.51863897\",\n \"0.5173515\",\n \"0.51703244\",\n \"0.5135122\",\n \"0.5129557\",\n \"0.5126211\",\n \"0.5114361\",\n \"0.51135707\",\n \"0.5112207\",\n \"0.51084524\",\n \"0.5105865\",\n \"0.5095333\",\n \"0.50933015\",\n \"0.508934\",\n \"0.50757\",\n \"0.5068307\",\n \"0.50655556\",\n \"0.50587535\",\n \"0.50536525\",\n \"0.5044922\",\n \"0.5043651\",\n \"0.50343657\",\n \"0.5029098\",\n \"0.50156194\",\n \"0.5012354\",\n \"0.4995906\",\n \"0.49953592\",\n \"0.49941313\",\n \"0.49927923\",\n \"0.49898827\",\n \"0.49776512\",\n \"0.49776435\",\n \"0.49741605\",\n \"0.4973675\",\n \"0.4970992\",\n \"0.49666584\",\n \"0.49661842\",\n \"0.49602306\",\n \"0.4958086\",\n \"0.49558613\",\n \"0.49545404\",\n \"0.49529073\",\n \"0.4951051\",\n \"0.49447107\",\n \"0.4939706\",\n \"0.49394515\",\n \"0.49383777\",\n \"0.49314016\",\n \"0.49282962\",\n \"0.49187917\",\n \"0.49147218\",\n \"0.4908163\",\n \"0.48991475\",\n \"0.48977572\",\n \"0.48952982\",\n \"0.48943675\",\n \"0.48918357\",\n \"0.48904267\",\n \"0.48792097\",\n \"0.48781523\",\n \"0.48760265\",\n \"0.4870114\",\n \"0.48683292\",\n \"0.48632476\",\n \"0.4858631\",\n \"0.48573348\",\n \"0.48552853\",\n \"0.48486215\",\n \"0.48453525\",\n \"0.48434594\",\n \"0.4842728\",\n \"0.48404872\",\n \"0.4839464\",\n \"0.4836494\",\n \"0.48331746\",\n \"0.48324686\",\n \"0.4832098\",\n \"0.48303214\",\n \"0.48279753\",\n \"0.48263064\",\n \"0.482215\",\n \"0.4820212\",\n \"0.48189494\",\n \"0.4818012\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63710725"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19892,"cells":{"query":{"kind":"string","value":"Not much tested I decided against doing overlapping line plots this way. The input arguments are two axes (AbstractAxis class), as compatible as necessary for the following to be sensible. This function has 3 return values. It returns a TransientAxis which includes all the points of the input axes. It may be one of the inputs. It also returs index information from which one can determine whether a point of the new axis came from axis1 or axis2 or both."},"document":{"kind":"string","value":"def common_axis( axis1, axis2 ):\n if hasattr( axis1, 'units' ):\n units1 = axis1.units.lower().replace(' ','_')\n if axis1.isTime():\n axis1.toRelativeTime( units1 ) #probably will change input argument\n else:\n units1 = None\n if hasattr( axis2, 'units' ):\n units2 = axis2.units.lower().replace(' ','_')\n else:\n units2 = None\n if units1!=None and units2!=None and units1 != units2:\n if axis1.isTime() and axis2.isTime():\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\n else:\n print \"ERROR. common_axis does not yet support differing units\",axis1.units,\" and \",axis2.units\n return None\n if axis1.isTime() or axis2.isTime():\n if not axis2.isTime() or not axis1.isTime():\n print \"ERROR. In common_axis, one axis is time, not the other\"\n return None\n if not axis1.calendar==axis2.calendar:\n print \"ERROR. common_axis does not yet support differing calendars.\"\n if len(axis1)==1 and len(axis2)==1:\n # There's just one time value, probably from averaging over time. The time value is meaningless\n # but it would be messy to have two.\n return (axis1,[0],[0])\n\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\n # units and calendar attributes should always be transferred if present.\n # Also to do: use bounds if available\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\n a1indexina3 = a12indexina3[0:len(axis1)]\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\n\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\n vid = axis1.id\n else:\n vid = None\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\n axis3.units = units1\n return (axis3,a1indexina3,a2indexina3)"},"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 common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n axes3.append(common_axis( axes1[i], axes2[i] ))\n return axes3","def _make_twin_axes(self, *args, **kwargs):\n # Typically, SubplotBase._make_twin_axes is called instead of this.\n # There is also an override in axes_grid1/axes_divider.py.\n if 'sharex' in kwargs and 'sharey' in kwargs:\n raise ValueError('Twinned Axes may share only one axis.')\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\n self.set_adjustable('datalim')\n ax2.set_adjustable('datalim')\n self._twinned_axes.join(self, ax2)\n return ax2","def intersection(self, axis2):","def _find_axes(cls, input_data, explicit_x=None):\n\n if isinstance(input_data, pd.Series):\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a pandas Series\")\n\n return input_data.index, input_data.values\n elif isinstance(input_data, pd.DataFrame):\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a pandas DataFrame\")\n\n return input_data.index, input_data.values[:, 0]\n elif isinstance(input_data, np.ndarray):\n if len(input_data.shape) == 2 and input_data.shape[0] == 2:\n if explicit_x is not None:\n raise ArgumentError(\"You cannot pass an explicit x axis with a 2D array of input data\")\n\n return input_data[:, 0], input_data[:, 1]\n elif len(input_data.shape) == 1:\n if explicit_x is not None:\n if len(explicit_x) != len(input_data):\n raise ArgumentError(\"Your explicit x data has a different length that your y data\", x_length=len(explicit_x), y_length=len(input_data))\n\n return explicit_x, input_data\n else:\n return np.linspace(0, len(input_data) - 1, len(input_data)), input_data\n elif explicit_x is not None:\n return np.array(explicit_x), np.array(explicit_x)\n\n return np.linspace(0, len(input_data) - 1, len(input_data)), np.array(input_data)","def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb","def axes2indices(\n self,\n axes:'Union['\n 'Tuple[Union[ConvertableAxisClass, ellipsis], ...], '\n 'Mapping[NamedIndex, ConvertableAxisClass],'\n ']',\n )->'Any':\n\n if isinstance(axes, dict):\n indices = []\n for dim, axes_ in self.items():\n axis = axes.get(dim)\n if axis is None and dim in axes:\n warnings.warn(f'it does not make sense using None(at dim {dim!r}) '\n 'in a named index, it whould be translated into '\n 'slice(None)(i.e. :)')\n index = slice(None) if axis is None else axis2index(axes_, axis)\n indices.append(index)\n return tuple(indices)\n\n axes = axes if isinstance(axes, tuple) else (axes, )\n idx_elps = naxis = len(axes)\n for idx_axis, axis in enumerate(axes):\n if isinstance(axis, type(Ellipsis)):\n assert idx_elps == naxis, 'more than one ellipsis is not allowed'\n\n idx_elps = idx_axis\n\n indices = []\n idx_axis = idx_dim = 0\n while idx_axis < idx_elps:\n axis = axes[idx_axis]\n index = None if axis is None else axis2index(self._dim_axes[idx_dim], axis)\n indices.append(index)\n idx_axis += 1\n idx_dim += index is not None\n\n if idx_elps < naxis:\n indices.append(axes[idx_elps])\n remainder = idx_elps + 1 - naxis\n indices_ = []\n idx_axis = idx_dim = -1\n while idx_axis >= remainder:\n axis = axes[idx_axis]\n index = None if axis is None else axis2index(self._dim_axes[idx_dim], axis)\n indices_.append(index)\n idx_axis -= 1\n idx_dim -= index is not None\n indices_.reverse()\n indices.extend(indices_)\n\n return tuple(indices)","def axline(x=None, y=None, a=None, b=None,\n xlim=None, ylim=None, xinvert=False, yinvert=False, xlog=False, ylog=False, title=None,\n xlabel=None, ylabel=None, label=None, grid=None, ax=None, plot_kw={}, **kwargs):\n\n # Get the relevant axis\n if ax is not None:\n if isinstance(ax, (list, tuple, ndarray)):\n if len(shape(ax)) > 1: # If ax array is multi-dimensional, flatten it\n ax = array(ax).flatten()\n else:\n ax = [ax] # Axis must be a list-like object\n else:\n ax = [gca()]\n \n old_ax = axes_handler(ax[0]) # sets the current axis and returns old axis\n\n # Validate input parameters\n if not (any([is_numeric(var) for var in [x, y, a, b]])): # If nothing has been specified\n raise TypeError(\"axline() missing one of optional arguments: 'x', 'y', 'a' or 'b'\")\n\n for i, val in enumerate([x, y, a, b]):\n if (val is not None):\n try: # Test whether the parameter is iterable\n _ = (k for k in val)\n except TypeError: # If not, convert to a list\n if (i == 0): x = [x]\n elif (i == 1): y = [y]\n elif (i == 2): a = [a]\n elif (i == 3): b = [b]\n\n if (x is not None and y is not None): # Check whether both x and y were specified\n raise ValueError(\"'x' and 'y' cannot be both specified\")\n\n if (x is not None): # Check conditions if x specified\n if (any([a, b])): # Should not specify a or b, if x given.\n raise ValueError(\"'{0}' cannot be specified if x specified\".format('a' if a else 'b'))\n L = len(x)\n\n if (y is not None): # Check conditions if y specified\n if (any([a, b])): # Should not specify a or b, if y given.\n raise ValueError(\"'{0}' cannot be specified if y specified\".format('a' if a else 'b'))\n L = len(y)\n\n if (a is not None):\n if (b is None): # If no intercept specified\n b = [0] * len(a) # set b to 0 for all a\n else:\n if (len(b) == 1):\n b = [b[0]] * len(a)\n elif (len(b) != len(a)):\n if (len(a) == 1):\n a = [a[0]] * len(b)\n else:\n raise ValueError(f\"Length of 'a' ({len(a)}) and length of 'b' ({len(b)}) must be equal or otherwise 1\")\n L = len(a)\n elif (b is not None):\n if (a is None): # If no slope specified\n a = [1] * len(b) # set a to 1 for all b\n L = len(b)\n\n if not isinstance(label, list):\n label = [label] * L\n elif (len(label) != L):\n raise ValueError(\"Length of label list ({0}) must match the number of lines given ({1}).\".format(len(label), L))\n\n # Combine the `explicit` plot_kw dictionary with the `implicit` **kwargs dictionary\n plot_par = {**plot_kw, **kwargs}\n\n # Create 'L' number of plot kwarg dictionaries to parse into each plot call\n plot_par = dict_splicer(plot_par, L, [1] * L)\n\n lines = [[]] * len(ax) # Initialise list which contains each Line2D object\n for jj, axis in enumerate(ax): # Loop over all axes\n gridpar = grid_handler(grid, axis)\n\n ax_xlim = axis.get_xlim() if lims_handler(xlim, axis) is None else xlim\n ax_ylim = axis.get_ylim() if lims_handler(ylim, axis) is None else ylim\n\n if (x is not None):\n for ii, xx in enumerate(x):\n lines[jj].append(axis.axvline(x=xx, **plot_par[ii], label=label[ii]))\n if (y is not None):\n for ii, yy in enumerate(y):\n lines[jj].append(axis.axhline(y=yy, **plot_par[ii], label=label[ii]))\n if (a is not None):\n for ii, (aa, bb) in enumerate(zip(a, b)): # Loop over all lines\n lines[jj].append(axis.axline(xy1=(0, bb), slope=aa, label=label[ii], **plot_par[ii]))\n\n _plot_finalizer(xlog, ylog, ax_xlim, ax_ylim, title, xlabel, ylabel, xinvert, yinvert, gridpar, axis)\n\n if old_ax is not None: # Reset the previously set axis\n sca(old_ax)\n\n return squeeze(lines).tolist() # Reduce the dimensionality of the lines, if needed","def plot_line(ax, p1, p2, *args, **kwargs):\n ax.plot(*zip(p1, p2), *args, **kwargs)","def setup_axes(self):\n fig = plt.figure(1)\n axs = fig.add_subplot(1, 1, 1)\n fig.clf()\n axs = plt.subplots(1, 2)\n ax1 : plt.axis = axs[0]\n ax2 : plt.axis = axs[1]\n fig.canvas.draw()\n \n line1_t, = ax1.plot([], label='train')\n line1_v, = ax1.plot([], label='val')\n\n ax1.set_title('Loss vs Iterations')\n ax1.set_xlabel('Iterations')\n ax1.set_ylabel('Loss')\n ax1.grid(True)\n ax1.autoscale()\n # ax1.legend()\n\n line2_t, = ax2.plot([], label='train')\n line2_v, = ax2.plot([], label='val')\n\n ax2.set_title('Accuracy vs Iterations')\n ax2.set_xlabel('Time')\n ax2.set_ylabel('Percent Accuracy')\n ax2.grid(True)\n ax2.autoscale()\n # ax2.legend()\n\n lines = [line1_t, line1_v, line2_t, line2_v]\n\n return fig, ax1, ax2, lines","def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\n common_axis_lengths):\n cumul_lengths = np.cumsum(common_axis_lengths)\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\n if sequence_index == 0:\n common_axis_index = cube_like_index\n else:\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\n return sequence_index, common_axis_index","def _color_twin_axes(ax1, color1, ax2, color2):\n #spines\n ax1.spines['left'].set_color(color1)\n ax1.spines['right'].set_color(color2)\n ax2.spines['left'].set_color(color1)\n ax2.spines['right'].set_color(color2)\n #text\n ax1.yaxis.label.set_color(color1)\n ax2.yaxis.label.set_color(color2)\n #ticks\n ax1.tick_params(axis = 'y', colors = color1)\n ax2.tick_params(axis = 'y', colors = color2)","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def axis2index(axes:NamedAxes, axis:ConvertableAxisClass)->IndexClass:\n\n if axis is None:\n return axis\n\n # NOTE: iterating until hashable\n if isinstance(axis, Collection) and not isinstance(axis, Hashable):\n iter_index = (axis2index(axes, a) for a in axis)\n if isinstance(axis, np.ndarray): # force list output for numpy array\n return list(iter_index)\n return type(axis)(iter_index)\n\n if isinstance(axis, slice):\n start = axis2index(axes, axis.start)\n stop = axis2index(axes, axis.stop)\n return type(axis)(start, stop, axis.step)\n\n if isinstance(axes, dict):\n return axes[axis]\n\n if is_namedtuple(axes):\n return getattr(axes, axis)\n\n # fallback to int axes with int axis\n assert is_integer(axes) and is_integer(axis), f'unnamed axis({axis!r}) should be integer'\n\n return axis","def _lines_intersection(self, other):\n\n the_slope, the_y_intercept = False, False\n\n # parallel?\n if self.slope == other.slope:\n return (\n self.y_intercept == other.y_intercept and\n self.x_value == other.x_value\n )\n\n if self.is_vertical():\n x = self.x_value\n the_slope = other.slope\n the_y_intercept = other.y_intercept\n elif other.is_vertical():\n x = other.x_value\n else:\n x = (other.y_intercept - self.y_intercept) / (self.slope - other.slope)\n\n if the_slope is None or the_slope is False:\n the_slope = self.slope\n the_y_intercept = self.y_intercept\n\n y = the_slope * x + the_y_intercept\n\n return Point(x, y)","def _format_twin_axes(*args):\n if(len(args) > 1):\n #get minimum y limit\n ylow, yhigh = 0., 0.\n for ax in args:\n yl = ax.get_ylim()\n if(yl[0] < ylow):\n ylow = yl[0]\n yhigh = yl[1]\n #scale all axes identically so that they overlap at y = 0\n if(yhigh != 0):\n frac = ylow/yhigh\n for ax in args:\n yl = ax.get_ylim()\n ax.set_ylim(frac*yl[1], yl[1])","def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\n\n ps = phase_space[:, (id_begin-1):id_end, :]\n # print(np.shape(ps))\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\n\n x = ps[0, :, :]\n px = ps[1, :, :]\n y = ps[2, :, :]\n py = ps[3, :, :]\n\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\n\n for n in range(int(id_end-id_begin+1)):\n x_this = x[n, :]\n px_this = px[n, :]\n y_this = y[n, :]\n py_this = py[n, :]\n\n # Remove all NAN elements in the phase space array\n x_this = x_this[np.logical_not(np.isnan(x_this))]\n px_this = px_this[np.logical_not(np.isnan(px_this))]\n y_this = y_this[np.logical_not(np.isnan(y_this))]\n py_this = py_this[np.logical_not(np.isnan(py_this))]\n\n ## Plot X\n plt.subplot(2, 2, 1)\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\n plt.ylabel('Position in X/ $\\mu$m', fontsize=10)\n\n ## Plot Y\n plt.subplot(2, 2, 2)\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\n plt.ylabel('Position in Y/ $\\mu$m', fontsize=10)\n\n ## Plot px\n plt.subplot(2, 2, 3)\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\n plt.ylabel('Angle in X', fontsize=10)\n\n ## Plot py\n plt.subplot(2, 2, 4)\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\n plt.ylabel('Angle in Y', fontsize=10)\n\n\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\mu$m')\n # plt.title('First Undulator Section')\n # plt.title('Second Undulator Section')\n # plt.title('Third Undulator Section')\n\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\n\n fig = plt.gcf()\n fig.set_size_inches(13.5, 9)\n ax = plt.gca()\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\n fig.savefig('phase_space_U3_new.png', dpi=100)\n plt.show()\n\n\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\n\n return id_on_axis, s_on_axis","def get_tick_iterators(self, axes):\n\n lat_levs, lat_n, lat_factor = self._grid_info[\"lat_info\"]\n yy0 = lat_levs / lat_factor\n\n lon_levs, lon_n, lon_factor = self._grid_info[\"lon_info\"]\n xx0 = lon_levs / lon_factor\n\n e0, e1 = self._extremes\n\n def trf_xy(x, y):\n trf = self.grid_helper.grid_finder.get_transform() + axes.transData\n return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T\n\n # find angles\n if self.nth_coord == 0:\n mask = (e0 <= yy0) & (yy0 <= e1)\n (xx1, yy1), (dxx1, dyy1), (dxx2, dyy2) = _value_and_jacobian(\n trf_xy, self.value, yy0[mask], (-np.inf, np.inf), (e0, e1))\n labels = self._grid_info[\"lat_labels\"]\n\n elif self.nth_coord == 1:\n mask = (e0 <= xx0) & (xx0 <= e1)\n (xx1, yy1), (dxx2, dyy2), (dxx1, dyy1) = _value_and_jacobian(\n trf_xy, xx0[mask], self.value, (-np.inf, np.inf), (e0, e1))\n labels = self._grid_info[\"lon_labels\"]\n\n labels = [l for l, m in zip(labels, mask) if m]\n\n angle_normal = np.arctan2(dyy1, dxx1)\n angle_tangent = np.arctan2(dyy2, dxx2)\n mm = (dyy1 == 0) & (dxx1 == 0) # points with degenerate normal\n angle_normal[mm] = angle_tangent[mm] + np.pi / 2\n\n tick_to_axes = self.get_tick_transform(axes) - axes.transAxes\n in_01 = functools.partial(\n mpl.transforms._interval_contains_close, (0, 1))\n\n def f1():\n for x, y, normal, tangent, lab \\\n in zip(xx1, yy1, angle_normal, angle_tangent, labels):\n c2 = tick_to_axes.transform((x, y))\n if in_01(c2[0]) and in_01(c2[1]):\n yield [x, y], *np.rad2deg([normal, tangent]), lab\n\n return f1(), iter([])","def ft_ax(ax=None,\n y=1.03,\n yy=1.1,\n title=None,\n subtitle=None,\n source=None,\n add_box=False,\n left_axis=False):\n\n if ax is None:\n ax = plt.gca()\n\n ax.set_axisbelow(True)\n \n if title is not None:\n title = plt.title(title, y=y, loc='left')\n if subtitle is not None:\n plt.annotate(subtitle, xy=title.get_position(),\n xycoords='axes fraction', xytext=(0,-11), \n textcoords='offset points', size='large') \n \n if source is not None:\n src = plt.annotate(source, xy=(0,0), \n xycoords='axes fraction', xytext=(0,-35), \n textcoords='offset points', ha='left', va='top', size='small')\n \n # axes and grid-lines\n plt.grid(axis='y', linewidth=.5)\n sns.despine(left=True)\n if not left_axis:\n ax.yaxis.tick_right()\n ax.yaxis.set_label_position('right')\n ax.yaxis.set_label_coords(1,yy)\n ax.yaxis.get_label().set_rotation(0)\n ax.tick_params('y', length=0)\n \n plt.tight_layout()\n \n if add_box:\n ax2 = plt.axes(ax.get_position().bounds, facecolor=(1,1,1,0))\n ax2.xaxis.set_visible(False)\n ax2.yaxis.set_visible(False)\n x,y = np.array([[.01, 0.15], [y+.12, y+.12]])\n line = matplotlib.lines.Line2D(x, y, lw=6., color='k')\n ax2.add_line(line)\n line.set_clip_on(False)\n \n if add_box and source is not None:\n return (line, src)\n elif not add_box and source is not None:\n return (src,)\n elif add_box and source is None:\n return (line,)\n else:\n return []","def maybe_get_ax(*args, **kwargs):\n\n if 'ax' in kwargs:\n ax = kwargs.pop('ax')\n elif len(args) == 0:\n fig = plt.gcf()\n ax = plt.gca()\n elif isinstance(args[0], mpl.axes.Axes):\n ax = args[0]\n args = args[1:]\n else:\n ax = plt.gca()\n return ax, args, dict(kwargs)","def intersection(line1, line2):\n p0, p1, p2, p3 = map(\n lambda tup : np.array(tup[:2]),\n [line1[0], line1[1], line2[0], line2[1]]\n )\n p1, p2, p3 = map(lambda x : x - p0, [p1, p2, p3])\n transform = np.zeros((2, 2))\n transform[:,0], transform[:,1] = p1, p2\n if np.linalg.det(transform) == 0: return\n inv = np.linalg.inv(transform)\n new_p3 = np.dot(inv, p3.reshape((2, 1)))\n #Where does line connecting (0, 1) to new_p3 hit x axis\n x_intercept = new_p3[0] / (1 - new_p3[1]) \n result = np.dot(transform, [[x_intercept], [0]])\n result = result.reshape((2,)) + p0\n return result","def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\n\n tr =PolarAxes.PolarTransform()\n pi = np.pi\n\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\n\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\n tick_formatter1 = DictFormatter(dict(angle_ticks))\n\n grid_locator2 = MaxNLocator(4)\n\n grid_helper = floating_axes.GridHelperCurveLinear(\n tr, extremes=(tmax, tmin, zmax, zmin),\n grid_locator1=grid_locator1,\n grid_locator2=grid_locator2,\n tick_formatter1=tick_formatter1,\n tick_formatter2=None)\n\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\n fig.add_subplot(ax1)\n\n # create a parasite axes whose transData in RA, cz\n aux_ax = ax1.get_aux_axes(tr)\n\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\n # drawn twice, and possibly over some other\n # artists. So, we decrease the zorder a bit to\n # prevent this.\n\n return ax1, aux_ax","def setX(ax1: Union[object, List], ax2: Union[object, List]):\n if type(ax1) is list:\n print(\"PlotHelpers: cannot use list as source to set Y axis\")\n return\n ax2 = _ax_tolist(ax2)\n # if type(ax2) is not list:\n # ax2 = [ax2]\n refx = ax1.get_xlim()\n for ax in ax2:\n ax.set_xlim(refx)","def itrace(a, axes=(0, 1)):\n # Single index pair to trace out\n if isinstance(axes[0], Integral):\n return np.trace(a, axis1=axes[0], axis2=axes[1])\n elif len(axes[0]) == 1:\n return np.trace(a, axis1=axes[0][0], axis2=axes[1][0])\n\n # Multiple index pairs to trace out\n gone = set()\n for axis1, axis2 in zip(*axes):\n # Modify indices to adjust for traced out dimensions\n mod1 = sum(x < axis1 for x in gone)\n mod2 = sum(x < axis2 for x in gone)\n gone |= {axis1, axis2}\n a = np.trace(a, axis1=axis1 - mod1, axis2=axis2 - mod2)\n return a","def plot_sensors_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor info and transform loc to fit with headmodel\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 = []\n bads_epo1 = epo1.info['bads']\n bads_epo2 = []\n bads_epo2 = epo2.info['bads']\n\n # plot sensors\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='x', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='o', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n \n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='x', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='o', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def plot_2d_topomap_intra(ax):\n\n # plot first Head \n N = 300 # number of points for interpolation\n xy_center = [-0.178,0] # center of the plot\n radius = 0.1 # radius\n\n # draw a circle\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n # add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon) \n \n\n # Plot second Head \n x2y2_center = [0.178,0] # center of the plot\n radius2 = 0.1 # radius\n \n # draw a circle\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n ## add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon)","def _get_lines_parallel_to_axis(\n self,\n axis_parallel_to: NumberLine,\n axis_perpendicular_to: NumberLine,\n freq: float,\n ratio_faded_lines: int,\n ) -> tuple[VGroup, VGroup]:\n\n line = Line(axis_parallel_to.get_start(), axis_parallel_to.get_end())\n if ratio_faded_lines == 0: # don't show faded lines\n ratio_faded_lines = 1 # i.e. set ratio to 1\n step = (1 / ratio_faded_lines) * freq\n lines1 = VGroup()\n lines2 = VGroup()\n unit_vector_axis_perp_to = axis_perpendicular_to.get_unit_vector()\n\n # need to unpack all three values\n x_min, x_max, _ = axis_perpendicular_to.x_range\n\n # account for different axis scalings (logarithmic), where\n # negative values do not exist and [-2 , 4] should output lines\n # similar to [0, 6]\n if axis_perpendicular_to.x_min > 0 and x_min < 0:\n x_min, x_max = (0, np.abs(x_min) + np.abs(x_max))\n\n # min/max used in case range does not include 0. i.e. if (2,6):\n # the range becomes (0,4), not (0,6).\n ranges = (\n [0],\n np.arange(step, min(x_max - x_min, x_max), step),\n np.arange(-step, max(x_min - x_max, x_min), -step),\n )\n\n for inputs in ranges:\n for k, x in enumerate(inputs):\n new_line = line.copy()\n new_line.shift(unit_vector_axis_perp_to * x)\n if (k + 1) % ratio_faded_lines == 0:\n lines1.add(new_line)\n else:\n lines2.add(new_line)\n return lines1, lines2","def axes_subplots():\n # gerenate data\n x = np.arange(0, 6 * np.pi+0.2, 0.2)\n y_1 = np.cos(x)\n y_2 = np.sin(2*x)\n y_3 = y_1 + y_2\n\n # display multiple\n fig, axs = plt.subplots(3, 1, sharex=True)\n fig.suptitle('Subplots w/ shared axes')\n axs[0].plot(x, y_1)\n axs[1].plot(x, y_2)\n axs[2].plot(x, y_3)\n axs[0].set_ylabel('$y$')\n axs[1].set_ylabel('$y$')\n axs[2].set_ylabel('$y$')\n\n plt.show()\n\n return None","def _getAxesExtent(\n self,\n x0: float,\n y0: float,\n x1: float,\n y1: float,\n enabledAxes: Optional[EnabledAxes] = None,\n ) -> AxesExtent:\n if enabledAxes is None:\n enabledAxes = self.enabledAxes\n\n y2_0, y2_1 = y0, y1\n left, top, width, height = self.plot.getPlotBoundsInPixels()\n\n if not all(enabledAxes) and not self.plot.isKeepDataAspectRatio():\n # Handle axes disabled for zoom if plot is not keeping aspec ratio\n if not enabledAxes.xaxis:\n x0, x1 = left, left + width\n if not enabledAxes.yaxis:\n y0, y1 = top, top + height\n if not enabledAxes.y2axis:\n y2_0, y2_1 = top, top + height\n\n if self.plot.isKeepDataAspectRatio() and height != 0 and width != 0:\n ratio = width / height\n xextent, yextent = math.fabs(x1 - x0), math.fabs(y1 - y0)\n if xextent != 0 and yextent != 0:\n if xextent / yextent > ratio:\n areaHeight = xextent / ratio\n center = 0.5 * (y0 + y1)\n y0 = center - numpy.sign(y1 - y0) * 0.5 * areaHeight\n y1 = center + numpy.sign(y1 - y0) * 0.5 * areaHeight\n else:\n areaWidth = yextent * ratio\n center = 0.5 * (x0 + x1)\n x0 = center - numpy.sign(x1 - x0) * 0.5 * areaWidth\n x1 = center + numpy.sign(x1 - x0) * 0.5 * areaWidth\n\n # Convert to data space\n x0, y0 = self.plot.pixelToData(x0, y0, check=False)\n x1, y1 = self.plot.pixelToData(x1, y1, check=False)\n y2_0 = self.plot.pixelToData(None, y2_0, axis=\"right\", check=False)[1]\n y2_1 = self.plot.pixelToData(None, y2_1, axis=\"right\", check=False)[1]\n\n return AxesExtent(\n min(x0, x1),\n max(x0, x1),\n min(y0, y1),\n max(y0, y1),\n min(y2_0, y2_1),\n max(y2_0, y2_1),\n )","def convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )","def _lines_overlap_on_x_axis(self, line1, line2):\n x1, x2, = line1[0][0], line1[1][0]\n x3, x4, = line2[0][0], line2[1][0]\n e1_left, e1_right = min(x1, x2), max(x1, x2)\n e2_left, e2_right = min(x3, x4), max(x3, x4)\n return (e1_left >= e2_left and e1_left <= e2_right) or (e1_right >= e2_left and e1_right <= e2_right) or \\\n (e2_left >= e1_left and e2_left <= e1_right) or (e2_right >= e1_left and e2_right <= e1_right)","def change_axes_geometry_stack(fig, ax, naxes):\n for ii in range(len(ax)):\n geometry = (naxes, 1, ii + 1)\n if ax[ii].get_geometry() != geometry:\n ax[ii].change_geometry(*geometry)\n\n for ii in np.arange(len(ax), naxes):\n print('adding axis ', ii)\n fig.add_subplot(naxes, 1, ii + 1)\n\n ax = fig.axes\n return fig, ax","def dualx(self, arg, **kwargs):\n # NOTE: Matplotlib 3.1 has a 'secondary axis' feature. For the time\n # being, our version is more robust (see FuncScale) and simpler, since\n # we do not create an entirely separate _SecondaryAxis class.\n ax = self.altx(**kwargs)\n self._dualx_arg = arg\n self._dualx_overrides()\n return ax","def cartesian_coordinates(self, *axes):","def draw_line(xy1, xy2, ax, **kwargs): \n x_arr = [xy1[0], xy2[0]]\n y_arr = [xy1[1], xy2[1]]\n edge = Line2D([x_arr],[y_arr], **kwargs)\n ax.add_line(edge)\n\n return ax,","def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\n if log:\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\n else:\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)","def secondAxis(ax,label,limits,secondY =True,color=\"Black\",scale=None,\n tick_color='k',tick_axis_kw=dict()):\n current = ax\n if (scale is None):\n if secondY:\n scale = ax.get_yscale() \n else:\n scale = ax.get_xscale()\n axis = \"y\" if secondY else \"x\"\n spines = \"right\" if secondY else \"top\"\n if(secondY):\n ax2 = ax.twinx()\n ax2.set_yscale(scale, nonposy='clip')\n ax2.set_ylim(limits)\n # set the y axis to the appropriate label\n lab = ylabel(label,ax=ax2)\n tickLabels = ax2.get_yticklabels()\n tickLims = ax2.get_yticks()\n axis_opt = dict(axis=axis,left=False,**tick_axis_kw)\n other_axis_opt = dict(axis=axis,right=False)\n ax.yaxis.tick_left()\n else:\n ax2 = ax.twiny()\n ax2.set_xscale(scale, nonposx='clip')\n ax2.set_xlim(limits)\n # set the x axis to the appropriate label\n lab = xlabel(label,ax=ax2)\n tickLabels = ax2.get_xticklabels()\n tickLims = ax2.get_xticks()\n axis_opt = dict(axis=axis,bottom=False,**tick_axis_kw)\n other_axis_opt = dict(axis=axis,top=False)\n color_axis_ticks(color=tick_color,spine_name=spines,axis_name=axis,ax=ax2) \n [i.set_color(color) for i in tickLabels]\n lab.set_color(color)\n current.tick_params(**other_axis_opt)\n tickAxisFont(ax=ax2,**axis_opt)\n plt.sca(current)\n return ax2","def createCustomXYaxis(origin: Tuple[float, float, float], endPoints: List[Tuple[float, float, float]]) -> List[\n vtkActor]:\n\n output = []\n\n for endPoint in endPoints:\n output.append(createLine(origin, endPoint, color=\"lightgreen\"))\n\n return output","def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def intersection(self, axis2):\n if type(axis2) is not type(self):\n raise TypeError(\"Cell edges with such combination of axes is not supported.\")\n\n intersection = np.zeros([self.size, axis2.size])\n\n def inters_len(a_min, a_max, b_min, b_max):\n res = min(a_max, b_max) - max(a_min, b_min)\n if res < 0:\n res = 0\n return res\n\n j_start = 0\n for i, row in enumerate(intersection):\n for j in range(j_start, len(row)):\n dist = inters_len(self.cell_edges[i], self.cell_edges[i + 1],\n axis2.cell_edges[j], axis2.cell_edges[j + 1])\n if not dist and j != j_start:\n j_start = j - 1\n break\n intersection[i, j] = dist\n return intersection","def getAxisTuple(axis):","def swapaxes(self, a1, a2):\n an = self.axes_names[:]\n ia1, ia2 = self.get_axis_id(a1), self.get_axis_id(a2)\n an[ia2], an[ia1] = an[ia1], an[ia2]\n return xndarray(np.swapaxes(self.data, ia1, ia2), an, self.axes_domains,\n self.value_label, self.meta_data)","def _get_lines(self) -> tuple[VGroup, VGroup]:\n x_axis = self.get_x_axis()\n y_axis = self.get_y_axis()\n\n x_lines1, x_lines2 = self._get_lines_parallel_to_axis(\n x_axis,\n y_axis,\n self.y_axis.x_range[2],\n self.faded_line_ratio,\n )\n\n y_lines1, y_lines2 = self._get_lines_parallel_to_axis(\n y_axis,\n x_axis,\n self.x_axis.x_range[2],\n self.faded_line_ratio,\n )\n\n # TODO this was added so that we can run tests on NumberPlane\n # In the future these attributes will be tacked onto self.background_lines\n self.x_lines = x_lines1\n self.y_lines = y_lines1\n lines1 = VGroup(*x_lines1, *y_lines1)\n lines2 = VGroup(*x_lines2, *y_lines2)\n\n return lines1, lines2","def _get_lines(self) -> tuple[VGroup, VGroup]:\n center = self.get_origin()\n ratio_faded_lines = self.faded_line_ratio\n offset = self.azimuth_offset\n\n if ratio_faded_lines == 0: # don't show faded lines\n ratio_faded_lines = 1 # i.e. set ratio to 1\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\n rlines1 = VGroup()\n rlines2 = VGroup()\n alines1 = VGroup()\n alines2 = VGroup()\n\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\n ainput = np.arange(0, TAU, astep)\n\n unit_vector = self.x_axis.get_unit_vector()[0]\n\n for k, x in enumerate(rinput):\n new_line = Circle(radius=x * unit_vector)\n if k % ratio_faded_lines == 0:\n alines1.add(new_line)\n else:\n alines2.add(new_line)\n\n line = Line(center, self.get_x_axis().get_end())\n\n for k, x in enumerate(ainput):\n new_line = line.copy()\n new_line.rotate(x + offset, about_point=center)\n if k % ratio_faded_lines == 0:\n rlines1.add(new_line)\n else:\n rlines2.add(new_line)\n\n lines1 = VGroup(*rlines1, *alines1)\n lines2 = VGroup(*rlines2, *alines2)\n return lines1, lines2","def axis2D(xlow,xhigh,xfirst,xstep,ylow,yhigh,yfirst,ystep):\n dislin.graf(xlow,xhigh,xfirst,xstep,\\\n ylow,yhigh,yfirst,ystep)","def getAxis(self,axis):\n\n\t\tif axis == \"u\":\n\t\t\tif len(self.usr) != 0:\n\t\t\t\treturn np.append([0], self.usr)\n\n\t\tif axis == \"s\":\n\t\t\tif len(self.seg) != 0:\n\t\t\t\tif self.radiograph:\n\t\t\t\t\treturn self.seg\n\t\t\t\telse:\n\t\t\t\t\tfirst = self.seg[0] - 1.\n\t\t\t\t\treturn np.append([first], self.seg)\n\n\t\tif axis == \"c\":\n\t\t\tif len(self.cos) != 0:\n\t\t\t\tif self.radiograph:\n\t\t\t\t\treturn self.cos\n\t\t\t\telse:\n\t\t\t\t\tfirst = -1.\n\t\t\t\t\treturn np.append([first], self.cos)\n\n\t\tif axis == \"e\":\n\t\t\tif len(self.erg) != 0:\n\t\t\t\tfirst = self.erg[0] - 1.\n\t\t\t\treturn np.append([first], self.erg)\n\n\t\tif axis == \"t\":\n\t\t\tif len(self.tim) != 0:\n\t\t\t\tfirst = self.tim[0] - 1.\n\t\t\t\treturn np.append([first], self.tim)\n\n\t\tif axis == \"i\":\n\t\t\treturn self.cora\n\n\t\tif axis == \"j\":\n\t\t\treturn self.corb\n\n\t\tif axis == \"k\":\n\t\t\treturn self.corc\n\n\t\treturn []","def axes(*x: Iterable[int]):\n return [_ti_core.Axis(i) for i in x]","def _axes_domain(self, *args, **kwargs):\n # See _add_gridline_label for detials\n lon_0 = self.axes.projection.proj4_params.get('lon_0', 0)\n x_range, y_range = type(self)._axes_domain(self, *args, **kwargs)\n x_range = np.asarray(x_range) + lon_0\n return x_range, y_range","def from_cartesian(self, coordinates, *axes):","def plot_2d_topomap_inter(ax):\n\n # plot first Head \n N = 300 # number of points for interpolation\n xy_center = [-0.178,0] # center of the plot\n radius = 0.1 # radius\n\n # draw a circle\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n # add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [-0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [-0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n xy = [[-0.087,-0.027],[-0.087,0.027], [-0.068,0]]\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon) \n \n\n # Plot second Head \n x2y2_center = [0.178,0] # center of the plot\n radius2 = 0.1 # radius\n \n # draw a circle\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n ## add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n x2y2 = [[0.087,-0.027],[0.087,0.027], [0.068,0]]\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon)","def line_axes (self):\n return self._line_axes","def baseline_idx(self, axis=None, strict=False, extrapolate=False):\n # Get stress/release pairs\n if strict:\n # Get only stress/release pairs, i.e. only segment pairs, whose\n # release's stop and stress's start index equal an extremum.\n pairs = self.stress_release_pairs(axis=axis, slices=False)\n stresses = pairs['stress']['idx']\n releases = pairs['release']['idx']\n else:\n # Get all stress/release segments, even those without a\n # corresponding extremum.\n stresses = self.sections(axis=axis, cycle='stress', slices=False)\n releases = self.sections(axis=axis, cycle='release', slices=False)\n\n # A baseline point lies exactly beetween a release and a following\n # stress section. Therefore, the baseline point idx equals a stress's\n # start and a release's stop.\n stress_base_idx = stresses[:, 0]\n release_base_idx = releases[:, 1]\n\n # Remove stresses, whose start, and releases, whose stop is equal to\n # an extremum, which means, the excitation as above or below the\n # baseline.\n extrema = self._extrema(axis=axis)\n stress_base_idx = np.setdiff1d(stress_base_idx, extrema,\n assume_unique=True)\n release_base_idx = np.setdiff1d(release_base_idx, extrema,\n assume_unique=True)\n\n base_idx = np.r_[stress_base_idx, release_base_idx]\n if strict or not extrapolate:\n # Take only baseline point indices, that lie exactly between a\n # release and a following stress section, i.e. have two equal\n # entries, one from a release's start and one from a stress's stop.\n # I.e. sort out all indices that did not come from a stress/release\n # pair but instead only a single stress or release segment.\n base_idx.sort()\n base_idx = base_idx[np.r_[base_idx[:-1] == base_idx[1:], False]]\n return np.unique(base_idx)","def same_emitter(track_1, track_2):\n alternate_consistency = False\n start_consistency = False\n start_1_index = 0\n start_2_index = 0\n\n # First of all, check if both tracks use the same frequence to communicate\n freq_consistency = False\n f_1 = track_1.itr_measurement.central_freq_hz\n f_2 = track_2.itr_measurement.central_freq_hz\n if f_1 > 0.99*f_2 and f_1 < 1.01*f_2:\n freq_consistency = True\n\n # Then, check if the bandwidth of both tracks is the same\n bandwidth_consistency = False\n bw_1 = track_1.itr_measurement.bandwidth_hz\n bw_2 = track_2.itr_measurement.bandwidth_hz\n if bw_1 > 0.99*bw_2 and bw_1 < 1.01*bw_2:\n bandwidth_consistency = True\n\n # Is the emission type the same for both tracks ?\n type_consistency = False\n t_1 = track_1.itr_measurement.type\n t_2 = track_2.itr_measurement.type\n if t_1 == t_2:\n type_consistency = True\n\n # If all three criteria above have been fulfilled, check if alternates sequences are similar\n if freq_consistency and type_consistency and bandwidth_consistency:\n # logger.debug(\n # \"\\tFreq and type consistency found : \\n\\t\\t1° Freq - %s - Type - %s \\n\\t\\t2° Freq - %s - Type - %s\" % (f_1, t_1, f_2, t_2))\n alternate_consistency = True\n alternates_1 = track_1.alternates\n alternates_2 = track_2.alternates\n\n alt_duration_1 = [alt.duration_us for alt in alternates_1]\n alt_start_1 = [alt.start.date_ms for alt in alternates_1]\n alt_duration_2 = [alt.duration_us for alt in alternates_2]\n alt_start_2 = [alt.start.date_ms for alt in alternates_2]\n\n # Both tracks may not have been recorded at exactly the same time. Therefore,\n # we only analyse alternates that have finished. Not ongoing alternates.\n n = min(len(alternates_1), len(alternates_2)) - 1\n\n for start_1 in alt_start_1:\n if start_1 in alt_start_2:\n start_1_index = alt_start_1.index(start_1)\n start_2_index = alt_start_2.index(start_1)\n start_consistency = True\n break\n if not start_consistency:\n for start_2 in alt_start_2:\n if start_2 in alt_start_1:\n start_1_index = alt_start_1.index(start_2)\n start_2_index = alt_start_2.index(start_2)\n start_consistency = True\n break\n\n if start_consistency and track_1.itr_measurement.type != 1:\n if start_1_index == 0 or start_2_index == 0:\n start_1_index += 1\n start_2_index += 1\n while start_1_index < len(alt_start_1) and start_2_index < len(alt_start_2):\n # If there is more than a single alternate, we check if the duration of the alternates is consistent\n if alt_duration_1[start_1_index] != alt_duration_2[start_2_index]:\n alternate_consistency = False\n break\n\n # Always check that the start-dates of all alternates are the same.\n if alt_start_1[start_1_index] != alt_start_2[start_2_index]:\n alternate_consistency = False\n break\n\n start_1_index += 1\n start_2_index += 1\n\n # if alternate_consistency:\n # logger.debug(\n # \"\\tBoth tracks are from the same emitter !\")\n bool_response = freq_consistency and bandwidth_consistency and type_consistency and start_consistency and alternate_consistency\n\n track_id = get_track_id(track_1)\n return bool_response, track_id","def _lines_overlap_on_y_axis(self, line1, line2):\n y1, y2, = line1[0][1], line1[1][1]\n y3, y4, = line2[0][1], line2[1][1]\n e1_top, e1_bot = min(y1, y2), max(y1, y2)\n e2_top, e2_bot = min(y3, y4), max(y3, y4)\n return (e1_top >= e2_top and e1_top <= e2_bot) or (e1_bot >= e2_top and e1_bot <= e2_bot) or \\\n (e2_top >= e1_top and e2_top <= e1_bot) or (e2_bot >= e1_top and e2_bot <= e1_bot)","def swapaxes(a, axis1, axis2):\n # TODO(okuta): check type\n return a.swapaxes(axis1, axis2)","def plot_item_add_second_right_axis(plot_item):\n ax = _pyqtgraph.AxisItem('left')\n vb = _pyqtgraph.ViewBox()\n plot_item.layout.addItem(ax, 2, 3)\n plot_item.scene().addItem(vb)\n ax.linkToView(vb)\n vb.setXLink(plot_item)\n\n def update_views():\n vb.setGeometry(plot_item.vb.sceneBoundingRect())\n vb.linkedViewChanged(plot_item.vb, vb.XAxis)\n\n update_views()\n plot_item.vb.sigResized.connect(update_views)\n return ax","def AllSidesTicks( ax ):\n return; ## depreceate for now as it doesn't work correctly...\n axy = ax.twinx()\n axy.set_ylim( ax.get_ylim() )\n axy.set_yscale( ax.get_yscale() )\n axy.set_yticklabels(labels=[])\n\n axx = ax.twiny()\n axx.set_xlim( ax.get_xlim() )\n axx.set_xscale( ax.get_xscale() )\n axx.set_xticklabels(labels=[])","def take_along_axis(x1, indices, axis):\n\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\n indices_desc = dpnp.get_dpnp_descriptor(\n indices, copy_when_nondefault_queue=False\n )\n if x1_desc and indices_desc:\n if x1_desc.ndim != indices_desc.ndim:\n pass\n elif not isinstance(axis, int):\n pass\n elif axis >= x1_desc.ndim:\n pass\n elif x1_desc.ndim == indices_desc.ndim:\n val_list = []\n for i in list(indices_desc.shape)[:-1]:\n if i == 1:\n val_list.append(True)\n else:\n val_list.append(False)\n if not all(val_list):\n pass\n else:\n return dpnp_take_along_axis(x1, indices, axis)\n else:\n return dpnp_take_along_axis(x1, indices, axis)\n\n return call_origin(numpy.take_along_axis, x1, indices, axis)","def discrete_scatter(x1, x2, y=None, markers=None, s=10, ax=None,\n labels=None, padding=.2, alpha=1, c=None, markeredgewidth=None):\n if ax is None:\n ax = plt.gca()\n\n if y is None:\n y = np.zeros(len(x1))\n\n unique_y = np.unique(y)\n\n if markers is None:\n markers = ['o', '^', 'v', 'D', 's', '*', 'p', 'h', 'H', '8', '<', '>'] * 10\n\n if len(markers) == 1:\n markers = markers * len(unique_y)\n\n if labels is None:\n labels = unique_y\n\n # lines in the matplotlib sense, not actual lines\n lines = []\n\n current_cycler = mpl.rcParams['axes.prop_cycle']\n\n for i, (yy, cycle) in enumerate(zip(unique_y, current_cycler())):\n mask = y == yy\n # if c is none, use color cycle\n if c is None:\n color = cycle['color']\n elif len(c) > 1:\n color = c[i]\n else:\n color = c\n # use light edge for dark markers\n if np.mean(colorConverter.to_rgb(color)) < .4:\n markeredgecolor = \"grey\"\n else:\n markeredgecolor = \"black\"\n\n lines.append(ax.plot(x1[mask], x2[mask], markers[i], markersize=s,\n label=labels[i], alpha=alpha, c=color,\n markeredgewidth=markeredgewidth,\n markeredgecolor=markeredgecolor)[0])\n\n if padding != 0:\n pad1 = x1.std() * padding\n pad2 = x2.std() * padding\n xlim = ax.get_xlim()\n ylim = ax.get_ylim()\n ax.set_xlim(min(x1.min() - pad1, xlim[0]), max(x1.max() + pad1, xlim[1]))\n ax.set_ylim(min(x2.min() - pad2, ylim[0]), max(x2.max() + pad2, ylim[1]))\n\n return lines","def plot_2_series_double_yaxis(x, y1, y2, figsize=(10,10), fontsize=12, title='', \\\n y1_label='', y2_label='', xlabel='', savefig=False,\\\n figname='figure'):\n x = x\n y1 = y1\n y2 = y2\n fig, ax = plt.subplots(figsize=figsize, sharex=True)\n ax2 = ax.twinx()\n ax.set_title(title, fontsize=fontsize+4)\n ax.plot(x, y1, 'r-', label=y1_label)\n ax.set_xlabel(xlabel, fontsize=fontsize)\n ax.set_ylabel(y1_label, fontsize=fontsize)\n ax.set_xticklabels(labels=x, rotation=45)\n ax2.plot(x, y2, 'b-', label=y2_label)\n ax2.set_ylabel(y2_label, fontsize=fontsize)\n ax.legend(loc='upper left')\n ax2.legend(loc='lower right')\n plt.show()\n if savefig == True:\n fig.savefig(figname)","def populate_plot_axis(self,plot,ax='x'):\n\n fig=plt.gcf()\n\n extra_ax=[]\n\n if ax=='x':\n\n ticks=plot.get_xticks()\n\n lim=plot.get_xlim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['bottom'].set_position(('outward',10))\n\n axn.spines['bottom'].set_visible(True)\n\n else:\n\n dy_fig=0.08\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0,\\\n prev_ax_position.y0-2*dy_fig,\\\n prev_ax_position.width,\\\n 0),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.yaxis.set_visible(False)\n\n for side in axn.spines.keys():\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_xticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_xticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n xlab=axn.set_xlabel(self.names[i])\n\n xlab.set_fontsize(10)\n\n axn.tick_params(axis='x',labelsize=10)\n\n axn.set_xlim(lim)\n\n\n\n elif ax=='y':\n\n ticks=plot.get_yticks()\n\n lim=plot.get_ylim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['left'].set_position(('outward',10))\n\n axn.spines['left'].set_visible(True)\n\n else:\n\n dx_fig=0.08\n\n plot_position=plot.get_position()\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0-2*dx_fig,\\\n prev_ax_position.y0,\\\n 0,\\\n prev_ax_position.height),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.xaxis.set_visible(False) # hide the yaxis\n\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_yticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_yticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n ylab=axn.set_ylabel(self.names[i])\n\n ylab.set_fontsize(10)\n\n axn.tick_params(axis='y',labelsize=10)\n\n axn.set_ylim(lim)\n\n else:\n\n raise ValueError(\"Axis can be 'x' or 'y'\")","def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices['E_tot1'])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\n \n plt.ylabel('Energy [kWh]')\n plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(24)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\n\n plt.ylabel('Energy Difference [kWh]')\n plt.legend()\n\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n return fig","def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\n axis = check_axes(axis)\n if len(axis) == x.ndim:\n return func(x)\n\n other_axes = negate_indices(axis, x.ndim)\n begin = np.arange(len(other_axes))\n\n y = np.moveaxis(x, other_axes, begin)\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)","def align_yaxis(ax1,v1,ax2,v2):\n _, y1 = ax1.transData.transform((0,v1))\n _, y2 = ax2.transData.transform((0,v2))\n inv = ax2.transData.inverted()\n _, dy = inv.transform((0,0)) - inv.transform((0,y1-y2))\n miny, maxy = ax2.get_ylim()\n ax2.set_ylim(miny+dy,maxy+dy)","def _filter_axes(self, channel_axis, spatial_axes):\n f_axes = ng.make_axis(length=self.nout, name=\"K\")\n for key, ax in zip(\"DHW\", spatial_axes):\n f_axes += ng.make_axis(length=self.filter_shape[key],\n name=ax.name)\n f_axes += channel_axis\n return f_axes","def _handle_setup_axis(self, axis_args):\n axis_name = axis_args['name']\n axes_dict = self.server.axes\n\n if axis_name not in [name for name, _ in axes_dict.items()]:\n print \"Adding a new axis:\", axis_name\n axis_count = len(axes_dict)\n newaxis = self.server.figure.add_subplot(axis_count+1, 1, axis_count+1)\n axes_dict[axis_name] = newaxis\n axes_dict[axis_name].grid(True)\n axes_dict[axis_name].set_xlabel(axis_args['x_label'])\n axes_dict[axis_name].set_ylabel(axis_args['y_label'])\n # TODO: support *.set_title(\"Title\")\n if FLAGS.logy:\n axes_dict[axis_name].set_yscale('log', nonposy='clip')\n\n if axis_count != 0:\n # Resize other axes if the above wasn't the first.\n axis_count = len(axes_dict)\n for row,(name, _) in enumerate(axes_dict.items(), 1):\n print name, axis_count, row\n axes_dict[name].change_geometry(axis_count, 1, row)","def _lines_intersect(self, line1, line2):\n return self._lines_overlap_on_x_axis(line1, line2) and self._lines_overlap_on_y_axis(line1, line2)","def plot_sensors_2d_inter(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor info and transform loc to fit with headmodel\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 = []\n bads_epo1 = epo1.info['bads']\n bads_epo2 = []\n bads_epo2 = epo2.info['bads']\n \n # plot sensors ('x' for bads)\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='x', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n plt.plot(x1, y1, marker='o', color='dimgrey')\n if lab:\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n \n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='x', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n plt.plot(x2, y2, marker='o', color='dimgrey')\n if lab:\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def intersection(self, other):\n log.info('self: '+str(self)+' other: '+str(other))\n if self == other:\n # Used to be return True, that is definitely not right (expects Coordinate)\n # Do we want start or end ? Does it matter? Lines are the same, everything is\n # an intersection.\n return self.start\n # If any of the start/end points match, return that point.\n if self.end==other.start or self.end == other.end:\n return self.end \n if self.start==other.start or self.start == other.end: \n return self.start\n\n # Line equation: y = mx + b\n # m = (y2-y1)/(x2-x1)\n # B_self = y - M_self*x\n # Pick any x/y on the line - try end point\n # B_self = self.end.lat - M_self*self.end.lon\n # B_other = other.end.lat - M_self*self.end.lon\n from pyresample.spherical_geometry import Coordinate\n\n selfendlon = self.end.lon\n selfstartlon = self.start.lon\n otherendlon = other.end.lon\n otherstartlon = other.start.lon\n # Not sure if this is necessary, or good...\n# if self.end.lon < 0:\n# selfendlon = self.end.lon + 2*math.pi\n# if self.start.lon < 0:\n# selfstartlon = self.start.lon + 2*math.pi\n# if other.end.lon < 0:\n# otherendlon = other.end.lon + 2*math.pi\n# if other.start.lon < 0:\n# otherstartlon = other.start.lon + 2*math.pi\n\n log.info(' self lons: '+str(math.degrees(selfstartlon))+' '+str(math.degrees(selfendlon))+' other lons: '+str(math.degrees(otherstartlon))+' '+str(math.degrees(otherendlon)))\n\n # If both vertical, will be no intersection\n if abs(selfendlon - selfstartlon) < EPSILON and abs(otherendlon - otherstartlon) < EPSILON:\n log.info(' Both vertical, no intersection')\n return None\n # If self is vertical, but not parallel, intersection will be selfstartlon and lat = Mother*lon+B_other\n if abs(selfendlon - selfstartlon) < EPSILON:\n lon = selfstartlon\n M_other = (other.end.lat - other.start.lat)/(otherendlon-otherstartlon)\n B_other = other.end.lat - M_other*otherendlon\n lat = M_other*lon+B_other\n log.info(' self is vertical')\n #Make sure it falls within the segment and not outside.\n # Previously was only checking lat, need to \n # also check lon or opposite side of world would match\n if (lat > min([self.end.lat,self.start.lat]) and \n lat < max([self.end.lat,self.start.lat]) and\n lon > min([otherendlon,otherstartlon]) and\n lon < max([otherendlon,otherstartlon])):\n log.info(' and intersects')\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\n # MLS use wrap_longitudes?\n if lon > math.pi:\n lon -= 2*math.pi\n return Coordinate(math.degrees(lon),math.degrees(lat))\n else:\n return None\n # same for other\n if abs(otherendlon - otherstartlon) < EPSILON:\n lon = otherstartlon\n M_self = (self.end.lat - self.start.lat)/(selfendlon-selfstartlon)\n B_self = self.end.lat - M_self*selfendlon\n lat = M_self*lon+B_self\n log.info(' other is vertical')\n #Make sure it falls within the segment and not outside.\n # Previously was only checking lat, need to \n # also check lon or opposite side of world would match\n if (lat > min([other.end.lat,other.start.lat]) and \n lat < max([other.end.lat,other.start.lat]) and \n lon > min([selfendlon,selfstartlon]) and\n lon < max([selfendlon,selfstartlon])):\n log.info(' and intersects')\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\n # MLS Use wrap_longitudes?\n if lon > math.pi:\n lon -= 2*math.pi\n return Coordinate(math.degrees(lon),math.degrees(lat))\n else:\n return None\n\n \n\n # Get slopes of the lines \n M_self = (self.end.lat - self.start.lat)/(selfendlon-selfstartlon)\n M_other = (other.end.lat - other.start.lat)/(otherendlon-otherstartlon)\n \n # If they are parallel, no intersection\n if (M_self-M_other) < EPSILON:\n log.info(' self and other are parallel, no intersection')\n return None\n\n # Get the y-intercepts of the lines \n B_self = self.end.lat - M_self*selfendlon\n B_other = other.end.lat - M_other*otherendlon\n\n # Solve the equation\n # y=m1x+b1 and y=m2x+b2, equate y's so m1x+b1=m2x+b2, x = (b1-b2)/(m2-m1)\n # equate x's so x=(y-b1)/m1=(y-b2)/m2, y = (b1m2-b2m1)/(m2-m1)\n lon = (B_self - B_other)/(M_other - M_self)\n lat = (B_self*M_other - B_other*M_self)/(M_other-M_self)\n\n # Make sure lat/lon intersects within the line segment, and not outside.\n if (lat > min([other.end.lat,other.start.lat]) and \n lat < max([other.end.lat,other.start.lat]) and\n lon > min([otherendlon,otherstartlon]) and \n lon < max([otherendlon,otherstartlon]) and\n lat > min([self.end.lat,self.start.lat]) and \n lat < max([self.end.lat,self.start.lat]) and\n lon > min([selfendlon,selfstartlon]) and \n lon < max([selfendlon,selfstartlon])):\n log.info(' self and other intersect within segment')\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\n # MLS use wrap longitudes?\n if lon > math.pi:\n lon -= 2*math.pi\n return Coordinate(math.degrees(lon),math.degrees(lat))\n else:\n log.info(' self and other intersect, but not within segment')\n return None","def proxy_line(**kwargs):\r\n return matplotlib.lines.Line2D(range(1), range(1), **kwargs)","def axis_helper(y_shape, x_shape):\n res = []\n j = len(x_shape) - 1\n for i in range(len(y_shape) - 1, -1, -1):\n if j < 0 or x_shape[j] != y_shape[i]:\n res.append(i)\n j -= 1\n return tuple(res[::-1])","def noAxisLines(axes='XYZ'):\n dislin.frame(0)\n dislin.noline(axes)","def crossAxes(axl, xyzero=[0.0, 0.0], limits=[None, None, None, None], labels:Union[str, None]=['nA', 'mV']):\n\n axl = _ax_tolist(axl)\n # if type(axl) is not list:\n # axl = [axl]\n for ax in axl:\n if ax is None:\n continue\n # ax.set_title('spines at data (1,2)')\n # ax.plot(x,y)\n ax.spines[\"left\"].set_position((\"data\", xyzero[0]))\n ax.spines[\"right\"].set_color(\"none\")\n ax.spines[\"bottom\"].set_position((\"data\", xyzero[1]))\n ax.spines[\"top\"].set_color(\"none\")\n # ax.spines['left'].set_smart_bounds(True)\n # ax.spines['bottom'].set_smart_bounds(True) # deprecated, not sure what to do\n ax.xaxis.set_ticks_position(\"bottom\")\n ax.yaxis.set_ticks_position(\"left\")\n if limits[0] is not None:\n ax.set_xlim(left=limits[0], right=limits[2])\n ax.set_ylim(bottom=limits[1], top=limits[3])","def calculate_axes_and_angle_directional(xrs1, xrs2):\n a1 = get_axis_from_xrs(xrs1)\n a2 = get_axis_from_xrs(xrs2)\n v1 = vector_from_two_points(xrs1.sites_cart()[0], xrs1.sites_cart()[-1])\n v2 = vector_from_two_points(xrs2.sites_cart()[0], xrs2.sites_cart()[-1])\n if a1.angle(v1)*180./math.pi > 90:\n a1 = -a1\n if a2.angle(v2)*180./math.pi > 90:\n a2 = -a2\n angle = a1.angle(a2)*180./math.pi\n return a1, a2, angle","def _sanity_check_two_series(\n series_1: TimeSeries,\n series_2: TimeSeries,\n):\n\n _assert_timeseries(series_1)\n _assert_timeseries(series_2)\n\n # check if the two inputs time series have the same number of components\n raise_if_not(\n series_1.width == series_2.width,\n \"Series must have the same number of components,\"\n + f\" found {series_1.width} and {series_2.width}.\",\n )\n\n # check if the time intersection between the two inputs time series is not empty\n raise_if_not(\n len(series_1.time_index.intersection(series_2.time_index)) > 0,\n \"Series must have a non-empty intersection timestamps.\",\n )","def _scatter_subplot(x, y, trendline_y=None, trendline_x=None, line_of_slope_1=False,\n x_label=None, y_label=None, x_limits=None, y_limits=None, axes_equal=True, subplot_title=None,\n trendline_dots=False, scatter_color=COLOR_PALETTE.primary,\n trendline_color=COLOR_PALETTE.secondary, legend=True, scatter_name=None,\n trendline_name=None, ax=None):\n if ax is None:\n ax = plt.gca()\n\n if scatter_name is None:\n scatter_name = 'Data points'\n\n if trendline_name is None:\n trendline_name = 'Regression line'\n\n if trendline_dots is True:\n trendline_marker = 'o-'\n else:\n trendline_marker = '-'\n\n if x_limits is None or y_limits is None:\n x_min, x_max, y_min, y_max = _derive_axes_limits_for_scatter_plot(x, y)\n\n if axes_equal:\n ax.set_aspect('equal')\n if x_limits is None and y_limits is None:\n axes_min = min(x_min, y_min)\n axes_max = max(x_max, y_max)\n x_limits = (axes_min, axes_max)\n y_limits = (axes_min, axes_max)\n\n if x_limits is None:\n x_limits = (x_min, x_max)\n if y_limits is None:\n y_limits = (y_min, y_max)\n\n ax.set_xlim(x_limits[0], x_limits[1])\n ax.set_ylim(y_limits[0], y_limits[1])\n\n no_dots = len(x)\n\n marker_size_max = 216\n marker_size_min = 18\n marker_size = -0.2 * no_dots + marker_size_max # y=mx+c, m = (216 - 18) / (1000 - 0) i.e. slope changes up to 1000\n marker_size = marker_size_min if marker_size < marker_size_min else marker_size\n\n max_alpha = 0.7\n min_alpha = 0.3\n alpha = -0.0004 * no_dots + max_alpha # y=mx+c, m = (0.7 - 0.3) / (1000 - 0) i.e. alpha changes up to 1000 dots\n alpha = min_alpha if alpha < min_alpha else alpha\n\n ax.scatter(x, y, marker='o', color=scatter_color, s=marker_size, alpha=alpha,\n edgecolors='none', label=scatter_name)\n\n if trendline_y is not None:\n if trendline_x is None:\n trendline_x = x\n\n ax.plot(trendline_x, trendline_y, trendline_marker, color=trendline_color, label=trendline_name)\n\n if line_of_slope_1:\n low_x, high_x = ax.get_xlim()\n low_y, high_y = ax.get_ylim()\n low = max(low_x, low_y)\n high = min(high_x, high_y)\n ax.plot([low, high], [low, high], color=COLOR_PALETTE.secondary_70, label='1:1 line')\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n\n if legend:\n ax.legend()\n\n if subplot_title is not None:\n ax.set_title(subplot_title, fontsize=mpl.rcParams['ytick.labelsize'])\n\n return ax","def axes_active(self) -> np.ndarray: # array[Axes]\n return self.axes.flat[:self.n_plots]","def viz_2D_topomap_intra (epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray,\n threshold: float=0.95, steps: int=2,\n lab: bool = False):\n\n # defining head model and adding sensors\n fig = plt.figure()\n ax = fig.add_subplot(111, aspect = 1)\n ax.axis(\"off\")\n plot_2d_topomap_intra(ax)\n # bads are represented as squares\n plot_sensors_2d_intra(epo1, epo2, lab = lab)\n # plotting links according to sign (red for positive values,\n # blue for negative) and value (line thickness increases\n # with the strength of connectivity)\n plot_links_2d_intra(epo1, epo2, C1=C1, C2=C2, threshold=threshold, steps=steps)\n plt.tight_layout()\n plt.show()\n\n return (ax)","def _add_dummy_rot_axis_edge(\n edges_1: np.ndarray,\n edges_2: np.ndarray,\n rot_axes: Literal[\"x\", \"y\", \"z\", \"xyz\"],\n ) -> Tuple[np.ndarray, np.ndarray]:\n if rot_axes == \"z\":\n edges_1[:, 2] = 0\n edges_2[:, 2] = 0\n edges_1 = np.vstack([edges_1, np.array([[0, 0, 1]])])\n edges_2 = np.vstack([edges_2, np.array([[0, 0, 1]])])\n if rot_axes == \"y\":\n edges_1[:, 1] = 0\n edges_2[:, 1] = 0\n edges_1 = np.vstack([edges_1, np.array([[0, 1, 0]])])\n edges_2 = np.vstack([edges_2, np.array([[0, 1, 0]])])\n if rot_axes == \"x\":\n edges_1[:, 0] = 0\n edges_2[:, 0] = 0\n edges_1 = np.vstack([edges_1, np.array([[1, 0, 0]])])\n edges_2 = np.vstack([edges_2, np.array([[1, 0, 0]])])\n return edges_1, edges_2","def test_link_axes(self):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n splt = SEGYPlotter(ax, self.segy)\n # should add one artist to our axes\n splt.plot_wiggles(wiggle_traces=True)\n self.assertEqual(len(splt.ACTIVE_LINES['wiggle_traces']), 1)\n self.assertTrue('wiggle_traces' not in splt.INACTIVE_LINES)\n self.assertEqual(len(ax.lines), 1)\n # should remove one artist to our axes\n splt.plot_wiggles(wiggle_traces=False)\n self.assertTrue('wiggle_traces' not in splt.ACTIVE_LINES)\n self.assertEqual(len(splt.INACTIVE_LINES['wiggle_traces']), 1)\n self.assertEqual(len(ax.lines), 0)","def duplicate_axes(isl_obj, duplicate_inames, new_inames):\n if isinstance(isl_obj, list):\n return [\n duplicate_axes(i, duplicate_inames, new_inames)\n for i in isl_obj]\n\n if not duplicate_inames:\n return isl_obj\n\n def _align_and_intersect(d1, d2):\n d1, d2 = isl.align_two(d1, d2)\n return d1 & d2\n\n old_name_to_new_name = dict(zip(duplicate_inames, new_inames))\n\n dup_isl_obj = isl_obj\n\n for old_name, (dt, pos) in isl_obj.get_var_dict().items():\n dup_isl_obj = dup_isl_obj.set_dim_name(dt, pos,\n old_name_to_new_name.get(old_name,\n old_name))\n\n return _align_and_intersect(dup_isl_obj, isl_obj)","def axes_maker(rows, cols):\n fig = plt.figure()\n current_subplot = [1] # Use list in order to modify\n def next_axes(**kwargs):\n current_subplot[0] += 1\n axes = fig.add_subplot(rows, cols, current_subplot[0] - 1, **kwargs)\n return axes\n return next_axes","def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors ('x' for bads)\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def findaxisbyname(self, *args, **kwargs):\n return _coordsys.coordsys_findaxisbyname(self, *args, **kwargs)","def comp_axes(self, machine, N0=None):\n if self.time is None and N0 is None:\n raise InputError(\"ERROR: time and N0 can't be both None\")\n\n # Get machine pole pair number\n p = machine.get_pole_pair_number()\n\n # Get electrical fundamental frequency\n f_elec = self.comp_felec()\n\n # Airgap radius\n Rag = machine.comp_Rgap_mec()\n\n # Setup normalizations for time and angle axes\n norm_time = {\n \"elec_order\": f_elec,\n \"mech_order\": f_elec / p,\n }\n if N0 is not None:\n norm_time[\"angle_rotor\"] = 1 / (360 * N0 / 60)\n\n norm_angle = {\"space_order\": p, \"distance\": 1 / Rag}\n\n # Create time axis\n if self.time is None:\n # Create time axis as a DataLinspace\n Time = DataLinspace(\n name=\"time\",\n unit=\"s\",\n initial=0,\n final=60 / N0 * self.Nrev,\n number=self.Nt_tot,\n include_endpoint=False,\n normalizations=norm_time,\n )\n else:\n # Load time data\n time = self.time.get_data()\n self.Nt_tot = len(time)\n Time = Data1D(name=\"time\", unit=\"s\", values=time, normalizations=norm_time)\n\n # Create angle axis\n if self.angle is None:\n # Create angle axis as a DataLinspace\n Angle = DataLinspace(\n name=\"angle\",\n unit=\"rad\",\n initial=0,\n final=2 * pi,\n number=self.Na_tot,\n include_endpoint=False,\n normalizations=norm_angle,\n )\n else:\n # Load angle data\n angle = self.angle.get_data()\n self.Na_tot = len(angle)\n Angle = Data1D(\n name=\"angle\", unit=\"rad\", values=angle, normalizations=norm_angle\n )\n\n return Time, Angle","def nonlinear_axis(start, end, res):\n axis = []\n i = start\n axis.append(i)\n i += i / fit_line(i, res[0], res[1])\n while i < end:\n axis.append(i)\n i += i / fit_line(i, res[0], res[1])\n return np.array(axis)","def _intersect(\n series_1: TimeSeries,\n series_2: TimeSeries,\n) -> Tuple[TimeSeries, TimeSeries]:\n\n new_series_1 = series_1.slice_intersect(series_2)\n raise_if(\n len(new_series_1) == 0,\n \"Time intersection between the two series must be non empty.\",\n )\n\n return new_series_1, series_2.slice_intersect(series_1)","def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\n width_axis.name = \"time\"\n assert len(conv1d_placeholder.axes.find_by_name(\"time\")) == 1\n\n conv_layer = Convolution((3, output_size), lambda x: 1)\n with pytest.raises(IncompatibleAxesError):\n conv_layer(conv1d_placeholder)\n # As a dictionary\n output = conv_layer(conv1d_placeholder, spatial_axes={\"W\": \"time\"})\n assert output.axes == conv1d_placeholder.axes\n # As a tuple\n output = conv_layer(conv1d_placeholder, spatial_axes=(\"D\", \"H\", \"time\"))\n assert output.axes == conv1d_placeholder.axes","def plot_overlay2axes(self, axes) -> None:\n # calculate height (based on leaf analysis ratio)\n upper_point = (\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\n )\n lower_point = (\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\n )\n height = abs(upper_point - lower_point) * 0.8\n\n for idx, line in enumerate(self.marker_lines):\n width = abs(self.error[idx]) * self._image.dpmm\n y = line.center.y\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\n\n if self._orientation == Orientation.UP_DOWN:\n r = Rectangle(width, height, center=(x, y))\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n else:\n r = Rectangle(height, width, center=(x, y))\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n r.plot2axes(\n axes, edgecolor=\"none\", fill=True, alpha=1, facecolor=self.bg_color[idx]\n )","def cross_time_index(df1, df2):\n series = pd.core.series.Series\n crossed_index = df1.index.intersection(df2.index)\n\n if type(df1) == series and type(df2) == series:\n df1 = df1[crossed_index]\n df2 = df2[crossed_index]\n elif type(df1) == series and type(df2) != series:\n df1 = df1[crossed_index]\n df2 = df2.loc[crossed_index, :]\n elif type(df1) != series and type(df2) == series:\n df1 = df1.loc[crossed_index, :]\n df2 = df2[crossed_index]\n else:\n df1 = df1.loc[crossed_index, :]\n df2 = df2.loc[crossed_index, :]\n return df1, df2","def plot_results_2d(p_1, p_2, d_1 = 'X', d_2 = 'Y'):\n plt.figure(figsize = (10, 10))\n ax = plt.axes() \n\n color=iter(cm.rainbow(np.linspace(0,1,p_1.shape[0]))) # (1)\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_1.shape[0], step = 1)]\n\n for p in np.arange(0, p_1.shape[0], step = 1): \n c = next(color) # (c)\n for t in np.arange(0, p_1.shape[1], step = 1): \n plt.plot(p_1[p, t], p_2[p, t], 'x', c = c, label = labels[p])\n legend_without_duplicate_labels(ax)\n ax.grid(b = 'True', which = 'major')\n ax.set_xlabel(d_1) \n ax.set_ylabel(d_2)\n ax.set_title('2D particle trajectories')","def advanced_line():\n\n # Make dataset specifying arguments\n dataset_a = DataSet(sine,line_style='-',line_width=1.5,marker_style='o',marker_size='4')\n\n # Make dataset changing options using setters\n dataset_b = DataSet(cosine)\n dataset_b.set_line(style='--',width=1.5)\n dataset_b.set_colour(colour='royalblue')\n\n # Make plot object and adjust properties using setters\n plot = Plot()\n plot.set_text(latex=True,label=12)\n plot.add_dataset(dataset_a)\n plot.add_dataset(dataset_b)\n plot.set_axes(xlim=(0,8),ylim=(-1.1,1.1),xlabel=r'$x$',ylabel=r'$f\\left(x\\right)$',xticks=(1.0,0.2),yticks=(0.2,0.05))\n\n # Plot graph and display\n plot.plot()\n plot.save(name='./figures/2d_advanced_line',fmt='png')\n plot.display()","def _handle_axes(self, drawable, option):\n # If we already have an axes object, ignore this one\n if self._axes_object is not None:\n return\n\n # Grab the histogram used for axes style/range manipulation\n if is_stack(drawable) or is_graph(drawable):\n axes_histogram = drawable.GetHistogram()\n else:\n axes_histogram = drawable\n\n # Grab the histogram used for title manipulation\n if is_stack(drawable):\n title_histogram = drawable.GetHists()[0]\n else:\n title_histogram = drawable\n\n # Set the plot title\n title_histogram.SetTitle(self._title)\n\n # Grab axes\n x_axis, y_axis = axes_histogram.GetXaxis(), axes_histogram.GetYaxis()\n\n # Grab titles from first histogram if not set explicitly\n if self._x_title is None:\n self._x_title = title_histogram.GetXaxis().GetTitle()\n if self._y_title is None:\n self._y_title = title_histogram.GetYaxis().GetTitle()\n\n # Style x-axis, or hide it if this plot has a ratio plot\n if self._x_range is not None:\n x_axis.SetRangeUser(*self._x_range)\n if self._ratio_plot:\n x_axis.SetLabelOffset(999)\n x_axis.SetTitleOffset(999)\n else:\n x_axis.SetTitle(self._x_title)\n x_axis.SetTitleSize(self.PLOT_X_AXIS_TITLE_SIZE)\n x_axis.SetTitleOffset(self.PLOT_X_AXIS_TITLE_OFFSET)\n x_axis.SetLabelSize(self.PLOT_X_AXIS_LABEL_SIZE)\n if self._x_integer_ticks:\n x_axis.SetNdivisions(11) # hack for integer ticks \n\n # Style y-axis\n y_axis.SetTitle(self._y_title)\n y_axis.SetLabelFont(self.PLOT_ATLAS_STAMP_TEXT_FONT)\n y_axis.SetTitleSize(\n (self.PLOT_Y_AXIS_TITLE_SIZE_WITH_RATIO\n if self._ratio_plot\n else self.PLOT_Y_AXIS_TITLE_SIZE)\n )\n y_axis.SetTitleOffset(\n (self.PLOT_Y_AXIS_TITLE_OFSET_WITH_RATIO\n if self._ratio_plot\n else self.PLOT_Y_AXIS_TITLE_OFFSET)\n )\n y_axis.SetNdivisions(5,5,0)\n \n # set axis text sizes \n if self._ratio_plot:\n y_axis.SetLabelSize(self.PLOT_Y_AXIS_LABEL_SIZE_WITH_RATIO)\n else:\n y_axis.SetLabelSize(self.PLOT_Y_AXIS_LABEL_SIZE) \n y_axis.SetTitleSize(self.PLOT_Y_AXIS_TITLE_SIZE)\n y_axis.SetTitleOffset(self.PLOT_RATIO_Y_AXIS_TITLE_OFFSET)\n\n # Redraw the drawable with the new style\n drawable.Draw(option)","def __init__(self, axis1, axis2=None, bins=100, same_scale=False,\n axis1_values=None, axis2_values=None, **kwargs):\n self.same_scale = same_scale\n\n self.axis1 = axis1\n self.axis1_limits = None\n\n if isinstance(axis1_values, (float, int)):\n axis1_values = [axis1_values]\n self.axis1_values = axis1_values\n\n self.axis2 = axis2\n self.axis2_limits = None\n if isinstance(axis2_values, (float, int)):\n axis2_values = [axis2_values]\n self.axis2_values = axis2_values\n\n self.bins = bins\n\n self.plot_options = kwargs","def align_yaxis(ax1, v1, ax2, v2):\n _, y1 = ax1.transData.transform((0, v1))\n _, y2 = ax2.transData.transform((0, v2))\n inv = ax2.transData.inverted()\n _, dy = inv.transform((0, 0)) - inv.transform((0, y1-y2))\n miny, maxy = ax2.get_ylim()\n ax2.set_ylim(miny+dy, maxy+dy)","def trace(self, axis1=0, axis2=1):\n assert self.compatible_indices(self, axis1, axis2)\n if axis1 < axis2:\n axis1, axis2 = axis2, axis1\n if self.dirs[axis1] + self.dirs[axis2] != 0:\n warnings.warn(\n \"Automatically flipping dir %i in trace.\" % axis1, stacklevel=2\n )\n self = self.flip_dir(axis1)\n # Create the result tensor by taking an empty tensor like self, and\n # removing the indices that are traced.\n res = self.empty_like()\n del res.shape[axis1]\n del res.shape[axis2]\n del res.qhape[axis1]\n del res.qhape[axis2]\n del res.dirs[axis1]\n del res.dirs[axis2]\n\n # We could avoid looping over the whole dictionary by constructing the\n # cartesian product of all the qims but not qhape[axis2], and then\n # infering what the qnum on axis2 should be. I suspect that this would\n # be slower, but I haven't tried.\n for k, v in self.sects.items():\n qnum = k[axis1] - k[axis2]\n if self.qodulus is not None:\n qnum %= self.qodulus\n if qnum == 0:\n new_k = tuple(\n i for j, i in enumerate(k) if j != axis1 and j != axis2\n )\n if new_k in res.sects:\n res[new_k] += v.trace(axis1=axis1, axis2=axis2)\n else:\n res[new_k] = v.trace(axis1=axis1, axis2=axis2)\n if res.isscalar():\n try:\n res.defval = res[()]\n res.sects = {}\n except KeyError:\n # There was no () block, so the tensor is 0 by symmetry.\n pass\n return res","def _line_from_two_points(pt1: np.array, pt2: np.array) -> np.array:\n numLine = pt1.shape[0]\n lines = np.zeros((numLine, 6))\n n = np.cross(pt1, pt2)\n n = n / (matlib.repmat(np.sqrt(np.sum(n ** 2, 1, keepdims=True)), 1, 3) + 1e-9)\n lines[:, 0:3] = n\n\n areaXY = np.abs(np.sum(n * matlib.repmat([0, 0, 1], numLine, 1), 1, keepdims=True))\n areaYZ = np.abs(np.sum(n * matlib.repmat([1, 0, 0], numLine, 1), 1, keepdims=True))\n areaZX = np.abs(np.sum(n * matlib.repmat([0, 1, 0], numLine, 1), 1, keepdims=True))\n planeIDs = np.argmax(np.hstack([areaXY, areaYZ, areaZX]), axis=1) + 1\n lines[:, 3] = planeIDs\n\n for i in range(numLine):\n uv = _xyz2uvN(np.vstack([pt1[i, :], pt2[i, :]]), lines[i, 3])\n umax = uv[:, 0].max() + np.pi\n umin = uv[:, 0].min() + np.pi\n if umax - umin > np.pi:\n lines[i, 4:6] = np.array([umax, umin]) / 2 / np.pi\n else:\n lines[i, 4:6] = np.array([umin, umax]) / 2 / np.pi\n\n return lines","def scatter_and_line():\n\n # Make random data points around straight line\n random_linear = np.zeros((1000,2))\n random_linear[:,0] = np.random.uniform(0,10,1000)\n random_error = np.random.normal(0.0,2.0,1000)\n random_linear[:,1] = random_linear[:,0]*2.0+1.0+random_error\n\n # Make datasets, order determining line graph on top\n dataset_a = DataSet(random_linear,plot='scatter',order=0,label='Random')\n dataset_b = DataSet(linear,plot='line',colour='black',order=1,label='Linear')\n\n # Colour scatter graph by error\n dataset_a.set_colour(map='coolwarm',colour=random_error)\n\n # Make plot object and add datasets\n plot = Plot()\n plot.set_text(latex=True)\n plot.add_dataset(dataset_a)\n plot.add_dataset(dataset_b)\n plot.set_legend(legend=True)\n\n # Plot graph and display\n plot.plot()\n plot.save(name='./figures/2d_scatter_and_line',fmt='png')\n plot.display()","def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\n steps: int=10):\n \n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n ctr1 = np.nanmean(loc1, 0)\n ctr1[2] -= 0.2\n ctr2 = np.nanmean(loc2, 0)\n ctr2[2] -= 0.2\n\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\n Cmax1=np.nanmax(C1[:])\n Cmax2=np.nanmax(C2[:])\n Cmax=[]\n Cmax=[Cmax1, Cmax2]\n vmax=np.nanmax(Cmax)\n Cmin1=np.nanmin(C1[:])\n Cmin2=np.nanmin(C2[:])\n Cmin=[]\n Cmin=[Cmin1, Cmin2]\n vmin=np.min(Cmin)\n\n # Calculate automatic threshold\n if threshold == 'auto':\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\n else:\n threshold = threshold\n\n # Define colormap for both participant\n cmap_p = matplotlib.cm.get_cmap('Reds')\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\n\n for e1 in range(len(loc1)):\n x1 = loc1[e1, 0]\n y1 = loc1[e1, 1]\n z1 = loc1[e1, 2]\n for e2 in range(len(loc1)):\n x2 = loc1[e2, 0]\n y2 = loc1[e2, 1]\n z2 = loc1[e2, 2]\n if C1[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C1[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)\n \n for e1 in range(len(loc2)):\n x1 = loc2[e1, 0]\n y1 = loc2[e1, 1]\n z1 = loc2[e1, 2]\n for e2 in range(len(loc2)):\n x2 = loc2[e2, 0]\n y2 = loc2[e2, 1]\n z2 = loc2[e2, 2]\n if C2[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C2[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)","def _filter_axes(self, channel_axes, spatial_axes):\n f_axes = ng.make_axes()\n f_axes += ng.make_axis(length=self.nout, name=\"K\")\n f_axes += channel_axes\n for key, ax in zip(self.spatial_keys, spatial_axes):\n f_axes += ng.make_axis(length=self.filter_spatial_shape[key],\n name=ax.name)\n\n return f_axes","def __eq__(self, other):\n return (\n isinstance(other, SeriesAxis)\n and self.start == other.start\n and self.step == other.step\n and self.size == other.size\n and self.unit == other.unit\n )"],"string":"[\n \"def common_axes( mv1, mv2 ):\\n axes1 = [a[0] for a in mv1.getDomain()]\\n axes2 = [a[0] for a in mv2.getDomain()]\\n if len(axes1)!=len(axes2):\\n print \\\"ERROR. common_axes requires same number of axes in\\\",mv1,\\\" and\\\",mv2\\n return None\\n axes3 = []\\n for i in range(len(axes1)):\\n axes3.append(common_axis( axes1[i], axes2[i] ))\\n return axes3\",\n \"def _make_twin_axes(self, *args, **kwargs):\\n # Typically, SubplotBase._make_twin_axes is called instead of this.\\n # There is also an override in axes_grid1/axes_divider.py.\\n if 'sharex' in kwargs and 'sharey' in kwargs:\\n raise ValueError('Twinned Axes may share only one axis.')\\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\\n self.set_adjustable('datalim')\\n ax2.set_adjustable('datalim')\\n self._twinned_axes.join(self, ax2)\\n return ax2\",\n \"def intersection(self, axis2):\",\n \"def _find_axes(cls, input_data, explicit_x=None):\\n\\n if isinstance(input_data, pd.Series):\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a pandas Series\\\")\\n\\n return input_data.index, input_data.values\\n elif isinstance(input_data, pd.DataFrame):\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a pandas DataFrame\\\")\\n\\n return input_data.index, input_data.values[:, 0]\\n elif isinstance(input_data, np.ndarray):\\n if len(input_data.shape) == 2 and input_data.shape[0] == 2:\\n if explicit_x is not None:\\n raise ArgumentError(\\\"You cannot pass an explicit x axis with a 2D array of input data\\\")\\n\\n return input_data[:, 0], input_data[:, 1]\\n elif len(input_data.shape) == 1:\\n if explicit_x is not None:\\n if len(explicit_x) != len(input_data):\\n raise ArgumentError(\\\"Your explicit x data has a different length that your y data\\\", x_length=len(explicit_x), y_length=len(input_data))\\n\\n return explicit_x, input_data\\n else:\\n return np.linspace(0, len(input_data) - 1, len(input_data)), input_data\\n elif explicit_x is not None:\\n return np.array(explicit_x), np.array(explicit_x)\\n\\n return np.linspace(0, len(input_data) - 1, len(input_data)), np.array(input_data)\",\n \"def aminusb_2ax( mv1, mv2 ):\\n return mv2\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n missing = mv1.get_fill_value()\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n if axes1 is None or axes2 is None: return None\\n if len(axes1)!=2: print \\\"ERROR @1, wrong number of axes for aminusb_2ax\\\",axes1\\n if len(axes2)!=2: print \\\"ERROR @2, wrong number of axes for aminusb_2ax\\\",axes2\\n if len(axes1[0])==len(axes2[0]):\\n # Only axis2 differs, there's a better way...\\n return aminusb_ax2( mv1, mv2 )\\n if len(axes1[0])<=len(axes2[0]):\\n if len(axes1[1])<=len(axes2[1]):\\n mv1new = mv1\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid1 = mv1.getGrid()\\n mv2new = mv2.regrid(grid1)\\n else:\\n # Interpolate mv1 from axis1[1] to axis2[1]\\n # Interpolate mv2 from axis2[0] to axis1[0]\\n print \\\"ERROR @3, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n if len(axes1[1])<=len(axes2[1]):\\n # Interpolate mv1 from axis1[0] to axis2[0]\\n # Interpolate mv2 from axis2[1] to axis1[1]\\n print \\\"ERROR @4, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n mv2new = mv2\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid2 = mv2.getGrid()\\n mv1new = mv1.regrid(grid2)\\n aminusb = mv1new - mv2new\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def axes2indices(\\n self,\\n axes:'Union['\\n 'Tuple[Union[ConvertableAxisClass, ellipsis], ...], '\\n 'Mapping[NamedIndex, ConvertableAxisClass],'\\n ']',\\n )->'Any':\\n\\n if isinstance(axes, dict):\\n indices = []\\n for dim, axes_ in self.items():\\n axis = axes.get(dim)\\n if axis is None and dim in axes:\\n warnings.warn(f'it does not make sense using None(at dim {dim!r}) '\\n 'in a named index, it whould be translated into '\\n 'slice(None)(i.e. :)')\\n index = slice(None) if axis is None else axis2index(axes_, axis)\\n indices.append(index)\\n return tuple(indices)\\n\\n axes = axes if isinstance(axes, tuple) else (axes, )\\n idx_elps = naxis = len(axes)\\n for idx_axis, axis in enumerate(axes):\\n if isinstance(axis, type(Ellipsis)):\\n assert idx_elps == naxis, 'more than one ellipsis is not allowed'\\n\\n idx_elps = idx_axis\\n\\n indices = []\\n idx_axis = idx_dim = 0\\n while idx_axis < idx_elps:\\n axis = axes[idx_axis]\\n index = None if axis is None else axis2index(self._dim_axes[idx_dim], axis)\\n indices.append(index)\\n idx_axis += 1\\n idx_dim += index is not None\\n\\n if idx_elps < naxis:\\n indices.append(axes[idx_elps])\\n remainder = idx_elps + 1 - naxis\\n indices_ = []\\n idx_axis = idx_dim = -1\\n while idx_axis >= remainder:\\n axis = axes[idx_axis]\\n index = None if axis is None else axis2index(self._dim_axes[idx_dim], axis)\\n indices_.append(index)\\n idx_axis -= 1\\n idx_dim -= index is not None\\n indices_.reverse()\\n indices.extend(indices_)\\n\\n return tuple(indices)\",\n \"def axline(x=None, y=None, a=None, b=None,\\n xlim=None, ylim=None, xinvert=False, yinvert=False, xlog=False, ylog=False, title=None,\\n xlabel=None, ylabel=None, label=None, grid=None, ax=None, plot_kw={}, **kwargs):\\n\\n # Get the relevant axis\\n if ax is not None:\\n if isinstance(ax, (list, tuple, ndarray)):\\n if len(shape(ax)) > 1: # If ax array is multi-dimensional, flatten it\\n ax = array(ax).flatten()\\n else:\\n ax = [ax] # Axis must be a list-like object\\n else:\\n ax = [gca()]\\n \\n old_ax = axes_handler(ax[0]) # sets the current axis and returns old axis\\n\\n # Validate input parameters\\n if not (any([is_numeric(var) for var in [x, y, a, b]])): # If nothing has been specified\\n raise TypeError(\\\"axline() missing one of optional arguments: 'x', 'y', 'a' or 'b'\\\")\\n\\n for i, val in enumerate([x, y, a, b]):\\n if (val is not None):\\n try: # Test whether the parameter is iterable\\n _ = (k for k in val)\\n except TypeError: # If not, convert to a list\\n if (i == 0): x = [x]\\n elif (i == 1): y = [y]\\n elif (i == 2): a = [a]\\n elif (i == 3): b = [b]\\n\\n if (x is not None and y is not None): # Check whether both x and y were specified\\n raise ValueError(\\\"'x' and 'y' cannot be both specified\\\")\\n\\n if (x is not None): # Check conditions if x specified\\n if (any([a, b])): # Should not specify a or b, if x given.\\n raise ValueError(\\\"'{0}' cannot be specified if x specified\\\".format('a' if a else 'b'))\\n L = len(x)\\n\\n if (y is not None): # Check conditions if y specified\\n if (any([a, b])): # Should not specify a or b, if y given.\\n raise ValueError(\\\"'{0}' cannot be specified if y specified\\\".format('a' if a else 'b'))\\n L = len(y)\\n\\n if (a is not None):\\n if (b is None): # If no intercept specified\\n b = [0] * len(a) # set b to 0 for all a\\n else:\\n if (len(b) == 1):\\n b = [b[0]] * len(a)\\n elif (len(b) != len(a)):\\n if (len(a) == 1):\\n a = [a[0]] * len(b)\\n else:\\n raise ValueError(f\\\"Length of 'a' ({len(a)}) and length of 'b' ({len(b)}) must be equal or otherwise 1\\\")\\n L = len(a)\\n elif (b is not None):\\n if (a is None): # If no slope specified\\n a = [1] * len(b) # set a to 1 for all b\\n L = len(b)\\n\\n if not isinstance(label, list):\\n label = [label] * L\\n elif (len(label) != L):\\n raise ValueError(\\\"Length of label list ({0}) must match the number of lines given ({1}).\\\".format(len(label), L))\\n\\n # Combine the `explicit` plot_kw dictionary with the `implicit` **kwargs dictionary\\n plot_par = {**plot_kw, **kwargs}\\n\\n # Create 'L' number of plot kwarg dictionaries to parse into each plot call\\n plot_par = dict_splicer(plot_par, L, [1] * L)\\n\\n lines = [[]] * len(ax) # Initialise list which contains each Line2D object\\n for jj, axis in enumerate(ax): # Loop over all axes\\n gridpar = grid_handler(grid, axis)\\n\\n ax_xlim = axis.get_xlim() if lims_handler(xlim, axis) is None else xlim\\n ax_ylim = axis.get_ylim() if lims_handler(ylim, axis) is None else ylim\\n\\n if (x is not None):\\n for ii, xx in enumerate(x):\\n lines[jj].append(axis.axvline(x=xx, **plot_par[ii], label=label[ii]))\\n if (y is not None):\\n for ii, yy in enumerate(y):\\n lines[jj].append(axis.axhline(y=yy, **plot_par[ii], label=label[ii]))\\n if (a is not None):\\n for ii, (aa, bb) in enumerate(zip(a, b)): # Loop over all lines\\n lines[jj].append(axis.axline(xy1=(0, bb), slope=aa, label=label[ii], **plot_par[ii]))\\n\\n _plot_finalizer(xlog, ylog, ax_xlim, ax_ylim, title, xlabel, ylabel, xinvert, yinvert, gridpar, axis)\\n\\n if old_ax is not None: # Reset the previously set axis\\n sca(old_ax)\\n\\n return squeeze(lines).tolist() # Reduce the dimensionality of the lines, if needed\",\n \"def plot_line(ax, p1, p2, *args, **kwargs):\\n ax.plot(*zip(p1, p2), *args, **kwargs)\",\n \"def setup_axes(self):\\n fig = plt.figure(1)\\n axs = fig.add_subplot(1, 1, 1)\\n fig.clf()\\n axs = plt.subplots(1, 2)\\n ax1 : plt.axis = axs[0]\\n ax2 : plt.axis = axs[1]\\n fig.canvas.draw()\\n \\n line1_t, = ax1.plot([], label='train')\\n line1_v, = ax1.plot([], label='val')\\n\\n ax1.set_title('Loss vs Iterations')\\n ax1.set_xlabel('Iterations')\\n ax1.set_ylabel('Loss')\\n ax1.grid(True)\\n ax1.autoscale()\\n # ax1.legend()\\n\\n line2_t, = ax2.plot([], label='train')\\n line2_v, = ax2.plot([], label='val')\\n\\n ax2.set_title('Accuracy vs Iterations')\\n ax2.set_xlabel('Time')\\n ax2.set_ylabel('Percent Accuracy')\\n ax2.grid(True)\\n ax2.autoscale()\\n # ax2.legend()\\n\\n lines = [line1_t, line1_v, line2_t, line2_v]\\n\\n return fig, ax1, ax2, lines\",\n \"def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\\n common_axis_lengths):\\n cumul_lengths = np.cumsum(common_axis_lengths)\\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\\n if sequence_index == 0:\\n common_axis_index = cube_like_index\\n else:\\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\\n return sequence_index, common_axis_index\",\n \"def _color_twin_axes(ax1, color1, ax2, color2):\\n #spines\\n ax1.spines['left'].set_color(color1)\\n ax1.spines['right'].set_color(color2)\\n ax2.spines['left'].set_color(color1)\\n ax2.spines['right'].set_color(color2)\\n #text\\n ax1.yaxis.label.set_color(color1)\\n ax2.yaxis.label.set_color(color2)\\n #ticks\\n ax1.tick_params(axis = 'y', colors = color1)\\n ax2.tick_params(axis = 'y', colors = color2)\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def axis2index(axes:NamedAxes, axis:ConvertableAxisClass)->IndexClass:\\n\\n if axis is None:\\n return axis\\n\\n # NOTE: iterating until hashable\\n if isinstance(axis, Collection) and not isinstance(axis, Hashable):\\n iter_index = (axis2index(axes, a) for a in axis)\\n if isinstance(axis, np.ndarray): # force list output for numpy array\\n return list(iter_index)\\n return type(axis)(iter_index)\\n\\n if isinstance(axis, slice):\\n start = axis2index(axes, axis.start)\\n stop = axis2index(axes, axis.stop)\\n return type(axis)(start, stop, axis.step)\\n\\n if isinstance(axes, dict):\\n return axes[axis]\\n\\n if is_namedtuple(axes):\\n return getattr(axes, axis)\\n\\n # fallback to int axes with int axis\\n assert is_integer(axes) and is_integer(axis), f'unnamed axis({axis!r}) should be integer'\\n\\n return axis\",\n \"def _lines_intersection(self, other):\\n\\n the_slope, the_y_intercept = False, False\\n\\n # parallel?\\n if self.slope == other.slope:\\n return (\\n self.y_intercept == other.y_intercept and\\n self.x_value == other.x_value\\n )\\n\\n if self.is_vertical():\\n x = self.x_value\\n the_slope = other.slope\\n the_y_intercept = other.y_intercept\\n elif other.is_vertical():\\n x = other.x_value\\n else:\\n x = (other.y_intercept - self.y_intercept) / (self.slope - other.slope)\\n\\n if the_slope is None or the_slope is False:\\n the_slope = self.slope\\n the_y_intercept = self.y_intercept\\n\\n y = the_slope * x + the_y_intercept\\n\\n return Point(x, y)\",\n \"def _format_twin_axes(*args):\\n if(len(args) > 1):\\n #get minimum y limit\\n ylow, yhigh = 0., 0.\\n for ax in args:\\n yl = ax.get_ylim()\\n if(yl[0] < ylow):\\n ylow = yl[0]\\n yhigh = yl[1]\\n #scale all axes identically so that they overlap at y = 0\\n if(yhigh != 0):\\n frac = ylow/yhigh\\n for ax in args:\\n yl = ax.get_ylim()\\n ax.set_ylim(frac*yl[1], yl[1])\",\n \"def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\\n\\n ps = phase_space[:, (id_begin-1):id_end, :]\\n # print(np.shape(ps))\\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\\n\\n x = ps[0, :, :]\\n px = ps[1, :, :]\\n y = ps[2, :, :]\\n py = ps[3, :, :]\\n\\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\\n\\n for n in range(int(id_end-id_begin+1)):\\n x_this = x[n, :]\\n px_this = px[n, :]\\n y_this = y[n, :]\\n py_this = py[n, :]\\n\\n # Remove all NAN elements in the phase space array\\n x_this = x_this[np.logical_not(np.isnan(x_this))]\\n px_this = px_this[np.logical_not(np.isnan(px_this))]\\n y_this = y_this[np.logical_not(np.isnan(y_this))]\\n py_this = py_this[np.logical_not(np.isnan(py_this))]\\n\\n ## Plot X\\n plt.subplot(2, 2, 1)\\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\\n plt.ylabel('Position in X/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot Y\\n plt.subplot(2, 2, 2)\\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\\n plt.ylabel('Position in Y/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot px\\n plt.subplot(2, 2, 3)\\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\\n plt.ylabel('Angle in X', fontsize=10)\\n\\n ## Plot py\\n plt.subplot(2, 2, 4)\\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\\n plt.ylabel('Angle in Y', fontsize=10)\\n\\n\\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\\\mu$m')\\n # plt.title('First Undulator Section')\\n # plt.title('Second Undulator Section')\\n # plt.title('Third Undulator Section')\\n\\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\\n\\n fig = plt.gcf()\\n fig.set_size_inches(13.5, 9)\\n ax = plt.gca()\\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\\n fig.savefig('phase_space_U3_new.png', dpi=100)\\n plt.show()\\n\\n\\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\\n\\n return id_on_axis, s_on_axis\",\n \"def get_tick_iterators(self, axes):\\n\\n lat_levs, lat_n, lat_factor = self._grid_info[\\\"lat_info\\\"]\\n yy0 = lat_levs / lat_factor\\n\\n lon_levs, lon_n, lon_factor = self._grid_info[\\\"lon_info\\\"]\\n xx0 = lon_levs / lon_factor\\n\\n e0, e1 = self._extremes\\n\\n def trf_xy(x, y):\\n trf = self.grid_helper.grid_finder.get_transform() + axes.transData\\n return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T\\n\\n # find angles\\n if self.nth_coord == 0:\\n mask = (e0 <= yy0) & (yy0 <= e1)\\n (xx1, yy1), (dxx1, dyy1), (dxx2, dyy2) = _value_and_jacobian(\\n trf_xy, self.value, yy0[mask], (-np.inf, np.inf), (e0, e1))\\n labels = self._grid_info[\\\"lat_labels\\\"]\\n\\n elif self.nth_coord == 1:\\n mask = (e0 <= xx0) & (xx0 <= e1)\\n (xx1, yy1), (dxx2, dyy2), (dxx1, dyy1) = _value_and_jacobian(\\n trf_xy, xx0[mask], self.value, (-np.inf, np.inf), (e0, e1))\\n labels = self._grid_info[\\\"lon_labels\\\"]\\n\\n labels = [l for l, m in zip(labels, mask) if m]\\n\\n angle_normal = np.arctan2(dyy1, dxx1)\\n angle_tangent = np.arctan2(dyy2, dxx2)\\n mm = (dyy1 == 0) & (dxx1 == 0) # points with degenerate normal\\n angle_normal[mm] = angle_tangent[mm] + np.pi / 2\\n\\n tick_to_axes = self.get_tick_transform(axes) - axes.transAxes\\n in_01 = functools.partial(\\n mpl.transforms._interval_contains_close, (0, 1))\\n\\n def f1():\\n for x, y, normal, tangent, lab \\\\\\n in zip(xx1, yy1, angle_normal, angle_tangent, labels):\\n c2 = tick_to_axes.transform((x, y))\\n if in_01(c2[0]) and in_01(c2[1]):\\n yield [x, y], *np.rad2deg([normal, tangent]), lab\\n\\n return f1(), iter([])\",\n \"def ft_ax(ax=None,\\n y=1.03,\\n yy=1.1,\\n title=None,\\n subtitle=None,\\n source=None,\\n add_box=False,\\n left_axis=False):\\n\\n if ax is None:\\n ax = plt.gca()\\n\\n ax.set_axisbelow(True)\\n \\n if title is not None:\\n title = plt.title(title, y=y, loc='left')\\n if subtitle is not None:\\n plt.annotate(subtitle, xy=title.get_position(),\\n xycoords='axes fraction', xytext=(0,-11), \\n textcoords='offset points', size='large') \\n \\n if source is not None:\\n src = plt.annotate(source, xy=(0,0), \\n xycoords='axes fraction', xytext=(0,-35), \\n textcoords='offset points', ha='left', va='top', size='small')\\n \\n # axes and grid-lines\\n plt.grid(axis='y', linewidth=.5)\\n sns.despine(left=True)\\n if not left_axis:\\n ax.yaxis.tick_right()\\n ax.yaxis.set_label_position('right')\\n ax.yaxis.set_label_coords(1,yy)\\n ax.yaxis.get_label().set_rotation(0)\\n ax.tick_params('y', length=0)\\n \\n plt.tight_layout()\\n \\n if add_box:\\n ax2 = plt.axes(ax.get_position().bounds, facecolor=(1,1,1,0))\\n ax2.xaxis.set_visible(False)\\n ax2.yaxis.set_visible(False)\\n x,y = np.array([[.01, 0.15], [y+.12, y+.12]])\\n line = matplotlib.lines.Line2D(x, y, lw=6., color='k')\\n ax2.add_line(line)\\n line.set_clip_on(False)\\n \\n if add_box and source is not None:\\n return (line, src)\\n elif not add_box and source is not None:\\n return (src,)\\n elif add_box and source is None:\\n return (line,)\\n else:\\n return []\",\n \"def maybe_get_ax(*args, **kwargs):\\n\\n if 'ax' in kwargs:\\n ax = kwargs.pop('ax')\\n elif len(args) == 0:\\n fig = plt.gcf()\\n ax = plt.gca()\\n elif isinstance(args[0], mpl.axes.Axes):\\n ax = args[0]\\n args = args[1:]\\n else:\\n ax = plt.gca()\\n return ax, args, dict(kwargs)\",\n \"def intersection(line1, line2):\\n p0, p1, p2, p3 = map(\\n lambda tup : np.array(tup[:2]),\\n [line1[0], line1[1], line2[0], line2[1]]\\n )\\n p1, p2, p3 = map(lambda x : x - p0, [p1, p2, p3])\\n transform = np.zeros((2, 2))\\n transform[:,0], transform[:,1] = p1, p2\\n if np.linalg.det(transform) == 0: return\\n inv = np.linalg.inv(transform)\\n new_p3 = np.dot(inv, p3.reshape((2, 1)))\\n #Where does line connecting (0, 1) to new_p3 hit x axis\\n x_intercept = new_p3[0] / (1 - new_p3[1]) \\n result = np.dot(transform, [[x_intercept], [0]])\\n result = result.reshape((2,)) + p0\\n return result\",\n \"def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\\n\\n tr =PolarAxes.PolarTransform()\\n pi = np.pi\\n\\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\\n\\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\\n tick_formatter1 = DictFormatter(dict(angle_ticks))\\n\\n grid_locator2 = MaxNLocator(4)\\n\\n grid_helper = floating_axes.GridHelperCurveLinear(\\n tr, extremes=(tmax, tmin, zmax, zmin),\\n grid_locator1=grid_locator1,\\n grid_locator2=grid_locator2,\\n tick_formatter1=tick_formatter1,\\n tick_formatter2=None)\\n\\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\\n fig.add_subplot(ax1)\\n\\n # create a parasite axes whose transData in RA, cz\\n aux_ax = ax1.get_aux_axes(tr)\\n\\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\\n # drawn twice, and possibly over some other\\n # artists. So, we decrease the zorder a bit to\\n # prevent this.\\n\\n return ax1, aux_ax\",\n \"def setX(ax1: Union[object, List], ax2: Union[object, List]):\\n if type(ax1) is list:\\n print(\\\"PlotHelpers: cannot use list as source to set Y axis\\\")\\n return\\n ax2 = _ax_tolist(ax2)\\n # if type(ax2) is not list:\\n # ax2 = [ax2]\\n refx = ax1.get_xlim()\\n for ax in ax2:\\n ax.set_xlim(refx)\",\n \"def itrace(a, axes=(0, 1)):\\n # Single index pair to trace out\\n if isinstance(axes[0], Integral):\\n return np.trace(a, axis1=axes[0], axis2=axes[1])\\n elif len(axes[0]) == 1:\\n return np.trace(a, axis1=axes[0][0], axis2=axes[1][0])\\n\\n # Multiple index pairs to trace out\\n gone = set()\\n for axis1, axis2 in zip(*axes):\\n # Modify indices to adjust for traced out dimensions\\n mod1 = sum(x < axis1 for x in gone)\\n mod2 = sum(x < axis2 for x in gone)\\n gone |= {axis1, axis2}\\n a = np.trace(a, axis1=axis1 - mod1, axis2=axis2 - mod2)\\n return a\",\n \"def plot_sensors_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor info and transform loc to fit with headmodel\\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 = []\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 = []\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n \\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def plot_2d_topomap_intra(ax):\\n\\n # plot first Head \\n N = 300 # number of points for interpolation\\n xy_center = [-0.178,0] # center of the plot\\n radius = 0.1 # radius\\n\\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n # add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon) \\n \\n\\n # Plot second Head \\n x2y2_center = [0.178,0] # center of the plot\\n radius2 = 0.1 # radius\\n \\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n ## add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon)\",\n \"def _get_lines_parallel_to_axis(\\n self,\\n axis_parallel_to: NumberLine,\\n axis_perpendicular_to: NumberLine,\\n freq: float,\\n ratio_faded_lines: int,\\n ) -> tuple[VGroup, VGroup]:\\n\\n line = Line(axis_parallel_to.get_start(), axis_parallel_to.get_end())\\n if ratio_faded_lines == 0: # don't show faded lines\\n ratio_faded_lines = 1 # i.e. set ratio to 1\\n step = (1 / ratio_faded_lines) * freq\\n lines1 = VGroup()\\n lines2 = VGroup()\\n unit_vector_axis_perp_to = axis_perpendicular_to.get_unit_vector()\\n\\n # need to unpack all three values\\n x_min, x_max, _ = axis_perpendicular_to.x_range\\n\\n # account for different axis scalings (logarithmic), where\\n # negative values do not exist and [-2 , 4] should output lines\\n # similar to [0, 6]\\n if axis_perpendicular_to.x_min > 0 and x_min < 0:\\n x_min, x_max = (0, np.abs(x_min) + np.abs(x_max))\\n\\n # min/max used in case range does not include 0. i.e. if (2,6):\\n # the range becomes (0,4), not (0,6).\\n ranges = (\\n [0],\\n np.arange(step, min(x_max - x_min, x_max), step),\\n np.arange(-step, max(x_min - x_max, x_min), -step),\\n )\\n\\n for inputs in ranges:\\n for k, x in enumerate(inputs):\\n new_line = line.copy()\\n new_line.shift(unit_vector_axis_perp_to * x)\\n if (k + 1) % ratio_faded_lines == 0:\\n lines1.add(new_line)\\n else:\\n lines2.add(new_line)\\n return lines1, lines2\",\n \"def axes_subplots():\\n # gerenate data\\n x = np.arange(0, 6 * np.pi+0.2, 0.2)\\n y_1 = np.cos(x)\\n y_2 = np.sin(2*x)\\n y_3 = y_1 + y_2\\n\\n # display multiple\\n fig, axs = plt.subplots(3, 1, sharex=True)\\n fig.suptitle('Subplots w/ shared axes')\\n axs[0].plot(x, y_1)\\n axs[1].plot(x, y_2)\\n axs[2].plot(x, y_3)\\n axs[0].set_ylabel('$y$')\\n axs[1].set_ylabel('$y$')\\n axs[2].set_ylabel('$y$')\\n\\n plt.show()\\n\\n return None\",\n \"def _getAxesExtent(\\n self,\\n x0: float,\\n y0: float,\\n x1: float,\\n y1: float,\\n enabledAxes: Optional[EnabledAxes] = None,\\n ) -> AxesExtent:\\n if enabledAxes is None:\\n enabledAxes = self.enabledAxes\\n\\n y2_0, y2_1 = y0, y1\\n left, top, width, height = self.plot.getPlotBoundsInPixels()\\n\\n if not all(enabledAxes) and not self.plot.isKeepDataAspectRatio():\\n # Handle axes disabled for zoom if plot is not keeping aspec ratio\\n if not enabledAxes.xaxis:\\n x0, x1 = left, left + width\\n if not enabledAxes.yaxis:\\n y0, y1 = top, top + height\\n if not enabledAxes.y2axis:\\n y2_0, y2_1 = top, top + height\\n\\n if self.plot.isKeepDataAspectRatio() and height != 0 and width != 0:\\n ratio = width / height\\n xextent, yextent = math.fabs(x1 - x0), math.fabs(y1 - y0)\\n if xextent != 0 and yextent != 0:\\n if xextent / yextent > ratio:\\n areaHeight = xextent / ratio\\n center = 0.5 * (y0 + y1)\\n y0 = center - numpy.sign(y1 - y0) * 0.5 * areaHeight\\n y1 = center + numpy.sign(y1 - y0) * 0.5 * areaHeight\\n else:\\n areaWidth = yextent * ratio\\n center = 0.5 * (x0 + x1)\\n x0 = center - numpy.sign(x1 - x0) * 0.5 * areaWidth\\n x1 = center + numpy.sign(x1 - x0) * 0.5 * areaWidth\\n\\n # Convert to data space\\n x0, y0 = self.plot.pixelToData(x0, y0, check=False)\\n x1, y1 = self.plot.pixelToData(x1, y1, check=False)\\n y2_0 = self.plot.pixelToData(None, y2_0, axis=\\\"right\\\", check=False)[1]\\n y2_1 = self.plot.pixelToData(None, y2_1, axis=\\\"right\\\", check=False)[1]\\n\\n return AxesExtent(\\n min(x0, x1),\\n max(x0, x1),\\n min(y0, y1),\\n max(y0, y1),\\n min(y2_0, y2_1),\\n max(y2_0, y2_1),\\n )\",\n \"def convert_axis( mv, axisold, axisindnew ):\\n (axisnew, indexina3) = axisindnew\\n axes = allAxes(mv)\\n kold = None\\n for k in range(len(axes)):\\n if axes[k]==axisold: kold=k\\n if kold==None:\\n print \\\"ERROR. convert_axis cannot find axis\\\",axisold,\\\" in variable\\\",mv\\n if len(axisold)==len(axisnew):\\n mv.setAxis( kold, axisnew )\\n return\\n # Here's what we would do in 1-D:\\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # for i in range(len(axisold)):\\n # newdata[ indexina3[i] ] = ma[i]\\n # newmv = cdms2.createVariable( newdata, id=mv.id )\\n # >1-D is the same idea, but more dimensions are coming along for the ride,\\n # making it more complicated...\\n shape0 = mv.shape\\n shape0[kold] = len(axisnew)\\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\\n # There seems to be nothing in numpy for treating one axis differently from the rest\\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\\n # The following will do the job. It would be very slow for an array with many big dimensions,\\n # but the arrays here have already been reduced for graphics; the index sets will be small or\\n # empty...\\n ranges = map( range, shape0[0:kold] )\\n for i in range(len(axisold)):\\n for idx in apply(itertools.product,ranges):\\n idx = idx + [indexina3(i)] + [Ellipsis]\\n idxo = idx + [i] + [Ellipsis]\\n newdata[ tuple(idx) ] = mv[idxo]\\n newmv = cdms2.createVariable( newdata, id=mv.id )\",\n \"def _lines_overlap_on_x_axis(self, line1, line2):\\n x1, x2, = line1[0][0], line1[1][0]\\n x3, x4, = line2[0][0], line2[1][0]\\n e1_left, e1_right = min(x1, x2), max(x1, x2)\\n e2_left, e2_right = min(x3, x4), max(x3, x4)\\n return (e1_left >= e2_left and e1_left <= e2_right) or (e1_right >= e2_left and e1_right <= e2_right) or \\\\\\n (e2_left >= e1_left and e2_left <= e1_right) or (e2_right >= e1_left and e2_right <= e1_right)\",\n \"def change_axes_geometry_stack(fig, ax, naxes):\\n for ii in range(len(ax)):\\n geometry = (naxes, 1, ii + 1)\\n if ax[ii].get_geometry() != geometry:\\n ax[ii].change_geometry(*geometry)\\n\\n for ii in np.arange(len(ax), naxes):\\n print('adding axis ', ii)\\n fig.add_subplot(naxes, 1, ii + 1)\\n\\n ax = fig.axes\\n return fig, ax\",\n \"def dualx(self, arg, **kwargs):\\n # NOTE: Matplotlib 3.1 has a 'secondary axis' feature. For the time\\n # being, our version is more robust (see FuncScale) and simpler, since\\n # we do not create an entirely separate _SecondaryAxis class.\\n ax = self.altx(**kwargs)\\n self._dualx_arg = arg\\n self._dualx_overrides()\\n return ax\",\n \"def cartesian_coordinates(self, *axes):\",\n \"def draw_line(xy1, xy2, ax, **kwargs): \\n x_arr = [xy1[0], xy2[0]]\\n y_arr = [xy1[1], xy2[1]]\\n edge = Line2D([x_arr],[y_arr], **kwargs)\\n ax.add_line(edge)\\n\\n return ax,\",\n \"def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\\n if log:\\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\\n else:\\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)\",\n \"def secondAxis(ax,label,limits,secondY =True,color=\\\"Black\\\",scale=None,\\n tick_color='k',tick_axis_kw=dict()):\\n current = ax\\n if (scale is None):\\n if secondY:\\n scale = ax.get_yscale() \\n else:\\n scale = ax.get_xscale()\\n axis = \\\"y\\\" if secondY else \\\"x\\\"\\n spines = \\\"right\\\" if secondY else \\\"top\\\"\\n if(secondY):\\n ax2 = ax.twinx()\\n ax2.set_yscale(scale, nonposy='clip')\\n ax2.set_ylim(limits)\\n # set the y axis to the appropriate label\\n lab = ylabel(label,ax=ax2)\\n tickLabels = ax2.get_yticklabels()\\n tickLims = ax2.get_yticks()\\n axis_opt = dict(axis=axis,left=False,**tick_axis_kw)\\n other_axis_opt = dict(axis=axis,right=False)\\n ax.yaxis.tick_left()\\n else:\\n ax2 = ax.twiny()\\n ax2.set_xscale(scale, nonposx='clip')\\n ax2.set_xlim(limits)\\n # set the x axis to the appropriate label\\n lab = xlabel(label,ax=ax2)\\n tickLabels = ax2.get_xticklabels()\\n tickLims = ax2.get_xticks()\\n axis_opt = dict(axis=axis,bottom=False,**tick_axis_kw)\\n other_axis_opt = dict(axis=axis,top=False)\\n color_axis_ticks(color=tick_color,spine_name=spines,axis_name=axis,ax=ax2) \\n [i.set_color(color) for i in tickLabels]\\n lab.set_color(color)\\n current.tick_params(**other_axis_opt)\\n tickAxisFont(ax=ax2,**axis_opt)\\n plt.sca(current)\\n return ax2\",\n \"def createCustomXYaxis(origin: Tuple[float, float, float], endPoints: List[Tuple[float, float, float]]) -> List[\\n vtkActor]:\\n\\n output = []\\n\\n for endPoint in endPoints:\\n output.append(createLine(origin, endPoint, color=\\\"lightgreen\\\"))\\n\\n return output\",\n \"def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def intersection(self, axis2):\\n if type(axis2) is not type(self):\\n raise TypeError(\\\"Cell edges with such combination of axes is not supported.\\\")\\n\\n intersection = np.zeros([self.size, axis2.size])\\n\\n def inters_len(a_min, a_max, b_min, b_max):\\n res = min(a_max, b_max) - max(a_min, b_min)\\n if res < 0:\\n res = 0\\n return res\\n\\n j_start = 0\\n for i, row in enumerate(intersection):\\n for j in range(j_start, len(row)):\\n dist = inters_len(self.cell_edges[i], self.cell_edges[i + 1],\\n axis2.cell_edges[j], axis2.cell_edges[j + 1])\\n if not dist and j != j_start:\\n j_start = j - 1\\n break\\n intersection[i, j] = dist\\n return intersection\",\n \"def getAxisTuple(axis):\",\n \"def swapaxes(self, a1, a2):\\n an = self.axes_names[:]\\n ia1, ia2 = self.get_axis_id(a1), self.get_axis_id(a2)\\n an[ia2], an[ia1] = an[ia1], an[ia2]\\n return xndarray(np.swapaxes(self.data, ia1, ia2), an, self.axes_domains,\\n self.value_label, self.meta_data)\",\n \"def _get_lines(self) -> tuple[VGroup, VGroup]:\\n x_axis = self.get_x_axis()\\n y_axis = self.get_y_axis()\\n\\n x_lines1, x_lines2 = self._get_lines_parallel_to_axis(\\n x_axis,\\n y_axis,\\n self.y_axis.x_range[2],\\n self.faded_line_ratio,\\n )\\n\\n y_lines1, y_lines2 = self._get_lines_parallel_to_axis(\\n y_axis,\\n x_axis,\\n self.x_axis.x_range[2],\\n self.faded_line_ratio,\\n )\\n\\n # TODO this was added so that we can run tests on NumberPlane\\n # In the future these attributes will be tacked onto self.background_lines\\n self.x_lines = x_lines1\\n self.y_lines = y_lines1\\n lines1 = VGroup(*x_lines1, *y_lines1)\\n lines2 = VGroup(*x_lines2, *y_lines2)\\n\\n return lines1, lines2\",\n \"def _get_lines(self) -> tuple[VGroup, VGroup]:\\n center = self.get_origin()\\n ratio_faded_lines = self.faded_line_ratio\\n offset = self.azimuth_offset\\n\\n if ratio_faded_lines == 0: # don't show faded lines\\n ratio_faded_lines = 1 # i.e. set ratio to 1\\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\\n rlines1 = VGroup()\\n rlines2 = VGroup()\\n alines1 = VGroup()\\n alines2 = VGroup()\\n\\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\\n ainput = np.arange(0, TAU, astep)\\n\\n unit_vector = self.x_axis.get_unit_vector()[0]\\n\\n for k, x in enumerate(rinput):\\n new_line = Circle(radius=x * unit_vector)\\n if k % ratio_faded_lines == 0:\\n alines1.add(new_line)\\n else:\\n alines2.add(new_line)\\n\\n line = Line(center, self.get_x_axis().get_end())\\n\\n for k, x in enumerate(ainput):\\n new_line = line.copy()\\n new_line.rotate(x + offset, about_point=center)\\n if k % ratio_faded_lines == 0:\\n rlines1.add(new_line)\\n else:\\n rlines2.add(new_line)\\n\\n lines1 = VGroup(*rlines1, *alines1)\\n lines2 = VGroup(*rlines2, *alines2)\\n return lines1, lines2\",\n \"def axis2D(xlow,xhigh,xfirst,xstep,ylow,yhigh,yfirst,ystep):\\n dislin.graf(xlow,xhigh,xfirst,xstep,\\\\\\n ylow,yhigh,yfirst,ystep)\",\n \"def getAxis(self,axis):\\n\\n\\t\\tif axis == \\\"u\\\":\\n\\t\\t\\tif len(self.usr) != 0:\\n\\t\\t\\t\\treturn np.append([0], self.usr)\\n\\n\\t\\tif axis == \\\"s\\\":\\n\\t\\t\\tif len(self.seg) != 0:\\n\\t\\t\\t\\tif self.radiograph:\\n\\t\\t\\t\\t\\treturn self.seg\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tfirst = self.seg[0] - 1.\\n\\t\\t\\t\\t\\treturn np.append([first], self.seg)\\n\\n\\t\\tif axis == \\\"c\\\":\\n\\t\\t\\tif len(self.cos) != 0:\\n\\t\\t\\t\\tif self.radiograph:\\n\\t\\t\\t\\t\\treturn self.cos\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tfirst = -1.\\n\\t\\t\\t\\t\\treturn np.append([first], self.cos)\\n\\n\\t\\tif axis == \\\"e\\\":\\n\\t\\t\\tif len(self.erg) != 0:\\n\\t\\t\\t\\tfirst = self.erg[0] - 1.\\n\\t\\t\\t\\treturn np.append([first], self.erg)\\n\\n\\t\\tif axis == \\\"t\\\":\\n\\t\\t\\tif len(self.tim) != 0:\\n\\t\\t\\t\\tfirst = self.tim[0] - 1.\\n\\t\\t\\t\\treturn np.append([first], self.tim)\\n\\n\\t\\tif axis == \\\"i\\\":\\n\\t\\t\\treturn self.cora\\n\\n\\t\\tif axis == \\\"j\\\":\\n\\t\\t\\treturn self.corb\\n\\n\\t\\tif axis == \\\"k\\\":\\n\\t\\t\\treturn self.corc\\n\\n\\t\\treturn []\",\n \"def axes(*x: Iterable[int]):\\n return [_ti_core.Axis(i) for i in x]\",\n \"def _axes_domain(self, *args, **kwargs):\\n # See _add_gridline_label for detials\\n lon_0 = self.axes.projection.proj4_params.get('lon_0', 0)\\n x_range, y_range = type(self)._axes_domain(self, *args, **kwargs)\\n x_range = np.asarray(x_range) + lon_0\\n return x_range, y_range\",\n \"def from_cartesian(self, coordinates, *axes):\",\n \"def plot_2d_topomap_inter(ax):\\n\\n # plot first Head \\n N = 300 # number of points for interpolation\\n xy_center = [-0.178,0] # center of the plot\\n radius = 0.1 # radius\\n\\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n # add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [-0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [-0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n xy = [[-0.087,-0.027],[-0.087,0.027], [-0.068,0]]\\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon) \\n \\n\\n # Plot second Head \\n x2y2_center = [0.178,0] # center of the plot\\n radius2 = 0.1 # radius\\n \\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n ## add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [0.19,0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [0.19,-0.095], width = 0.05, height = 0.025, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n x2y2 = [[0.087,-0.027],[0.087,0.027], [0.068,0]]\\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon)\",\n \"def line_axes (self):\\n return self._line_axes\",\n \"def baseline_idx(self, axis=None, strict=False, extrapolate=False):\\n # Get stress/release pairs\\n if strict:\\n # Get only stress/release pairs, i.e. only segment pairs, whose\\n # release's stop and stress's start index equal an extremum.\\n pairs = self.stress_release_pairs(axis=axis, slices=False)\\n stresses = pairs['stress']['idx']\\n releases = pairs['release']['idx']\\n else:\\n # Get all stress/release segments, even those without a\\n # corresponding extremum.\\n stresses = self.sections(axis=axis, cycle='stress', slices=False)\\n releases = self.sections(axis=axis, cycle='release', slices=False)\\n\\n # A baseline point lies exactly beetween a release and a following\\n # stress section. Therefore, the baseline point idx equals a stress's\\n # start and a release's stop.\\n stress_base_idx = stresses[:, 0]\\n release_base_idx = releases[:, 1]\\n\\n # Remove stresses, whose start, and releases, whose stop is equal to\\n # an extremum, which means, the excitation as above or below the\\n # baseline.\\n extrema = self._extrema(axis=axis)\\n stress_base_idx = np.setdiff1d(stress_base_idx, extrema,\\n assume_unique=True)\\n release_base_idx = np.setdiff1d(release_base_idx, extrema,\\n assume_unique=True)\\n\\n base_idx = np.r_[stress_base_idx, release_base_idx]\\n if strict or not extrapolate:\\n # Take only baseline point indices, that lie exactly between a\\n # release and a following stress section, i.e. have two equal\\n # entries, one from a release's start and one from a stress's stop.\\n # I.e. sort out all indices that did not come from a stress/release\\n # pair but instead only a single stress or release segment.\\n base_idx.sort()\\n base_idx = base_idx[np.r_[base_idx[:-1] == base_idx[1:], False]]\\n return np.unique(base_idx)\",\n \"def same_emitter(track_1, track_2):\\n alternate_consistency = False\\n start_consistency = False\\n start_1_index = 0\\n start_2_index = 0\\n\\n # First of all, check if both tracks use the same frequence to communicate\\n freq_consistency = False\\n f_1 = track_1.itr_measurement.central_freq_hz\\n f_2 = track_2.itr_measurement.central_freq_hz\\n if f_1 > 0.99*f_2 and f_1 < 1.01*f_2:\\n freq_consistency = True\\n\\n # Then, check if the bandwidth of both tracks is the same\\n bandwidth_consistency = False\\n bw_1 = track_1.itr_measurement.bandwidth_hz\\n bw_2 = track_2.itr_measurement.bandwidth_hz\\n if bw_1 > 0.99*bw_2 and bw_1 < 1.01*bw_2:\\n bandwidth_consistency = True\\n\\n # Is the emission type the same for both tracks ?\\n type_consistency = False\\n t_1 = track_1.itr_measurement.type\\n t_2 = track_2.itr_measurement.type\\n if t_1 == t_2:\\n type_consistency = True\\n\\n # If all three criteria above have been fulfilled, check if alternates sequences are similar\\n if freq_consistency and type_consistency and bandwidth_consistency:\\n # logger.debug(\\n # \\\"\\\\tFreq and type consistency found : \\\\n\\\\t\\\\t1° Freq - %s - Type - %s \\\\n\\\\t\\\\t2° Freq - %s - Type - %s\\\" % (f_1, t_1, f_2, t_2))\\n alternate_consistency = True\\n alternates_1 = track_1.alternates\\n alternates_2 = track_2.alternates\\n\\n alt_duration_1 = [alt.duration_us for alt in alternates_1]\\n alt_start_1 = [alt.start.date_ms for alt in alternates_1]\\n alt_duration_2 = [alt.duration_us for alt in alternates_2]\\n alt_start_2 = [alt.start.date_ms for alt in alternates_2]\\n\\n # Both tracks may not have been recorded at exactly the same time. Therefore,\\n # we only analyse alternates that have finished. Not ongoing alternates.\\n n = min(len(alternates_1), len(alternates_2)) - 1\\n\\n for start_1 in alt_start_1:\\n if start_1 in alt_start_2:\\n start_1_index = alt_start_1.index(start_1)\\n start_2_index = alt_start_2.index(start_1)\\n start_consistency = True\\n break\\n if not start_consistency:\\n for start_2 in alt_start_2:\\n if start_2 in alt_start_1:\\n start_1_index = alt_start_1.index(start_2)\\n start_2_index = alt_start_2.index(start_2)\\n start_consistency = True\\n break\\n\\n if start_consistency and track_1.itr_measurement.type != 1:\\n if start_1_index == 0 or start_2_index == 0:\\n start_1_index += 1\\n start_2_index += 1\\n while start_1_index < len(alt_start_1) and start_2_index < len(alt_start_2):\\n # If there is more than a single alternate, we check if the duration of the alternates is consistent\\n if alt_duration_1[start_1_index] != alt_duration_2[start_2_index]:\\n alternate_consistency = False\\n break\\n\\n # Always check that the start-dates of all alternates are the same.\\n if alt_start_1[start_1_index] != alt_start_2[start_2_index]:\\n alternate_consistency = False\\n break\\n\\n start_1_index += 1\\n start_2_index += 1\\n\\n # if alternate_consistency:\\n # logger.debug(\\n # \\\"\\\\tBoth tracks are from the same emitter !\\\")\\n bool_response = freq_consistency and bandwidth_consistency and type_consistency and start_consistency and alternate_consistency\\n\\n track_id = get_track_id(track_1)\\n return bool_response, track_id\",\n \"def _lines_overlap_on_y_axis(self, line1, line2):\\n y1, y2, = line1[0][1], line1[1][1]\\n y3, y4, = line2[0][1], line2[1][1]\\n e1_top, e1_bot = min(y1, y2), max(y1, y2)\\n e2_top, e2_bot = min(y3, y4), max(y3, y4)\\n return (e1_top >= e2_top and e1_top <= e2_bot) or (e1_bot >= e2_top and e1_bot <= e2_bot) or \\\\\\n (e2_top >= e1_top and e2_top <= e1_bot) or (e2_bot >= e1_top and e2_bot <= e1_bot)\",\n \"def swapaxes(a, axis1, axis2):\\n # TODO(okuta): check type\\n return a.swapaxes(axis1, axis2)\",\n \"def plot_item_add_second_right_axis(plot_item):\\n ax = _pyqtgraph.AxisItem('left')\\n vb = _pyqtgraph.ViewBox()\\n plot_item.layout.addItem(ax, 2, 3)\\n plot_item.scene().addItem(vb)\\n ax.linkToView(vb)\\n vb.setXLink(plot_item)\\n\\n def update_views():\\n vb.setGeometry(plot_item.vb.sceneBoundingRect())\\n vb.linkedViewChanged(plot_item.vb, vb.XAxis)\\n\\n update_views()\\n plot_item.vb.sigResized.connect(update_views)\\n return ax\",\n \"def AllSidesTicks( ax ):\\n return; ## depreceate for now as it doesn't work correctly...\\n axy = ax.twinx()\\n axy.set_ylim( ax.get_ylim() )\\n axy.set_yscale( ax.get_yscale() )\\n axy.set_yticklabels(labels=[])\\n\\n axx = ax.twiny()\\n axx.set_xlim( ax.get_xlim() )\\n axx.set_xscale( ax.get_xscale() )\\n axx.set_xticklabels(labels=[])\",\n \"def take_along_axis(x1, indices, axis):\\n\\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\\n indices_desc = dpnp.get_dpnp_descriptor(\\n indices, copy_when_nondefault_queue=False\\n )\\n if x1_desc and indices_desc:\\n if x1_desc.ndim != indices_desc.ndim:\\n pass\\n elif not isinstance(axis, int):\\n pass\\n elif axis >= x1_desc.ndim:\\n pass\\n elif x1_desc.ndim == indices_desc.ndim:\\n val_list = []\\n for i in list(indices_desc.shape)[:-1]:\\n if i == 1:\\n val_list.append(True)\\n else:\\n val_list.append(False)\\n if not all(val_list):\\n pass\\n else:\\n return dpnp_take_along_axis(x1, indices, axis)\\n else:\\n return dpnp_take_along_axis(x1, indices, axis)\\n\\n return call_origin(numpy.take_along_axis, x1, indices, axis)\",\n \"def discrete_scatter(x1, x2, y=None, markers=None, s=10, ax=None,\\n labels=None, padding=.2, alpha=1, c=None, markeredgewidth=None):\\n if ax is None:\\n ax = plt.gca()\\n\\n if y is None:\\n y = np.zeros(len(x1))\\n\\n unique_y = np.unique(y)\\n\\n if markers is None:\\n markers = ['o', '^', 'v', 'D', 's', '*', 'p', 'h', 'H', '8', '<', '>'] * 10\\n\\n if len(markers) == 1:\\n markers = markers * len(unique_y)\\n\\n if labels is None:\\n labels = unique_y\\n\\n # lines in the matplotlib sense, not actual lines\\n lines = []\\n\\n current_cycler = mpl.rcParams['axes.prop_cycle']\\n\\n for i, (yy, cycle) in enumerate(zip(unique_y, current_cycler())):\\n mask = y == yy\\n # if c is none, use color cycle\\n if c is None:\\n color = cycle['color']\\n elif len(c) > 1:\\n color = c[i]\\n else:\\n color = c\\n # use light edge for dark markers\\n if np.mean(colorConverter.to_rgb(color)) < .4:\\n markeredgecolor = \\\"grey\\\"\\n else:\\n markeredgecolor = \\\"black\\\"\\n\\n lines.append(ax.plot(x1[mask], x2[mask], markers[i], markersize=s,\\n label=labels[i], alpha=alpha, c=color,\\n markeredgewidth=markeredgewidth,\\n markeredgecolor=markeredgecolor)[0])\\n\\n if padding != 0:\\n pad1 = x1.std() * padding\\n pad2 = x2.std() * padding\\n xlim = ax.get_xlim()\\n ylim = ax.get_ylim()\\n ax.set_xlim(min(x1.min() - pad1, xlim[0]), max(x1.max() + pad1, xlim[1]))\\n ax.set_ylim(min(x2.min() - pad2, ylim[0]), max(x2.max() + pad2, ylim[1]))\\n\\n return lines\",\n \"def plot_2_series_double_yaxis(x, y1, y2, figsize=(10,10), fontsize=12, title='', \\\\\\n y1_label='', y2_label='', xlabel='', savefig=False,\\\\\\n figname='figure'):\\n x = x\\n y1 = y1\\n y2 = y2\\n fig, ax = plt.subplots(figsize=figsize, sharex=True)\\n ax2 = ax.twinx()\\n ax.set_title(title, fontsize=fontsize+4)\\n ax.plot(x, y1, 'r-', label=y1_label)\\n ax.set_xlabel(xlabel, fontsize=fontsize)\\n ax.set_ylabel(y1_label, fontsize=fontsize)\\n ax.set_xticklabels(labels=x, rotation=45)\\n ax2.plot(x, y2, 'b-', label=y2_label)\\n ax2.set_ylabel(y2_label, fontsize=fontsize)\\n ax.legend(loc='upper left')\\n ax2.legend(loc='lower right')\\n plt.show()\\n if savefig == True:\\n fig.savefig(figname)\",\n \"def populate_plot_axis(self,plot,ax='x'):\\n\\n fig=plt.gcf()\\n\\n extra_ax=[]\\n\\n if ax=='x':\\n\\n ticks=plot.get_xticks()\\n\\n lim=plot.get_xlim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['bottom'].set_position(('outward',10))\\n\\n axn.spines['bottom'].set_visible(True)\\n\\n else:\\n\\n dy_fig=0.08\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0,\\\\\\n prev_ax_position.y0-2*dy_fig,\\\\\\n prev_ax_position.width,\\\\\\n 0),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.yaxis.set_visible(False)\\n\\n for side in axn.spines.keys():\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_xticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_xticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n xlab=axn.set_xlabel(self.names[i])\\n\\n xlab.set_fontsize(10)\\n\\n axn.tick_params(axis='x',labelsize=10)\\n\\n axn.set_xlim(lim)\\n\\n\\n\\n elif ax=='y':\\n\\n ticks=plot.get_yticks()\\n\\n lim=plot.get_ylim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['left'].set_position(('outward',10))\\n\\n axn.spines['left'].set_visible(True)\\n\\n else:\\n\\n dx_fig=0.08\\n\\n plot_position=plot.get_position()\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0-2*dx_fig,\\\\\\n prev_ax_position.y0,\\\\\\n 0,\\\\\\n prev_ax_position.height),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.xaxis.set_visible(False) # hide the yaxis\\n\\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_yticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_yticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n ylab=axn.set_ylabel(self.names[i])\\n\\n ylab.set_fontsize(10)\\n\\n axn.tick_params(axis='y',labelsize=10)\\n\\n axn.set_ylim(lim)\\n\\n else:\\n\\n raise ValueError(\\\"Axis can be 'x' or 'y'\\\")\",\n \"def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices['E_tot1'])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\\n \\n plt.ylabel('Energy [kWh]')\\n plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(24)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\\n\\n plt.ylabel('Energy Difference [kWh]')\\n plt.legend()\\n\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n return fig\",\n \"def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\\n axis = check_axes(axis)\\n if len(axis) == x.ndim:\\n return func(x)\\n\\n other_axes = negate_indices(axis, x.ndim)\\n begin = np.arange(len(other_axes))\\n\\n y = np.moveaxis(x, other_axes, begin)\\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)\",\n \"def align_yaxis(ax1,v1,ax2,v2):\\n _, y1 = ax1.transData.transform((0,v1))\\n _, y2 = ax2.transData.transform((0,v2))\\n inv = ax2.transData.inverted()\\n _, dy = inv.transform((0,0)) - inv.transform((0,y1-y2))\\n miny, maxy = ax2.get_ylim()\\n ax2.set_ylim(miny+dy,maxy+dy)\",\n \"def _filter_axes(self, channel_axis, spatial_axes):\\n f_axes = ng.make_axis(length=self.nout, name=\\\"K\\\")\\n for key, ax in zip(\\\"DHW\\\", spatial_axes):\\n f_axes += ng.make_axis(length=self.filter_shape[key],\\n name=ax.name)\\n f_axes += channel_axis\\n return f_axes\",\n \"def _handle_setup_axis(self, axis_args):\\n axis_name = axis_args['name']\\n axes_dict = self.server.axes\\n\\n if axis_name not in [name for name, _ in axes_dict.items()]:\\n print \\\"Adding a new axis:\\\", axis_name\\n axis_count = len(axes_dict)\\n newaxis = self.server.figure.add_subplot(axis_count+1, 1, axis_count+1)\\n axes_dict[axis_name] = newaxis\\n axes_dict[axis_name].grid(True)\\n axes_dict[axis_name].set_xlabel(axis_args['x_label'])\\n axes_dict[axis_name].set_ylabel(axis_args['y_label'])\\n # TODO: support *.set_title(\\\"Title\\\")\\n if FLAGS.logy:\\n axes_dict[axis_name].set_yscale('log', nonposy='clip')\\n\\n if axis_count != 0:\\n # Resize other axes if the above wasn't the first.\\n axis_count = len(axes_dict)\\n for row,(name, _) in enumerate(axes_dict.items(), 1):\\n print name, axis_count, row\\n axes_dict[name].change_geometry(axis_count, 1, row)\",\n \"def _lines_intersect(self, line1, line2):\\n return self._lines_overlap_on_x_axis(line1, line2) and self._lines_overlap_on_y_axis(line1, line2)\",\n \"def plot_sensors_2d_inter(epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor info and transform loc to fit with headmodel\\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 = []\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 = []\\n bads_epo2 = epo2.info['bads']\\n \\n # plot sensors ('x' for bads)\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n plt.plot(x1, y1, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x1+0.012, y1+0.012, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n \\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='x', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n plt.plot(x2, y2, marker='o', color='dimgrey')\\n if lab:\\n plt.text(x2+0.012, y2+0.012, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def intersection(self, other):\\n log.info('self: '+str(self)+' other: '+str(other))\\n if self == other:\\n # Used to be return True, that is definitely not right (expects Coordinate)\\n # Do we want start or end ? Does it matter? Lines are the same, everything is\\n # an intersection.\\n return self.start\\n # If any of the start/end points match, return that point.\\n if self.end==other.start or self.end == other.end:\\n return self.end \\n if self.start==other.start or self.start == other.end: \\n return self.start\\n\\n # Line equation: y = mx + b\\n # m = (y2-y1)/(x2-x1)\\n # B_self = y - M_self*x\\n # Pick any x/y on the line - try end point\\n # B_self = self.end.lat - M_self*self.end.lon\\n # B_other = other.end.lat - M_self*self.end.lon\\n from pyresample.spherical_geometry import Coordinate\\n\\n selfendlon = self.end.lon\\n selfstartlon = self.start.lon\\n otherendlon = other.end.lon\\n otherstartlon = other.start.lon\\n # Not sure if this is necessary, or good...\\n# if self.end.lon < 0:\\n# selfendlon = self.end.lon + 2*math.pi\\n# if self.start.lon < 0:\\n# selfstartlon = self.start.lon + 2*math.pi\\n# if other.end.lon < 0:\\n# otherendlon = other.end.lon + 2*math.pi\\n# if other.start.lon < 0:\\n# otherstartlon = other.start.lon + 2*math.pi\\n\\n log.info(' self lons: '+str(math.degrees(selfstartlon))+' '+str(math.degrees(selfendlon))+' other lons: '+str(math.degrees(otherstartlon))+' '+str(math.degrees(otherendlon)))\\n\\n # If both vertical, will be no intersection\\n if abs(selfendlon - selfstartlon) < EPSILON and abs(otherendlon - otherstartlon) < EPSILON:\\n log.info(' Both vertical, no intersection')\\n return None\\n # If self is vertical, but not parallel, intersection will be selfstartlon and lat = Mother*lon+B_other\\n if abs(selfendlon - selfstartlon) < EPSILON:\\n lon = selfstartlon\\n M_other = (other.end.lat - other.start.lat)/(otherendlon-otherstartlon)\\n B_other = other.end.lat - M_other*otherendlon\\n lat = M_other*lon+B_other\\n log.info(' self is vertical')\\n #Make sure it falls within the segment and not outside.\\n # Previously was only checking lat, need to \\n # also check lon or opposite side of world would match\\n if (lat > min([self.end.lat,self.start.lat]) and \\n lat < max([self.end.lat,self.start.lat]) and\\n lon > min([otherendlon,otherstartlon]) and\\n lon < max([otherendlon,otherstartlon])):\\n log.info(' and intersects')\\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\\n # MLS use wrap_longitudes?\\n if lon > math.pi:\\n lon -= 2*math.pi\\n return Coordinate(math.degrees(lon),math.degrees(lat))\\n else:\\n return None\\n # same for other\\n if abs(otherendlon - otherstartlon) < EPSILON:\\n lon = otherstartlon\\n M_self = (self.end.lat - self.start.lat)/(selfendlon-selfstartlon)\\n B_self = self.end.lat - M_self*selfendlon\\n lat = M_self*lon+B_self\\n log.info(' other is vertical')\\n #Make sure it falls within the segment and not outside.\\n # Previously was only checking lat, need to \\n # also check lon or opposite side of world would match\\n if (lat > min([other.end.lat,other.start.lat]) and \\n lat < max([other.end.lat,other.start.lat]) and \\n lon > min([selfendlon,selfstartlon]) and\\n lon < max([selfendlon,selfstartlon])):\\n log.info(' and intersects')\\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\\n # MLS Use wrap_longitudes?\\n if lon > math.pi:\\n lon -= 2*math.pi\\n return Coordinate(math.degrees(lon),math.degrees(lat))\\n else:\\n return None\\n\\n \\n\\n # Get slopes of the lines \\n M_self = (self.end.lat - self.start.lat)/(selfendlon-selfstartlon)\\n M_other = (other.end.lat - other.start.lat)/(otherendlon-otherstartlon)\\n \\n # If they are parallel, no intersection\\n if (M_self-M_other) < EPSILON:\\n log.info(' self and other are parallel, no intersection')\\n return None\\n\\n # Get the y-intercepts of the lines \\n B_self = self.end.lat - M_self*selfendlon\\n B_other = other.end.lat - M_other*otherendlon\\n\\n # Solve the equation\\n # y=m1x+b1 and y=m2x+b2, equate y's so m1x+b1=m2x+b2, x = (b1-b2)/(m2-m1)\\n # equate x's so x=(y-b1)/m1=(y-b2)/m2, y = (b1m2-b2m1)/(m2-m1)\\n lon = (B_self - B_other)/(M_other - M_self)\\n lat = (B_self*M_other - B_other*M_self)/(M_other-M_self)\\n\\n # Make sure lat/lon intersects within the line segment, and not outside.\\n if (lat > min([other.end.lat,other.start.lat]) and \\n lat < max([other.end.lat,other.start.lat]) and\\n lon > min([otherendlon,otherstartlon]) and \\n lon < max([otherendlon,otherstartlon]) and\\n lat > min([self.end.lat,self.start.lat]) and \\n lat < max([self.end.lat,self.start.lat]) and\\n lon > min([selfendlon,selfstartlon]) and \\n lon < max([selfendlon,selfstartlon])):\\n log.info(' self and other intersect within segment')\\n # Apparently Coordinate takes degrees ??? And must be -180 to 180 ?!\\n # MLS use wrap longitudes?\\n if lon > math.pi:\\n lon -= 2*math.pi\\n return Coordinate(math.degrees(lon),math.degrees(lat))\\n else:\\n log.info(' self and other intersect, but not within segment')\\n return None\",\n \"def proxy_line(**kwargs):\\r\\n return matplotlib.lines.Line2D(range(1), range(1), **kwargs)\",\n \"def axis_helper(y_shape, x_shape):\\n res = []\\n j = len(x_shape) - 1\\n for i in range(len(y_shape) - 1, -1, -1):\\n if j < 0 or x_shape[j] != y_shape[i]:\\n res.append(i)\\n j -= 1\\n return tuple(res[::-1])\",\n \"def noAxisLines(axes='XYZ'):\\n dislin.frame(0)\\n dislin.noline(axes)\",\n \"def crossAxes(axl, xyzero=[0.0, 0.0], limits=[None, None, None, None], labels:Union[str, None]=['nA', 'mV']):\\n\\n axl = _ax_tolist(axl)\\n # if type(axl) is not list:\\n # axl = [axl]\\n for ax in axl:\\n if ax is None:\\n continue\\n # ax.set_title('spines at data (1,2)')\\n # ax.plot(x,y)\\n ax.spines[\\\"left\\\"].set_position((\\\"data\\\", xyzero[0]))\\n ax.spines[\\\"right\\\"].set_color(\\\"none\\\")\\n ax.spines[\\\"bottom\\\"].set_position((\\\"data\\\", xyzero[1]))\\n ax.spines[\\\"top\\\"].set_color(\\\"none\\\")\\n # ax.spines['left'].set_smart_bounds(True)\\n # ax.spines['bottom'].set_smart_bounds(True) # deprecated, not sure what to do\\n ax.xaxis.set_ticks_position(\\\"bottom\\\")\\n ax.yaxis.set_ticks_position(\\\"left\\\")\\n if limits[0] is not None:\\n ax.set_xlim(left=limits[0], right=limits[2])\\n ax.set_ylim(bottom=limits[1], top=limits[3])\",\n \"def calculate_axes_and_angle_directional(xrs1, xrs2):\\n a1 = get_axis_from_xrs(xrs1)\\n a2 = get_axis_from_xrs(xrs2)\\n v1 = vector_from_two_points(xrs1.sites_cart()[0], xrs1.sites_cart()[-1])\\n v2 = vector_from_two_points(xrs2.sites_cart()[0], xrs2.sites_cart()[-1])\\n if a1.angle(v1)*180./math.pi > 90:\\n a1 = -a1\\n if a2.angle(v2)*180./math.pi > 90:\\n a2 = -a2\\n angle = a1.angle(a2)*180./math.pi\\n return a1, a2, angle\",\n \"def _sanity_check_two_series(\\n series_1: TimeSeries,\\n series_2: TimeSeries,\\n):\\n\\n _assert_timeseries(series_1)\\n _assert_timeseries(series_2)\\n\\n # check if the two inputs time series have the same number of components\\n raise_if_not(\\n series_1.width == series_2.width,\\n \\\"Series must have the same number of components,\\\"\\n + f\\\" found {series_1.width} and {series_2.width}.\\\",\\n )\\n\\n # check if the time intersection between the two inputs time series is not empty\\n raise_if_not(\\n len(series_1.time_index.intersection(series_2.time_index)) > 0,\\n \\\"Series must have a non-empty intersection timestamps.\\\",\\n )\",\n \"def _scatter_subplot(x, y, trendline_y=None, trendline_x=None, line_of_slope_1=False,\\n x_label=None, y_label=None, x_limits=None, y_limits=None, axes_equal=True, subplot_title=None,\\n trendline_dots=False, scatter_color=COLOR_PALETTE.primary,\\n trendline_color=COLOR_PALETTE.secondary, legend=True, scatter_name=None,\\n trendline_name=None, ax=None):\\n if ax is None:\\n ax = plt.gca()\\n\\n if scatter_name is None:\\n scatter_name = 'Data points'\\n\\n if trendline_name is None:\\n trendline_name = 'Regression line'\\n\\n if trendline_dots is True:\\n trendline_marker = 'o-'\\n else:\\n trendline_marker = '-'\\n\\n if x_limits is None or y_limits is None:\\n x_min, x_max, y_min, y_max = _derive_axes_limits_for_scatter_plot(x, y)\\n\\n if axes_equal:\\n ax.set_aspect('equal')\\n if x_limits is None and y_limits is None:\\n axes_min = min(x_min, y_min)\\n axes_max = max(x_max, y_max)\\n x_limits = (axes_min, axes_max)\\n y_limits = (axes_min, axes_max)\\n\\n if x_limits is None:\\n x_limits = (x_min, x_max)\\n if y_limits is None:\\n y_limits = (y_min, y_max)\\n\\n ax.set_xlim(x_limits[0], x_limits[1])\\n ax.set_ylim(y_limits[0], y_limits[1])\\n\\n no_dots = len(x)\\n\\n marker_size_max = 216\\n marker_size_min = 18\\n marker_size = -0.2 * no_dots + marker_size_max # y=mx+c, m = (216 - 18) / (1000 - 0) i.e. slope changes up to 1000\\n marker_size = marker_size_min if marker_size < marker_size_min else marker_size\\n\\n max_alpha = 0.7\\n min_alpha = 0.3\\n alpha = -0.0004 * no_dots + max_alpha # y=mx+c, m = (0.7 - 0.3) / (1000 - 0) i.e. alpha changes up to 1000 dots\\n alpha = min_alpha if alpha < min_alpha else alpha\\n\\n ax.scatter(x, y, marker='o', color=scatter_color, s=marker_size, alpha=alpha,\\n edgecolors='none', label=scatter_name)\\n\\n if trendline_y is not None:\\n if trendline_x is None:\\n trendline_x = x\\n\\n ax.plot(trendline_x, trendline_y, trendline_marker, color=trendline_color, label=trendline_name)\\n\\n if line_of_slope_1:\\n low_x, high_x = ax.get_xlim()\\n low_y, high_y = ax.get_ylim()\\n low = max(low_x, low_y)\\n high = min(high_x, high_y)\\n ax.plot([low, high], [low, high], color=COLOR_PALETTE.secondary_70, label='1:1 line')\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n\\n if legend:\\n ax.legend()\\n\\n if subplot_title is not None:\\n ax.set_title(subplot_title, fontsize=mpl.rcParams['ytick.labelsize'])\\n\\n return ax\",\n \"def axes_active(self) -> np.ndarray: # array[Axes]\\n return self.axes.flat[:self.n_plots]\",\n \"def viz_2D_topomap_intra (epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray,\\n threshold: float=0.95, steps: int=2,\\n lab: bool = False):\\n\\n # defining head model and adding sensors\\n fig = plt.figure()\\n ax = fig.add_subplot(111, aspect = 1)\\n ax.axis(\\\"off\\\")\\n plot_2d_topomap_intra(ax)\\n # bads are represented as squares\\n plot_sensors_2d_intra(epo1, epo2, lab = lab)\\n # plotting links according to sign (red for positive values,\\n # blue for negative) and value (line thickness increases\\n # with the strength of connectivity)\\n plot_links_2d_intra(epo1, epo2, C1=C1, C2=C2, threshold=threshold, steps=steps)\\n plt.tight_layout()\\n plt.show()\\n\\n return (ax)\",\n \"def _add_dummy_rot_axis_edge(\\n edges_1: np.ndarray,\\n edges_2: np.ndarray,\\n rot_axes: Literal[\\\"x\\\", \\\"y\\\", \\\"z\\\", \\\"xyz\\\"],\\n ) -> Tuple[np.ndarray, np.ndarray]:\\n if rot_axes == \\\"z\\\":\\n edges_1[:, 2] = 0\\n edges_2[:, 2] = 0\\n edges_1 = np.vstack([edges_1, np.array([[0, 0, 1]])])\\n edges_2 = np.vstack([edges_2, np.array([[0, 0, 1]])])\\n if rot_axes == \\\"y\\\":\\n edges_1[:, 1] = 0\\n edges_2[:, 1] = 0\\n edges_1 = np.vstack([edges_1, np.array([[0, 1, 0]])])\\n edges_2 = np.vstack([edges_2, np.array([[0, 1, 0]])])\\n if rot_axes == \\\"x\\\":\\n edges_1[:, 0] = 0\\n edges_2[:, 0] = 0\\n edges_1 = np.vstack([edges_1, np.array([[1, 0, 0]])])\\n edges_2 = np.vstack([edges_2, np.array([[1, 0, 0]])])\\n return edges_1, edges_2\",\n \"def test_link_axes(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n splt = SEGYPlotter(ax, self.segy)\\n # should add one artist to our axes\\n splt.plot_wiggles(wiggle_traces=True)\\n self.assertEqual(len(splt.ACTIVE_LINES['wiggle_traces']), 1)\\n self.assertTrue('wiggle_traces' not in splt.INACTIVE_LINES)\\n self.assertEqual(len(ax.lines), 1)\\n # should remove one artist to our axes\\n splt.plot_wiggles(wiggle_traces=False)\\n self.assertTrue('wiggle_traces' not in splt.ACTIVE_LINES)\\n self.assertEqual(len(splt.INACTIVE_LINES['wiggle_traces']), 1)\\n self.assertEqual(len(ax.lines), 0)\",\n \"def duplicate_axes(isl_obj, duplicate_inames, new_inames):\\n if isinstance(isl_obj, list):\\n return [\\n duplicate_axes(i, duplicate_inames, new_inames)\\n for i in isl_obj]\\n\\n if not duplicate_inames:\\n return isl_obj\\n\\n def _align_and_intersect(d1, d2):\\n d1, d2 = isl.align_two(d1, d2)\\n return d1 & d2\\n\\n old_name_to_new_name = dict(zip(duplicate_inames, new_inames))\\n\\n dup_isl_obj = isl_obj\\n\\n for old_name, (dt, pos) in isl_obj.get_var_dict().items():\\n dup_isl_obj = dup_isl_obj.set_dim_name(dt, pos,\\n old_name_to_new_name.get(old_name,\\n old_name))\\n\\n return _align_and_intersect(dup_isl_obj, isl_obj)\",\n \"def axes_maker(rows, cols):\\n fig = plt.figure()\\n current_subplot = [1] # Use list in order to modify\\n def next_axes(**kwargs):\\n current_subplot[0] += 1\\n axes = fig.add_subplot(rows, cols, current_subplot[0] - 1, **kwargs)\\n return axes\\n return next_axes\",\n \"def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors ('x' for bads)\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def findaxisbyname(self, *args, **kwargs):\\n return _coordsys.coordsys_findaxisbyname(self, *args, **kwargs)\",\n \"def comp_axes(self, machine, N0=None):\\n if self.time is None and N0 is None:\\n raise InputError(\\\"ERROR: time and N0 can't be both None\\\")\\n\\n # Get machine pole pair number\\n p = machine.get_pole_pair_number()\\n\\n # Get electrical fundamental frequency\\n f_elec = self.comp_felec()\\n\\n # Airgap radius\\n Rag = machine.comp_Rgap_mec()\\n\\n # Setup normalizations for time and angle axes\\n norm_time = {\\n \\\"elec_order\\\": f_elec,\\n \\\"mech_order\\\": f_elec / p,\\n }\\n if N0 is not None:\\n norm_time[\\\"angle_rotor\\\"] = 1 / (360 * N0 / 60)\\n\\n norm_angle = {\\\"space_order\\\": p, \\\"distance\\\": 1 / Rag}\\n\\n # Create time axis\\n if self.time is None:\\n # Create time axis as a DataLinspace\\n Time = DataLinspace(\\n name=\\\"time\\\",\\n unit=\\\"s\\\",\\n initial=0,\\n final=60 / N0 * self.Nrev,\\n number=self.Nt_tot,\\n include_endpoint=False,\\n normalizations=norm_time,\\n )\\n else:\\n # Load time data\\n time = self.time.get_data()\\n self.Nt_tot = len(time)\\n Time = Data1D(name=\\\"time\\\", unit=\\\"s\\\", values=time, normalizations=norm_time)\\n\\n # Create angle axis\\n if self.angle is None:\\n # Create angle axis as a DataLinspace\\n Angle = DataLinspace(\\n name=\\\"angle\\\",\\n unit=\\\"rad\\\",\\n initial=0,\\n final=2 * pi,\\n number=self.Na_tot,\\n include_endpoint=False,\\n normalizations=norm_angle,\\n )\\n else:\\n # Load angle data\\n angle = self.angle.get_data()\\n self.Na_tot = len(angle)\\n Angle = Data1D(\\n name=\\\"angle\\\", unit=\\\"rad\\\", values=angle, normalizations=norm_angle\\n )\\n\\n return Time, Angle\",\n \"def nonlinear_axis(start, end, res):\\n axis = []\\n i = start\\n axis.append(i)\\n i += i / fit_line(i, res[0], res[1])\\n while i < end:\\n axis.append(i)\\n i += i / fit_line(i, res[0], res[1])\\n return np.array(axis)\",\n \"def _intersect(\\n series_1: TimeSeries,\\n series_2: TimeSeries,\\n) -> Tuple[TimeSeries, TimeSeries]:\\n\\n new_series_1 = series_1.slice_intersect(series_2)\\n raise_if(\\n len(new_series_1) == 0,\\n \\\"Time intersection between the two series must be non empty.\\\",\\n )\\n\\n return new_series_1, series_2.slice_intersect(series_1)\",\n \"def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\\n width_axis.name = \\\"time\\\"\\n assert len(conv1d_placeholder.axes.find_by_name(\\\"time\\\")) == 1\\n\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n with pytest.raises(IncompatibleAxesError):\\n conv_layer(conv1d_placeholder)\\n # As a dictionary\\n output = conv_layer(conv1d_placeholder, spatial_axes={\\\"W\\\": \\\"time\\\"})\\n assert output.axes == conv1d_placeholder.axes\\n # As a tuple\\n output = conv_layer(conv1d_placeholder, spatial_axes=(\\\"D\\\", \\\"H\\\", \\\"time\\\"))\\n assert output.axes == conv1d_placeholder.axes\",\n \"def plot_overlay2axes(self, axes) -> None:\\n # calculate height (based on leaf analysis ratio)\\n upper_point = (\\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n lower_point = (\\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n height = abs(upper_point - lower_point) * 0.8\\n\\n for idx, line in enumerate(self.marker_lines):\\n width = abs(self.error[idx]) * self._image.dpmm\\n y = line.center.y\\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\\n\\n if self._orientation == Orientation.UP_DOWN:\\n r = Rectangle(width, height, center=(x, y))\\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n else:\\n r = Rectangle(height, width, center=(x, y))\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n r.plot2axes(\\n axes, edgecolor=\\\"none\\\", fill=True, alpha=1, facecolor=self.bg_color[idx]\\n )\",\n \"def cross_time_index(df1, df2):\\n series = pd.core.series.Series\\n crossed_index = df1.index.intersection(df2.index)\\n\\n if type(df1) == series and type(df2) == series:\\n df1 = df1[crossed_index]\\n df2 = df2[crossed_index]\\n elif type(df1) == series and type(df2) != series:\\n df1 = df1[crossed_index]\\n df2 = df2.loc[crossed_index, :]\\n elif type(df1) != series and type(df2) == series:\\n df1 = df1.loc[crossed_index, :]\\n df2 = df2[crossed_index]\\n else:\\n df1 = df1.loc[crossed_index, :]\\n df2 = df2.loc[crossed_index, :]\\n return df1, df2\",\n \"def plot_results_2d(p_1, p_2, d_1 = 'X', d_2 = 'Y'):\\n plt.figure(figsize = (10, 10))\\n ax = plt.axes() \\n\\n color=iter(cm.rainbow(np.linspace(0,1,p_1.shape[0]))) # (1)\\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_1.shape[0], step = 1)]\\n\\n for p in np.arange(0, p_1.shape[0], step = 1): \\n c = next(color) # (c)\\n for t in np.arange(0, p_1.shape[1], step = 1): \\n plt.plot(p_1[p, t], p_2[p, t], 'x', c = c, label = labels[p])\\n legend_without_duplicate_labels(ax)\\n ax.grid(b = 'True', which = 'major')\\n ax.set_xlabel(d_1) \\n ax.set_ylabel(d_2)\\n ax.set_title('2D particle trajectories')\",\n \"def advanced_line():\\n\\n # Make dataset specifying arguments\\n dataset_a = DataSet(sine,line_style='-',line_width=1.5,marker_style='o',marker_size='4')\\n\\n # Make dataset changing options using setters\\n dataset_b = DataSet(cosine)\\n dataset_b.set_line(style='--',width=1.5)\\n dataset_b.set_colour(colour='royalblue')\\n\\n # Make plot object and adjust properties using setters\\n plot = Plot()\\n plot.set_text(latex=True,label=12)\\n plot.add_dataset(dataset_a)\\n plot.add_dataset(dataset_b)\\n plot.set_axes(xlim=(0,8),ylim=(-1.1,1.1),xlabel=r'$x$',ylabel=r'$f\\\\left(x\\\\right)$',xticks=(1.0,0.2),yticks=(0.2,0.05))\\n\\n # Plot graph and display\\n plot.plot()\\n plot.save(name='./figures/2d_advanced_line',fmt='png')\\n plot.display()\",\n \"def _handle_axes(self, drawable, option):\\n # If we already have an axes object, ignore this one\\n if self._axes_object is not None:\\n return\\n\\n # Grab the histogram used for axes style/range manipulation\\n if is_stack(drawable) or is_graph(drawable):\\n axes_histogram = drawable.GetHistogram()\\n else:\\n axes_histogram = drawable\\n\\n # Grab the histogram used for title manipulation\\n if is_stack(drawable):\\n title_histogram = drawable.GetHists()[0]\\n else:\\n title_histogram = drawable\\n\\n # Set the plot title\\n title_histogram.SetTitle(self._title)\\n\\n # Grab axes\\n x_axis, y_axis = axes_histogram.GetXaxis(), axes_histogram.GetYaxis()\\n\\n # Grab titles from first histogram if not set explicitly\\n if self._x_title is None:\\n self._x_title = title_histogram.GetXaxis().GetTitle()\\n if self._y_title is None:\\n self._y_title = title_histogram.GetYaxis().GetTitle()\\n\\n # Style x-axis, or hide it if this plot has a ratio plot\\n if self._x_range is not None:\\n x_axis.SetRangeUser(*self._x_range)\\n if self._ratio_plot:\\n x_axis.SetLabelOffset(999)\\n x_axis.SetTitleOffset(999)\\n else:\\n x_axis.SetTitle(self._x_title)\\n x_axis.SetTitleSize(self.PLOT_X_AXIS_TITLE_SIZE)\\n x_axis.SetTitleOffset(self.PLOT_X_AXIS_TITLE_OFFSET)\\n x_axis.SetLabelSize(self.PLOT_X_AXIS_LABEL_SIZE)\\n if self._x_integer_ticks:\\n x_axis.SetNdivisions(11) # hack for integer ticks \\n\\n # Style y-axis\\n y_axis.SetTitle(self._y_title)\\n y_axis.SetLabelFont(self.PLOT_ATLAS_STAMP_TEXT_FONT)\\n y_axis.SetTitleSize(\\n (self.PLOT_Y_AXIS_TITLE_SIZE_WITH_RATIO\\n if self._ratio_plot\\n else self.PLOT_Y_AXIS_TITLE_SIZE)\\n )\\n y_axis.SetTitleOffset(\\n (self.PLOT_Y_AXIS_TITLE_OFSET_WITH_RATIO\\n if self._ratio_plot\\n else self.PLOT_Y_AXIS_TITLE_OFFSET)\\n )\\n y_axis.SetNdivisions(5,5,0)\\n \\n # set axis text sizes \\n if self._ratio_plot:\\n y_axis.SetLabelSize(self.PLOT_Y_AXIS_LABEL_SIZE_WITH_RATIO)\\n else:\\n y_axis.SetLabelSize(self.PLOT_Y_AXIS_LABEL_SIZE) \\n y_axis.SetTitleSize(self.PLOT_Y_AXIS_TITLE_SIZE)\\n y_axis.SetTitleOffset(self.PLOT_RATIO_Y_AXIS_TITLE_OFFSET)\\n\\n # Redraw the drawable with the new style\\n drawable.Draw(option)\",\n \"def __init__(self, axis1, axis2=None, bins=100, same_scale=False,\\n axis1_values=None, axis2_values=None, **kwargs):\\n self.same_scale = same_scale\\n\\n self.axis1 = axis1\\n self.axis1_limits = None\\n\\n if isinstance(axis1_values, (float, int)):\\n axis1_values = [axis1_values]\\n self.axis1_values = axis1_values\\n\\n self.axis2 = axis2\\n self.axis2_limits = None\\n if isinstance(axis2_values, (float, int)):\\n axis2_values = [axis2_values]\\n self.axis2_values = axis2_values\\n\\n self.bins = bins\\n\\n self.plot_options = kwargs\",\n \"def align_yaxis(ax1, v1, ax2, v2):\\n _, y1 = ax1.transData.transform((0, v1))\\n _, y2 = ax2.transData.transform((0, v2))\\n inv = ax2.transData.inverted()\\n _, dy = inv.transform((0, 0)) - inv.transform((0, y1-y2))\\n miny, maxy = ax2.get_ylim()\\n ax2.set_ylim(miny+dy, maxy+dy)\",\n \"def trace(self, axis1=0, axis2=1):\\n assert self.compatible_indices(self, axis1, axis2)\\n if axis1 < axis2:\\n axis1, axis2 = axis2, axis1\\n if self.dirs[axis1] + self.dirs[axis2] != 0:\\n warnings.warn(\\n \\\"Automatically flipping dir %i in trace.\\\" % axis1, stacklevel=2\\n )\\n self = self.flip_dir(axis1)\\n # Create the result tensor by taking an empty tensor like self, and\\n # removing the indices that are traced.\\n res = self.empty_like()\\n del res.shape[axis1]\\n del res.shape[axis2]\\n del res.qhape[axis1]\\n del res.qhape[axis2]\\n del res.dirs[axis1]\\n del res.dirs[axis2]\\n\\n # We could avoid looping over the whole dictionary by constructing the\\n # cartesian product of all the qims but not qhape[axis2], and then\\n # infering what the qnum on axis2 should be. I suspect that this would\\n # be slower, but I haven't tried.\\n for k, v in self.sects.items():\\n qnum = k[axis1] - k[axis2]\\n if self.qodulus is not None:\\n qnum %= self.qodulus\\n if qnum == 0:\\n new_k = tuple(\\n i for j, i in enumerate(k) if j != axis1 and j != axis2\\n )\\n if new_k in res.sects:\\n res[new_k] += v.trace(axis1=axis1, axis2=axis2)\\n else:\\n res[new_k] = v.trace(axis1=axis1, axis2=axis2)\\n if res.isscalar():\\n try:\\n res.defval = res[()]\\n res.sects = {}\\n except KeyError:\\n # There was no () block, so the tensor is 0 by symmetry.\\n pass\\n return res\",\n \"def _line_from_two_points(pt1: np.array, pt2: np.array) -> np.array:\\n numLine = pt1.shape[0]\\n lines = np.zeros((numLine, 6))\\n n = np.cross(pt1, pt2)\\n n = n / (matlib.repmat(np.sqrt(np.sum(n ** 2, 1, keepdims=True)), 1, 3) + 1e-9)\\n lines[:, 0:3] = n\\n\\n areaXY = np.abs(np.sum(n * matlib.repmat([0, 0, 1], numLine, 1), 1, keepdims=True))\\n areaYZ = np.abs(np.sum(n * matlib.repmat([1, 0, 0], numLine, 1), 1, keepdims=True))\\n areaZX = np.abs(np.sum(n * matlib.repmat([0, 1, 0], numLine, 1), 1, keepdims=True))\\n planeIDs = np.argmax(np.hstack([areaXY, areaYZ, areaZX]), axis=1) + 1\\n lines[:, 3] = planeIDs\\n\\n for i in range(numLine):\\n uv = _xyz2uvN(np.vstack([pt1[i, :], pt2[i, :]]), lines[i, 3])\\n umax = uv[:, 0].max() + np.pi\\n umin = uv[:, 0].min() + np.pi\\n if umax - umin > np.pi:\\n lines[i, 4:6] = np.array([umax, umin]) / 2 / np.pi\\n else:\\n lines[i, 4:6] = np.array([umin, umax]) / 2 / np.pi\\n\\n return lines\",\n \"def scatter_and_line():\\n\\n # Make random data points around straight line\\n random_linear = np.zeros((1000,2))\\n random_linear[:,0] = np.random.uniform(0,10,1000)\\n random_error = np.random.normal(0.0,2.0,1000)\\n random_linear[:,1] = random_linear[:,0]*2.0+1.0+random_error\\n\\n # Make datasets, order determining line graph on top\\n dataset_a = DataSet(random_linear,plot='scatter',order=0,label='Random')\\n dataset_b = DataSet(linear,plot='line',colour='black',order=1,label='Linear')\\n\\n # Colour scatter graph by error\\n dataset_a.set_colour(map='coolwarm',colour=random_error)\\n\\n # Make plot object and add datasets\\n plot = Plot()\\n plot.set_text(latex=True)\\n plot.add_dataset(dataset_a)\\n plot.add_dataset(dataset_b)\\n plot.set_legend(legend=True)\\n\\n # Plot graph and display\\n plot.plot()\\n plot.save(name='./figures/2d_scatter_and_line',fmt='png')\\n plot.display()\",\n \"def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\\n steps: int=10):\\n \\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n ctr1 = np.nanmean(loc1, 0)\\n ctr1[2] -= 0.2\\n ctr2 = np.nanmean(loc2, 0)\\n ctr2[2] -= 0.2\\n\\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\\n Cmax1=np.nanmax(C1[:])\\n Cmax2=np.nanmax(C2[:])\\n Cmax=[]\\n Cmax=[Cmax1, Cmax2]\\n vmax=np.nanmax(Cmax)\\n Cmin1=np.nanmin(C1[:])\\n Cmin2=np.nanmin(C2[:])\\n Cmin=[]\\n Cmin=[Cmin1, Cmin2]\\n vmin=np.min(Cmin)\\n\\n # Calculate automatic threshold\\n if threshold == 'auto':\\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\\n else:\\n threshold = threshold\\n\\n # Define colormap for both participant\\n cmap_p = matplotlib.cm.get_cmap('Reds')\\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\\n\\n for e1 in range(len(loc1)):\\n x1 = loc1[e1, 0]\\n y1 = loc1[e1, 1]\\n z1 = loc1[e1, 2]\\n for e2 in range(len(loc1)):\\n x2 = loc1[e2, 0]\\n y2 = loc1[e2, 1]\\n z2 = loc1[e2, 2]\\n if C1[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C1[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\\n \\n for e1 in range(len(loc2)):\\n x1 = loc2[e1, 0]\\n y1 = loc2[e1, 1]\\n z1 = loc2[e1, 2]\\n for e2 in range(len(loc2)):\\n x2 = loc2[e2, 0]\\n y2 = loc2[e2, 1]\\n z2 = loc2[e2, 2]\\n if C2[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C2[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\",\n \"def _filter_axes(self, channel_axes, spatial_axes):\\n f_axes = ng.make_axes()\\n f_axes += ng.make_axis(length=self.nout, name=\\\"K\\\")\\n f_axes += channel_axes\\n for key, ax in zip(self.spatial_keys, spatial_axes):\\n f_axes += ng.make_axis(length=self.filter_spatial_shape[key],\\n name=ax.name)\\n\\n return f_axes\",\n \"def __eq__(self, other):\\n return (\\n isinstance(other, SeriesAxis)\\n and self.start == other.start\\n and self.step == other.step\\n and self.size == other.size\\n and self.unit == other.unit\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61138195","0.6088058","0.6041942","0.5724058","0.55722874","0.54428166","0.5421346","0.5317659","0.53087","0.52630603","0.5246884","0.521855","0.5203898","0.5200251","0.51671886","0.5156836","0.51552814","0.5126504","0.51036406","0.5095335","0.5079292","0.507371","0.5068818","0.5067907","0.5063909","0.5045423","0.50289595","0.5015576","0.5002713","0.5001157","0.49788442","0.49719414","0.49710396","0.4966713","0.4954035","0.49528587","0.49306583","0.49243277","0.49120444","0.49013466","0.49001938","0.48767823","0.48680952","0.48645702","0.4857732","0.48543733","0.48537374","0.48525012","0.48424858","0.48327753","0.48316157","0.48189354","0.48027557","0.47959623","0.4780534","0.47613725","0.47588947","0.47482666","0.4745309","0.47437522","0.4738578","0.47382948","0.47331488","0.47249183","0.4721315","0.47187826","0.47183728","0.47114712","0.4701064","0.46953326","0.46900085","0.46867532","0.4684767","0.46835095","0.46789926","0.46765533","0.46746406","0.46676803","0.4664809","0.4663614","0.46571293","0.46562186","0.46544766","0.4652856","0.46512058","0.46376088","0.46357727","0.46343824","0.4627512","0.46184897","0.4612797","0.46029803","0.4601747","0.45988584","0.4597284","0.45901194","0.45839134","0.4580499","0.4576419","0.4568742"],"string":"[\n \"0.61138195\",\n \"0.6088058\",\n \"0.6041942\",\n \"0.5724058\",\n \"0.55722874\",\n \"0.54428166\",\n \"0.5421346\",\n \"0.5317659\",\n \"0.53087\",\n \"0.52630603\",\n \"0.5246884\",\n \"0.521855\",\n \"0.5203898\",\n \"0.5200251\",\n \"0.51671886\",\n \"0.5156836\",\n \"0.51552814\",\n \"0.5126504\",\n \"0.51036406\",\n \"0.5095335\",\n \"0.5079292\",\n \"0.507371\",\n \"0.5068818\",\n \"0.5067907\",\n \"0.5063909\",\n \"0.5045423\",\n \"0.50289595\",\n \"0.5015576\",\n \"0.5002713\",\n \"0.5001157\",\n \"0.49788442\",\n \"0.49719414\",\n \"0.49710396\",\n \"0.4966713\",\n \"0.4954035\",\n \"0.49528587\",\n \"0.49306583\",\n \"0.49243277\",\n \"0.49120444\",\n \"0.49013466\",\n \"0.49001938\",\n \"0.48767823\",\n \"0.48680952\",\n \"0.48645702\",\n \"0.4857732\",\n \"0.48543733\",\n \"0.48537374\",\n \"0.48525012\",\n \"0.48424858\",\n \"0.48327753\",\n \"0.48316157\",\n \"0.48189354\",\n \"0.48027557\",\n \"0.47959623\",\n \"0.4780534\",\n \"0.47613725\",\n \"0.47588947\",\n \"0.47482666\",\n \"0.4745309\",\n \"0.47437522\",\n \"0.4738578\",\n \"0.47382948\",\n \"0.47331488\",\n \"0.47249183\",\n \"0.4721315\",\n \"0.47187826\",\n \"0.47183728\",\n \"0.47114712\",\n \"0.4701064\",\n \"0.46953326\",\n \"0.46900085\",\n \"0.46867532\",\n \"0.4684767\",\n \"0.46835095\",\n \"0.46789926\",\n \"0.46765533\",\n \"0.46746406\",\n \"0.46676803\",\n \"0.4664809\",\n \"0.4663614\",\n \"0.46571293\",\n \"0.46562186\",\n \"0.46544766\",\n \"0.4652856\",\n \"0.46512058\",\n \"0.46376088\",\n \"0.46357727\",\n \"0.46343824\",\n \"0.4627512\",\n \"0.46184897\",\n \"0.4612797\",\n \"0.46029803\",\n \"0.4601747\",\n \"0.45988584\",\n \"0.4597284\",\n \"0.45901194\",\n \"0.45839134\",\n \"0.4580499\",\n \"0.4576419\",\n \"0.4568742\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69112474"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19893,"cells":{"query":{"kind":"string","value":"Not much tested I decided against doing overlapping line plots this way. Returns a TransientVaraible made by replacing an axis axisold of a TransientVariable mv with a new axis. The new axis will have all points of the old axis, but may have more, thus requiring the new variable to have more missing data. The variable axisnindew is a 2tuple, containing the new axis and index information describing which elements came from the old axis. In terms of common_axis(), it is (axis3,a1indexina3) or (axis3,a2indexina3)."},"document":{"kind":"string","value":"def convert_axis( mv, axisold, axisindnew ):\n (axisnew, indexina3) = axisindnew\n axes = allAxes(mv)\n kold = None\n for k in range(len(axes)):\n if axes[k]==axisold: kold=k\n if kold==None:\n print \"ERROR. convert_axis cannot find axis\",axisold,\" in variable\",mv\n if len(axisold)==len(axisnew):\n mv.setAxis( kold, axisnew )\n return\n # Here's what we would do in 1-D:\n # newdata = ma.ones(len(axisnew))*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # for i in range(len(axisold)):\n # newdata[ indexina3[i] ] = ma[i]\n # newmv = cdms2.createVariable( newdata, id=mv.id )\n # >1-D is the same idea, but more dimensions are coming along for the ride,\n # making it more complicated...\n shape0 = mv.shape\n shape0[kold] = len(axisnew)\n newdata = ma.ones(shape0)*mv.missing_value # Note that a FileVariable's missing_value is a tuple.\n # We want to copy ma to newdata - except that we need indirect indexing for the kold-th axis.\n # There seems to be nothing in numpy for treating one axis differently from the rest\n # (except for ellipsis, but it makes sense to use only one ellipsis and we would need two here).\n # The following will do the job. It would be very slow for an array with many big dimensions,\n # but the arrays here have already been reduced for graphics; the index sets will be small or\n # empty...\n ranges = map( range, shape0[0:kold] )\n for i in range(len(axisold)):\n for idx in apply(itertools.product,ranges):\n idx = idx + [indexina3(i)] + [Ellipsis]\n idxo = idx + [i] + [Ellipsis]\n newdata[ tuple(idx) ] = mv[idxo]\n newmv = cdms2.createVariable( newdata, id=mv.id )"},"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 replace_axis(self, dim:NamedIndex,\n mapping_or_old:'Union[Mapping[NamedIndex, NamedIndex], NamedIndex]',\n new:'Optional[NamedIndex]'=None):\n\n axes = self[dim] # disable idx_dim access\n # axes = self.get(dim) or self._dim_axes[dim] # dim:'Union[int, NamedIndex]'\n is_tuple_axes = is_namedtuple(axes)\n assert isinstance(axes, dict) or is_tuple_axes, (\n f'unnamed dim({dim!r}) cannot be renamed')\n\n axes_keys = axes._fields if is_tuple_axes else axes.keys()\n axes_iter = iter(zip(axes._fields, axes)) if is_tuple_axes else axes.items()\n axes_ = OrderedDict()\n\n if new is None:\n assert isinstance(mapping_or_old, dict), (\n f\"'mapping_or_old'({type(mapping_or_old)}) is expected to be a dict \"\n \"when 'new' is None\")\n\n mapping = mapping_or_old\n for axis, index in axes_iter:\n axis = mapping.get(axis, axis)\n assert axis not in axes_, f'axis {axis!r} in mapping is conflicted'\n\n axes_[axis] = index\n else:\n assert new not in axes_keys, f'new axis({new!r}) is confilicted'\n\n old = mapping_or_old\n for axis, index in axes_iter:\n axes_[new if axis == old else axis] = index\n\n axes_ = namedtuple(dim, axes_.keys())(**axes_) if is_tuple_axes else type(axes)(axes_)\n ret = OrderedDict()\n for dim_, axes in self.items():\n ret[dim_] = axes_ if dim_ == dim else axes\n\n return type(self)(ret)","def common_axis( axis1, axis2 ):\n if hasattr( axis1, 'units' ):\n units1 = axis1.units.lower().replace(' ','_')\n if axis1.isTime():\n axis1.toRelativeTime( units1 ) #probably will change input argument\n else:\n units1 = None\n if hasattr( axis2, 'units' ):\n units2 = axis2.units.lower().replace(' ','_')\n else:\n units2 = None\n if units1!=None and units2!=None and units1 != units2:\n if axis1.isTime() and axis2.isTime():\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\n else:\n print \"ERROR. common_axis does not yet support differing units\",axis1.units,\" and \",axis2.units\n return None\n if axis1.isTime() or axis2.isTime():\n if not axis2.isTime() or not axis1.isTime():\n print \"ERROR. In common_axis, one axis is time, not the other\"\n return None\n if not axis1.calendar==axis2.calendar:\n print \"ERROR. common_axis does not yet support differing calendars.\"\n if len(axis1)==1 and len(axis2)==1:\n # There's just one time value, probably from averaging over time. The time value is meaningless\n # but it would be messy to have two.\n return (axis1,[0],[0])\n\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\n # units and calendar attributes should always be transferred if present.\n # Also to do: use bounds if available\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\n a1indexina3 = a12indexina3[0:len(axis1)]\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\n\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\n vid = axis1.id\n else:\n vid = None\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\n axis3.units = units1\n return (axis3,a1indexina3,a2indexina3)","def delete_singleton_axis( mv, vid=None ):\n axes = allAxes(mv)\n saxis = None\n si = None\n for i in range(len(axes)):\n if len(axes[i])==1 and (vid==None or axes[i].id==vid):\n saxis = axes[i]\n si = i\n del axes[si]\n break\n if saxis==None: return mv\n data = ma.copy( mv.data )\n if numpy.version.version >= '1.7.0':\n data = ma.squeeze( data, axis=si )\n else:\n data = ma.squeeze( data ) # let's hope that there's only one singleton!\n mvnew = cdms2.createVariable ( data, axes=axes, id=mv.id )\n if hasattr(mv,'units'): mvnew.units = mv.units\n return mvnew","def replace_dim(self, old:NamedIndex, new:NamedIndex):\n\n assert new not in self, f'new dim({new!r}) is confilicted'\n\n ret = OrderedDict()\n for dim, axes in self.items():\n if dim == old:\n if is_namedtuple(axes):\n axes = namedtuple(new, axes._fields)(*axes)\n ret[new] = axes\n else:\n ret[old] = axes\n\n return type(self)(ret)","def test_newaxis(self):\r\n newaxis = numpy.newaxis\r\n\r\n n = self.shared(numpy.arange(24, dtype=self.dtype).reshape((2, 3, 4)))\r\n assert n.ndim == 3\r\n\r\n n4 = n[newaxis, :, :, :]\r\n assert n4.broadcastable == (True, False, False, False), n4\r\n\r\n n4 = n[:, newaxis, :, :]\r\n assert n4.broadcastable == (False, True, False, False), n4\r\n\r\n n4 = n[:, :, newaxis, :]\r\n assert n4.broadcastable == (False, False, True, False), n4\r\n\r\n n4 = n[:, :, :, newaxis]\r\n assert n4.broadcastable == (False, False, False, True), n4\r\n\r\n n3 = n.flatten()[newaxis, :, newaxis]\r\n assert n3.broadcastable == (True, False, True), n3\r\n\r\n s = cscalar()\r\n s1 = s[newaxis]\r\n assert s1.broadcastable == (True,), s1\r\n\r\n vs1, vn3, vn4 = theano.function([s], [s1, n3, n4])(-2.0)\r\n\r\n assert numpy.all(vs1 == [-2.0])\r\n assert numpy.all(vn3\r\n == numpy.arange(24)[newaxis, :, newaxis])\r\n assert numpy.all(vn4\r\n == numpy.arange(24).reshape((2, 3, 4))[:, :, :, newaxis])","def common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n axes3.append(common_axis( axes1[i], axes2[i] ))\n return axes3","def addExtraAxis(slab,newaxis=None,axis=0,verbose=False):\n\n import cdms2 as cdms\n import MV2 as MV\n\n if newaxis is None:\n newaxis=cdms.createAxis([1,])\n newaxis.units=''\n\n # add new axis to axis list of input <slab>\n axislist=slab.getAxisList()\n axislist.insert(axis,newaxis)\n\n #----------------Reshape----------------\n shape=list(slab.shape)\n shape.insert(axis,len(newaxis))\n slab2=MV.reshape(slab,shape)\n\n #------------Create variable------------\n att_dict=attribute_obj2dict(slab)\n slab2=cdms.createVariable(slab2,axes=axislist,attributes=att_dict,\\\n typecode='f')\n slab2.id=slab.id\n\n if verbose:\n print('\\n# <addExtraAxis>: Originial variable shape:',slab.shape)\n print('# <addExtraAxis>: New variable shape:',slab2.shape)\n\n return slab2","def _make_twin_axes(self, *args, **kwargs):\n # Typically, SubplotBase._make_twin_axes is called instead of this.\n # There is also an override in axes_grid1/axes_divider.py.\n if 'sharex' in kwargs and 'sharey' in kwargs:\n raise ValueError('Twinned Axes may share only one axis.')\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\n self.set_adjustable('datalim')\n ax2.set_adjustable('datalim')\n self._twinned_axes.join(self, ax2)\n return ax2","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def swapaxes(self, a1, a2):\n an = self.axes_names[:]\n ia1, ia2 = self.get_axis_id(a1), self.get_axis_id(a2)\n an[ia2], an[ia1] = an[ia1], an[ia2]\n return xndarray(np.swapaxes(self.data, ia1, ia2), an, self.axes_domains,\n self.value_label, self.meta_data)","def interp2( newaxis1, mv ):\n missing = mv.get_fill_value()\n axes = allAxes(mv)\n if len(newaxis1[:])>len(axes[1][:]): return mv\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\n for i in range(len( axes[0] )):\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\n # the mask - which numpy.interp treats False as 0, True as 1:\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\n right=missing ) )>0\n return new_vals","def aminusb_2ax( mv1, mv2 ):\n return mv2\n mv1, mv2 = reconcile_units( mv1, mv2 )\n missing = mv1.get_fill_value()\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n if axes1 is None or axes2 is None: return None\n if len(axes1)!=2: print \"ERROR @1, wrong number of axes for aminusb_2ax\",axes1\n if len(axes2)!=2: print \"ERROR @2, wrong number of axes for aminusb_2ax\",axes2\n if len(axes1[0])==len(axes2[0]):\n # Only axis2 differs, there's a better way...\n return aminusb_ax2( mv1, mv2 )\n if len(axes1[0])<=len(axes2[0]):\n if len(axes1[1])<=len(axes2[1]):\n mv1new = mv1\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid1 = mv1.getGrid()\n mv2new = mv2.regrid(grid1)\n else:\n # Interpolate mv1 from axis1[1] to axis2[1]\n # Interpolate mv2 from axis2[0] to axis1[0]\n print \"ERROR @3, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n if len(axes1[1])<=len(axes2[1]):\n # Interpolate mv1 from axis1[0] to axis2[0]\n # Interpolate mv2 from axis2[1] to axis1[1]\n print \"ERROR @4, aminusb_2ax IS NOT FINISHED\"\n return None\n else:\n mv2new = mv2\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\n grid2 = mv2.getGrid()\n mv1new = mv1.regrid(grid2)\n aminusb = mv1new - mv2new\n aminusb.id = mv1.id\n return aminusb","def duplicate_axes(isl_obj, duplicate_inames, new_inames):\n if isinstance(isl_obj, list):\n return [\n duplicate_axes(i, duplicate_inames, new_inames)\n for i in isl_obj]\n\n if not duplicate_inames:\n return isl_obj\n\n def _align_and_intersect(d1, d2):\n d1, d2 = isl.align_two(d1, d2)\n return d1 & d2\n\n old_name_to_new_name = dict(zip(duplicate_inames, new_inames))\n\n dup_isl_obj = isl_obj\n\n for old_name, (dt, pos) in isl_obj.get_var_dict().items():\n dup_isl_obj = dup_isl_obj.set_dim_name(dt, pos,\n old_name_to_new_name.get(old_name,\n old_name))\n\n return _align_and_intersect(dup_isl_obj, isl_obj)","def reorderAxesEvent(self):\n axisB = self.sender().text()\n self.myParent.swapAxes(self.axisName, axisB)\n self.myParent.setVistrailsVariableAxes()","def test_var_and_raw_var_same_index(self):\n\n # Swap first row for second one\n var = Validator.getattr_anndata(self.validator.adata, \"var\")\n\n # First swap the index\n new_index = list(var.index)\n tmp = new_index[0]\n new_index[0] = new_index[1]\n new_index[1] = tmp\n var.set_index(pd.Index(new_index), inplace=True)\n\n # Then swap the actual rows\n tmp = var.iloc[0, :].copy()\n var.iloc[0, :] = var.iloc[1, :].copy()\n var.iloc[1, :] = tmp\n\n self.validator.validate_adata()\n print(\"FOO\", self.validator.errors)\n self.assertEqual(\n self.validator.errors,\n [\"ERROR: Index of 'raw.var' is not identical to index of 'var'.\"],\n )","def interpolate_vertical(ml_file, inter_file, new_vertical_axis):\n with xr.load_dataset(inter_file) as interpolated:\n reference = [variable for variable in interpolated.variables if len(interpolated[variable].shape) == 4][0]\n with xr.open_dataset(ml_file) as ml:\n for variable in [variable for variable in ml.variables if variable not in interpolated.variables\n and len(ml[variable].dims) == 4\n and \"lev_2\" in ml[variable].dims]:\n try:\n x = np.array(ml[new_vertical_axis].data)\n y = np.array(ml[variable].data)\n interpolated_data = interpolate_1d(interpolated[\"lev\"].data, x, y, axis=1)\n attributes = ml[variable].attrs\n\n interpolated[variable] = interpolated[reference].copy(data=interpolated_data)\n interpolated[variable].attrs = ml[variable].attrs\n except Exception as e:\n print(variable, e)\n interpolated.to_netcdf(inter_file)","def adjust_axes(axes):\n # TODO: Uncomment & decide for each subplot!\n for ax in axes.itervalues():\n core.hide_axis(ax)\n\n for k in [\n \"placeholder\",\n \"placeholder1\",\n \"placeholder2\",\n \"spikes_stim\",\n \"spikes_stim1\",\n \"spikes_stim2\",\n \"spikes_post\",\n \"stimulation_schema\"\n ]:\n axes[k].set_frame_on(False)","def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1.get_fill_value()\n axis1 = allAxes(mv1)[0]\n axis2 = allAxes(mv2)[0]\n if len(axis1)<=len(axis2):\n a = mv1\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\n else:\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\n b = mv2\n aminusb = a - b\n aminusb.id = mv1.id\n return aminusb","def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def adjust_axes(axis):\r\n x_lim = axis.get_xlim()\r\n y_lim = axis.get_ylim()\r\n new_lim = (min(x_lim[0], y_lim[0]), max(x_lim[1], y_lim[1]))\r\n axis.set_xlim(new_lim)\r\n axis.set_ylim(new_lim)\r\n axis.set_aspect('equal')","def _metadata_changed(self, old, new):\n\n #self.cross_plot.value_range.low = self.minz\n #self.cross_plot.value_range.high = self.maxz\n #self.cross_plot2.value_range.low = self.minz\n #self.cross_plot2.value_range.high = self.maxz\n if self._imag_index.metadata.has_key(\"selections\"):\n x_ndx, y_ndx = self._imag_index.metadata[\"selections\"]\n if y_ndx and x_ndx:\n# xdata, ydata = self._image_index.get_data()\n# xdata, ydata = xdata.get_data(), ydata.get_data()\n self.pd_horiz.set_data(\"horiz\", self._image_value.data[y_ndx,:])\n self.pd_vert.set_data(\"vert\", self._image_value.data[:,x_ndx])","def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\n\n ps = phase_space[:, (id_begin-1):id_end, :]\n # print(np.shape(ps))\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\n\n x = ps[0, :, :]\n px = ps[1, :, :]\n y = ps[2, :, :]\n py = ps[3, :, :]\n\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\n\n for n in range(int(id_end-id_begin+1)):\n x_this = x[n, :]\n px_this = px[n, :]\n y_this = y[n, :]\n py_this = py[n, :]\n\n # Remove all NAN elements in the phase space array\n x_this = x_this[np.logical_not(np.isnan(x_this))]\n px_this = px_this[np.logical_not(np.isnan(px_this))]\n y_this = y_this[np.logical_not(np.isnan(y_this))]\n py_this = py_this[np.logical_not(np.isnan(py_this))]\n\n ## Plot X\n plt.subplot(2, 2, 1)\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\n plt.ylabel('Position in X/ $\\mu$m', fontsize=10)\n\n ## Plot Y\n plt.subplot(2, 2, 2)\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\n plt.ylabel('Position in Y/ $\\mu$m', fontsize=10)\n\n ## Plot px\n plt.subplot(2, 2, 3)\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\n plt.ylabel('Angle in X', fontsize=10)\n\n ## Plot py\n plt.subplot(2, 2, 4)\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\n plt.ylabel('Angle in Y', fontsize=10)\n\n\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\mu$m')\n # plt.title('First Undulator Section')\n # plt.title('Second Undulator Section')\n # plt.title('Third Undulator Section')\n\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\n\n fig = plt.gcf()\n fig.set_size_inches(13.5, 9)\n ax = plt.gca()\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\n fig.savefig('phase_space_U3_new.png', dpi=100)\n plt.show()\n\n\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\n\n return id_on_axis, s_on_axis","def setupVariableAxes(self):\n if self.var is None:\n return\n \n if (self.axisList is None):\n self.axisList = self.var.getAxisList()\n self.axisOrder = range(len(self.axisList))\n\n self.clear() \n self.setAxesNames()\n \n # Iterate through the variables axes & init each axis widget\n axisIndex = 0\n for axis, axisName in zip(self.axisList, self.axesNames):\n # Create the axis widget\n axisWidget = QAxis(axis, axisName, axisIndex, self)\n axisWidget.setAxisButtonText(axisName)\n self.axisWidgets.append(axisWidget)\n\n # Setup the layout for each axis\n row = self.gridLayout.rowCount()\n self.gridLayout.addWidget(axisWidget.getAxisButton(), row, 0)\n self.gridLayout.addWidget(axisWidget, row, 1) \n self.gridLayout.addWidget(axisWidget.getAxisOperationsButton(), row, 2)\n\n # Create separator line between each axis widget\n vline = QtGui.QFrame()\n vline.setFrameStyle(QtGui.QFrame.HLine | QtGui.QFrame.Sunken)\n self.gridLayout.addWidget(vline, row+1, 0, 1,\n self.gridLayout.columnCount())\n\n axisIndex += 1\n\n self.gridLayout.setRowStretch(self.gridLayout.rowCount(), 1)","def translate(self, diff: AnyVec) -> None:\n for p in self.planes:\n p += diff\n\n u_axis = Vec(self.uaxis.x, self.uaxis.y, self.uaxis.z)\n v_axis = Vec(self.vaxis.x, self.vaxis.y, self.vaxis.z)\n\n # Fix offset - see 2013 SDK utils/vbsp/map.cpp:2237\n self.uaxis.offset -= Vec.dot(u_axis, diff) / self.uaxis.scale\n self.vaxis.offset -= Vec.dot(v_axis, diff) / self.vaxis.scale","def _update_axes(self):\n data_shape = self.data.shape\n if len(self.axes) < self.data.ndim + 1:\n self._axes.append(Axis())\n for index in range(self.data.ndim):\n if len(self.axes[index].values) != data_shape[index]:\n self.axes[index].values = np.arange(data_shape[index],\n dtype=np.float64)","def _make_axes(self, hdr, quiet=False, novec=False, vonly=False, simple=False):\n\n # PULL THE IMAGE/CUBE SIZES FROM THE HEADER\n naxis = int(hdr['NAXIS'])\n naxis1 = int(hdr['NAXIS1'])\n naxis2 = int(hdr['NAXIS2'])\n if naxis > 2:\n naxis3 = hdr['NAXIS3']\n\n ## EXTRACT FITS ASTROMETRY STRUCTURE\n ww = astropy.wcs.WCS(hdr)\n\n #IF DATASET IS A CUBE THEN WE MAKE THE THIRD AXIS IN THE SIMPLEST WAY POSSIBLE (NO COMPLICATED ASTROMETRY WORRIES FOR FREQUENCY INFORMATION)\n if naxis > 3:\n #GRAB THE RELEVANT INFORMATION FROM THE ASTROMETRY HEADER\n cd = ww.wcs.cd\n crpix = ww.wcs.crpix\n cdelt = ww.wcs.crelt\n crval = ww.wcs.crval\n\n if naxis > 2:\n # MAKE THE VELOCITY AXIS (WILL BE M/S)\n v = np.arange(naxis3) * 1.0\n vdif = v - (hdr['CRPIX3']-1)\n vaxis = (vdif * hdr['CDELT3'] + hdr['CRVAL3'])\n\n # CUT OUT HERE IF WE ONLY WANT VELOCITY INFO\n if vonly:\n return vaxis\n\n #IF 'SIMPLE' IS CALLED THEN DO THE REALLY TRIVIAL THING:\n if simple:\n print('Using simple aproach to make axes.')\n print('BE SURE THIS IS WHAT YOU WANT! It probably is not.')\n raxis = np.arange(naxis1) * 1.0\n rdif = raxis - (hdr['CRPIX1'] - 1)\n raxis = (rdif * hdr['CDELT1'] + hdr['CRVAL1'])\n\n daxis = np.arange(naxis2) * 1.0\n ddif = daxis - (hdr['CRPIX1'] - 1)\n daxis = (ddif * hdr['CDELT1'] + hdr['CRVAL1'])\n\n rimg = raxis # (fltarr(naxis2) + 1.)\n dimg = (np.asarray(naxis1) + 1.) # daxis\n return rimg, dimg\n\n # OBNOXIOUS SFL/GLS THING\n glspos = ww.wcs.ctype[0].find('GLS')\n if glspos != -1:\n ctstr = ww.wcs.ctype[0]\n newtype = 'SFL'\n ctstr.replace('GLS', 'SFL')\n ww.wcs.ctype[0] = ctstr\n print('Replaced GLS with SFL; CTYPE1 now =' + ww.wcs.ctype[0])\n\n glspos = ww.wcs.ctype[1].find('GLS')\n if glspos != -1:\n ctstr = ww.wcs.ctype[1]\n newtype = 'SFL'\n ctstr.replace('GLS', 'SFL')\n ww.wcs.ctype[1] = ctstr\n print('Replaced GLS with SFL; CTYPE2 now = ' + ww.wcs.ctype[1])\n\n # CALL 'xy2ad' TO FIND THE RA AND DEC FOR EVERY POINT IN THE IMAGE\n if novec:\n rimg = np.zeros((naxis1, naxis2))\n dimg = np.zeros((naxis1, naxis2))\n for i in range(naxis1):\n j = np.asarray([0 for i in xrange(naxis2)])\n\n pixcrd = np.array([[zip(float(i), float(j))]], numpy.float_)\n ra, dec = ww.all_pix2world(pixcrd, 1)\n\n rimg[i, :] = ra\n dimg[i, :] = dec\n else:\n ximg = np.arange(naxis1) * 1.0\n yimg = np.arange(naxis1) * 1.0\n X, Y = np.meshgrid(ximg, yimg, indexing='xy')\n ss = X.shape\n xx, yy = X.flatten(), Y.flatten()\n\n pixcrd = np.array(zip(xx, yy), np.float_)\n img_new = ww.all_pix2world(pixcrd, 0)\n rimg_new, dimg_new = img_new[:,0], img_new[:,1]\n\n rimg = rimg_new.reshape(ss)\n dimg = dimg_new.reshape(ss)\n\n # GET AXES FROM THE IMAGES. USE THE CENTRAL COLUMN AND CENTRAL ROW\n raxis = np.squeeze(rimg[:, naxis2/2])\n daxis = np.squeeze(dimg[naxis1/2, :])\n\n return rimg, dimg","def setaxesnames(self):\n if not self._axesnames or self.prop['skipsai']:\n return\n debug('ControllerStartup.setaxesnames()')\n oldaxes = self.pidevice.qSAI_ALL()\n for i, newaxis in enumerate(self.axesnames):\n if newaxis != oldaxes[i] or self.prop['forcesai']:\n setstage = False\n if self.pidevice.HasqCST():\n if self.pidevice.qCST()[oldaxes[i]] == 'NOSTAGE':\n try:\n debug('try rename NOSTAGE to TEMP (0x3C)')\n self.pidevice.SPA(oldaxes[i], 0x3c, 'TEMP')\n setstage = True\n except GCSError:\n pass\n self.pidevice.SAI(oldaxes[i], newaxis)\n if setstage:\n self.pidevice.SPA(newaxis, 0x3c, 'NOSTAGE')\n debug('restore NOSTAGE (0x3C)')","def InterpolateSurfaceVectorsWithLine():\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, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n print('Loading Finished \\n Inserting Centre Line...')\r\n # Create Plane of vectors through centreline.\r\n PlaneCentroids,PlaneVectors = InsertCentreLine(Centroids1,Vectors1,50)\r\n print('Centre Line Inserted \\n Interpolating Centroids...')\r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.1)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\r\n print('Interpolation Finished \\n Plotting...')\r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(121,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,5,10)\r\n\r\n ax2 = fig.add_subplot(122,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,5,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"Normal Surface Vectors With Central axis Line\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/SurfaceLineVectorInterpolation.dat\",Vectors2,header = header,comments='')","def _update_vars(self, axis, traj_s, traj_o, rank_s, rank_o, t):\n if axis == 0:\n self.x_traj = traj_s\n self.x_ranking = rank_s\n self.x_scores = traj_s[-1]\n self.inverse_y_traj = traj_o\n self.inverse_y_ranking = rank_o\n self.inverse_y_scores = traj_o[-1]\n if axis == 1:\n self.y_traj = traj_s\n self.y_ranking = rank_s\n self.y_scores = traj_s[-1]\n self.inverse_x_traj = traj_o\n self.inverse_x_ranking = rank_o\n self.inverse_x_scores = traj_o[-1]","def _plot_interpolation(x, y, x_new, y_new, title=\"\"):\n f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, sharey=True)\n axes = (ax1, ax2, ax3)\n coord = [\"X\", \"Y\", \"Z\"]\n\n for idx, ax in enumerate(axes):\n ax.set_title(title + \" (\" + coord[idx] + \" coordinate)\", fontsize=12)\n ax.set_ylabel(\"m\")\n ax.plot(x, y[:, idx], \"bo\", label=\"Original data\")\n ax.plot(x_new, y_new[:, idx], \"ro\", label=\"Interpolated data\")\n\n ax3.set_xlabel(\"Time\")\n ax1.legend(fontsize=8, loc=1)\n f.subplots_adjust(hspace=0.3)\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\n plt.show()","def reshape_differential(x, y, xnew):\r\n foo = scipy.interpolate.interp1d(\r\n x, y,\r\n axis=0,\r\n copy=False,\r\n kind=\"slinear\",\r\n bounds_error=False,\r\n fill_value=0.,\r\n assume_sorted=True,\r\n )\r\n return foo(xnew)","def observable_coplot_axis_annotator(target_axis: mpa.Axes, file_pattern: str,\n variable_index: int, variable_name: str, variable_expr: str,\n differential_toggle: bool = False,\n log_axis_x: bool = False, log_axis_y: bool = False,\n no_legend: bool = False) -> mpa.Axes:\n file_names = _find_data_files(file_pattern)\n file_data_list = []\n for file_name in file_names:\n legend_data, numeric_data = observable_file_reader(file_name)\n if numeric_data.shape[0] <= 1:\n warnings.warn('Only one time point in file ' + file_name)\n file_data_list.append((legend_data, numeric_data, file_name))\n if not variable_index and not variable_name and not variable_expr:\n raise ValueError('Function requires the index of a variable,'\n ' a name for one, or an expression of variables found in the observable file.')\n _multi_data_axis_annotator(co_plot_axis=target_axis, file_data_list=file_data_list,\n coplot_index=variable_index, coplot_name=variable_name, coplot_expression=variable_expr,\n diff_toggle=differential_toggle, log_x=log_axis_x, log_y=log_axis_y,\n omit_legend=no_legend)\n return target_axis","def mirror_axis(self, axis_index=0, reverse=False):\n self.smd3.mirror(axis_index=axis_index, reverse=reverse)\n self.logic.mirror(axis_index=axis_index, reverse=reverse)\n min_vector, max_vector = self.smd3.get_min_max_vector()\n self.header.set_box(min_vector, max_vector)\n self.header.update(self.smd3)\n self.logic.update(self.smd3)\n # self.meta.mirror(axis_index=axis_index, reverse=reverse)","def swapaxes(a, axis1, axis2):\n # TODO(okuta): check type\n return a.swapaxes(axis1, axis2)","def plot_item_add_second_right_axis(plot_item):\n ax = _pyqtgraph.AxisItem('left')\n vb = _pyqtgraph.ViewBox()\n plot_item.layout.addItem(ax, 2, 3)\n plot_item.scene().addItem(vb)\n ax.linkToView(vb)\n vb.setXLink(plot_item)\n\n def update_views():\n vb.setGeometry(plot_item.vb.sceneBoundingRect())\n vb.linkedViewChanged(plot_item.vb, vb.XAxis)\n\n update_views()\n plot_item.vb.sigResized.connect(update_views)\n return ax","def moveaxis(self, tensor, source, destination):\n\n axes = list(range(self.ndim(tensor)))\n if source < 0:\n source = axes[source]\n if destination < 0:\n destination = axes[destination]\n try:\n axes.pop(source)\n except IndexError:\n raise ValueError(\n \"Source should verify 0 <= source < tensor.ndim\" \"Got %d\" % source\n )\n try:\n axes.insert(destination, source)\n except IndexError:\n raise ValueError(\n \"Destination should verify 0 <= destination < tensor.ndim\"\n \"Got %d\" % destination\n )\n return self.transpose(tensor, axes)","def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\n\n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\n lab1 = [ch for ch in epo1.ch_names]\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\n lab2 = [ch for ch in epo2.ch_names]\n\n bads_epo1 =[]\n bads_epo1 = epo1.info['bads']\n bads_epo2 =[]\n bads_epo2 = epo2.info['bads']\n\n # plot sensors ('x' for bads)\n for ch in epo1.ch_names:\n if ch in bads_epo1:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo1.ch_names.index(ch)\n x1, y1, z1 = loc1[index_ch, :]\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\n if lab:\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n\n for ch in epo2.ch_names:\n if ch in bads_epo2:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')\n else:\n index_ch = epo2.ch_names.index(ch)\n x2, y2, z2 = loc2[index_ch, :]\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\n if lab:\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\n horizontalalignment='center',\n verticalalignment='center')","def register_manual_translation(vol_a: Volume, vol_b: Volume) -> np.ndarray:\n plt.ion()\n fig, ax = plt.subplots(1, 2)\n w, h, l = vol_a.data.shape\n ax[0].imshow(\n np.mean(vol_a.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=2, dtype=np.float32).T / 2 ** 16)\n w, h, l = vol_b.data.shape\n ax[1].imshow(\n np.mean(vol_b.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=2, dtype=np.float32).T / 2 ** 16)\n\n points = plt.ginput(2, timeout=0)\n plt.close()\n\n fig, ax = plt.subplots(1, 2)\n w, h, l = vol_a.data.shape\n ax[0].imshow(\n np.mean(vol_a.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=1, dtype=np.float32).T / 2 ** 16)\n w, h, l = vol_b.data.shape\n ax[1].imshow(\n np.mean(vol_b.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=1, dtype=np.float32).T / 2 ** 16)\n\n points2 = plt.ginput(2, timeout=0)\n plt.close()\n\n return np.array([points[1][0] - points[0][0], points[1][1] - points[0][1], points2[1][1] - points2[0][1]])","def getReplacementAxisValuesEvent(self):\n definedVars = self.myParent.getParent().getDefinedVars()\n QReplaceAxisValuesDialog(definedVars, self).show()","def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\n width_axis.name = \"time\"\n assert len(conv1d_placeholder.axes.find_by_name(\"time\")) == 1\n\n conv_layer = Convolution((3, output_size), lambda x: 1)\n with pytest.raises(IncompatibleAxesError):\n conv_layer(conv1d_placeholder)\n # As a dictionary\n output = conv_layer(conv1d_placeholder, spatial_axes={\"W\": \"time\"})\n assert output.axes == conv1d_placeholder.axes\n # As a tuple\n output = conv_layer(conv1d_placeholder, spatial_axes=(\"D\", \"H\", \"time\"))\n assert output.axes == conv1d_placeholder.axes","def with_same_shape(old, new):\n if isinstance(old, tf.Tensor) and isinstance(new, tf.Tensor):\n return tensor_util.with_same_shape(old, new)\n return new","def _share_long_axis(self, share, side, level):\n # NOTE: We do not check _panel_share because that only controls\n # sharing with main subplot, not other subplots\n if share is None or self._panel_side:\n return\n s = side[0]\n axis = 'x' if s in 'tb' else 'y'\n paxs = getattr(self, '_' + s + 'panels')\n paxs = [pax for pax in paxs if not pax._panel_filled]\n for pax in paxs:\n getattr(pax, '_share' + axis + '_setup')(share, level)","def __lineartrans(self):\n do = self.domain\n self.transpoints = copy(self.pts)\n def t(x):\n return (x - do[0])/(do[1]-do[0])\n for i in range(len(self.transpoints)):\n self.transpoints[i,0] = t(self.transpoints[i,0])","def dualx(self, arg, **kwargs):\n # NOTE: Matplotlib 3.1 has a 'secondary axis' feature. For the time\n # being, our version is more robust (see FuncScale) and simpler, since\n # we do not create an entirely separate _SecondaryAxis class.\n ax = self.altx(**kwargs)\n self._dualx_arg = arg\n self._dualx_overrides()\n return ax","def _synchronize_vars_using_mean(new_var: NestedMap,\n old_var: NestedMap) -> NestedMap:\n delta = new_var - old_var\n delta_mean = jax.lax.pmean(delta, axis_name=data_parallel_axis_name)\n updated_var = old_var + delta_mean\n return updated_var","def _adjustFramesAsAxes(self, frames, idx, framesAsAxes):\n axisRange = {}\n slen = len(frames)\n check = 1\n for stride, axis in sorted([[v, k] for k, v in framesAsAxes.items()], reverse=True):\n axisRange[axis] = slen // stride\n slen = stride\n check *= axisRange[axis]\n if check != len(frames) and not hasattr(self, '_warnedAdjustFramesAsAxes'):\n self.logger.warning('framesAsAxes strides do not use all frames.')\n self._warnedAdjustFramesAsAxes = True\n frame = frames[idx].copy()\n for axis in self._axesList:\n frame.pop('Index' + axis.upper(), None)\n for axis, stride in framesAsAxes.items():\n frame['Index' + axis.upper()] = (idx // stride) % axisRange[axis]\n return frame","def InterpolateSurfaceOrtho():\r\n \r\n print('Opening Data...')\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, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n \r\n # Rotate Vectors\r\n RotVectors1 = LongaxisOrtho(Vectors1)\r\n print('Vectors Rotated \\n Interpolating Centroids...')\r\n \r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(Centroids1,RotVectors1,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(Centroids1,RotVectors1,0.1)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\r\n print('Interpolation Finished \\n Plotting...')\r\n \r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(211,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,7,10)\r\n\r\n ax2 = fig.add_subplot(212,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,7,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"Normal Surface Vectors\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/OrthoVectorInterpolation.dat\",Vectors2,header = header,comments='')","def _split_ode(self, newVar, oldVar):\n # Get the free variable in the interface component\n free_var = self.model.find_free_vars()[0]\n if free_var.component is not newVar.component:\n free_var = self.add_input(free_var, free_var.get_units())\n # Add a new variable to assign the RHS to, with units of the original derivative\n deriv_name = self._uniquify_var_name(u'd_%s_d_%s' % (oldVar.name, free_var.name), oldVar.component)\n orig_ode = oldVar.get_all_expr_dependencies()[0]\n orig_rhs_var = self.add_variable(oldVar.component, deriv_name, orig_ode.eq.lhs.get_units().extract())\n # Add an output version of this in the interface, with desired units\n desired_units = newVar.get_units().quotient(free_var.get_units())\n mapped_rhs_var = self.add_output(orig_rhs_var, desired_units, annotate=False)\n # Replace the original ODE with an assignment\n orig_rhs = orig_ode.eq.rhs\n orig_ode.safe_remove_child(orig_rhs)\n self.remove_expr(orig_ode)\n self.add_expr_to_comp(oldVar.component,\n mathml_apply.create_new(self.model, u'eq',\n [orig_rhs_var.name, orig_rhs]))\n # Create a new ODE in the interface component\n new_ode = mathml_diff.create_new(self.model, free_var.name, newVar.name, mapped_rhs_var.name)\n self.add_expr_to_comp(newVar.component, new_ode)\n new_ode.classify_variables(root=True, dependencies_only=True)","def apply_over_axes(\n func: Callable,\n a: PolyLike,\n axes: numpy.typing.ArrayLike,\n) -> ndpoly:\n\n @wraps(func)\n def wrapper_func(array, axis):\n \"\"\"Wrap func function.\"\"\"\n # Align indeterminants in case slicing changed them\n array = numpoly.polynomial(array, names=a.indeterminants)\n array, _ = numpoly.align.align_indeterminants(array, a.indeterminants)\n # Evaluate function\n out = func(array, axis=axis)\n # Restore indeterminants in case func changed them.\n out, _ = numpoly.align.align_indeterminants(out, a.indeterminants)\n return out\n\n # Initiate wrapper\n a = numpoly.aspolynomial(a)\n out = numpy.apply_over_axes(wrapper_func, a=a.values, axes=axes)\n return out","def _assume_meta(self, new_meta, new_var, old_var):\n meta = self._meta\n n_masks = new_meta['masks']\n n_cols = new_meta['columns']\n n_sets = new_meta['sets']\n n_lib_v = new_meta['lib']['values']\n\n if self.is_array(old_var):\n n_masks[new_var] = org_copy.deepcopy(meta['masks'][old_var])\n n_masks[new_var]['name'] = new_var\n if self._has_categorical_data(old_var):\n n_lib_v[new_var] = meta['lib']['values'][old_var]\n n_sets[new_var] = org_copy.deepcopy(meta['sets'][old_var])\n n_sets['data file']['items'].append('masks@{}'.format(new_var))\n for var in self.sources(old_var):\n new_meta = self._assume_meta(new_meta, var, var)\n else:\n n_cols[new_var] = org_copy.deepcopy(meta['columns'][old_var])\n n_cols[new_var]['name'] = new_var\n if self._is_array_item(old_var):\n if not self._maskname_from_item(old_var) in new_meta['masks']:\n n_cols[new_var]['parent'] = {}\n n_cols[new_var]['values'] = self._get_value_loc(old_var)\n n_sets['data file']['items'].append('columns@{}'.format(new_var))\n else:\n n_sets['data file']['items'].append('columns@{}'.format(new_var))\n\n return new_meta","def setup_axes3(fig, rect):\n\n # rotate a bit for better orientation\n tr_rotate = Affine2D().translate(-95, 0)\n\n # scale degree to radians\n tr_scale = Affine2D().scale(np.pi/180., 1.)\n\n tr = tr_rotate + tr_scale + PolarAxes.PolarTransform()\n\n grid_locator1 = angle_helper.LocatorHMS(4)\n tick_formatter1 = angle_helper.FormatterHMS()\n\n grid_locator2 = MaxNLocator(3)\n\n ra0, ra1 = 8.*15, 14.*15\n cz0, cz1 = 0, 14000\n grid_helper = floating_axes.GridHelperCurveLinear(\n tr, extremes=(ra0, ra1, cz0, cz1),\n grid_locator1=grid_locator1,\n grid_locator2=grid_locator2,\n tick_formatter1=tick_formatter1,\n tick_formatter2=None)\n\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\n fig.add_subplot(ax1)\n\n # adjust axis\n ax1.axis[\"left\"].set_axis_direction(\"bottom\")\n ax1.axis[\"right\"].set_axis_direction(\"top\")\n\n ax1.axis[\"bottom\"].set_visible(False)\n ax1.axis[\"top\"].set_axis_direction(\"bottom\")\n ax1.axis[\"top\"].toggle(ticklabels=True, label=True)\n ax1.axis[\"top\"].major_ticklabels.set_axis_direction(\"top\")\n ax1.axis[\"top\"].label.set_axis_direction(\"top\")\n\n ax1.axis[\"left\"].label.set_text(r\"cz [km$^{-1}$]\")\n ax1.axis[\"top\"].label.set_text(r\"$\\alpha_{1950}$\")\n\n # create a parasite axes whose transData in RA, cz\n aux_ax = ax1.get_aux_axes(tr)\n\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\n ax1.patch.zorder = 0.9 # but this has a side effect that the patch is\n # drawn twice, and possibly over some other\n # artists. So, we decrease the zorder a bit to\n # prevent this.\n\n return ax1, aux_ax","def _translations_along_axis(self, axis: int) -> PermutationGroup:\n if self.lattice._pbc[axis]:\n trans_list = [Identity()]\n # note that we need the preimages in the permutation\n trans_perm = self.lattice.id_from_position(\n self.lattice.positions - self.lattice.basis_vectors[axis]\n )\n vector = np.zeros(self.lattice.ndim, dtype=int)\n vector[axis] = 1\n trans_by_one = Translation(trans_perm, vector)\n\n for _ in range(1, self.lattice.extent[axis]):\n trans_list.append(trans_list[-1] @ trans_by_one)\n\n return PermutationGroup(trans_list, degree=self.lattice.n_nodes)\n else:\n return PermutationGroup([Identity()], degree=self.lattice.n_nodes)","def new_part(self, indices, master_axis_to_position, master_flip):\n shape = self.shape\n\n if indices == [slice(0, stop, 1) for stop in shape]:\n return\n\n # ------------------------------------------------------------\n # If a dimension runs in the wrong direction then change its\n # index to account for this.\n #\n # For example, if a dimension with the wrong direction has\n # size 10 and its index is slice(3,8,2) then after the\n # direction is set correctly, the index needs to changed to\n # slice(6,0,-2):\n #\n # >>> a = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n # >>> a[slice(3, 8, 2)]\n # [6, 4, 2]\n # >>> a.reverse()\n # >>> print(a)\n # >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n # >>> a[slice(6, 0, -2)]\n # [6, 4, 2]\n # ------------------------------------------------------------\n\n if self._subarray.size > 1:\n indices = indices[:]\n\n p_flip = self.flip\n\n for axis, i in master_axis_to_position.items():\n\n if (axis not in p_flip and axis not in master_flip) or (\n axis in p_flip and axis in master_flip\n ):\n # This axis runs in the correct direction\n continue\n\n # Still here? Then this axis runs in the wrong\n # direction.\n\n # Reset the direction\n p_flip = p_flip[:]\n if axis in self.flip:\n p_flip.remove(axis)\n else:\n p_flip.append(axis)\n\n # Modify the index to account for the changed\n # direction\n size = shape[i]\n\n if isinstance(indices[i], slice):\n start, stop, step = indices[i].indices(size)\n # Note that step is assumed to be always +ve here\n div, mod = divmod(stop - start - 1, step)\n start = size - 1 - start\n stop = start - div * step - 1\n if stop < 0:\n stop = None\n indices[i] = slice(start, stop, -step)\n else:\n size -= 1\n indices[i] = [size - j for j in indices[i]]\n # --- End: for\n\n self.flip = p_flip\n # --- End: if\n\n slice_None = slice(None)\n\n # Reorder the new indices\n indices = [\n (\n indices[master_axis_to_position[axis]]\n if axis in master_axis_to_position\n else slice_None\n )\n for axis in self.axes\n ]\n\n part = self.part\n\n if not part:\n self.part = indices\n return\n\n # Still here? update an existing part\n p_part = []\n for part_index, index, size in zip(\n part, indices, self._subarray.shape\n ):\n\n if index == slice_None:\n p_part.append(part_index)\n continue\n\n if isinstance(part_index, slice):\n if isinstance(index, slice):\n\n start, stop, step = part_index.indices(size)\n\n size1, mod = divmod(stop - start - 1, step)\n\n start1, stop1, step1 = index.indices(size1 + 1)\n\n size2, mod = divmod(stop1 - start1, step1)\n\n if mod != 0:\n size2 += 1\n\n start += start1 * step\n step *= step1\n stop = start + (size2 - 1) * step\n\n if step > 0:\n stop += 1\n else:\n stop -= 1\n if stop < 0:\n stop = None\n p_part.append(slice(start, stop, step))\n\n continue\n else:\n new_part = list(range(*part_index.indices(size)))\n new_part = [new_part[i] for i in index]\n else:\n if isinstance(index, slice):\n new_part = part_index[index]\n else:\n new_part = [part_index[i] for i in index]\n # --- End: if\n\n # Still here? Then the new element of p_part is a list of\n # integers, so let's see if we can convert it to a slice\n # before appending it.\n new_part0 = new_part[0]\n if len(new_part) == 1:\n # Convert a single element list to a slice object\n new_part = slice(new_part0, new_part0 + 1, 1)\n else:\n step = new_part[1] - new_part0\n if step:\n if step > 0:\n start, stop = new_part0, new_part[-1] + 1\n else:\n start, stop = new_part0, new_part[-1] - 1\n if new_part == list(range(start, stop, step)):\n if stop < 0:\n stop = None\n new_part = slice(start, stop, step)\n # --- End: if\n\n p_part.append(new_part)\n # --- End: for\n\n self.part = p_part","def _move_spectral_axis(wcs, flux, mask=None, uncertainty=None):\n naxis = getattr(wcs, 'naxis', len(wcs.world_axis_physical_types))\n if naxis > 1:\n temp_axes = []\n phys_axes = wcs.world_axis_physical_types\n for i in range(len(phys_axes)):\n if phys_axes[i] is None:\n continue\n if phys_axes[i][0:2] == \"em\" or phys_axes[i][0:5] == \"spect\":\n temp_axes.append(i)\n if len(temp_axes) != 1:\n raise ValueError(\"Input WCS must have exactly one axis with \"\n \"spectral units, found {}\".format(len(temp_axes)))\n\n # Due to FITS conventions, a WCS with spectral axis first corresponds\n # to a flux array with spectral axis last.\n if temp_axes[0] != 0:\n wcs = wcs.swapaxes(0, temp_axes[0])\n if flux is not None:\n flux = np.swapaxes(flux, len(flux.shape) - temp_axes[0] - 1, -1)\n if mask is not None:\n mask = np.swapaxes(mask, len(mask.shape) - temp_axes[0] - 1, -1)\n if uncertainty is not None:\n if isinstance(uncertainty, NDUncertainty):\n # Account for Astropy uncertainty types\n unc_len = len(uncertainty.array.shape)\n temp_unc = np.swapaxes(uncertainty.array,\n unc_len - temp_axes[0] - 1, -1)\n if uncertainty.unit is not None:\n temp_unc = temp_unc * u.Unit(uncertainty.unit)\n uncertainty = type(uncertainty)(temp_unc)\n else:\n uncertainty = np.swapaxes(uncertainty,\n len(uncertainty.shape) -\n temp_axes[0] - 1, -1)\n return wcs, flux, mask, uncertainty","def comp_axes(self, machine, N0=None):\n if self.time is None and N0 is None:\n raise InputError(\"ERROR: time and N0 can't be both None\")\n\n # Get machine pole pair number\n p = machine.get_pole_pair_number()\n\n # Get electrical fundamental frequency\n f_elec = self.comp_felec()\n\n # Airgap radius\n Rag = machine.comp_Rgap_mec()\n\n # Setup normalizations for time and angle axes\n norm_time = {\n \"elec_order\": f_elec,\n \"mech_order\": f_elec / p,\n }\n if N0 is not None:\n norm_time[\"angle_rotor\"] = 1 / (360 * N0 / 60)\n\n norm_angle = {\"space_order\": p, \"distance\": 1 / Rag}\n\n # Create time axis\n if self.time is None:\n # Create time axis as a DataLinspace\n Time = DataLinspace(\n name=\"time\",\n unit=\"s\",\n initial=0,\n final=60 / N0 * self.Nrev,\n number=self.Nt_tot,\n include_endpoint=False,\n normalizations=norm_time,\n )\n else:\n # Load time data\n time = self.time.get_data()\n self.Nt_tot = len(time)\n Time = Data1D(name=\"time\", unit=\"s\", values=time, normalizations=norm_time)\n\n # Create angle axis\n if self.angle is None:\n # Create angle axis as a DataLinspace\n Angle = DataLinspace(\n name=\"angle\",\n unit=\"rad\",\n initial=0,\n final=2 * pi,\n number=self.Na_tot,\n include_endpoint=False,\n normalizations=norm_angle,\n )\n else:\n # Load angle data\n angle = self.angle.get_data()\n self.Na_tot = len(angle)\n Angle = Data1D(\n name=\"angle\", unit=\"rad\", values=angle, normalizations=norm_angle\n )\n\n return Time, Angle","def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\n steps: int=10):\n \n # extract sensor infos and transform loc to fit with headmodel \n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\n \n\n ctr1 = np.nanmean(loc1, 0)\n ctr1[2] -= 0.2\n ctr2 = np.nanmean(loc2, 0)\n ctr2[2] -= 0.2\n\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\n Cmax1=np.nanmax(C1[:])\n Cmax2=np.nanmax(C2[:])\n Cmax=[]\n Cmax=[Cmax1, Cmax2]\n vmax=np.nanmax(Cmax)\n Cmin1=np.nanmin(C1[:])\n Cmin2=np.nanmin(C2[:])\n Cmin=[]\n Cmin=[Cmin1, Cmin2]\n vmin=np.min(Cmin)\n\n # Calculate automatic threshold\n if threshold == 'auto':\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\n else:\n threshold = threshold\n\n # Define colormap for both participant\n cmap_p = matplotlib.cm.get_cmap('Reds')\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\n\n for e1 in range(len(loc1)):\n x1 = loc1[e1, 0]\n y1 = loc1[e1, 1]\n z1 = loc1[e1, 2]\n for e2 in range(len(loc1)):\n x2 = loc1[e2, 0]\n y2 = loc1[e2, 1]\n z2 = loc1[e2, 2]\n if C1[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C1[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n [loc1[e1, 2], loc1[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)\n \n for e1 in range(len(loc2)):\n x1 = loc2[e1, 0]\n y1 = loc2[e1, 1]\n z1 = loc2[e1, 2]\n for e2 in range(len(loc2)):\n x2 = loc2[e2, 0]\n y2 = loc2[e2, 1]\n z2 = loc2[e2, 2]\n if C2[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_p, linewidth=weight)\n if C2[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n [loc2[e1, 2], loc2[e2, 2]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n zn = ((1-a)**3 * z1 +\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\n a**3 * z2)\n znn = ((1-b)**3 * z1 +\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\n b**3 * z2)\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\n '-', color=color_n, linewidth=weight)","def _update_non_learnable_var(old_var: NestedMap, new_var: NestedMap,\n var_params: ParamsT) -> NestedMap:\n if not base_layer.var_not_trainable(var_params):\n assert new_var is None\n return old_var\n elif not in_pmap:\n # No aggregation is needed.\n assert new_var is not None\n return new_var\n elif base_layer.var_requires_mean_sync(var_params):\n assert new_var is not None\n return _synchronize_vars_using_mean(new_var, old_var)\n else:\n raise ValueError('Non-trainable variables must have a cross-replica '\n 'synchronization method specified.')","def make_corrections_animation(XX,VV,tensorsx,myspacex,tensorsxv,myspacexv,gs=150):\n sr,sp,sz=bovy_coords.rect_to_cyl(XX[:,0], XX[:,1], XX[:,2])\n sp=sp+np.pi\n dist2=np.sqrt(XX[:,0]**2+XX[:,1]**2)\n rindx=(dist2>0.2)*(dist2<.5)*(np.fabs(XX[:,2])<0.2)\n for i in range(0,36):\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))\n if i==34:\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))+rindx*(sp>0.)*(sp<((1)*np.pi/18.))\n if i==35:\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))+rindx*(sp>0.)*(sp<((2)*np.pi/18.))\n print(wedgedex.sum(),'stars in wedge',i)\n\n fixx=myspacex.get_model_v(tensorsx,VV[wedgedex],XX[wedgedex])\n fixxv=myspacexv.get_model_v(tensorsxv,VV[wedgedex],XX[wedgedex])\n\n f, ((ax1,ax2),(ax3,ax4)) = plt.subplots(2, 2, figsize=(15,15))\n ax1.hist2d(XX[:,0][wedgedex],XX[:,1][wedgedex],range=[[-0.5,0.5],[-0.5,0.5]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\n ax1.set_xlabel(r'$X\\ (\\mathrm{kpc})$',fontsize=20)\n ax1.set_ylabel(r'$Y\\ (\\mathrm{kpc})$',fontsize=20)\n ax1.set_xlim(-0.5,0.5)\n ax1.set_ylim(-0.5,0.5)\n ax1.set_title(r'$\\mathrm{Selected\\ area}$',fontsize=20)\n ax2.hist2d(VV[:,0][wedgedex],VV[:,1][wedgedex],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\n ax2.set_xlabel(r'$v_X\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax2.set_ylabel(r'$v_Y\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax2.set_xlim(-125,125)\n ax2.set_ylim(-125,125)\n ax2.set_title(r'$\\mathrm{No\\ correction}$',fontsize=20)\n ax3.hist2d(fixx[:,0],fixx[:,1],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\n ax3.set_xlabel(r'$v_X\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax3.set_ylabel(r'$v_Y\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax3.set_xlim(-125,125)\n ax3.set_ylim(-125,125)\n ax3.set_title(r'$\\mathrm{x\\ correction}$',fontsize=20)\n ax4.hist2d(fixxv[:,0],fixxv[:,1],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\n ax4.set_xlabel(r'$v_X\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax4.set_ylabel(r'$v_Y\\ (\\mathrm{km\\ s}^{-1})$',fontsize=20)\n ax4.set_xlim(-125,125)\n ax4.set_ylim(-125,125)\n ax4.set_title(r'$\\mathrm{xv\\ correction}$',fontsize=20)\n ax1.tick_params(axis='both', which='major', labelsize=15)\n ax2.tick_params(axis='both', which='major', labelsize=15)\n ax3.tick_params(axis='both', which='major', labelsize=15)\n ax4.tick_params(axis='both', which='major', labelsize=15)\n plt.savefig('orders'+str(\"{:02d}\".format(i))+'.pdf',bbox_inches='tight')\n plt.close()\n\n os.system('convert -delay 5 -loop 0 orders*.pdf orders.gif')","def plot_output_3axes(axes, name, color):\n\tout = vice.output(name)\n\taxes[0].plot(out.history[\"time\"][1:], out.history[\"ifr\"][1:],\n\t\tc = visuals.colors()[color], linestyle = '--')\n\taxes[0].plot(out.history[\"time\"], out.history[\"sfr\"],\n\t\tc = visuals.colors()[color], linestyle = '-')\n\taxes[1].plot(out.history[\"[Fe/H]\"], out.history[\"[O/Fe]\"],\n\t\tc = visuals.colors()[color])\n\taxes[2].plot(list(map(lambda x, y: (x + y) / 2., out.mdf[\"bin_edge_left\"],\n\t\tout.mdf[\"bin_edge_right\"])), out.mdf[\"dn/d[O/Fe]\"],\n\t\tc = visuals.colors()[color])","def _apply_toffoli(self, state, axes, **kwargs):\n cntrl_max = np.argmax(axes[:2])\n cntrl_min = cntrl_max ^ 1\n ndim = self._ndim(state)\n sl_a0 = _get_slice(0, axes[cntrl_max], ndim)\n sl_a1 = _get_slice(1, axes[cntrl_max], ndim)\n sl_b0 = _get_slice(0, axes[cntrl_min], ndim - 1)\n sl_b1 = _get_slice(1, axes[cntrl_min], ndim - 1)\n\n # If both controls are smaller than the target, shift the target axis down by two. If one\n # control is greater and one control is smaller than the target, shift the target axis\n # down by one. If both controls are greater than the target, leave the target axis as-is.\n if axes[cntrl_min] > axes[2]:\n target_axes = [axes[2]]\n elif axes[cntrl_max] > axes[2]:\n target_axes = [axes[2] - 1]\n else:\n target_axes = [axes[2] - 2]\n\n # state[sl_a1][sl_b1] gives us all of the amplitudes with a |11> for the two control qubits.\n state_x = self._apply_x(state[sl_a1][sl_b1], axes=target_axes)\n state_stacked_a1 = self._stack([state[sl_a1][sl_b0], state_x], axis=axes[cntrl_min])\n return self._stack([state[sl_a0], state_stacked_a1], axis=axes[cntrl_max])","def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require getBounds() to work.\n # If it doesn't, we'll have to give it one.\n # Setting the _bounds_ attribute will do it.\n timeax = timeAxis(mv)\n if timeax.getBounds()==None:\n timeax._bounds_ = timeax.genGenericBounds()\n mvseas = seasons.climatology(mv)\n \n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\n axes_string = '('+')('.join(axis_names)+')'\n\n if len(axes_string)>2:\n for axis in mvseas.getAxisList():\n if axis.getBounds() is None:\n axis._bounds_ = axis.genGenericBounds()\n avmv = averager( mvseas, axis=axes_string )\n else:\n avmv = mvseas\n if avmv is None: return avmv\n avmv.id = vid\n if hasattr(mv,'units'): avmv.units = mv.units\n avmv = delete_singleton_axis( avmv, vid='time' )\n avmv.units = mv.units\n return avmv","def clean_axes(axl):\n cleanAxes(axl)","def populate_plot_axis(self,plot,ax='x'):\n\n fig=plt.gcf()\n\n extra_ax=[]\n\n if ax=='x':\n\n ticks=plot.get_xticks()\n\n lim=plot.get_xlim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['bottom'].set_position(('outward',10))\n\n axn.spines['bottom'].set_visible(True)\n\n else:\n\n dy_fig=0.08\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0,\\\n prev_ax_position.y0-2*dy_fig,\\\n prev_ax_position.width,\\\n 0),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.yaxis.set_visible(False)\n\n for side in axn.spines.keys():\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_xticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_xticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n xlab=axn.set_xlabel(self.names[i])\n\n xlab.set_fontsize(10)\n\n axn.tick_params(axis='x',labelsize=10)\n\n axn.set_xlim(lim)\n\n\n\n elif ax=='y':\n\n ticks=plot.get_yticks()\n\n lim=plot.get_ylim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['left'].set_position(('outward',10))\n\n axn.spines['left'].set_visible(True)\n\n else:\n\n dx_fig=0.08\n\n plot_position=plot.get_position()\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0-2*dx_fig,\\\n prev_ax_position.y0,\\\n 0,\\\n prev_ax_position.height),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.xaxis.set_visible(False) # hide the yaxis\n\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_yticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_yticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n ylab=axn.set_ylabel(self.names[i])\n\n ylab.set_fontsize(10)\n\n axn.tick_params(axis='y',labelsize=10)\n\n axn.set_ylim(lim)\n\n else:\n\n raise ValueError(\"Axis can be 'x' or 'y'\")","def plot_dual(los_tra, los_val, acc_tra, acc_val):\n fig, ax_acc = plt.subplots(figsize=(8, 6))\n\n cl_acc = 'tab:red'\n ax_acc.plot(acc_tra, '--', color=cl_acc)\n ax_acc.plot(acc_val, '-', color=cl_acc)\n ax_acc.set_xlabel('round')\n ax_acc.set_xlim([0, len(los_tra)])\n ax_acc.set_ylabel('Test Acc', color=cl_acc)\n ax_acc.set_ylim([0, 100])\n ax_acc.tick_params(axis='y', labelcolor=cl_acc)\n ax_acc.grid(True, ls='--')\n # ax_omg.set_title('$\\\\theta$ and $\\omega$ over time')\n\n ax_los = ax_acc.twinx()\n cl_los = 'tab:blue'\n ax_los.plot(los_tra, '--', color=cl_los)\n ax_los.plot(los_val, '-', color=cl_los)\n ax_los.set_ylabel('Test Loss', color=cl_los)\n ax_los.set_ylim([0, max(los_tra)])\n ax_los.tick_params(axis='y', labelcolor=cl_los)\n ax_los.grid(False)\n\n fig.tight_layout()\n # plt.show()\n return fig","def setAxisParts(lowx='all', lefty='all', upx='ticks', righty='ticks'):\n partdict = {'none':'NONE','lines':'LINE','ticks':'TICKS',\n 'labels':'LABELS', 'all':'NAME'} \n dislin.setgrf(partdict[lowx], partdict[lefty],\\\n partdict[upx], partdict[righty])","def change_axis_names(self, axis_map):\n axes = self.axes\n\n # Partition axes\n self.axes = [axis_map[axis] for axis in axes]\n\n # Flipped axes\n flip = self.flip\n if flip:\n self.flip = [axis_map[axis] for axis in flip]","def multiPlot(self,indexSelect=None,varSelect=None,wrapNumber=5,\n compLines=None, save = None, xlim = None,\n forceYAxisZero = True, colourOverride = None,\n style = None, legend = None, varAsAxis = False,\n xAxisLabel = None, yAxisLabel = None, figsize = (12,10),\n legendLoc = 'lower right'):\n if isinstance(compLines,list):\n compVars = [list(i.columns) for i in compLines]\n dfB = [i.copy() for i in compLines]\n for i in range(len(compLines)):\n if \"Time\" not in compVars[i]:\n dfB[i][\"Time\"]=dfB[i].index\n else:\n compVars[i].remove(\"Time\")\n dfB[i] = pd.melt(dfB[i], id_vars=[\"Time\"],\n value_vars=compVars[i])\n elif compLines is not None:\n compVars=list(compLines.columns)\n dfB = compLines.copy()\n if \"Time\" not in compVars:\n dfB[\"Time\"]=dfB.index\n else:\n compVars.remove(\"Time\")\n dfB = pd.melt(dfB,id_vars=[\"Time\"],\n value_vars=compVars)\n if varSelect is None:\n varSelect=list(self.longData['variable'].unique())\n if indexSelect is None:\n indexSelect=list(self.longData['index'].unique())\n if not isinstance(indexSelect,list):\n indexSelect = [indexSelect]\n if len(varSelect)<wrapNumber:\n #cols = math.floor(math.sqrt(len(varSelect)))\n cols = math.ceil(math.sqrt(len(varSelect)))\n else:\n cols = wrapNumber\n rows = math.ceil(len(varSelect)/cols)\n if style is None:\n myStyle = \"darkgrid\"\n else:\n myStyle = style\n with sns.axes_style(style):\n fig, axs = plt.subplots(rows, cols, sharex=True,\n figsize=figsize)\n if (rows>1):\n axs = trim_axs(axs, len(varSelect))\n elif (cols==1):\n axs = [axs]\n if colourOverride is not None:\n myColorMap = plt.get_cmap(name=\"cool\")\n else:\n myColorMap = plt.get_cmap(name=\"hsv\",\n lut=len(indexSelect)+1)\n for ax, theVar, j in zip(axs, varSelect, range(len(varSelect))):\n if varAsAxis:\n if isinstance(yAxisLabel,list):\n ax.set_ylabel(theVar+\" \"+yAxisLabel[j])\n elif yAxisLabel is not None:\n ax.set_ylabel(theVar+\" \"+yAxisLabel)\n else:\n ax.set_ylabel(theVar)\n else:\n ax.set_title(theVar)\n if isinstance(yAxisLabel,list):\n ax.set_ylabel(yAxisLabel[j])\n elif yAxisLabel is not None:\n ax.set_ylabel(yAxisLabel)\n if xAxisLabel is not None:\n ax.set_xlabel(xAxisLabel)\n df = self.longData\n df = df[df['variable']==theVar]\n if indexSelect is not None:\n for theIndex, i in zip(indexSelect,\n range(len(indexSelect))):\n df2 = df[df['index']==theIndex]\n if colourOverride is not None:\n ax.plot(df2[\"Time\"], df2[\"value\"],\n linestyle='solid',\n color=myColorMap(colourOverride[i]))\n else:\n ax.plot(df2[\"Time\"], df2[\"value\"],\n linestyle='solid',\n color=myColorMap(i))\n if isinstance(compLines,list):\n for i, theIndex in enumerate(indexSelect):\n dfB2 = dfB[theIndex][\n dfB[theIndex]['variable']==theVar]\n if colourOverride is not None:\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"o\",\n color=myColorMap(colourOverride[i]))\n else:\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"o\",\n color=myColorMap(i))\n elif compLines is not None:\n dfB2 = dfB[dfB['variable']==theVar]\n ax.plot(dfB2[\"Time\"], dfB2[\"value\"],\"ko\")\n if xlim is not None:\n ax.set_xlim(xlim)\n if forceYAxisZero:\n ax.set_ylim([0, None])\n if legend is not None:\n if colourOverride is not None:\n custom_lines = [Line2D([0], [0], color=myColorMap(\n colourOverride[i]), lw=4)\n for i in range(len(indexSelect))]\n else:\n custom_lines = [Line2D([0], [0], color=myColorMap(i),\n lw=4)\n for i in range(len(indexSelect))]\n if ((not isinstance(compLines,list)) and\n (compLines is not None)):\n custom_lines.append(Line2D([0], [0], \n color=\"k\", lw=4))\n fig.legend(custom_lines, legend,\n loc = legendLoc)\n fig.tight_layout()\n if save is not None:\n fig.savefig(save)","def sub_analysis(vdata, prefix=\"\"):\n new = vdata[(vdata.direction == \"away\") & (vdata.tether == \"new\")]\n # for new pole, towards mid-cell is +ve v_mid\n new_towards, new_away, new_static = _sub_analyse(new)\n new_set = pd.DataFrame({\n \"v_mid\": np.hstack([\n new_towards.v_mid.values,\n -new_away.v_mid.values,\n np.abs(new_static.v_mid.values),\n ]),\n \"direction\": ([\"towards\"] * len(new_towards) +\n [\"away\"] * len(new_away) +\n [\"static\"] * len(new_static)),\n })\n\n fig = plt.figure()\n _bigax(\n fig,\n xlabel=(\"Direction Relative to Midcell\", {\"labelpad\": 10}),\n spec=(2, 1, 1),\n )\n ax = fig.add_subplot(2, 2, 1)\n ax.set_title(\"New Pole\")\n sns.barplot(\n x=\"direction\",\n y=\"v_mid\",\n data=new_set,\n order=[\"towards\", \"away\", \"static\"],\n ci=95\n )\n ax.set_ylabel(\"Velocity (\\si{\\micro\\metre\\per\\hour})\")\n ax.set_xlabel(\"\")\n sns.despine()\n\n old = vdata[(vdata.direction == \"away\") & (vdata.tether == \"old\")]\n # for old pole, towards mid-cell is -ve v_mid\n old_away, old_towards, old_static = _sub_analyse(old)\n old_set = pd.DataFrame({\n \"v_mid\": np.hstack([\n old_away.v_mid.values,\n -old_towards.v_mid.values,\n np.abs(old_static.v_mid.values),\n ]),\n \"direction\": ([\"away\"] * len(old_away) +\n [\"towards\"] * len(old_towards) +\n [\"static\"] * len(old_static)),\n })\n\n ax = fig.add_subplot(2, 2, 2)\n ax.set_title(\"Old Pole\")\n sns.barplot(\n x=\"direction\",\n y=\"v_mid\",\n data=old_set,\n order=[\"towards\", \"away\", \"static\"],\n ci=95\n )\n ax.set_ylabel(\"Velocity (\\si{\\micro\\metre\\per\\hour})\")\n ax.set_xlabel(\"\")\n sns.despine()\n\n# _bigax(\n# fig,\n# xlabel=(\"Velocity (\\si{\\micro\\metre\\per\\hour})\", {\"labelpad\": 10}),\n# title=(\"Mid-cell\", {\"y\": 1.08}),\n# spec=(2, 1, 2),\n# )\n ax = fig.add_subplot(2, 2, 3)\n# sns.distplot(new.v_mid, kde=False)\n# ax.set_title(\"New Pole\", y=1.08)\n# ax.set_xlabel(\"\")\n# ax.yaxis.set_visible(False)\n# ax.spines[\"left\"].set_color(\"none\")\n sns.countplot(\n x=\"direction\",\n data=new_set,\n order=[\"towards\", \"away\", \"static\"],\n )\n ax.set_xlabel(\"\")\n ax.set_ylabel(\"Number of Foci\")\n sns.despine()\n\n ax = fig.add_subplot(2, 2, 4)\n# sns.distplot(old.v_mid, kde=False)\n# ax.set_title(\"Old Pole\", y=1.08)\n# ax.set_xlabel(\"\")\n# ax.yaxis.set_visible(False)\n# ax.spines[\"left\"].set_color(\"none\")\n sns.countplot(\n x=\"direction\",\n data=old_set,\n order=[\"towards\", \"away\", \"static\"],\n )\n ax.set_xlabel(\"\")\n ax.set_ylabel(\"Number of Foci\")\n sns.despine()\n\n plt.tight_layout()\n\n fn = os.path.join(\n \"ParB_velocity\",\n \"{2}-away-T{0}-N{1}.pdf\".format(THRESHOLD, MIN_POINTS, prefix)\n )\n print(\"Saved file to {0}\".format(fn))\n plt.savefig(fn)\n plt.close()","def adjust_mario_position(self):\n self.last_x_position = self.mario.rect.right\n self.mario.rect.x += round(self.mario.x_vel)\n self.check_mario_x_collisions()\n\n if self.mario.in_transition_state == False:\n self.mario.rect.y += round(self.mario.y_vel)\n self.check_mario_y_collisions()","def front_wheel_from_axis():","def _color_twin_axes(ax1, color1, ax2, color2):\n #spines\n ax1.spines['left'].set_color(color1)\n ax1.spines['right'].set_color(color2)\n ax2.spines['left'].set_color(color1)\n ax2.spines['right'].set_color(color2)\n #text\n ax1.yaxis.label.set_color(color1)\n ax2.yaxis.label.set_color(color2)\n #ticks\n ax1.tick_params(axis = 'y', colors = color1)\n ax2.tick_params(axis = 'y', colors = color2)","def test_axis_with_no_mapping_does_not_error_in_roundtrip_with_2_axes(ufo_module):\n doc = _make_designspace_with_axes(\n [(\"wght\", \"Weight with mapping\"), (\"wdth\", \"Width without mapping\")], ufo_module\n )\n # Add mapping to weight axis\n doc.axes[0].map = [(0, 0), (50, 350), (100, 1000)]\n\n doc2 = deepcopy(doc)\n font = to_glyphs(doc2)\n doc_rt = to_designspace(font)\n\n assert doc_rt.axes[0].serialize() == doc.axes[0].serialize()\n assert doc_rt.axes[1].serialize() == doc.axes[1].serialize()","def rotateAlignToWorld( alignObject, primaryAxisVector = [1, 0, 0], worldAxisToKeep = ['x'], alignTwist = True ):\n \n # normalize primary axis vector\n primaryAxisVectorVec = vector.makeMVector( primaryAxisVector )\n primaryAxisVectorVec.normalize()\n primaryAxisVector = [ primaryAxisVectorVec.x, primaryAxisVectorVec.y, primaryAxisVectorVec.z ]\n \n \n axisSign = primaryAxisVector[0] + primaryAxisVector[1] + primaryAxisVector[2]\n \n primaryAxisVectorVecMove = primaryAxisVector[:]\n primaryAxisVector = [ abs( primaryAxisVector[0] ), abs( primaryAxisVector[1] ), abs( primaryAxisVector[2] ) ]\n \n # prepare align twist vector\n allaxis = ['x', 'y', 'z']\n \n for axiskeep in worldAxisToKeep:\n \n allaxis.remove( axiskeep.lower() )\n \n skipUpAxis = allaxis[0]\n upVectorMove = {'x':[1, 0, 0], 'y':[0, 1, 0], 'z':[0, 0, 1]}[skipUpAxis]\n upVector = {'x':[1 * axisSign, 0, 0], 'y':[0, 1 * axisSign, 0], 'z':[0, 0, 1 * axisSign]}[skipUpAxis]\n \n # prepare align setup\n prefix = name.removeSuffix( alignObject )\n \n alignObjectAim = mc.group( n = prefix + 'alignObjectAim', em = 1, p = alignObject )\n alignObjectAimUp = mc.group( n = prefix + 'alignObjectAimUp', em = 1, p = alignObject )\n mc.move( primaryAxisVectorVecMove[0], primaryAxisVectorVecMove[1], primaryAxisVectorVecMove[2], alignObjectAim, objectSpace = True )\n mc.move( upVectorMove[0], upVectorMove[1], upVectorMove[2], alignObjectAimUp, objectSpace = True )\n mc.parent( [alignObjectAim, alignObjectAimUp], w = 1 )\n mc.delete( mc.pointConstraint( alignObject, alignObjectAim, skip = worldAxisToKeep ) )\n \n if alignTwist:\n \n mc.delete( mc.pointConstraint( alignObject, alignObjectAimUp, skip = skipUpAxis ) )\n \n # rotate object\n mc.delete( mc.aimConstraint( alignObjectAim, alignObject, aim = primaryAxisVector, u = upVector, wut = 'object', wuo = alignObjectAimUp ) )\n mc.delete( alignObjectAim, alignObjectAimUp )","def test_reset_temporal_axis(PM_ds_control_3d_full):\r\n smooth = 10\r\n tsmooth_kws = {\"time\": smooth}\r\n first_ori = PM_ds_control_3d_full.time[0].values\r\n first_actual = _reset_temporal_axis(\r\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\"time\"\r\n ).time.values[0]\r\n first_expected = f\"{first_ori}-{first_ori+smooth*1-1}\"\r\n assert first_actual == first_expected","def _replace_dim(da, olddim, newdim, drop=True):\n\n da_new = da.rename({olddim: newdim.name})\n # note that alignment along a dimension is skipped when you are overriding\n # the relevant coordinate values\n da_new .coords[newdim.name] = newdim\n da_new = da_new.reset_coords(drop=drop)\n return da_new","def test_alternate_channel_axes(conv1d_placeholder, output_size, channel_axis):\n channel_axis.name = \"channel\"\n assert len(conv1d_placeholder.axes.find_by_name(\"channel\")) == 1\n\n conv_layer = Convolution((3, output_size), lambda x: 1)\n with pytest.raises(IncompatibleAxesError):\n conv_layer(conv1d_placeholder)\n output = conv_layer(conv1d_placeholder, channel_axes=\"channel\")\n assert output.axes == conv1d_placeholder.axes","def plot_2d_topomap_intra(ax):\n\n # plot first Head \n N = 300 # number of points for interpolation\n xy_center = [-0.178,0] # center of the plot\n radius = 0.1 # radius\n\n # draw a circle\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n # add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon) \n \n\n # Plot second Head \n x2y2_center = [0.178,0] # center of the plot\n radius2 = 0.1 # radius\n \n # draw a circle\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \"k\", facecolor = \"w\")\n ax.add_patch(circle)\n \n # make the axis invisible \n for loc, spine in ax.spines.items():\n spine.set_linewidth(0)\n \n # remove the ticks\n ax.set_xticks([])\n ax.set_yticks([])\n \n ## add some body parts. Hide unwanted parts by setting the zorder low\n # add two ears\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(circle)\n ## add a nose\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \"k\", facecolor = \"w\", zorder = 0)\n ax.add_patch(polygon)","def test_overplotting(self):\n arr = self.arr\n out = ternary(arr)\n self.assertTrue(hasattr(out, \"tax\"))\n out2 = ternary(arr, ax=out)\n self.assertTrue(out.tax is out2.tax) # hasn't added a new ternary axis","def set_axes(self, a):\r\n self.axes = a","def explode_along_axis(self, axis):\n # If axis is -ve then calculate the axis from the length of the dimensions of one cube\n if axis < 0:\n axis = len(self.dimensions) + axis\n # To store the resultant cube\n result_cubes = []\n # All slices are initially initialised as slice(None, None, None)\n cube_slices = [slice(None, None, None)] * self.data.ndim\n # Slicing the cube inside result_cube\n for i in range(self.data.shape[axis]):\n # Setting the slice value to the index so that the slices are done correctly.\n cube_slices[axis] = i\n # Set to None the metadata of sliced cubes.\n item = tuple(cube_slices)\n sliced_cube = self[item]\n sliced_cube.meta = None\n # Appending the sliced cubes in the result_cube list\n result_cubes.append(sliced_cube)\n # Creating a new NDCubeSequence with the result_cubes and common axis as axis\n return NDCubeSequence(result_cubes, meta=self.meta)","def _filter_axes(self, channel_axis, spatial_axes):\n f_axes = ng.make_axis(length=self.nout, name=\"K\")\n for key, ax in zip(\"DHW\", spatial_axes):\n f_axes += ng.make_axis(length=self.filter_shape[key],\n name=ax.name)\n f_axes += channel_axis\n return f_axes","def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\n common_axis_lengths):\n cumul_lengths = np.cumsum(common_axis_lengths)\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\n if sequence_index == 0:\n common_axis_index = cube_like_index\n else:\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\n return sequence_index, common_axis_index","def align_yaxis(ax1,v1,ax2,v2):\n _, y1 = ax1.transData.transform((0,v1))\n _, y2 = ax2.transData.transform((0,v2))\n inv = ax2.transData.inverted()\n _, dy = inv.transform((0,0)) - inv.transform((0,y1-y2))\n miny, maxy = ax2.get_ylim()\n ax2.set_ylim(miny+dy,maxy+dy)","def SwapAxis(self, axis0, axis1):\n\n axis0 = int(axis0)\n axis1 = int(axis1)\n\n self.points[:,[axis0,axis1]] = self.points[:,[axis1,axis0]]","def _share_short_axis(self, share, side, level):\n if share is None or self._panel_side: # not None\n return\n s = side[0]\n axis = 'x' if s in 'lr' else 'y'\n caxs = getattr(self, '_' + s + 'panels')\n paxs = getattr(share, '_' + s + 'panels')\n caxs = [pax for pax in caxs if not pax._panel_filled]\n paxs = [pax for pax in paxs if not pax._panel_filled]\n for cax, pax in zip(caxs, paxs): # may be uneven\n getattr(cax, '_share' + axis + '_setup')(pax, level)","def change_axes_geometry_stack(fig, ax, naxes):\n for ii in range(len(ax)):\n geometry = (naxes, 1, ii + 1)\n if ax[ii].get_geometry() != geometry:\n ax[ii].change_geometry(*geometry)\n\n for ii in np.arange(len(ax), naxes):\n print('adding axis ', ii)\n fig.add_subplot(naxes, 1, ii + 1)\n\n ax = fig.axes\n return fig, ax","def onAxisLogScaleChanged(self, axis_name, on):\n if axis_name in self.axes:\n # take the old axis and replace it with the new one\n old_axis = self.axes[axis_name]\n if on:\n new_axis = QtChart.QLogValueAxis()\n else:\n new_axis = QtChart.QValueAxis()\n\n # copy the values from old_axis into new_axis\n new_axis.setRange(old_axis.min(), old_axis.max())\n new_axis.setVisible(old_axis.isVisible())\n new_axis.setGridLineVisible(old_axis.isGridLineVisible())\n new_axis.setTitleText(old_axis.titleText())\n self.axes[axis_name] = new_axis\n\n # swap the old axis for the new one in chart and all series\n # attached to old_axis\n self.chart().addAxis(self.axes[axis_name],\n self.axis_alignment[axis_name])\n for unused_name, series in self.series.items():\n if old_axis in series.attachedAxes():\n series.detachAxis(old_axis)\n series.attachAxis(new_axis)\n self.chart().removeAxis(old_axis)","def reconfig_to_datetime(all_files, datetime_axis, time_freq, nrows=1):\n\n new_ydata = {}\n max_primary = max_secondary = float(\"-inf\")\n min_primary = min_secondary = float(\"inf\")\n for key, value in all_files.iteritems():\n \n\tassert isinstance(value, nio.InputData)\n\t\n\t# Convert original xaxis to datetime objects #\n\t\n\torig_dtaxis = value.datetimes\n\t\n\t# Check the start point of original xaxis against the new datetime_axis #\n\t\n\tmissval = value.data.missing_value\n\tydata = value.data[:]\n\t\n if orig_dtaxis[0] in datetime_axis[:]:\n\t nfill = rrule(eval(time_freq), dtstart=datetime_axis[0], until=orig_dtaxis[0]).count() - 1\n\t for i in xrange(nfill):\n\t ydata = numpy.insert(ydata, 0, missval)\n\telse:\n\t ystart = orig_dtaxis[:].index(datetime_axis[0])\n\t ydata = ydata[ystart:]\n\t orig_dtaxis = orig_dtaxis[ystart:]\n\t\t \n # Check the end point of original xaxis against the new datetime_axis #\n\t\n if orig_dtaxis[-1] in datetime_axis[:]:\n nfill = rrule(eval(time_freq), dtstart=orig_dtaxis[-1], until=datetime_axis[-1]).count() - 1\n\t for i in xrange(nfill):\n\t ydata = numpy.append(ydata, missval)\n else:\n\t yend = orig_dtaxis[:].index(datetime_axis[-1]) + 1\n ydata = ydata[:yend]\n\n # Update the minimum and maximum value #\n\n ydata = numpy.ma.masked_values(ydata, missval)\n\n if value.set == 'primary':\n max_primary, min_primary = nio.hi_lo(ydata, max_primary, min_primary)\n elif value.set == 'secondary':\n max_secondary, min_secondary = nio.hi_lo(ydata, max_secondary, min_secondary)\n\n new_ydata[key] = YaxisElement(split_nrows(ydata, nrows), \n all_files[key].tag, \n all_files[key].set)\n \n primary_bounds = (min_primary, max_primary)\n secondary_bounds = None if max_secondary == float(\"inf\") else (min_secondary, max_secondary)\n\n\n return new_ydata, primary_bounds, secondary_bounds","def set_primeScaleAxis(control = None, primeAxis = None, slaveOthers = False, alias = None): \n _str_func = 'set_primeAxis'\n _l = ['X','Y','Z']\n _primeAxis = cgmValid.kw_fromList(primeAxis, _l)\n _idx = _l.index(_primeAxis)\n _attr_prime = 'scale{0}'.format(_primeAxis)\n \n _l_others = []\n for i,v in enumerate(_l):\n if i != _idx:\n _l_others.append(v)\n \n log.debug(\"{0} || control:{1}\".format(_str_func,control)) \n log.debug(\"{0} || primeAxis:{1}\".format(_str_func,_primeAxis))\n log.debug(\"{0} || slaveOthers:{1}\".format(_str_func,slaveOthers))\n log.debug(\"{0} || alias:{1}\".format(_str_func,alias))\n log.debug(\"{0} || prime attr:{1}\".format(_str_func,_attr_prime))\n log.debug(\"{0} || other attrs:{1}\".format(_str_func,_l_others))\n \n if alias:\n coreAttr.alias_set(\"{0}.{1}\".format(control,_attr_prime),alias)\n \n for attr in _l_others:\n if slaveOthers:\n try:attributes.doConnectAttr(\"{0}.{1}\".format(control,_attr_prime),\n \"{0}.scale{1}\".format(control,attr.capitalize()),\n transferConnection=True)\n except:pass\n attributes.doSetLockHideKeyableAttr(control, lock = True, visible= False, keyable=False, channels=['s{0}'.format(attr.lower())])\n \n return True","def moveaxis(a, source, destination):\n a = astensor(a)\n\n source = normalize_axis_tuple(source, a.ndim, \"source\")\n destination = normalize_axis_tuple(destination, a.ndim, \"destination\")\n if len(source) != len(destination):\n raise ValueError(\n \"`source` and `destination` arguments must have \"\n \"the same number of elements\"\n )\n\n order = [n for n in range(a.ndim) if n not in source]\n\n for dest, src in sorted(zip(destination, source)):\n order.insert(dest, src)\n\n return transpose(a, order)","def _swap_axis(input_tensor, dim_index, last_index, name=None):\n return array_ops.transpose(\n input_tensor,\n array_ops.concat([\n math_ops.range(dim_index), [last_index],\n math_ops.range(dim_index + 1, last_index), [dim_index]\n ], 0),\n name=name)","def _update_axislabels(self, x='x', **kwargs):\n if x not in 'xy':\n return\n # Update label on this axes\n axis = getattr(self, x + 'axis')\n axis.label.update(kwargs)\n kwargs.pop('color', None)\n\n # Defer to parent (main) axes if possible, then get the axes\n # shared by that parent\n ax = self._panel_parent or self\n ax = getattr(ax, '_share' + x) or ax\n\n # Apply to spanning axes and their panels\n axs = [ax]\n if getattr(ax.figure, '_span' + x):\n s = axis.get_label_position()[0]\n if s in 'lb':\n axs = ax._get_side_axes(s)\n for ax in axs:\n getattr(ax, x + 'axis').label.update(kwargs) # apply to main axes\n pax = getattr(ax, '_share' + x)\n if pax is not None: # apply to panel?\n getattr(pax, x + 'axis').label.update(kwargs)","def fix_axes_ticks(self, axis='x', style=None, dtype=float, N=None, \n rotate_x=False, rotate_y=False):\n \n # Grab functions we need by name\n get_lim = \"get_{!s}lim\".format(axis)\n get_ticks = \"get_{!s}ticks\".format(axis)\n get_ticklabels = \"get_{!s}ticklabels\".format(axis)\n set_ticks = \"set_{!s}ticks\".format(axis)\n set_ticklabels = \"set_{!s}ticklabels\".format(axis)\n shared = eval(\"self.share_{!s}\".format(axis))\n \n # Get locations of ticks on bottom row\n if axis is 'x':\n ticks_by_col = []\n for i in self.bottom:\n ticks_by_col.append(self.grid[i].get_xticks())\n \n # Get locations of ticks on left column\n if axis is 'y':\n ticks_by_row = []\n for i in self.left:\n ticks_by_row.append(self.grid[i].get_xticks())\n \n # Figure out if axes are shared or not\n if axis == 'x':\n j = 0\n if shared:\n axes = self.xaxes\n else:\n axes = np.arange(self.N)\n elif axis == 'y':\n j = 1\n if shared:\n axes = self.yaxes\n else:\n axes = np.arange(self.N)\n else:\n raise ValueError('axis must be set to \\'x\\' or \\'y\\'')\n \n if not shared:\n return\n \n # Loop over axes and make corrections\n for i in axes:\n \n # Skip non-existent elements\n if self.diagonal:\n if self.above_diagonal(i):\n continue\n \n if self.grid[i] is None:\n continue\n\n # Retrieve current ticks, tick-spacings, and axis limits\n ticks = eval(\"list(self.grid[{0}].{1!s}())\".format(i, get_ticks))\n\n if not ticks:\n continue\n \n # Get all the info for current set of ticks\n ticklabels = eval((\"[tick for tick in \" +\\\n \"self.grid[{0}].{1!s}()]\").format(i, get_ticklabels))\n \n labels = [] \n for tick in ticklabels: \n l = tick.get_text()\n \n # Minus signs are weird in unicode...\n try:\n assert isinstance(l, unicode)\n except:\n new = l\n else:\n if u'\\u2212' in l:\n new = '-' + l.encode('ascii', 'ignore')\n else:\n new = l.encode('ascii', 'ignore') \n \n labels.append(new)\n \n Nticks = len(labels) \n dt = np.diff(ticks)[0] \n \n # Axes limits\n limits = eval(\"self.grid[{0}].{1!s}()\".format(i, get_lim))\n \n # column or row number. Need this to know whether or not to...?\n pos = self.axis_position(i)[j]\n\n # Determine if we're chopping off the first and/or last tick mark\n # e.g., if the axes are adjoined\n ul = None\n if shared and pos < (self.dims[int(not j)] - 1):\n ul = -1\n \n ll = 0 \n \n # If number of ticks was specified by hand \n if N is not None:\n mi, ma = round(limits[0], 1), round(limits[1], 1)\n \n prec = 2\n while mi == ma:\n mi, ma = round(limits[0], prec), round(limits[1], prec)\n prec += 1\n\n dt = (ma - mi) / float(N)\n\n if dt < 1:\n dt = np.round(dt, abs(int(np.log10(dt))) + 1)\n ticks = np.arange(mi, mi + (N+1)*dt, dt)\n else:\n ticks = np.round(np.linspace(mi, ma, N), 1)\n \n labels = ['{0:g}'.format(val) for val in ticks]\n \n if (axis == 'x' and rotate_x):\n rotate = rotate_x\n elif (axis == 'y' and rotate_y):\n rotate = rotate_y\n else:\n rotate = False\n \n if ul is None:\n eval(\"self.grid[{0}].{1!s}(ticks)\".format(i, set_ticks))\n \n if rotate:\n if type(rotate) == bool:\n eval((\"self.grid[{0}].{1!s}(labels, \" +\\\n \"rotation=90)\").format(i, set_ticklabels))\n else:\n eval((\"self.grid[{0}].{1!s}(labels, \" +\\\n \"rotation={2:g})\").format(i, set_ticklabels,\\\n rotate)) \n else:\n eval(\"self.grid[{0}].{1!s}(labels)\".format(i,\\\n set_ticklabels))\n else:\n eval(\"self.grid[{0}].{1!s}(ticks[{2}:{3}])\".format(i,\\\n set_ticks, ll, ul))\n\n if rotate:\n if type(rotate) == bool:\n eval((\"self.grid[{0}].{1!s}(labels[{2}:{3}], \" +\\\n \"rotation=90)\").format(i, set_ticklabels, ll, ul))\n else:\n eval((\"self.grid[{0}].{1!s}(labels[{2}:{3}], \" +\\\n \"rotation={4:g})\").format(i, set_ticklabels, ll,\\\n ul, rotate)) \n else:\n eval(\"self.grid[{0}].{1!s}(labels[{2}:{3}])\".format(i,\\\n set_ticklabels, ll, ul))\n \n if style is not None: \n self.grid[i].ticklabel_format(style=style)\n \n # Loop over columns, force those not in row 0 to share ticks with \n # whatever tick marks there are in row #0\n if axis == 'x':\n for k in range(len(self.elements_by_column)):\n loc = self.axis_number(0, k)\n xticks = self.grid[loc].get_xticks()\n xticks = [round(tick, 3) for tick in xticks]\n xlim = [round(lim, 3) for lim in self.grid[loc].get_xlim()]\n \n xticks = [0 if abs(tick) < 1e-8 * max(np.abs(xticks)) else tick \\\n for tick in xticks]\n \n for h, element in enumerate(self.elements_by_column[k]):\n if element in self.bottom:\n continue \n \n self.grid[element].set_xticks(xticks)\n self.grid[element].set_xlim(xlim)\n \n # Same deal for y ticks\n if axis == 'y':\n for k in range(len(self.elements_by_row)):\n loc = self.axis_number(k, 0)\n yticks = self.grid[loc].get_yticks()\n yticks = [round(tick, 3) for tick in yticks]\n ylim = [round(lim, 3) for lim in self.grid[loc].get_ylim()]\n \n yticks = [0 if abs(tick) < 1e-8 * max(np.abs(yticks)) else tick \\\n for tick in yticks]\n \n for h, element in enumerate(self.elements_by_row[k]):\n if element in self.left:\n continue \n if self.diag is not None:\n if element in self.diag:\n continue \n \n self.grid[element].set_yticks(yticks)\n self.grid[element].set_ylim(ylim)\n \n # Remove ticklabels of interior panels completely\n if shared:\n for k in range(self.N):\n if self.grid[k] is None:\n continue\n \n if (self.diagonal is not None):\n if self.above_diagonal(k):\n continue\n \n if k not in axes:\n eval(\"self.grid[{0}].{1!s}([])\".format(k, set_ticklabels))\n \n pl.draw()","def test_axis_preservation(conv1d_placeholder, output_size):\n conv_layer = Convolution((3, output_size), lambda x: 1)\n output = conv_layer(conv1d_placeholder)\n assert output.axes == conv1d_placeholder.axes, (\"Output axes are not the same as input axes: \"\n \"{} != {}\").format(output.axes,\n conv1d_placeholder.axes)","def set_axes_equal(ax):\n\n x_limits = ax.get_xlim3d()\n y_limits = ax.get_ylim3d()\n z_limits = ax.get_zlim3d()\n\n x_range = abs(x_limits[1] - x_limits[0])\n x_middle = np.mean(x_limits)\n y_range = abs(y_limits[1] - y_limits[0])\n y_middle = np.mean(y_limits)\n z_range = abs(z_limits[1] - z_limits[0])\n z_middle = np.mean(z_limits)\n\n # The plot bounding box is a sphere in the sense of the infinity\n # norm, hence I call half the max range the plot radius.\n plot_radius = 0.5*max([x_range, y_range, z_range])\n\n ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\n ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\n ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])","def set_axes_equal(ax):\n\n x_limits = ax.get_xlim3d()\n y_limits = ax.get_ylim3d()\n z_limits = ax.get_zlim3d()\n\n x_range = abs(x_limits[1] - x_limits[0])\n x_middle = np.mean(x_limits)\n y_range = abs(y_limits[1] - y_limits[0])\n y_middle = np.mean(y_limits)\n z_range = abs(z_limits[1] - z_limits[0])\n z_middle = np.mean(z_limits)\n\n # The plot bounding box is a sphere in the sense of the infinity\n # norm, hence I call half the max range the plot radius.\n plot_radius = 0.5*max([x_range, y_range, z_range])\n\n ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\n ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\n ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])","def replot(self,ax):\n self.XP_Plotter.replot(ax)\n # theoretical lines\n self.lines_theory[0].set_xdata(self.xx)\n self.lines_theory[1].set_xdata(self.xx)\n self.lines_theory[2].set_xdata(self.xx_itpl)\n for line in self.lines_theory: \n ax.draw_artist(line)","def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\n\n tr =PolarAxes.PolarTransform()\n pi = np.pi\n\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\n\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\n tick_formatter1 = DictFormatter(dict(angle_ticks))\n\n grid_locator2 = MaxNLocator(4)\n\n grid_helper = floating_axes.GridHelperCurveLinear(\n tr, extremes=(tmax, tmin, zmax, zmin),\n grid_locator1=grid_locator1,\n grid_locator2=grid_locator2,\n tick_formatter1=tick_formatter1,\n tick_formatter2=None)\n\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\n fig.add_subplot(ax1)\n\n # create a parasite axes whose transData in RA, cz\n aux_ax = ax1.get_aux_axes(tr)\n\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\n # drawn twice, and possibly over some other\n # artists. So, we decrease the zorder a bit to\n # prevent this.\n\n return ax1, aux_ax","def getAxisValuesEvent(self): \n varID = self.myParent.getVar().id\n axisVar = MV2.array(self.axis)\n axisVar.setAxis(0, self.axis)\n axisVar.id = varID +'_' + self.axis.id + '_axis'\n\n # Generate teaching command string\n fileID = 'fid2'\n teachingCommand = \"\\n## Getting axis %s\\n\" % self.axis.id\n teachingCommand += \"%s = MV2.array(%s[\\\"%s\\\"].getAxisList(axes = \\\"%s\\\")[0][:])\\n\" % (axisVar.id, fileID, varID, self.axis.id)\n teachingCommand += \"%s.setAxis(0, %s[\\\"%s\\\"].getAxisList(axes = \\\"%s\\\")[0])\\n\" % (axisVar.id, fileID, varID, self.axis.id)\n teachingCommand += \"%s.id = \\\"%s\\\"\\n\" % (axisVar.id, axisVar.id)\n\n # Record teaching commands associate 'get axis values' and\n # define a new variable/tab with only the axis' values \n self.myParent.defineVarAxis(axisVar, teachingCommand)","def _handle_setup_axis(self, axis_args):\n axis_name = axis_args['name']\n axes_dict = self.server.axes\n\n if axis_name not in [name for name, _ in axes_dict.items()]:\n print \"Adding a new axis:\", axis_name\n axis_count = len(axes_dict)\n newaxis = self.server.figure.add_subplot(axis_count+1, 1, axis_count+1)\n axes_dict[axis_name] = newaxis\n axes_dict[axis_name].grid(True)\n axes_dict[axis_name].set_xlabel(axis_args['x_label'])\n axes_dict[axis_name].set_ylabel(axis_args['y_label'])\n # TODO: support *.set_title(\"Title\")\n if FLAGS.logy:\n axes_dict[axis_name].set_yscale('log', nonposy='clip')\n\n if axis_count != 0:\n # Resize other axes if the above wasn't the first.\n axis_count = len(axes_dict)\n for row,(name, _) in enumerate(axes_dict.items(), 1):\n print name, axis_count, row\n axes_dict[name].change_geometry(axis_count, 1, row)"],"string":"[\n \"def replace_axis(self, dim:NamedIndex,\\n mapping_or_old:'Union[Mapping[NamedIndex, NamedIndex], NamedIndex]',\\n new:'Optional[NamedIndex]'=None):\\n\\n axes = self[dim] # disable idx_dim access\\n # axes = self.get(dim) or self._dim_axes[dim] # dim:'Union[int, NamedIndex]'\\n is_tuple_axes = is_namedtuple(axes)\\n assert isinstance(axes, dict) or is_tuple_axes, (\\n f'unnamed dim({dim!r}) cannot be renamed')\\n\\n axes_keys = axes._fields if is_tuple_axes else axes.keys()\\n axes_iter = iter(zip(axes._fields, axes)) if is_tuple_axes else axes.items()\\n axes_ = OrderedDict()\\n\\n if new is None:\\n assert isinstance(mapping_or_old, dict), (\\n f\\\"'mapping_or_old'({type(mapping_or_old)}) is expected to be a dict \\\"\\n \\\"when 'new' is None\\\")\\n\\n mapping = mapping_or_old\\n for axis, index in axes_iter:\\n axis = mapping.get(axis, axis)\\n assert axis not in axes_, f'axis {axis!r} in mapping is conflicted'\\n\\n axes_[axis] = index\\n else:\\n assert new not in axes_keys, f'new axis({new!r}) is confilicted'\\n\\n old = mapping_or_old\\n for axis, index in axes_iter:\\n axes_[new if axis == old else axis] = index\\n\\n axes_ = namedtuple(dim, axes_.keys())(**axes_) if is_tuple_axes else type(axes)(axes_)\\n ret = OrderedDict()\\n for dim_, axes in self.items():\\n ret[dim_] = axes_ if dim_ == dim else axes\\n\\n return type(self)(ret)\",\n \"def common_axis( axis1, axis2 ):\\n if hasattr( axis1, 'units' ):\\n units1 = axis1.units.lower().replace(' ','_')\\n if axis1.isTime():\\n axis1.toRelativeTime( units1 ) #probably will change input argument\\n else:\\n units1 = None\\n if hasattr( axis2, 'units' ):\\n units2 = axis2.units.lower().replace(' ','_')\\n else:\\n units2 = None\\n if units1!=None and units2!=None and units1 != units2:\\n if axis1.isTime() and axis2.isTime():\\n axis2.toRelativeTime( units1, axis1.getCalendar() ) #probably will change input argument\\n else:\\n print \\\"ERROR. common_axis does not yet support differing units\\\",axis1.units,\\\" and \\\",axis2.units\\n return None\\n if axis1.isTime() or axis2.isTime():\\n if not axis2.isTime() or not axis1.isTime():\\n print \\\"ERROR. In common_axis, one axis is time, not the other\\\"\\n return None\\n if not axis1.calendar==axis2.calendar:\\n print \\\"ERROR. common_axis does not yet support differing calendars.\\\"\\n if len(axis1)==1 and len(axis2)==1:\\n # There's just one time value, probably from averaging over time. The time value is meaningless\\n # but it would be messy to have two.\\n return (axis1,[0],[0])\\n\\n # to do: similar checks using isLatitude and isLongitude and isLevel <<<<<<\\n # Also, transfer long_name, standard_name, axis attributes if in agreement;\\n # units and calendar attributes should always be transferred if present.\\n # Also to do: use bounds if available\\n a12 = numpy.concatenate( [ axis1.getData(), axis2.getData() ] )\\n a3, a12indexina3 = numpy.unique( a12, return_inverse=True )\\n #... a3 has only unique indices and is sorted (unfortunately, uniqueness is based on exact identity,\\n # not to some numerical tolerance). For an i index into a12 (thus 0<=i<len(axis1)+len(axis2),\\n # j is an index into a3 such that, if a12indexina3[i]==j, then a1[i]==a3[j].\\n a1indexina3 = a12indexina3[0:len(axis1)]\\n a2indexina3 = a12indexina3[len(axis1):len(axis1)+len(axis2)]\\n\\n if hasattr(axis1,'id') and hasattr(axis2,'id') and axis1.id==axis2.id :\\n vid = axis1.id\\n else:\\n vid = None\\n axis3 = cdms2.createAxis( a3, bounds=None, id=vid )\\n axis3.units = units1\\n return (axis3,a1indexina3,a2indexina3)\",\n \"def delete_singleton_axis( mv, vid=None ):\\n axes = allAxes(mv)\\n saxis = None\\n si = None\\n for i in range(len(axes)):\\n if len(axes[i])==1 and (vid==None or axes[i].id==vid):\\n saxis = axes[i]\\n si = i\\n del axes[si]\\n break\\n if saxis==None: return mv\\n data = ma.copy( mv.data )\\n if numpy.version.version >= '1.7.0':\\n data = ma.squeeze( data, axis=si )\\n else:\\n data = ma.squeeze( data ) # let's hope that there's only one singleton!\\n mvnew = cdms2.createVariable ( data, axes=axes, id=mv.id )\\n if hasattr(mv,'units'): mvnew.units = mv.units\\n return mvnew\",\n \"def replace_dim(self, old:NamedIndex, new:NamedIndex):\\n\\n assert new not in self, f'new dim({new!r}) is confilicted'\\n\\n ret = OrderedDict()\\n for dim, axes in self.items():\\n if dim == old:\\n if is_namedtuple(axes):\\n axes = namedtuple(new, axes._fields)(*axes)\\n ret[new] = axes\\n else:\\n ret[old] = axes\\n\\n return type(self)(ret)\",\n \"def test_newaxis(self):\\r\\n newaxis = numpy.newaxis\\r\\n\\r\\n n = self.shared(numpy.arange(24, dtype=self.dtype).reshape((2, 3, 4)))\\r\\n assert n.ndim == 3\\r\\n\\r\\n n4 = n[newaxis, :, :, :]\\r\\n assert n4.broadcastable == (True, False, False, False), n4\\r\\n\\r\\n n4 = n[:, newaxis, :, :]\\r\\n assert n4.broadcastable == (False, True, False, False), n4\\r\\n\\r\\n n4 = n[:, :, newaxis, :]\\r\\n assert n4.broadcastable == (False, False, True, False), n4\\r\\n\\r\\n n4 = n[:, :, :, newaxis]\\r\\n assert n4.broadcastable == (False, False, False, True), n4\\r\\n\\r\\n n3 = n.flatten()[newaxis, :, newaxis]\\r\\n assert n3.broadcastable == (True, False, True), n3\\r\\n\\r\\n s = cscalar()\\r\\n s1 = s[newaxis]\\r\\n assert s1.broadcastable == (True,), s1\\r\\n\\r\\n vs1, vn3, vn4 = theano.function([s], [s1, n3, n4])(-2.0)\\r\\n\\r\\n assert numpy.all(vs1 == [-2.0])\\r\\n assert numpy.all(vn3\\r\\n == numpy.arange(24)[newaxis, :, newaxis])\\r\\n assert numpy.all(vn4\\r\\n == numpy.arange(24).reshape((2, 3, 4))[:, :, :, newaxis])\",\n \"def common_axes( mv1, mv2 ):\\n axes1 = [a[0] for a in mv1.getDomain()]\\n axes2 = [a[0] for a in mv2.getDomain()]\\n if len(axes1)!=len(axes2):\\n print \\\"ERROR. common_axes requires same number of axes in\\\",mv1,\\\" and\\\",mv2\\n return None\\n axes3 = []\\n for i in range(len(axes1)):\\n axes3.append(common_axis( axes1[i], axes2[i] ))\\n return axes3\",\n \"def addExtraAxis(slab,newaxis=None,axis=0,verbose=False):\\n\\n import cdms2 as cdms\\n import MV2 as MV\\n\\n if newaxis is None:\\n newaxis=cdms.createAxis([1,])\\n newaxis.units=''\\n\\n # add new axis to axis list of input <slab>\\n axislist=slab.getAxisList()\\n axislist.insert(axis,newaxis)\\n\\n #----------------Reshape----------------\\n shape=list(slab.shape)\\n shape.insert(axis,len(newaxis))\\n slab2=MV.reshape(slab,shape)\\n\\n #------------Create variable------------\\n att_dict=attribute_obj2dict(slab)\\n slab2=cdms.createVariable(slab2,axes=axislist,attributes=att_dict,\\\\\\n typecode='f')\\n slab2.id=slab.id\\n\\n if verbose:\\n print('\\\\n# <addExtraAxis>: Originial variable shape:',slab.shape)\\n print('# <addExtraAxis>: New variable shape:',slab2.shape)\\n\\n return slab2\",\n \"def _make_twin_axes(self, *args, **kwargs):\\n # Typically, SubplotBase._make_twin_axes is called instead of this.\\n # There is also an override in axes_grid1/axes_divider.py.\\n if 'sharex' in kwargs and 'sharey' in kwargs:\\n raise ValueError('Twinned Axes may share only one axis.')\\n ax2 = self.figure.add_axes(self.get_position(True), *args, **kwargs)\\n self.set_adjustable('datalim')\\n ax2.set_adjustable('datalim')\\n self._twinned_axes.join(self, ax2)\\n return ax2\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def swapaxes(self, a1, a2):\\n an = self.axes_names[:]\\n ia1, ia2 = self.get_axis_id(a1), self.get_axis_id(a2)\\n an[ia2], an[ia1] = an[ia1], an[ia2]\\n return xndarray(np.swapaxes(self.data, ia1, ia2), an, self.axes_domains,\\n self.value_label, self.meta_data)\",\n \"def interp2( newaxis1, mv ):\\n missing = mv.get_fill_value()\\n axes = allAxes(mv)\\n if len(newaxis1[:])>len(axes[1][:]): return mv\\n new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )\\n for i in range(len( axes[0] )):\\n new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], left=missing, right=missing )\\n # numpy.interp loses the mask, and I want to propagate it! But we can separately interpolate\\n # the mask - which numpy.interp treats False as 0, True as 1:\\n new_vals.mask[i,:] = ( numpy.interp( newaxis1[:], axes[1][:], mv.mask[i,:], left=missing,\\n right=missing ) )>0\\n return new_vals\",\n \"def aminusb_2ax( mv1, mv2 ):\\n return mv2\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n missing = mv1.get_fill_value()\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n if axes1 is None or axes2 is None: return None\\n if len(axes1)!=2: print \\\"ERROR @1, wrong number of axes for aminusb_2ax\\\",axes1\\n if len(axes2)!=2: print \\\"ERROR @2, wrong number of axes for aminusb_2ax\\\",axes2\\n if len(axes1[0])==len(axes2[0]):\\n # Only axis2 differs, there's a better way...\\n return aminusb_ax2( mv1, mv2 )\\n if len(axes1[0])<=len(axes2[0]):\\n if len(axes1[1])<=len(axes2[1]):\\n mv1new = mv1\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid1 = mv1.getGrid()\\n mv2new = mv2.regrid(grid1)\\n else:\\n # Interpolate mv1 from axis1[1] to axis2[1]\\n # Interpolate mv2 from axis2[0] to axis1[0]\\n print \\\"ERROR @3, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n if len(axes1[1])<=len(axes2[1]):\\n # Interpolate mv1 from axis1[0] to axis2[0]\\n # Interpolate mv2 from axis2[1] to axis1[1]\\n print \\\"ERROR @4, aminusb_2ax IS NOT FINISHED\\\"\\n return None\\n else:\\n mv2new = mv2\\n # Interpolate mv2 from axis2 to axis1 in both directions. Use the CDAT regridder.\\n grid2 = mv2.getGrid()\\n mv1new = mv1.regrid(grid2)\\n aminusb = mv1new - mv2new\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def duplicate_axes(isl_obj, duplicate_inames, new_inames):\\n if isinstance(isl_obj, list):\\n return [\\n duplicate_axes(i, duplicate_inames, new_inames)\\n for i in isl_obj]\\n\\n if not duplicate_inames:\\n return isl_obj\\n\\n def _align_and_intersect(d1, d2):\\n d1, d2 = isl.align_two(d1, d2)\\n return d1 & d2\\n\\n old_name_to_new_name = dict(zip(duplicate_inames, new_inames))\\n\\n dup_isl_obj = isl_obj\\n\\n for old_name, (dt, pos) in isl_obj.get_var_dict().items():\\n dup_isl_obj = dup_isl_obj.set_dim_name(dt, pos,\\n old_name_to_new_name.get(old_name,\\n old_name))\\n\\n return _align_and_intersect(dup_isl_obj, isl_obj)\",\n \"def reorderAxesEvent(self):\\n axisB = self.sender().text()\\n self.myParent.swapAxes(self.axisName, axisB)\\n self.myParent.setVistrailsVariableAxes()\",\n \"def test_var_and_raw_var_same_index(self):\\n\\n # Swap first row for second one\\n var = Validator.getattr_anndata(self.validator.adata, \\\"var\\\")\\n\\n # First swap the index\\n new_index = list(var.index)\\n tmp = new_index[0]\\n new_index[0] = new_index[1]\\n new_index[1] = tmp\\n var.set_index(pd.Index(new_index), inplace=True)\\n\\n # Then swap the actual rows\\n tmp = var.iloc[0, :].copy()\\n var.iloc[0, :] = var.iloc[1, :].copy()\\n var.iloc[1, :] = tmp\\n\\n self.validator.validate_adata()\\n print(\\\"FOO\\\", self.validator.errors)\\n self.assertEqual(\\n self.validator.errors,\\n [\\\"ERROR: Index of 'raw.var' is not identical to index of 'var'.\\\"],\\n )\",\n \"def interpolate_vertical(ml_file, inter_file, new_vertical_axis):\\n with xr.load_dataset(inter_file) as interpolated:\\n reference = [variable for variable in interpolated.variables if len(interpolated[variable].shape) == 4][0]\\n with xr.open_dataset(ml_file) as ml:\\n for variable in [variable for variable in ml.variables if variable not in interpolated.variables\\n and len(ml[variable].dims) == 4\\n and \\\"lev_2\\\" in ml[variable].dims]:\\n try:\\n x = np.array(ml[new_vertical_axis].data)\\n y = np.array(ml[variable].data)\\n interpolated_data = interpolate_1d(interpolated[\\\"lev\\\"].data, x, y, axis=1)\\n attributes = ml[variable].attrs\\n\\n interpolated[variable] = interpolated[reference].copy(data=interpolated_data)\\n interpolated[variable].attrs = ml[variable].attrs\\n except Exception as e:\\n print(variable, e)\\n interpolated.to_netcdf(inter_file)\",\n \"def adjust_axes(axes):\\n # TODO: Uncomment & decide for each subplot!\\n for ax in axes.itervalues():\\n core.hide_axis(ax)\\n\\n for k in [\\n \\\"placeholder\\\",\\n \\\"placeholder1\\\",\\n \\\"placeholder2\\\",\\n \\\"spikes_stim\\\",\\n \\\"spikes_stim1\\\",\\n \\\"spikes_stim2\\\",\\n \\\"spikes_post\\\",\\n \\\"stimulation_schema\\\"\\n ]:\\n axes[k].set_frame_on(False)\",\n \"def aminusb_1ax( mv1, mv2 ):\\n mv1, mv2 = reconcile_units( mv1, mv2 )\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARNING: aminusb_1ax1 is subtracting variables with different units!\\\",mv1,mv1\\n if mv1 is None or mv2 is None: return None\\n missing = mv1.get_fill_value()\\n axis1 = allAxes(mv1)[0]\\n axis2 = allAxes(mv2)[0]\\n if len(axis1)<=len(axis2):\\n a = mv1\\n b = numpy.interp( axis1[:], axis2[:], mv2[:], left=missing, right=missing )\\n else:\\n a = numpy.interp( axis2[:], axis1[:], mv1[:], left=missing, right=missing )\\n b = mv2\\n aminusb = a - b\\n aminusb.id = mv1.id\\n return aminusb\",\n \"def plot_sensors_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def adjust_axes(axis):\\r\\n x_lim = axis.get_xlim()\\r\\n y_lim = axis.get_ylim()\\r\\n new_lim = (min(x_lim[0], y_lim[0]), max(x_lim[1], y_lim[1]))\\r\\n axis.set_xlim(new_lim)\\r\\n axis.set_ylim(new_lim)\\r\\n axis.set_aspect('equal')\",\n \"def _metadata_changed(self, old, new):\\n\\n #self.cross_plot.value_range.low = self.minz\\n #self.cross_plot.value_range.high = self.maxz\\n #self.cross_plot2.value_range.low = self.minz\\n #self.cross_plot2.value_range.high = self.maxz\\n if self._imag_index.metadata.has_key(\\\"selections\\\"):\\n x_ndx, y_ndx = self._imag_index.metadata[\\\"selections\\\"]\\n if y_ndx and x_ndx:\\n# xdata, ydata = self._image_index.get_data()\\n# xdata, ydata = xdata.get_data(), ydata.get_data()\\n self.pd_horiz.set_data(\\\"horiz\\\", self._image_value.data[y_ndx,:])\\n self.pd_vert.set_data(\\\"vert\\\", self._image_value.data[:,x_ndx])\",\n \"def analyze_on_axis(phase_space, id_begin, id_end, ds_slice, zplot):\\n\\n ps = phase_space[:, (id_begin-1):id_end, :]\\n # print(np.shape(ps))\\n # ps = ps[numpy.logical_not(numpy.isnan(ps))]\\n\\n x = ps[0, :, :]\\n px = ps[1, :, :]\\n y = ps[2, :, :]\\n py = ps[3, :, :]\\n\\n id_on_axis = np.zeros((4, int(id_end-id_begin+1)))\\n\\n for n in range(int(id_end-id_begin+1)):\\n x_this = x[n, :]\\n px_this = px[n, :]\\n y_this = y[n, :]\\n py_this = py[n, :]\\n\\n # Remove all NAN elements in the phase space array\\n x_this = x_this[np.logical_not(np.isnan(x_this))]\\n px_this = px_this[np.logical_not(np.isnan(px_this))]\\n y_this = y_this[np.logical_not(np.isnan(y_this))]\\n py_this = py_this[np.logical_not(np.isnan(py_this))]\\n\\n ## Plot X\\n plt.subplot(2, 2, 1)\\n plt.plot(zplot[0:len(x_this)]*1e+6, x_this*1e+6)\\n plt.ylabel('Position in X/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot Y\\n plt.subplot(2, 2, 2)\\n plt.plot(zplot[0:len(y_this)]*1e+6, y_this*1e+6)\\n plt.ylabel('Position in Y/ $\\\\mu$m', fontsize=10)\\n\\n ## Plot px\\n plt.subplot(2, 2, 3)\\n plt.plot(zplot[0:len(px_this)]*1e+6, px_this)\\n plt.ylabel('Angle in X', fontsize=10)\\n\\n ## Plot py\\n plt.subplot(2, 2, 4)\\n plt.plot(zplot[0:len(py_this)]*1e+6, py_this)\\n plt.ylabel('Angle in Y', fontsize=10)\\n\\n\\n # plt.xlabel('Longitudianl Direction of the Bunch $s$/ $\\\\mu$m')\\n # plt.title('First Undulator Section')\\n # plt.title('Second Undulator Section')\\n # plt.title('Third Undulator Section')\\n\\n id_on_axis[0, n] = np.argmin(np.abs(x_this))\\n id_on_axis[1, n] = np.argmin(np.abs(px_this))\\n id_on_axis[2, n] = np.argmin(np.abs(y_this))\\n id_on_axis[3, n] = np.argmin(np.abs(py_this))\\n\\n fig = plt.gcf()\\n fig.set_size_inches(13.5, 9)\\n ax = plt.gca()\\n ax.yaxis.get_major_formatter().set_powerlimits((0,1))\\n fig.savefig('phase_space_U3_new.png', dpi=100)\\n plt.show()\\n\\n\\n s_on_axis = np.average(id_on_axis[2:4,:])*ds_slice\\n\\n return id_on_axis, s_on_axis\",\n \"def setupVariableAxes(self):\\n if self.var is None:\\n return\\n \\n if (self.axisList is None):\\n self.axisList = self.var.getAxisList()\\n self.axisOrder = range(len(self.axisList))\\n\\n self.clear() \\n self.setAxesNames()\\n \\n # Iterate through the variables axes & init each axis widget\\n axisIndex = 0\\n for axis, axisName in zip(self.axisList, self.axesNames):\\n # Create the axis widget\\n axisWidget = QAxis(axis, axisName, axisIndex, self)\\n axisWidget.setAxisButtonText(axisName)\\n self.axisWidgets.append(axisWidget)\\n\\n # Setup the layout for each axis\\n row = self.gridLayout.rowCount()\\n self.gridLayout.addWidget(axisWidget.getAxisButton(), row, 0)\\n self.gridLayout.addWidget(axisWidget, row, 1) \\n self.gridLayout.addWidget(axisWidget.getAxisOperationsButton(), row, 2)\\n\\n # Create separator line between each axis widget\\n vline = QtGui.QFrame()\\n vline.setFrameStyle(QtGui.QFrame.HLine | QtGui.QFrame.Sunken)\\n self.gridLayout.addWidget(vline, row+1, 0, 1,\\n self.gridLayout.columnCount())\\n\\n axisIndex += 1\\n\\n self.gridLayout.setRowStretch(self.gridLayout.rowCount(), 1)\",\n \"def translate(self, diff: AnyVec) -> None:\\n for p in self.planes:\\n p += diff\\n\\n u_axis = Vec(self.uaxis.x, self.uaxis.y, self.uaxis.z)\\n v_axis = Vec(self.vaxis.x, self.vaxis.y, self.vaxis.z)\\n\\n # Fix offset - see 2013 SDK utils/vbsp/map.cpp:2237\\n self.uaxis.offset -= Vec.dot(u_axis, diff) / self.uaxis.scale\\n self.vaxis.offset -= Vec.dot(v_axis, diff) / self.vaxis.scale\",\n \"def _update_axes(self):\\n data_shape = self.data.shape\\n if len(self.axes) < self.data.ndim + 1:\\n self._axes.append(Axis())\\n for index in range(self.data.ndim):\\n if len(self.axes[index].values) != data_shape[index]:\\n self.axes[index].values = np.arange(data_shape[index],\\n dtype=np.float64)\",\n \"def _make_axes(self, hdr, quiet=False, novec=False, vonly=False, simple=False):\\n\\n # PULL THE IMAGE/CUBE SIZES FROM THE HEADER\\n naxis = int(hdr['NAXIS'])\\n naxis1 = int(hdr['NAXIS1'])\\n naxis2 = int(hdr['NAXIS2'])\\n if naxis > 2:\\n naxis3 = hdr['NAXIS3']\\n\\n ## EXTRACT FITS ASTROMETRY STRUCTURE\\n ww = astropy.wcs.WCS(hdr)\\n\\n #IF DATASET IS A CUBE THEN WE MAKE THE THIRD AXIS IN THE SIMPLEST WAY POSSIBLE (NO COMPLICATED ASTROMETRY WORRIES FOR FREQUENCY INFORMATION)\\n if naxis > 3:\\n #GRAB THE RELEVANT INFORMATION FROM THE ASTROMETRY HEADER\\n cd = ww.wcs.cd\\n crpix = ww.wcs.crpix\\n cdelt = ww.wcs.crelt\\n crval = ww.wcs.crval\\n\\n if naxis > 2:\\n # MAKE THE VELOCITY AXIS (WILL BE M/S)\\n v = np.arange(naxis3) * 1.0\\n vdif = v - (hdr['CRPIX3']-1)\\n vaxis = (vdif * hdr['CDELT3'] + hdr['CRVAL3'])\\n\\n # CUT OUT HERE IF WE ONLY WANT VELOCITY INFO\\n if vonly:\\n return vaxis\\n\\n #IF 'SIMPLE' IS CALLED THEN DO THE REALLY TRIVIAL THING:\\n if simple:\\n print('Using simple aproach to make axes.')\\n print('BE SURE THIS IS WHAT YOU WANT! It probably is not.')\\n raxis = np.arange(naxis1) * 1.0\\n rdif = raxis - (hdr['CRPIX1'] - 1)\\n raxis = (rdif * hdr['CDELT1'] + hdr['CRVAL1'])\\n\\n daxis = np.arange(naxis2) * 1.0\\n ddif = daxis - (hdr['CRPIX1'] - 1)\\n daxis = (ddif * hdr['CDELT1'] + hdr['CRVAL1'])\\n\\n rimg = raxis # (fltarr(naxis2) + 1.)\\n dimg = (np.asarray(naxis1) + 1.) # daxis\\n return rimg, dimg\\n\\n # OBNOXIOUS SFL/GLS THING\\n glspos = ww.wcs.ctype[0].find('GLS')\\n if glspos != -1:\\n ctstr = ww.wcs.ctype[0]\\n newtype = 'SFL'\\n ctstr.replace('GLS', 'SFL')\\n ww.wcs.ctype[0] = ctstr\\n print('Replaced GLS with SFL; CTYPE1 now =' + ww.wcs.ctype[0])\\n\\n glspos = ww.wcs.ctype[1].find('GLS')\\n if glspos != -1:\\n ctstr = ww.wcs.ctype[1]\\n newtype = 'SFL'\\n ctstr.replace('GLS', 'SFL')\\n ww.wcs.ctype[1] = ctstr\\n print('Replaced GLS with SFL; CTYPE2 now = ' + ww.wcs.ctype[1])\\n\\n # CALL 'xy2ad' TO FIND THE RA AND DEC FOR EVERY POINT IN THE IMAGE\\n if novec:\\n rimg = np.zeros((naxis1, naxis2))\\n dimg = np.zeros((naxis1, naxis2))\\n for i in range(naxis1):\\n j = np.asarray([0 for i in xrange(naxis2)])\\n\\n pixcrd = np.array([[zip(float(i), float(j))]], numpy.float_)\\n ra, dec = ww.all_pix2world(pixcrd, 1)\\n\\n rimg[i, :] = ra\\n dimg[i, :] = dec\\n else:\\n ximg = np.arange(naxis1) * 1.0\\n yimg = np.arange(naxis1) * 1.0\\n X, Y = np.meshgrid(ximg, yimg, indexing='xy')\\n ss = X.shape\\n xx, yy = X.flatten(), Y.flatten()\\n\\n pixcrd = np.array(zip(xx, yy), np.float_)\\n img_new = ww.all_pix2world(pixcrd, 0)\\n rimg_new, dimg_new = img_new[:,0], img_new[:,1]\\n\\n rimg = rimg_new.reshape(ss)\\n dimg = dimg_new.reshape(ss)\\n\\n # GET AXES FROM THE IMAGES. USE THE CENTRAL COLUMN AND CENTRAL ROW\\n raxis = np.squeeze(rimg[:, naxis2/2])\\n daxis = np.squeeze(dimg[naxis1/2, :])\\n\\n return rimg, dimg\",\n \"def setaxesnames(self):\\n if not self._axesnames or self.prop['skipsai']:\\n return\\n debug('ControllerStartup.setaxesnames()')\\n oldaxes = self.pidevice.qSAI_ALL()\\n for i, newaxis in enumerate(self.axesnames):\\n if newaxis != oldaxes[i] or self.prop['forcesai']:\\n setstage = False\\n if self.pidevice.HasqCST():\\n if self.pidevice.qCST()[oldaxes[i]] == 'NOSTAGE':\\n try:\\n debug('try rename NOSTAGE to TEMP (0x3C)')\\n self.pidevice.SPA(oldaxes[i], 0x3c, 'TEMP')\\n setstage = True\\n except GCSError:\\n pass\\n self.pidevice.SAI(oldaxes[i], newaxis)\\n if setstage:\\n self.pidevice.SPA(newaxis, 0x3c, 'NOSTAGE')\\n debug('restore NOSTAGE (0x3C)')\",\n \"def InterpolateSurfaceVectorsWithLine():\\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, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n print('Loading Finished \\\\n Inserting Centre Line...')\\r\\n # Create Plane of vectors through centreline.\\r\\n PlaneCentroids,PlaneVectors = InsertCentreLine(Centroids1,Vectors1,50)\\r\\n print('Centre Line Inserted \\\\n Interpolating Centroids...')\\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\\r\\n # Make the data more sparse to display better.\\r\\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.1)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\\r\\n print('Interpolation Finished \\\\n Plotting...')\\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(121,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,5,10)\\r\\n\\r\\n ax2 = fig.add_subplot(122,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,5,10)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"Normal Surface Vectors With Central axis Line\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/SurfaceLineVectorInterpolation.dat\\\",Vectors2,header = header,comments='')\",\n \"def _update_vars(self, axis, traj_s, traj_o, rank_s, rank_o, t):\\n if axis == 0:\\n self.x_traj = traj_s\\n self.x_ranking = rank_s\\n self.x_scores = traj_s[-1]\\n self.inverse_y_traj = traj_o\\n self.inverse_y_ranking = rank_o\\n self.inverse_y_scores = traj_o[-1]\\n if axis == 1:\\n self.y_traj = traj_s\\n self.y_ranking = rank_s\\n self.y_scores = traj_s[-1]\\n self.inverse_x_traj = traj_o\\n self.inverse_x_ranking = rank_o\\n self.inverse_x_scores = traj_o[-1]\",\n \"def _plot_interpolation(x, y, x_new, y_new, title=\\\"\\\"):\\n f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, sharey=True)\\n axes = (ax1, ax2, ax3)\\n coord = [\\\"X\\\", \\\"Y\\\", \\\"Z\\\"]\\n\\n for idx, ax in enumerate(axes):\\n ax.set_title(title + \\\" (\\\" + coord[idx] + \\\" coordinate)\\\", fontsize=12)\\n ax.set_ylabel(\\\"m\\\")\\n ax.plot(x, y[:, idx], \\\"bo\\\", label=\\\"Original data\\\")\\n ax.plot(x_new, y_new[:, idx], \\\"ro\\\", label=\\\"Interpolated data\\\")\\n\\n ax3.set_xlabel(\\\"Time\\\")\\n ax1.legend(fontsize=8, loc=1)\\n f.subplots_adjust(hspace=0.3)\\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\\n plt.show()\",\n \"def reshape_differential(x, y, xnew):\\r\\n foo = scipy.interpolate.interp1d(\\r\\n x, y,\\r\\n axis=0,\\r\\n copy=False,\\r\\n kind=\\\"slinear\\\",\\r\\n bounds_error=False,\\r\\n fill_value=0.,\\r\\n assume_sorted=True,\\r\\n )\\r\\n return foo(xnew)\",\n \"def observable_coplot_axis_annotator(target_axis: mpa.Axes, file_pattern: str,\\n variable_index: int, variable_name: str, variable_expr: str,\\n differential_toggle: bool = False,\\n log_axis_x: bool = False, log_axis_y: bool = False,\\n no_legend: bool = False) -> mpa.Axes:\\n file_names = _find_data_files(file_pattern)\\n file_data_list = []\\n for file_name in file_names:\\n legend_data, numeric_data = observable_file_reader(file_name)\\n if numeric_data.shape[0] <= 1:\\n warnings.warn('Only one time point in file ' + file_name)\\n file_data_list.append((legend_data, numeric_data, file_name))\\n if not variable_index and not variable_name and not variable_expr:\\n raise ValueError('Function requires the index of a variable,'\\n ' a name for one, or an expression of variables found in the observable file.')\\n _multi_data_axis_annotator(co_plot_axis=target_axis, file_data_list=file_data_list,\\n coplot_index=variable_index, coplot_name=variable_name, coplot_expression=variable_expr,\\n diff_toggle=differential_toggle, log_x=log_axis_x, log_y=log_axis_y,\\n omit_legend=no_legend)\\n return target_axis\",\n \"def mirror_axis(self, axis_index=0, reverse=False):\\n self.smd3.mirror(axis_index=axis_index, reverse=reverse)\\n self.logic.mirror(axis_index=axis_index, reverse=reverse)\\n min_vector, max_vector = self.smd3.get_min_max_vector()\\n self.header.set_box(min_vector, max_vector)\\n self.header.update(self.smd3)\\n self.logic.update(self.smd3)\\n # self.meta.mirror(axis_index=axis_index, reverse=reverse)\",\n \"def swapaxes(a, axis1, axis2):\\n # TODO(okuta): check type\\n return a.swapaxes(axis1, axis2)\",\n \"def plot_item_add_second_right_axis(plot_item):\\n ax = _pyqtgraph.AxisItem('left')\\n vb = _pyqtgraph.ViewBox()\\n plot_item.layout.addItem(ax, 2, 3)\\n plot_item.scene().addItem(vb)\\n ax.linkToView(vb)\\n vb.setXLink(plot_item)\\n\\n def update_views():\\n vb.setGeometry(plot_item.vb.sceneBoundingRect())\\n vb.linkedViewChanged(plot_item.vb, vb.XAxis)\\n\\n update_views()\\n plot_item.vb.sigResized.connect(update_views)\\n return ax\",\n \"def moveaxis(self, tensor, source, destination):\\n\\n axes = list(range(self.ndim(tensor)))\\n if source < 0:\\n source = axes[source]\\n if destination < 0:\\n destination = axes[destination]\\n try:\\n axes.pop(source)\\n except IndexError:\\n raise ValueError(\\n \\\"Source should verify 0 <= source < tensor.ndim\\\" \\\"Got %d\\\" % source\\n )\\n try:\\n axes.insert(destination, source)\\n except IndexError:\\n raise ValueError(\\n \\\"Destination should verify 0 <= destination < tensor.ndim\\\"\\n \\\"Got %d\\\" % destination\\n )\\n return self.transpose(tensor, axes)\",\n \"def plot_sensors_3d_inter(ax: str, epo1: mne.Epochs, epo2: mne.Epochs, lab: bool = False):\\n\\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=-0.17, traY=0, traZ=0.08, rotY=(-np.pi/12), rotZ=(-np.pi/2))\\n lab1 = [ch for ch in epo1.ch_names]\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0.17, traY=0, traZ=0.08, rotY=(np.pi/12), rotZ=np.pi/2)\\n lab2 = [ch for ch in epo2.ch_names]\\n\\n bads_epo1 =[]\\n bads_epo1 = epo1.info['bads']\\n bads_epo2 =[]\\n bads_epo2 = epo2.info['bads']\\n\\n # plot sensors ('x' for bads)\\n for ch in epo1.ch_names:\\n if ch in bads_epo1:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo1.ch_names.index(ch)\\n x1, y1, z1 = loc1[index_ch, :]\\n ax.scatter(x1, y1, z1, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x1+0.012, y1+0.012 ,z1, lab1[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n\\n for ch in epo2.ch_names:\\n if ch in bads_epo2:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='x', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\\n else:\\n index_ch = epo2.ch_names.index(ch)\\n x2, y2, z2 = loc2[index_ch, :]\\n ax.scatter(x2, y2, z2, marker='o', color='dimgrey')\\n if lab:\\n ax.text(x2+0.012, y2+0.012 ,z2, lab2[index_ch],\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def register_manual_translation(vol_a: Volume, vol_b: Volume) -> np.ndarray:\\n plt.ion()\\n fig, ax = plt.subplots(1, 2)\\n w, h, l = vol_a.data.shape\\n ax[0].imshow(\\n np.mean(vol_a.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=2, dtype=np.float32).T / 2 ** 16)\\n w, h, l = vol_b.data.shape\\n ax[1].imshow(\\n np.mean(vol_b.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=2, dtype=np.float32).T / 2 ** 16)\\n\\n points = plt.ginput(2, timeout=0)\\n plt.close()\\n\\n fig, ax = plt.subplots(1, 2)\\n w, h, l = vol_a.data.shape\\n ax[0].imshow(\\n np.mean(vol_a.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=1, dtype=np.float32).T / 2 ** 16)\\n w, h, l = vol_b.data.shape\\n ax[1].imshow(\\n np.mean(vol_b.data[w // 4:-w // 4, h // 4:-h // 4, l // 4:-l // 4], axis=1, dtype=np.float32).T / 2 ** 16)\\n\\n points2 = plt.ginput(2, timeout=0)\\n plt.close()\\n\\n return np.array([points[1][0] - points[0][0], points[1][1] - points[0][1], points2[1][1] - points2[0][1]])\",\n \"def getReplacementAxisValuesEvent(self):\\n definedVars = self.myParent.getParent().getDefinedVars()\\n QReplaceAxisValuesDialog(definedVars, self).show()\",\n \"def test_alternate_spatial_axes(conv1d_placeholder, output_size, width_axis):\\n width_axis.name = \\\"time\\\"\\n assert len(conv1d_placeholder.axes.find_by_name(\\\"time\\\")) == 1\\n\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n with pytest.raises(IncompatibleAxesError):\\n conv_layer(conv1d_placeholder)\\n # As a dictionary\\n output = conv_layer(conv1d_placeholder, spatial_axes={\\\"W\\\": \\\"time\\\"})\\n assert output.axes == conv1d_placeholder.axes\\n # As a tuple\\n output = conv_layer(conv1d_placeholder, spatial_axes=(\\\"D\\\", \\\"H\\\", \\\"time\\\"))\\n assert output.axes == conv1d_placeholder.axes\",\n \"def with_same_shape(old, new):\\n if isinstance(old, tf.Tensor) and isinstance(new, tf.Tensor):\\n return tensor_util.with_same_shape(old, new)\\n return new\",\n \"def _share_long_axis(self, share, side, level):\\n # NOTE: We do not check _panel_share because that only controls\\n # sharing with main subplot, not other subplots\\n if share is None or self._panel_side:\\n return\\n s = side[0]\\n axis = 'x' if s in 'tb' else 'y'\\n paxs = getattr(self, '_' + s + 'panels')\\n paxs = [pax for pax in paxs if not pax._panel_filled]\\n for pax in paxs:\\n getattr(pax, '_share' + axis + '_setup')(share, level)\",\n \"def __lineartrans(self):\\n do = self.domain\\n self.transpoints = copy(self.pts)\\n def t(x):\\n return (x - do[0])/(do[1]-do[0])\\n for i in range(len(self.transpoints)):\\n self.transpoints[i,0] = t(self.transpoints[i,0])\",\n \"def dualx(self, arg, **kwargs):\\n # NOTE: Matplotlib 3.1 has a 'secondary axis' feature. For the time\\n # being, our version is more robust (see FuncScale) and simpler, since\\n # we do not create an entirely separate _SecondaryAxis class.\\n ax = self.altx(**kwargs)\\n self._dualx_arg = arg\\n self._dualx_overrides()\\n return ax\",\n \"def _synchronize_vars_using_mean(new_var: NestedMap,\\n old_var: NestedMap) -> NestedMap:\\n delta = new_var - old_var\\n delta_mean = jax.lax.pmean(delta, axis_name=data_parallel_axis_name)\\n updated_var = old_var + delta_mean\\n return updated_var\",\n \"def _adjustFramesAsAxes(self, frames, idx, framesAsAxes):\\n axisRange = {}\\n slen = len(frames)\\n check = 1\\n for stride, axis in sorted([[v, k] for k, v in framesAsAxes.items()], reverse=True):\\n axisRange[axis] = slen // stride\\n slen = stride\\n check *= axisRange[axis]\\n if check != len(frames) and not hasattr(self, '_warnedAdjustFramesAsAxes'):\\n self.logger.warning('framesAsAxes strides do not use all frames.')\\n self._warnedAdjustFramesAsAxes = True\\n frame = frames[idx].copy()\\n for axis in self._axesList:\\n frame.pop('Index' + axis.upper(), None)\\n for axis, stride in framesAsAxes.items():\\n frame['Index' + axis.upper()] = (idx // stride) % axisRange[axis]\\n return frame\",\n \"def InterpolateSurfaceOrtho():\\r\\n \\r\\n print('Opening Data...')\\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, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n \\r\\n # Rotate Vectors\\r\\n RotVectors1 = LongaxisOrtho(Vectors1)\\r\\n print('Vectors Rotated \\\\n Interpolating Centroids...')\\r\\n \\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(Centroids1,RotVectors1,Centroids2)\\r\\n # Make the data more sparse to display better.\\r\\n C1,V1 = SparseData(Centroids1,RotVectors1,0.1)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\\r\\n print('Interpolation Finished \\\\n Plotting...')\\r\\n \\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(211,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,7,10)\\r\\n\\r\\n ax2 = fig.add_subplot(212,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,7,10)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"Normal Surface Vectors\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/OrthoVectorInterpolation.dat\\\",Vectors2,header = header,comments='')\",\n \"def _split_ode(self, newVar, oldVar):\\n # Get the free variable in the interface component\\n free_var = self.model.find_free_vars()[0]\\n if free_var.component is not newVar.component:\\n free_var = self.add_input(free_var, free_var.get_units())\\n # Add a new variable to assign the RHS to, with units of the original derivative\\n deriv_name = self._uniquify_var_name(u'd_%s_d_%s' % (oldVar.name, free_var.name), oldVar.component)\\n orig_ode = oldVar.get_all_expr_dependencies()[0]\\n orig_rhs_var = self.add_variable(oldVar.component, deriv_name, orig_ode.eq.lhs.get_units().extract())\\n # Add an output version of this in the interface, with desired units\\n desired_units = newVar.get_units().quotient(free_var.get_units())\\n mapped_rhs_var = self.add_output(orig_rhs_var, desired_units, annotate=False)\\n # Replace the original ODE with an assignment\\n orig_rhs = orig_ode.eq.rhs\\n orig_ode.safe_remove_child(orig_rhs)\\n self.remove_expr(orig_ode)\\n self.add_expr_to_comp(oldVar.component,\\n mathml_apply.create_new(self.model, u'eq',\\n [orig_rhs_var.name, orig_rhs]))\\n # Create a new ODE in the interface component\\n new_ode = mathml_diff.create_new(self.model, free_var.name, newVar.name, mapped_rhs_var.name)\\n self.add_expr_to_comp(newVar.component, new_ode)\\n new_ode.classify_variables(root=True, dependencies_only=True)\",\n \"def apply_over_axes(\\n func: Callable,\\n a: PolyLike,\\n axes: numpy.typing.ArrayLike,\\n) -> ndpoly:\\n\\n @wraps(func)\\n def wrapper_func(array, axis):\\n \\\"\\\"\\\"Wrap func function.\\\"\\\"\\\"\\n # Align indeterminants in case slicing changed them\\n array = numpoly.polynomial(array, names=a.indeterminants)\\n array, _ = numpoly.align.align_indeterminants(array, a.indeterminants)\\n # Evaluate function\\n out = func(array, axis=axis)\\n # Restore indeterminants in case func changed them.\\n out, _ = numpoly.align.align_indeterminants(out, a.indeterminants)\\n return out\\n\\n # Initiate wrapper\\n a = numpoly.aspolynomial(a)\\n out = numpy.apply_over_axes(wrapper_func, a=a.values, axes=axes)\\n return out\",\n \"def _assume_meta(self, new_meta, new_var, old_var):\\n meta = self._meta\\n n_masks = new_meta['masks']\\n n_cols = new_meta['columns']\\n n_sets = new_meta['sets']\\n n_lib_v = new_meta['lib']['values']\\n\\n if self.is_array(old_var):\\n n_masks[new_var] = org_copy.deepcopy(meta['masks'][old_var])\\n n_masks[new_var]['name'] = new_var\\n if self._has_categorical_data(old_var):\\n n_lib_v[new_var] = meta['lib']['values'][old_var]\\n n_sets[new_var] = org_copy.deepcopy(meta['sets'][old_var])\\n n_sets['data file']['items'].append('masks@{}'.format(new_var))\\n for var in self.sources(old_var):\\n new_meta = self._assume_meta(new_meta, var, var)\\n else:\\n n_cols[new_var] = org_copy.deepcopy(meta['columns'][old_var])\\n n_cols[new_var]['name'] = new_var\\n if self._is_array_item(old_var):\\n if not self._maskname_from_item(old_var) in new_meta['masks']:\\n n_cols[new_var]['parent'] = {}\\n n_cols[new_var]['values'] = self._get_value_loc(old_var)\\n n_sets['data file']['items'].append('columns@{}'.format(new_var))\\n else:\\n n_sets['data file']['items'].append('columns@{}'.format(new_var))\\n\\n return new_meta\",\n \"def setup_axes3(fig, rect):\\n\\n # rotate a bit for better orientation\\n tr_rotate = Affine2D().translate(-95, 0)\\n\\n # scale degree to radians\\n tr_scale = Affine2D().scale(np.pi/180., 1.)\\n\\n tr = tr_rotate + tr_scale + PolarAxes.PolarTransform()\\n\\n grid_locator1 = angle_helper.LocatorHMS(4)\\n tick_formatter1 = angle_helper.FormatterHMS()\\n\\n grid_locator2 = MaxNLocator(3)\\n\\n ra0, ra1 = 8.*15, 14.*15\\n cz0, cz1 = 0, 14000\\n grid_helper = floating_axes.GridHelperCurveLinear(\\n tr, extremes=(ra0, ra1, cz0, cz1),\\n grid_locator1=grid_locator1,\\n grid_locator2=grid_locator2,\\n tick_formatter1=tick_formatter1,\\n tick_formatter2=None)\\n\\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\\n fig.add_subplot(ax1)\\n\\n # adjust axis\\n ax1.axis[\\\"left\\\"].set_axis_direction(\\\"bottom\\\")\\n ax1.axis[\\\"right\\\"].set_axis_direction(\\\"top\\\")\\n\\n ax1.axis[\\\"bottom\\\"].set_visible(False)\\n ax1.axis[\\\"top\\\"].set_axis_direction(\\\"bottom\\\")\\n ax1.axis[\\\"top\\\"].toggle(ticklabels=True, label=True)\\n ax1.axis[\\\"top\\\"].major_ticklabels.set_axis_direction(\\\"top\\\")\\n ax1.axis[\\\"top\\\"].label.set_axis_direction(\\\"top\\\")\\n\\n ax1.axis[\\\"left\\\"].label.set_text(r\\\"cz [km$^{-1}$]\\\")\\n ax1.axis[\\\"top\\\"].label.set_text(r\\\"$\\\\alpha_{1950}$\\\")\\n\\n # create a parasite axes whose transData in RA, cz\\n aux_ax = ax1.get_aux_axes(tr)\\n\\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\\n ax1.patch.zorder = 0.9 # but this has a side effect that the patch is\\n # drawn twice, and possibly over some other\\n # artists. So, we decrease the zorder a bit to\\n # prevent this.\\n\\n return ax1, aux_ax\",\n \"def _translations_along_axis(self, axis: int) -> PermutationGroup:\\n if self.lattice._pbc[axis]:\\n trans_list = [Identity()]\\n # note that we need the preimages in the permutation\\n trans_perm = self.lattice.id_from_position(\\n self.lattice.positions - self.lattice.basis_vectors[axis]\\n )\\n vector = np.zeros(self.lattice.ndim, dtype=int)\\n vector[axis] = 1\\n trans_by_one = Translation(trans_perm, vector)\\n\\n for _ in range(1, self.lattice.extent[axis]):\\n trans_list.append(trans_list[-1] @ trans_by_one)\\n\\n return PermutationGroup(trans_list, degree=self.lattice.n_nodes)\\n else:\\n return PermutationGroup([Identity()], degree=self.lattice.n_nodes)\",\n \"def new_part(self, indices, master_axis_to_position, master_flip):\\n shape = self.shape\\n\\n if indices == [slice(0, stop, 1) for stop in shape]:\\n return\\n\\n # ------------------------------------------------------------\\n # If a dimension runs in the wrong direction then change its\\n # index to account for this.\\n #\\n # For example, if a dimension with the wrong direction has\\n # size 10 and its index is slice(3,8,2) then after the\\n # direction is set correctly, the index needs to changed to\\n # slice(6,0,-2):\\n #\\n # >>> a = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\\n # >>> a[slice(3, 8, 2)]\\n # [6, 4, 2]\\n # >>> a.reverse()\\n # >>> print(a)\\n # >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\\n # >>> a[slice(6, 0, -2)]\\n # [6, 4, 2]\\n # ------------------------------------------------------------\\n\\n if self._subarray.size > 1:\\n indices = indices[:]\\n\\n p_flip = self.flip\\n\\n for axis, i in master_axis_to_position.items():\\n\\n if (axis not in p_flip and axis not in master_flip) or (\\n axis in p_flip and axis in master_flip\\n ):\\n # This axis runs in the correct direction\\n continue\\n\\n # Still here? Then this axis runs in the wrong\\n # direction.\\n\\n # Reset the direction\\n p_flip = p_flip[:]\\n if axis in self.flip:\\n p_flip.remove(axis)\\n else:\\n p_flip.append(axis)\\n\\n # Modify the index to account for the changed\\n # direction\\n size = shape[i]\\n\\n if isinstance(indices[i], slice):\\n start, stop, step = indices[i].indices(size)\\n # Note that step is assumed to be always +ve here\\n div, mod = divmod(stop - start - 1, step)\\n start = size - 1 - start\\n stop = start - div * step - 1\\n if stop < 0:\\n stop = None\\n indices[i] = slice(start, stop, -step)\\n else:\\n size -= 1\\n indices[i] = [size - j for j in indices[i]]\\n # --- End: for\\n\\n self.flip = p_flip\\n # --- End: if\\n\\n slice_None = slice(None)\\n\\n # Reorder the new indices\\n indices = [\\n (\\n indices[master_axis_to_position[axis]]\\n if axis in master_axis_to_position\\n else slice_None\\n )\\n for axis in self.axes\\n ]\\n\\n part = self.part\\n\\n if not part:\\n self.part = indices\\n return\\n\\n # Still here? update an existing part\\n p_part = []\\n for part_index, index, size in zip(\\n part, indices, self._subarray.shape\\n ):\\n\\n if index == slice_None:\\n p_part.append(part_index)\\n continue\\n\\n if isinstance(part_index, slice):\\n if isinstance(index, slice):\\n\\n start, stop, step = part_index.indices(size)\\n\\n size1, mod = divmod(stop - start - 1, step)\\n\\n start1, stop1, step1 = index.indices(size1 + 1)\\n\\n size2, mod = divmod(stop1 - start1, step1)\\n\\n if mod != 0:\\n size2 += 1\\n\\n start += start1 * step\\n step *= step1\\n stop = start + (size2 - 1) * step\\n\\n if step > 0:\\n stop += 1\\n else:\\n stop -= 1\\n if stop < 0:\\n stop = None\\n p_part.append(slice(start, stop, step))\\n\\n continue\\n else:\\n new_part = list(range(*part_index.indices(size)))\\n new_part = [new_part[i] for i in index]\\n else:\\n if isinstance(index, slice):\\n new_part = part_index[index]\\n else:\\n new_part = [part_index[i] for i in index]\\n # --- End: if\\n\\n # Still here? Then the new element of p_part is a list of\\n # integers, so let's see if we can convert it to a slice\\n # before appending it.\\n new_part0 = new_part[0]\\n if len(new_part) == 1:\\n # Convert a single element list to a slice object\\n new_part = slice(new_part0, new_part0 + 1, 1)\\n else:\\n step = new_part[1] - new_part0\\n if step:\\n if step > 0:\\n start, stop = new_part0, new_part[-1] + 1\\n else:\\n start, stop = new_part0, new_part[-1] - 1\\n if new_part == list(range(start, stop, step)):\\n if stop < 0:\\n stop = None\\n new_part = slice(start, stop, step)\\n # --- End: if\\n\\n p_part.append(new_part)\\n # --- End: for\\n\\n self.part = p_part\",\n \"def _move_spectral_axis(wcs, flux, mask=None, uncertainty=None):\\n naxis = getattr(wcs, 'naxis', len(wcs.world_axis_physical_types))\\n if naxis > 1:\\n temp_axes = []\\n phys_axes = wcs.world_axis_physical_types\\n for i in range(len(phys_axes)):\\n if phys_axes[i] is None:\\n continue\\n if phys_axes[i][0:2] == \\\"em\\\" or phys_axes[i][0:5] == \\\"spect\\\":\\n temp_axes.append(i)\\n if len(temp_axes) != 1:\\n raise ValueError(\\\"Input WCS must have exactly one axis with \\\"\\n \\\"spectral units, found {}\\\".format(len(temp_axes)))\\n\\n # Due to FITS conventions, a WCS with spectral axis first corresponds\\n # to a flux array with spectral axis last.\\n if temp_axes[0] != 0:\\n wcs = wcs.swapaxes(0, temp_axes[0])\\n if flux is not None:\\n flux = np.swapaxes(flux, len(flux.shape) - temp_axes[0] - 1, -1)\\n if mask is not None:\\n mask = np.swapaxes(mask, len(mask.shape) - temp_axes[0] - 1, -1)\\n if uncertainty is not None:\\n if isinstance(uncertainty, NDUncertainty):\\n # Account for Astropy uncertainty types\\n unc_len = len(uncertainty.array.shape)\\n temp_unc = np.swapaxes(uncertainty.array,\\n unc_len - temp_axes[0] - 1, -1)\\n if uncertainty.unit is not None:\\n temp_unc = temp_unc * u.Unit(uncertainty.unit)\\n uncertainty = type(uncertainty)(temp_unc)\\n else:\\n uncertainty = np.swapaxes(uncertainty,\\n len(uncertainty.shape) -\\n temp_axes[0] - 1, -1)\\n return wcs, flux, mask, uncertainty\",\n \"def comp_axes(self, machine, N0=None):\\n if self.time is None and N0 is None:\\n raise InputError(\\\"ERROR: time and N0 can't be both None\\\")\\n\\n # Get machine pole pair number\\n p = machine.get_pole_pair_number()\\n\\n # Get electrical fundamental frequency\\n f_elec = self.comp_felec()\\n\\n # Airgap radius\\n Rag = machine.comp_Rgap_mec()\\n\\n # Setup normalizations for time and angle axes\\n norm_time = {\\n \\\"elec_order\\\": f_elec,\\n \\\"mech_order\\\": f_elec / p,\\n }\\n if N0 is not None:\\n norm_time[\\\"angle_rotor\\\"] = 1 / (360 * N0 / 60)\\n\\n norm_angle = {\\\"space_order\\\": p, \\\"distance\\\": 1 / Rag}\\n\\n # Create time axis\\n if self.time is None:\\n # Create time axis as a DataLinspace\\n Time = DataLinspace(\\n name=\\\"time\\\",\\n unit=\\\"s\\\",\\n initial=0,\\n final=60 / N0 * self.Nrev,\\n number=self.Nt_tot,\\n include_endpoint=False,\\n normalizations=norm_time,\\n )\\n else:\\n # Load time data\\n time = self.time.get_data()\\n self.Nt_tot = len(time)\\n Time = Data1D(name=\\\"time\\\", unit=\\\"s\\\", values=time, normalizations=norm_time)\\n\\n # Create angle axis\\n if self.angle is None:\\n # Create angle axis as a DataLinspace\\n Angle = DataLinspace(\\n name=\\\"angle\\\",\\n unit=\\\"rad\\\",\\n initial=0,\\n final=2 * pi,\\n number=self.Na_tot,\\n include_endpoint=False,\\n normalizations=norm_angle,\\n )\\n else:\\n # Load angle data\\n angle = self.angle.get_data()\\n self.Na_tot = len(angle)\\n Angle = Data1D(\\n name=\\\"angle\\\", unit=\\\"rad\\\", values=angle, normalizations=norm_angle\\n )\\n\\n return Time, Angle\",\n \"def plot_links_3d_intra(ax: str, epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray, threshold: str='auto',\\n steps: int=10):\\n \\n # extract sensor infos and transform loc to fit with headmodel \\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform(loc1, traX=0, traY=0, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform(loc2, traX=0, traY=0.5, traZ=0.04, rotY=0, rotZ=(-np.pi/2))\\n \\n\\n ctr1 = np.nanmean(loc1, 0)\\n ctr1[2] -= 0.2\\n ctr2 = np.nanmean(loc2, 0)\\n ctr2[2] -= 0.2\\n\\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\\n Cmax1=np.nanmax(C1[:])\\n Cmax2=np.nanmax(C2[:])\\n Cmax=[]\\n Cmax=[Cmax1, Cmax2]\\n vmax=np.nanmax(Cmax)\\n Cmin1=np.nanmin(C1[:])\\n Cmin2=np.nanmin(C2[:])\\n Cmin=[]\\n Cmin=[Cmin1, Cmin2]\\n vmin=np.min(Cmin)\\n\\n # Calculate automatic threshold\\n if threshold == 'auto':\\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\\n else:\\n threshold = threshold\\n\\n # Define colormap for both participant\\n cmap_p = matplotlib.cm.get_cmap('Reds')\\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\\n\\n for e1 in range(len(loc1)):\\n x1 = loc1[e1, 0]\\n y1 = loc1[e1, 1]\\n z1 = loc1[e1, 2]\\n for e2 in range(len(loc1)):\\n x2 = loc1[e2, 0]\\n y2 = loc1[e2, 1]\\n z2 = loc1[e2, 2]\\n if C1[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C1[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n [loc1[e1, 2], loc1[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr1[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr1[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr1[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr1[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\\n \\n for e1 in range(len(loc2)):\\n x1 = loc2[e1, 0]\\n y1 = loc2[e1, 1]\\n z1 = loc2[e1, 2]\\n for e2 in range(len(loc2)):\\n x2 = loc2[e2, 0]\\n y2 = loc2[e2, 1]\\n z2 = loc2[e2, 2]\\n if C2[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_p, linewidth=weight)\\n if C2[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n ax.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n [loc2[e1, 2], loc2[e2, 2]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n zn = ((1-a)**3 * z1 +\\n 3 * (1-a)**2 * a * (2 * z1 - ctr2[2]) +\\n 3 * (1-a) * a**2 * (2 * z2 - ctr2[2]) +\\n a**3 * z2)\\n znn = ((1-b)**3 * z1 +\\n 3 * (1-b)**2 * b * (2 * z1 - ctr2[2]) +\\n 3 * (1-b) * b**2 * (2 * z2 - ctr2[2]) +\\n b**3 * z2)\\n ax.plot([xn, xnn], [yn, ynn], [zn, znn],\\n '-', color=color_n, linewidth=weight)\",\n \"def _update_non_learnable_var(old_var: NestedMap, new_var: NestedMap,\\n var_params: ParamsT) -> NestedMap:\\n if not base_layer.var_not_trainable(var_params):\\n assert new_var is None\\n return old_var\\n elif not in_pmap:\\n # No aggregation is needed.\\n assert new_var is not None\\n return new_var\\n elif base_layer.var_requires_mean_sync(var_params):\\n assert new_var is not None\\n return _synchronize_vars_using_mean(new_var, old_var)\\n else:\\n raise ValueError('Non-trainable variables must have a cross-replica '\\n 'synchronization method specified.')\",\n \"def make_corrections_animation(XX,VV,tensorsx,myspacex,tensorsxv,myspacexv,gs=150):\\n sr,sp,sz=bovy_coords.rect_to_cyl(XX[:,0], XX[:,1], XX[:,2])\\n sp=sp+np.pi\\n dist2=np.sqrt(XX[:,0]**2+XX[:,1]**2)\\n rindx=(dist2>0.2)*(dist2<.5)*(np.fabs(XX[:,2])<0.2)\\n for i in range(0,36):\\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))\\n if i==34:\\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))+rindx*(sp>0.)*(sp<((1)*np.pi/18.))\\n if i==35:\\n wedgedex=rindx*(sp>(i*np.pi/18.))*(sp<((i+3)*np.pi/18.))+rindx*(sp>0.)*(sp<((2)*np.pi/18.))\\n print(wedgedex.sum(),'stars in wedge',i)\\n\\n fixx=myspacex.get_model_v(tensorsx,VV[wedgedex],XX[wedgedex])\\n fixxv=myspacexv.get_model_v(tensorsxv,VV[wedgedex],XX[wedgedex])\\n\\n f, ((ax1,ax2),(ax3,ax4)) = plt.subplots(2, 2, figsize=(15,15))\\n ax1.hist2d(XX[:,0][wedgedex],XX[:,1][wedgedex],range=[[-0.5,0.5],[-0.5,0.5]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\\n ax1.set_xlabel(r'$X\\\\ (\\\\mathrm{kpc})$',fontsize=20)\\n ax1.set_ylabel(r'$Y\\\\ (\\\\mathrm{kpc})$',fontsize=20)\\n ax1.set_xlim(-0.5,0.5)\\n ax1.set_ylim(-0.5,0.5)\\n ax1.set_title(r'$\\\\mathrm{Selected\\\\ area}$',fontsize=20)\\n ax2.hist2d(VV[:,0][wedgedex],VV[:,1][wedgedex],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\\n ax2.set_xlabel(r'$v_X\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax2.set_ylabel(r'$v_Y\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax2.set_xlim(-125,125)\\n ax2.set_ylim(-125,125)\\n ax2.set_title(r'$\\\\mathrm{No\\\\ correction}$',fontsize=20)\\n ax3.hist2d(fixx[:,0],fixx[:,1],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\\n ax3.set_xlabel(r'$v_X\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax3.set_ylabel(r'$v_Y\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax3.set_xlim(-125,125)\\n ax3.set_ylim(-125,125)\\n ax3.set_title(r'$\\\\mathrm{x\\\\ correction}$',fontsize=20)\\n ax4.hist2d(fixxv[:,0],fixxv[:,1],range=[[-125,125],[-125,125]],bins=gs,cmin=1.0e-50,rasterized=True,density=True)\\n ax4.set_xlabel(r'$v_X\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax4.set_ylabel(r'$v_Y\\\\ (\\\\mathrm{km\\\\ s}^{-1})$',fontsize=20)\\n ax4.set_xlim(-125,125)\\n ax4.set_ylim(-125,125)\\n ax4.set_title(r'$\\\\mathrm{xv\\\\ correction}$',fontsize=20)\\n ax1.tick_params(axis='both', which='major', labelsize=15)\\n ax2.tick_params(axis='both', which='major', labelsize=15)\\n ax3.tick_params(axis='both', which='major', labelsize=15)\\n ax4.tick_params(axis='both', which='major', labelsize=15)\\n plt.savefig('orders'+str(\\\"{:02d}\\\".format(i))+'.pdf',bbox_inches='tight')\\n plt.close()\\n\\n os.system('convert -delay 5 -loop 0 orders*.pdf orders.gif')\",\n \"def plot_output_3axes(axes, name, color):\\n\\tout = vice.output(name)\\n\\taxes[0].plot(out.history[\\\"time\\\"][1:], out.history[\\\"ifr\\\"][1:],\\n\\t\\tc = visuals.colors()[color], linestyle = '--')\\n\\taxes[0].plot(out.history[\\\"time\\\"], out.history[\\\"sfr\\\"],\\n\\t\\tc = visuals.colors()[color], linestyle = '-')\\n\\taxes[1].plot(out.history[\\\"[Fe/H]\\\"], out.history[\\\"[O/Fe]\\\"],\\n\\t\\tc = visuals.colors()[color])\\n\\taxes[2].plot(list(map(lambda x, y: (x + y) / 2., out.mdf[\\\"bin_edge_left\\\"],\\n\\t\\tout.mdf[\\\"bin_edge_right\\\"])), out.mdf[\\\"dn/d[O/Fe]\\\"],\\n\\t\\tc = visuals.colors()[color])\",\n \"def _apply_toffoli(self, state, axes, **kwargs):\\n cntrl_max = np.argmax(axes[:2])\\n cntrl_min = cntrl_max ^ 1\\n ndim = self._ndim(state)\\n sl_a0 = _get_slice(0, axes[cntrl_max], ndim)\\n sl_a1 = _get_slice(1, axes[cntrl_max], ndim)\\n sl_b0 = _get_slice(0, axes[cntrl_min], ndim - 1)\\n sl_b1 = _get_slice(1, axes[cntrl_min], ndim - 1)\\n\\n # If both controls are smaller than the target, shift the target axis down by two. If one\\n # control is greater and one control is smaller than the target, shift the target axis\\n # down by one. If both controls are greater than the target, leave the target axis as-is.\\n if axes[cntrl_min] > axes[2]:\\n target_axes = [axes[2]]\\n elif axes[cntrl_max] > axes[2]:\\n target_axes = [axes[2] - 1]\\n else:\\n target_axes = [axes[2] - 2]\\n\\n # state[sl_a1][sl_b1] gives us all of the amplitudes with a |11> for the two control qubits.\\n state_x = self._apply_x(state[sl_a1][sl_b1], axes=target_axes)\\n state_stacked_a1 = self._stack([state[sl_a1][sl_b0], state_x], axis=axes[cntrl_min])\\n return self._stack([state[sl_a0], state_stacked_a1], axis=axes[cntrl_max])\",\n \"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\\n # This differs from reduce2lat_seasonal only in the line \\\"axis_names =\\\"....\\n # I need to think about how to structure the code so there's less cut-and-paste!\\n if vid==None:\\n vid = 'reduced_'+mv.id\\n # Note that the averager function returns a variable with meaningless id.\\n # The climatology function returns the same id as mv, which we also don't want.\\n\\n # The slicers in time.py require getBounds() to work.\\n # If it doesn't, we'll have to give it one.\\n # Setting the _bounds_ attribute will do it.\\n timeax = timeAxis(mv)\\n if timeax.getBounds()==None:\\n timeax._bounds_ = timeax.genGenericBounds()\\n mvseas = seasons.climatology(mv)\\n \\n axes = allAxes( mv )\\n axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' and a.id!='time']\\n axes_string = '('+')('.join(axis_names)+')'\\n\\n if len(axes_string)>2:\\n for axis in mvseas.getAxisList():\\n if axis.getBounds() is None:\\n axis._bounds_ = axis.genGenericBounds()\\n avmv = averager( mvseas, axis=axes_string )\\n else:\\n avmv = mvseas\\n if avmv is None: return avmv\\n avmv.id = vid\\n if hasattr(mv,'units'): avmv.units = mv.units\\n avmv = delete_singleton_axis( avmv, vid='time' )\\n avmv.units = mv.units\\n return avmv\",\n \"def clean_axes(axl):\\n cleanAxes(axl)\",\n \"def populate_plot_axis(self,plot,ax='x'):\\n\\n fig=plt.gcf()\\n\\n extra_ax=[]\\n\\n if ax=='x':\\n\\n ticks=plot.get_xticks()\\n\\n lim=plot.get_xlim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['bottom'].set_position(('outward',10))\\n\\n axn.spines['bottom'].set_visible(True)\\n\\n else:\\n\\n dy_fig=0.08\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0,\\\\\\n prev_ax_position.y0-2*dy_fig,\\\\\\n prev_ax_position.width,\\\\\\n 0),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.yaxis.set_visible(False)\\n\\n for side in axn.spines.keys():\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_xticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_xticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n xlab=axn.set_xlabel(self.names[i])\\n\\n xlab.set_fontsize(10)\\n\\n axn.tick_params(axis='x',labelsize=10)\\n\\n axn.set_xlim(lim)\\n\\n\\n\\n elif ax=='y':\\n\\n ticks=plot.get_yticks()\\n\\n lim=plot.get_ylim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['left'].set_position(('outward',10))\\n\\n axn.spines['left'].set_visible(True)\\n\\n else:\\n\\n dx_fig=0.08\\n\\n plot_position=plot.get_position()\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0-2*dx_fig,\\\\\\n prev_ax_position.y0,\\\\\\n 0,\\\\\\n prev_ax_position.height),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.xaxis.set_visible(False) # hide the yaxis\\n\\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_yticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_yticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n ylab=axn.set_ylabel(self.names[i])\\n\\n ylab.set_fontsize(10)\\n\\n axn.tick_params(axis='y',labelsize=10)\\n\\n axn.set_ylim(lim)\\n\\n else:\\n\\n raise ValueError(\\\"Axis can be 'x' or 'y'\\\")\",\n \"def plot_dual(los_tra, los_val, acc_tra, acc_val):\\n fig, ax_acc = plt.subplots(figsize=(8, 6))\\n\\n cl_acc = 'tab:red'\\n ax_acc.plot(acc_tra, '--', color=cl_acc)\\n ax_acc.plot(acc_val, '-', color=cl_acc)\\n ax_acc.set_xlabel('round')\\n ax_acc.set_xlim([0, len(los_tra)])\\n ax_acc.set_ylabel('Test Acc', color=cl_acc)\\n ax_acc.set_ylim([0, 100])\\n ax_acc.tick_params(axis='y', labelcolor=cl_acc)\\n ax_acc.grid(True, ls='--')\\n # ax_omg.set_title('$\\\\\\\\theta$ and $\\\\omega$ over time')\\n\\n ax_los = ax_acc.twinx()\\n cl_los = 'tab:blue'\\n ax_los.plot(los_tra, '--', color=cl_los)\\n ax_los.plot(los_val, '-', color=cl_los)\\n ax_los.set_ylabel('Test Loss', color=cl_los)\\n ax_los.set_ylim([0, max(los_tra)])\\n ax_los.tick_params(axis='y', labelcolor=cl_los)\\n ax_los.grid(False)\\n\\n fig.tight_layout()\\n # plt.show()\\n return fig\",\n \"def setAxisParts(lowx='all', lefty='all', upx='ticks', righty='ticks'):\\n partdict = {'none':'NONE','lines':'LINE','ticks':'TICKS',\\n 'labels':'LABELS', 'all':'NAME'} \\n dislin.setgrf(partdict[lowx], partdict[lefty],\\\\\\n partdict[upx], partdict[righty])\",\n \"def change_axis_names(self, axis_map):\\n axes = self.axes\\n\\n # Partition axes\\n self.axes = [axis_map[axis] for axis in axes]\\n\\n # Flipped axes\\n flip = self.flip\\n if flip:\\n self.flip = [axis_map[axis] for axis in flip]\",\n \"def multiPlot(self,indexSelect=None,varSelect=None,wrapNumber=5,\\n compLines=None, save = None, xlim = None,\\n forceYAxisZero = True, colourOverride = None,\\n style = None, legend = None, varAsAxis = False,\\n xAxisLabel = None, yAxisLabel = None, figsize = (12,10),\\n legendLoc = 'lower right'):\\n if isinstance(compLines,list):\\n compVars = [list(i.columns) for i in compLines]\\n dfB = [i.copy() for i in compLines]\\n for i in range(len(compLines)):\\n if \\\"Time\\\" not in compVars[i]:\\n dfB[i][\\\"Time\\\"]=dfB[i].index\\n else:\\n compVars[i].remove(\\\"Time\\\")\\n dfB[i] = pd.melt(dfB[i], id_vars=[\\\"Time\\\"],\\n value_vars=compVars[i])\\n elif compLines is not None:\\n compVars=list(compLines.columns)\\n dfB = compLines.copy()\\n if \\\"Time\\\" not in compVars:\\n dfB[\\\"Time\\\"]=dfB.index\\n else:\\n compVars.remove(\\\"Time\\\")\\n dfB = pd.melt(dfB,id_vars=[\\\"Time\\\"],\\n value_vars=compVars)\\n if varSelect is None:\\n varSelect=list(self.longData['variable'].unique())\\n if indexSelect is None:\\n indexSelect=list(self.longData['index'].unique())\\n if not isinstance(indexSelect,list):\\n indexSelect = [indexSelect]\\n if len(varSelect)<wrapNumber:\\n #cols = math.floor(math.sqrt(len(varSelect)))\\n cols = math.ceil(math.sqrt(len(varSelect)))\\n else:\\n cols = wrapNumber\\n rows = math.ceil(len(varSelect)/cols)\\n if style is None:\\n myStyle = \\\"darkgrid\\\"\\n else:\\n myStyle = style\\n with sns.axes_style(style):\\n fig, axs = plt.subplots(rows, cols, sharex=True,\\n figsize=figsize)\\n if (rows>1):\\n axs = trim_axs(axs, len(varSelect))\\n elif (cols==1):\\n axs = [axs]\\n if colourOverride is not None:\\n myColorMap = plt.get_cmap(name=\\\"cool\\\")\\n else:\\n myColorMap = plt.get_cmap(name=\\\"hsv\\\",\\n lut=len(indexSelect)+1)\\n for ax, theVar, j in zip(axs, varSelect, range(len(varSelect))):\\n if varAsAxis:\\n if isinstance(yAxisLabel,list):\\n ax.set_ylabel(theVar+\\\" \\\"+yAxisLabel[j])\\n elif yAxisLabel is not None:\\n ax.set_ylabel(theVar+\\\" \\\"+yAxisLabel)\\n else:\\n ax.set_ylabel(theVar)\\n else:\\n ax.set_title(theVar)\\n if isinstance(yAxisLabel,list):\\n ax.set_ylabel(yAxisLabel[j])\\n elif yAxisLabel is not None:\\n ax.set_ylabel(yAxisLabel)\\n if xAxisLabel is not None:\\n ax.set_xlabel(xAxisLabel)\\n df = self.longData\\n df = df[df['variable']==theVar]\\n if indexSelect is not None:\\n for theIndex, i in zip(indexSelect,\\n range(len(indexSelect))):\\n df2 = df[df['index']==theIndex]\\n if colourOverride is not None:\\n ax.plot(df2[\\\"Time\\\"], df2[\\\"value\\\"],\\n linestyle='solid',\\n color=myColorMap(colourOverride[i]))\\n else:\\n ax.plot(df2[\\\"Time\\\"], df2[\\\"value\\\"],\\n linestyle='solid',\\n color=myColorMap(i))\\n if isinstance(compLines,list):\\n for i, theIndex in enumerate(indexSelect):\\n dfB2 = dfB[theIndex][\\n dfB[theIndex]['variable']==theVar]\\n if colourOverride is not None:\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"o\\\",\\n color=myColorMap(colourOverride[i]))\\n else:\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"o\\\",\\n color=myColorMap(i))\\n elif compLines is not None:\\n dfB2 = dfB[dfB['variable']==theVar]\\n ax.plot(dfB2[\\\"Time\\\"], dfB2[\\\"value\\\"],\\\"ko\\\")\\n if xlim is not None:\\n ax.set_xlim(xlim)\\n if forceYAxisZero:\\n ax.set_ylim([0, None])\\n if legend is not None:\\n if colourOverride is not None:\\n custom_lines = [Line2D([0], [0], color=myColorMap(\\n colourOverride[i]), lw=4)\\n for i in range(len(indexSelect))]\\n else:\\n custom_lines = [Line2D([0], [0], color=myColorMap(i),\\n lw=4)\\n for i in range(len(indexSelect))]\\n if ((not isinstance(compLines,list)) and\\n (compLines is not None)):\\n custom_lines.append(Line2D([0], [0], \\n color=\\\"k\\\", lw=4))\\n fig.legend(custom_lines, legend,\\n loc = legendLoc)\\n fig.tight_layout()\\n if save is not None:\\n fig.savefig(save)\",\n \"def sub_analysis(vdata, prefix=\\\"\\\"):\\n new = vdata[(vdata.direction == \\\"away\\\") & (vdata.tether == \\\"new\\\")]\\n # for new pole, towards mid-cell is +ve v_mid\\n new_towards, new_away, new_static = _sub_analyse(new)\\n new_set = pd.DataFrame({\\n \\\"v_mid\\\": np.hstack([\\n new_towards.v_mid.values,\\n -new_away.v_mid.values,\\n np.abs(new_static.v_mid.values),\\n ]),\\n \\\"direction\\\": ([\\\"towards\\\"] * len(new_towards) +\\n [\\\"away\\\"] * len(new_away) +\\n [\\\"static\\\"] * len(new_static)),\\n })\\n\\n fig = plt.figure()\\n _bigax(\\n fig,\\n xlabel=(\\\"Direction Relative to Midcell\\\", {\\\"labelpad\\\": 10}),\\n spec=(2, 1, 1),\\n )\\n ax = fig.add_subplot(2, 2, 1)\\n ax.set_title(\\\"New Pole\\\")\\n sns.barplot(\\n x=\\\"direction\\\",\\n y=\\\"v_mid\\\",\\n data=new_set,\\n order=[\\\"towards\\\", \\\"away\\\", \\\"static\\\"],\\n ci=95\\n )\\n ax.set_ylabel(\\\"Velocity (\\\\si{\\\\micro\\\\metre\\\\per\\\\hour})\\\")\\n ax.set_xlabel(\\\"\\\")\\n sns.despine()\\n\\n old = vdata[(vdata.direction == \\\"away\\\") & (vdata.tether == \\\"old\\\")]\\n # for old pole, towards mid-cell is -ve v_mid\\n old_away, old_towards, old_static = _sub_analyse(old)\\n old_set = pd.DataFrame({\\n \\\"v_mid\\\": np.hstack([\\n old_away.v_mid.values,\\n -old_towards.v_mid.values,\\n np.abs(old_static.v_mid.values),\\n ]),\\n \\\"direction\\\": ([\\\"away\\\"] * len(old_away) +\\n [\\\"towards\\\"] * len(old_towards) +\\n [\\\"static\\\"] * len(old_static)),\\n })\\n\\n ax = fig.add_subplot(2, 2, 2)\\n ax.set_title(\\\"Old Pole\\\")\\n sns.barplot(\\n x=\\\"direction\\\",\\n y=\\\"v_mid\\\",\\n data=old_set,\\n order=[\\\"towards\\\", \\\"away\\\", \\\"static\\\"],\\n ci=95\\n )\\n ax.set_ylabel(\\\"Velocity (\\\\si{\\\\micro\\\\metre\\\\per\\\\hour})\\\")\\n ax.set_xlabel(\\\"\\\")\\n sns.despine()\\n\\n# _bigax(\\n# fig,\\n# xlabel=(\\\"Velocity (\\\\si{\\\\micro\\\\metre\\\\per\\\\hour})\\\", {\\\"labelpad\\\": 10}),\\n# title=(\\\"Mid-cell\\\", {\\\"y\\\": 1.08}),\\n# spec=(2, 1, 2),\\n# )\\n ax = fig.add_subplot(2, 2, 3)\\n# sns.distplot(new.v_mid, kde=False)\\n# ax.set_title(\\\"New Pole\\\", y=1.08)\\n# ax.set_xlabel(\\\"\\\")\\n# ax.yaxis.set_visible(False)\\n# ax.spines[\\\"left\\\"].set_color(\\\"none\\\")\\n sns.countplot(\\n x=\\\"direction\\\",\\n data=new_set,\\n order=[\\\"towards\\\", \\\"away\\\", \\\"static\\\"],\\n )\\n ax.set_xlabel(\\\"\\\")\\n ax.set_ylabel(\\\"Number of Foci\\\")\\n sns.despine()\\n\\n ax = fig.add_subplot(2, 2, 4)\\n# sns.distplot(old.v_mid, kde=False)\\n# ax.set_title(\\\"Old Pole\\\", y=1.08)\\n# ax.set_xlabel(\\\"\\\")\\n# ax.yaxis.set_visible(False)\\n# ax.spines[\\\"left\\\"].set_color(\\\"none\\\")\\n sns.countplot(\\n x=\\\"direction\\\",\\n data=old_set,\\n order=[\\\"towards\\\", \\\"away\\\", \\\"static\\\"],\\n )\\n ax.set_xlabel(\\\"\\\")\\n ax.set_ylabel(\\\"Number of Foci\\\")\\n sns.despine()\\n\\n plt.tight_layout()\\n\\n fn = os.path.join(\\n \\\"ParB_velocity\\\",\\n \\\"{2}-away-T{0}-N{1}.pdf\\\".format(THRESHOLD, MIN_POINTS, prefix)\\n )\\n print(\\\"Saved file to {0}\\\".format(fn))\\n plt.savefig(fn)\\n plt.close()\",\n \"def adjust_mario_position(self):\\n self.last_x_position = self.mario.rect.right\\n self.mario.rect.x += round(self.mario.x_vel)\\n self.check_mario_x_collisions()\\n\\n if self.mario.in_transition_state == False:\\n self.mario.rect.y += round(self.mario.y_vel)\\n self.check_mario_y_collisions()\",\n \"def front_wheel_from_axis():\",\n \"def _color_twin_axes(ax1, color1, ax2, color2):\\n #spines\\n ax1.spines['left'].set_color(color1)\\n ax1.spines['right'].set_color(color2)\\n ax2.spines['left'].set_color(color1)\\n ax2.spines['right'].set_color(color2)\\n #text\\n ax1.yaxis.label.set_color(color1)\\n ax2.yaxis.label.set_color(color2)\\n #ticks\\n ax1.tick_params(axis = 'y', colors = color1)\\n ax2.tick_params(axis = 'y', colors = color2)\",\n \"def test_axis_with_no_mapping_does_not_error_in_roundtrip_with_2_axes(ufo_module):\\n doc = _make_designspace_with_axes(\\n [(\\\"wght\\\", \\\"Weight with mapping\\\"), (\\\"wdth\\\", \\\"Width without mapping\\\")], ufo_module\\n )\\n # Add mapping to weight axis\\n doc.axes[0].map = [(0, 0), (50, 350), (100, 1000)]\\n\\n doc2 = deepcopy(doc)\\n font = to_glyphs(doc2)\\n doc_rt = to_designspace(font)\\n\\n assert doc_rt.axes[0].serialize() == doc.axes[0].serialize()\\n assert doc_rt.axes[1].serialize() == doc.axes[1].serialize()\",\n \"def rotateAlignToWorld( alignObject, primaryAxisVector = [1, 0, 0], worldAxisToKeep = ['x'], alignTwist = True ):\\n \\n # normalize primary axis vector\\n primaryAxisVectorVec = vector.makeMVector( primaryAxisVector )\\n primaryAxisVectorVec.normalize()\\n primaryAxisVector = [ primaryAxisVectorVec.x, primaryAxisVectorVec.y, primaryAxisVectorVec.z ]\\n \\n \\n axisSign = primaryAxisVector[0] + primaryAxisVector[1] + primaryAxisVector[2]\\n \\n primaryAxisVectorVecMove = primaryAxisVector[:]\\n primaryAxisVector = [ abs( primaryAxisVector[0] ), abs( primaryAxisVector[1] ), abs( primaryAxisVector[2] ) ]\\n \\n # prepare align twist vector\\n allaxis = ['x', 'y', 'z']\\n \\n for axiskeep in worldAxisToKeep:\\n \\n allaxis.remove( axiskeep.lower() )\\n \\n skipUpAxis = allaxis[0]\\n upVectorMove = {'x':[1, 0, 0], 'y':[0, 1, 0], 'z':[0, 0, 1]}[skipUpAxis]\\n upVector = {'x':[1 * axisSign, 0, 0], 'y':[0, 1 * axisSign, 0], 'z':[0, 0, 1 * axisSign]}[skipUpAxis]\\n \\n # prepare align setup\\n prefix = name.removeSuffix( alignObject )\\n \\n alignObjectAim = mc.group( n = prefix + 'alignObjectAim', em = 1, p = alignObject )\\n alignObjectAimUp = mc.group( n = prefix + 'alignObjectAimUp', em = 1, p = alignObject )\\n mc.move( primaryAxisVectorVecMove[0], primaryAxisVectorVecMove[1], primaryAxisVectorVecMove[2], alignObjectAim, objectSpace = True )\\n mc.move( upVectorMove[0], upVectorMove[1], upVectorMove[2], alignObjectAimUp, objectSpace = True )\\n mc.parent( [alignObjectAim, alignObjectAimUp], w = 1 )\\n mc.delete( mc.pointConstraint( alignObject, alignObjectAim, skip = worldAxisToKeep ) )\\n \\n if alignTwist:\\n \\n mc.delete( mc.pointConstraint( alignObject, alignObjectAimUp, skip = skipUpAxis ) )\\n \\n # rotate object\\n mc.delete( mc.aimConstraint( alignObjectAim, alignObject, aim = primaryAxisVector, u = upVector, wut = 'object', wuo = alignObjectAimUp ) )\\n mc.delete( alignObjectAim, alignObjectAimUp )\",\n \"def test_reset_temporal_axis(PM_ds_control_3d_full):\\r\\n smooth = 10\\r\\n tsmooth_kws = {\\\"time\\\": smooth}\\r\\n first_ori = PM_ds_control_3d_full.time[0].values\\r\\n first_actual = _reset_temporal_axis(\\r\\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\\\"time\\\"\\r\\n ).time.values[0]\\r\\n first_expected = f\\\"{first_ori}-{first_ori+smooth*1-1}\\\"\\r\\n assert first_actual == first_expected\",\n \"def _replace_dim(da, olddim, newdim, drop=True):\\n\\n da_new = da.rename({olddim: newdim.name})\\n # note that alignment along a dimension is skipped when you are overriding\\n # the relevant coordinate values\\n da_new .coords[newdim.name] = newdim\\n da_new = da_new.reset_coords(drop=drop)\\n return da_new\",\n \"def test_alternate_channel_axes(conv1d_placeholder, output_size, channel_axis):\\n channel_axis.name = \\\"channel\\\"\\n assert len(conv1d_placeholder.axes.find_by_name(\\\"channel\\\")) == 1\\n\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n with pytest.raises(IncompatibleAxesError):\\n conv_layer(conv1d_placeholder)\\n output = conv_layer(conv1d_placeholder, channel_axes=\\\"channel\\\")\\n assert output.axes == conv1d_placeholder.axes\",\n \"def plot_2d_topomap_intra(ax):\\n\\n # plot first Head \\n N = 300 # number of points for interpolation\\n xy_center = [-0.178,0] # center of the plot\\n radius = 0.1 # radius\\n\\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = xy_center, radius = radius, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n # add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [-0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [-0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n xy = [[-0.151,0.091],[-0.205,0.091], [-0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = xy, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon) \\n \\n\\n # Plot second Head \\n x2y2_center = [0.178,0] # center of the plot\\n radius2 = 0.1 # radius\\n \\n # draw a circle\\n circle = matplotlib.patches.Circle(xy = x2y2_center, radius = radius2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\")\\n ax.add_patch(circle)\\n \\n # make the axis invisible \\n for loc, spine in ax.spines.items():\\n spine.set_linewidth(0)\\n \\n # remove the ticks\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n ## add some body parts. Hide unwanted parts by setting the zorder low\\n # add two ears\\n circle = matplotlib.patches.Ellipse(xy = [0.083,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n circle = matplotlib.patches.Ellipse(xy = [0.273,-0.012], width = 0.025, height = 0.05, angle = 0, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(circle)\\n ## add a nose\\n x2y2 = [[0.151,0.091],[0.205,0.091], [0.178,0.11]]\\n polygon = matplotlib.patches.Polygon(xy = x2y2, edgecolor = \\\"k\\\", facecolor = \\\"w\\\", zorder = 0)\\n ax.add_patch(polygon)\",\n \"def test_overplotting(self):\\n arr = self.arr\\n out = ternary(arr)\\n self.assertTrue(hasattr(out, \\\"tax\\\"))\\n out2 = ternary(arr, ax=out)\\n self.assertTrue(out.tax is out2.tax) # hasn't added a new ternary axis\",\n \"def set_axes(self, a):\\r\\n self.axes = a\",\n \"def explode_along_axis(self, axis):\\n # If axis is -ve then calculate the axis from the length of the dimensions of one cube\\n if axis < 0:\\n axis = len(self.dimensions) + axis\\n # To store the resultant cube\\n result_cubes = []\\n # All slices are initially initialised as slice(None, None, None)\\n cube_slices = [slice(None, None, None)] * self.data.ndim\\n # Slicing the cube inside result_cube\\n for i in range(self.data.shape[axis]):\\n # Setting the slice value to the index so that the slices are done correctly.\\n cube_slices[axis] = i\\n # Set to None the metadata of sliced cubes.\\n item = tuple(cube_slices)\\n sliced_cube = self[item]\\n sliced_cube.meta = None\\n # Appending the sliced cubes in the result_cube list\\n result_cubes.append(sliced_cube)\\n # Creating a new NDCubeSequence with the result_cubes and common axis as axis\\n return NDCubeSequence(result_cubes, meta=self.meta)\",\n \"def _filter_axes(self, channel_axis, spatial_axes):\\n f_axes = ng.make_axis(length=self.nout, name=\\\"K\\\")\\n for key, ax in zip(\\\"DHW\\\", spatial_axes):\\n f_axes += ng.make_axis(length=self.filter_shape[key],\\n name=ax.name)\\n f_axes += channel_axis\\n return f_axes\",\n \"def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\\n common_axis_lengths):\\n cumul_lengths = np.cumsum(common_axis_lengths)\\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\\n if sequence_index == 0:\\n common_axis_index = cube_like_index\\n else:\\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\\n return sequence_index, common_axis_index\",\n \"def align_yaxis(ax1,v1,ax2,v2):\\n _, y1 = ax1.transData.transform((0,v1))\\n _, y2 = ax2.transData.transform((0,v2))\\n inv = ax2.transData.inverted()\\n _, dy = inv.transform((0,0)) - inv.transform((0,y1-y2))\\n miny, maxy = ax2.get_ylim()\\n ax2.set_ylim(miny+dy,maxy+dy)\",\n \"def SwapAxis(self, axis0, axis1):\\n\\n axis0 = int(axis0)\\n axis1 = int(axis1)\\n\\n self.points[:,[axis0,axis1]] = self.points[:,[axis1,axis0]]\",\n \"def _share_short_axis(self, share, side, level):\\n if share is None or self._panel_side: # not None\\n return\\n s = side[0]\\n axis = 'x' if s in 'lr' else 'y'\\n caxs = getattr(self, '_' + s + 'panels')\\n paxs = getattr(share, '_' + s + 'panels')\\n caxs = [pax for pax in caxs if not pax._panel_filled]\\n paxs = [pax for pax in paxs if not pax._panel_filled]\\n for cax, pax in zip(caxs, paxs): # may be uneven\\n getattr(cax, '_share' + axis + '_setup')(pax, level)\",\n \"def change_axes_geometry_stack(fig, ax, naxes):\\n for ii in range(len(ax)):\\n geometry = (naxes, 1, ii + 1)\\n if ax[ii].get_geometry() != geometry:\\n ax[ii].change_geometry(*geometry)\\n\\n for ii in np.arange(len(ax), naxes):\\n print('adding axis ', ii)\\n fig.add_subplot(naxes, 1, ii + 1)\\n\\n ax = fig.axes\\n return fig, ax\",\n \"def onAxisLogScaleChanged(self, axis_name, on):\\n if axis_name in self.axes:\\n # take the old axis and replace it with the new one\\n old_axis = self.axes[axis_name]\\n if on:\\n new_axis = QtChart.QLogValueAxis()\\n else:\\n new_axis = QtChart.QValueAxis()\\n\\n # copy the values from old_axis into new_axis\\n new_axis.setRange(old_axis.min(), old_axis.max())\\n new_axis.setVisible(old_axis.isVisible())\\n new_axis.setGridLineVisible(old_axis.isGridLineVisible())\\n new_axis.setTitleText(old_axis.titleText())\\n self.axes[axis_name] = new_axis\\n\\n # swap the old axis for the new one in chart and all series\\n # attached to old_axis\\n self.chart().addAxis(self.axes[axis_name],\\n self.axis_alignment[axis_name])\\n for unused_name, series in self.series.items():\\n if old_axis in series.attachedAxes():\\n series.detachAxis(old_axis)\\n series.attachAxis(new_axis)\\n self.chart().removeAxis(old_axis)\",\n \"def reconfig_to_datetime(all_files, datetime_axis, time_freq, nrows=1):\\n\\n new_ydata = {}\\n max_primary = max_secondary = float(\\\"-inf\\\")\\n min_primary = min_secondary = float(\\\"inf\\\")\\n for key, value in all_files.iteritems():\\n \\n\\tassert isinstance(value, nio.InputData)\\n\\t\\n\\t# Convert original xaxis to datetime objects #\\n\\t\\n\\torig_dtaxis = value.datetimes\\n\\t\\n\\t# Check the start point of original xaxis against the new datetime_axis #\\n\\t\\n\\tmissval = value.data.missing_value\\n\\tydata = value.data[:]\\n\\t\\n if orig_dtaxis[0] in datetime_axis[:]:\\n\\t nfill = rrule(eval(time_freq), dtstart=datetime_axis[0], until=orig_dtaxis[0]).count() - 1\\n\\t for i in xrange(nfill):\\n\\t ydata = numpy.insert(ydata, 0, missval)\\n\\telse:\\n\\t ystart = orig_dtaxis[:].index(datetime_axis[0])\\n\\t ydata = ydata[ystart:]\\n\\t orig_dtaxis = orig_dtaxis[ystart:]\\n\\t\\t \\n # Check the end point of original xaxis against the new datetime_axis #\\n\\t\\n if orig_dtaxis[-1] in datetime_axis[:]:\\n nfill = rrule(eval(time_freq), dtstart=orig_dtaxis[-1], until=datetime_axis[-1]).count() - 1\\n\\t for i in xrange(nfill):\\n\\t ydata = numpy.append(ydata, missval)\\n else:\\n\\t yend = orig_dtaxis[:].index(datetime_axis[-1]) + 1\\n ydata = ydata[:yend]\\n\\n # Update the minimum and maximum value #\\n\\n ydata = numpy.ma.masked_values(ydata, missval)\\n\\n if value.set == 'primary':\\n max_primary, min_primary = nio.hi_lo(ydata, max_primary, min_primary)\\n elif value.set == 'secondary':\\n max_secondary, min_secondary = nio.hi_lo(ydata, max_secondary, min_secondary)\\n\\n new_ydata[key] = YaxisElement(split_nrows(ydata, nrows), \\n all_files[key].tag, \\n all_files[key].set)\\n \\n primary_bounds = (min_primary, max_primary)\\n secondary_bounds = None if max_secondary == float(\\\"inf\\\") else (min_secondary, max_secondary)\\n\\n\\n return new_ydata, primary_bounds, secondary_bounds\",\n \"def set_primeScaleAxis(control = None, primeAxis = None, slaveOthers = False, alias = None): \\n _str_func = 'set_primeAxis'\\n _l = ['X','Y','Z']\\n _primeAxis = cgmValid.kw_fromList(primeAxis, _l)\\n _idx = _l.index(_primeAxis)\\n _attr_prime = 'scale{0}'.format(_primeAxis)\\n \\n _l_others = []\\n for i,v in enumerate(_l):\\n if i != _idx:\\n _l_others.append(v)\\n \\n log.debug(\\\"{0} || control:{1}\\\".format(_str_func,control)) \\n log.debug(\\\"{0} || primeAxis:{1}\\\".format(_str_func,_primeAxis))\\n log.debug(\\\"{0} || slaveOthers:{1}\\\".format(_str_func,slaveOthers))\\n log.debug(\\\"{0} || alias:{1}\\\".format(_str_func,alias))\\n log.debug(\\\"{0} || prime attr:{1}\\\".format(_str_func,_attr_prime))\\n log.debug(\\\"{0} || other attrs:{1}\\\".format(_str_func,_l_others))\\n \\n if alias:\\n coreAttr.alias_set(\\\"{0}.{1}\\\".format(control,_attr_prime),alias)\\n \\n for attr in _l_others:\\n if slaveOthers:\\n try:attributes.doConnectAttr(\\\"{0}.{1}\\\".format(control,_attr_prime),\\n \\\"{0}.scale{1}\\\".format(control,attr.capitalize()),\\n transferConnection=True)\\n except:pass\\n attributes.doSetLockHideKeyableAttr(control, lock = True, visible= False, keyable=False, channels=['s{0}'.format(attr.lower())])\\n \\n return True\",\n \"def moveaxis(a, source, destination):\\n a = astensor(a)\\n\\n source = normalize_axis_tuple(source, a.ndim, \\\"source\\\")\\n destination = normalize_axis_tuple(destination, a.ndim, \\\"destination\\\")\\n if len(source) != len(destination):\\n raise ValueError(\\n \\\"`source` and `destination` arguments must have \\\"\\n \\\"the same number of elements\\\"\\n )\\n\\n order = [n for n in range(a.ndim) if n not in source]\\n\\n for dest, src in sorted(zip(destination, source)):\\n order.insert(dest, src)\\n\\n return transpose(a, order)\",\n \"def _swap_axis(input_tensor, dim_index, last_index, name=None):\\n return array_ops.transpose(\\n input_tensor,\\n array_ops.concat([\\n math_ops.range(dim_index), [last_index],\\n math_ops.range(dim_index + 1, last_index), [dim_index]\\n ], 0),\\n name=name)\",\n \"def _update_axislabels(self, x='x', **kwargs):\\n if x not in 'xy':\\n return\\n # Update label on this axes\\n axis = getattr(self, x + 'axis')\\n axis.label.update(kwargs)\\n kwargs.pop('color', None)\\n\\n # Defer to parent (main) axes if possible, then get the axes\\n # shared by that parent\\n ax = self._panel_parent or self\\n ax = getattr(ax, '_share' + x) or ax\\n\\n # Apply to spanning axes and their panels\\n axs = [ax]\\n if getattr(ax.figure, '_span' + x):\\n s = axis.get_label_position()[0]\\n if s in 'lb':\\n axs = ax._get_side_axes(s)\\n for ax in axs:\\n getattr(ax, x + 'axis').label.update(kwargs) # apply to main axes\\n pax = getattr(ax, '_share' + x)\\n if pax is not None: # apply to panel?\\n getattr(pax, x + 'axis').label.update(kwargs)\",\n \"def fix_axes_ticks(self, axis='x', style=None, dtype=float, N=None, \\n rotate_x=False, rotate_y=False):\\n \\n # Grab functions we need by name\\n get_lim = \\\"get_{!s}lim\\\".format(axis)\\n get_ticks = \\\"get_{!s}ticks\\\".format(axis)\\n get_ticklabels = \\\"get_{!s}ticklabels\\\".format(axis)\\n set_ticks = \\\"set_{!s}ticks\\\".format(axis)\\n set_ticklabels = \\\"set_{!s}ticklabels\\\".format(axis)\\n shared = eval(\\\"self.share_{!s}\\\".format(axis))\\n \\n # Get locations of ticks on bottom row\\n if axis is 'x':\\n ticks_by_col = []\\n for i in self.bottom:\\n ticks_by_col.append(self.grid[i].get_xticks())\\n \\n # Get locations of ticks on left column\\n if axis is 'y':\\n ticks_by_row = []\\n for i in self.left:\\n ticks_by_row.append(self.grid[i].get_xticks())\\n \\n # Figure out if axes are shared or not\\n if axis == 'x':\\n j = 0\\n if shared:\\n axes = self.xaxes\\n else:\\n axes = np.arange(self.N)\\n elif axis == 'y':\\n j = 1\\n if shared:\\n axes = self.yaxes\\n else:\\n axes = np.arange(self.N)\\n else:\\n raise ValueError('axis must be set to \\\\'x\\\\' or \\\\'y\\\\'')\\n \\n if not shared:\\n return\\n \\n # Loop over axes and make corrections\\n for i in axes:\\n \\n # Skip non-existent elements\\n if self.diagonal:\\n if self.above_diagonal(i):\\n continue\\n \\n if self.grid[i] is None:\\n continue\\n\\n # Retrieve current ticks, tick-spacings, and axis limits\\n ticks = eval(\\\"list(self.grid[{0}].{1!s}())\\\".format(i, get_ticks))\\n\\n if not ticks:\\n continue\\n \\n # Get all the info for current set of ticks\\n ticklabels = eval((\\\"[tick for tick in \\\" +\\\\\\n \\\"self.grid[{0}].{1!s}()]\\\").format(i, get_ticklabels))\\n \\n labels = [] \\n for tick in ticklabels: \\n l = tick.get_text()\\n \\n # Minus signs are weird in unicode...\\n try:\\n assert isinstance(l, unicode)\\n except:\\n new = l\\n else:\\n if u'\\\\u2212' in l:\\n new = '-' + l.encode('ascii', 'ignore')\\n else:\\n new = l.encode('ascii', 'ignore') \\n \\n labels.append(new)\\n \\n Nticks = len(labels) \\n dt = np.diff(ticks)[0] \\n \\n # Axes limits\\n limits = eval(\\\"self.grid[{0}].{1!s}()\\\".format(i, get_lim))\\n \\n # column or row number. Need this to know whether or not to...?\\n pos = self.axis_position(i)[j]\\n\\n # Determine if we're chopping off the first and/or last tick mark\\n # e.g., if the axes are adjoined\\n ul = None\\n if shared and pos < (self.dims[int(not j)] - 1):\\n ul = -1\\n \\n ll = 0 \\n \\n # If number of ticks was specified by hand \\n if N is not None:\\n mi, ma = round(limits[0], 1), round(limits[1], 1)\\n \\n prec = 2\\n while mi == ma:\\n mi, ma = round(limits[0], prec), round(limits[1], prec)\\n prec += 1\\n\\n dt = (ma - mi) / float(N)\\n\\n if dt < 1:\\n dt = np.round(dt, abs(int(np.log10(dt))) + 1)\\n ticks = np.arange(mi, mi + (N+1)*dt, dt)\\n else:\\n ticks = np.round(np.linspace(mi, ma, N), 1)\\n \\n labels = ['{0:g}'.format(val) for val in ticks]\\n \\n if (axis == 'x' and rotate_x):\\n rotate = rotate_x\\n elif (axis == 'y' and rotate_y):\\n rotate = rotate_y\\n else:\\n rotate = False\\n \\n if ul is None:\\n eval(\\\"self.grid[{0}].{1!s}(ticks)\\\".format(i, set_ticks))\\n \\n if rotate:\\n if type(rotate) == bool:\\n eval((\\\"self.grid[{0}].{1!s}(labels, \\\" +\\\\\\n \\\"rotation=90)\\\").format(i, set_ticklabels))\\n else:\\n eval((\\\"self.grid[{0}].{1!s}(labels, \\\" +\\\\\\n \\\"rotation={2:g})\\\").format(i, set_ticklabels,\\\\\\n rotate)) \\n else:\\n eval(\\\"self.grid[{0}].{1!s}(labels)\\\".format(i,\\\\\\n set_ticklabels))\\n else:\\n eval(\\\"self.grid[{0}].{1!s}(ticks[{2}:{3}])\\\".format(i,\\\\\\n set_ticks, ll, ul))\\n\\n if rotate:\\n if type(rotate) == bool:\\n eval((\\\"self.grid[{0}].{1!s}(labels[{2}:{3}], \\\" +\\\\\\n \\\"rotation=90)\\\").format(i, set_ticklabels, ll, ul))\\n else:\\n eval((\\\"self.grid[{0}].{1!s}(labels[{2}:{3}], \\\" +\\\\\\n \\\"rotation={4:g})\\\").format(i, set_ticklabels, ll,\\\\\\n ul, rotate)) \\n else:\\n eval(\\\"self.grid[{0}].{1!s}(labels[{2}:{3}])\\\".format(i,\\\\\\n set_ticklabels, ll, ul))\\n \\n if style is not None: \\n self.grid[i].ticklabel_format(style=style)\\n \\n # Loop over columns, force those not in row 0 to share ticks with \\n # whatever tick marks there are in row #0\\n if axis == 'x':\\n for k in range(len(self.elements_by_column)):\\n loc = self.axis_number(0, k)\\n xticks = self.grid[loc].get_xticks()\\n xticks = [round(tick, 3) for tick in xticks]\\n xlim = [round(lim, 3) for lim in self.grid[loc].get_xlim()]\\n \\n xticks = [0 if abs(tick) < 1e-8 * max(np.abs(xticks)) else tick \\\\\\n for tick in xticks]\\n \\n for h, element in enumerate(self.elements_by_column[k]):\\n if element in self.bottom:\\n continue \\n \\n self.grid[element].set_xticks(xticks)\\n self.grid[element].set_xlim(xlim)\\n \\n # Same deal for y ticks\\n if axis == 'y':\\n for k in range(len(self.elements_by_row)):\\n loc = self.axis_number(k, 0)\\n yticks = self.grid[loc].get_yticks()\\n yticks = [round(tick, 3) for tick in yticks]\\n ylim = [round(lim, 3) for lim in self.grid[loc].get_ylim()]\\n \\n yticks = [0 if abs(tick) < 1e-8 * max(np.abs(yticks)) else tick \\\\\\n for tick in yticks]\\n \\n for h, element in enumerate(self.elements_by_row[k]):\\n if element in self.left:\\n continue \\n if self.diag is not None:\\n if element in self.diag:\\n continue \\n \\n self.grid[element].set_yticks(yticks)\\n self.grid[element].set_ylim(ylim)\\n \\n # Remove ticklabels of interior panels completely\\n if shared:\\n for k in range(self.N):\\n if self.grid[k] is None:\\n continue\\n \\n if (self.diagonal is not None):\\n if self.above_diagonal(k):\\n continue\\n \\n if k not in axes:\\n eval(\\\"self.grid[{0}].{1!s}([])\\\".format(k, set_ticklabels))\\n \\n pl.draw()\",\n \"def test_axis_preservation(conv1d_placeholder, output_size):\\n conv_layer = Convolution((3, output_size), lambda x: 1)\\n output = conv_layer(conv1d_placeholder)\\n assert output.axes == conv1d_placeholder.axes, (\\\"Output axes are not the same as input axes: \\\"\\n \\\"{} != {}\\\").format(output.axes,\\n conv1d_placeholder.axes)\",\n \"def set_axes_equal(ax):\\n\\n x_limits = ax.get_xlim3d()\\n y_limits = ax.get_ylim3d()\\n z_limits = ax.get_zlim3d()\\n\\n x_range = abs(x_limits[1] - x_limits[0])\\n x_middle = np.mean(x_limits)\\n y_range = abs(y_limits[1] - y_limits[0])\\n y_middle = np.mean(y_limits)\\n z_range = abs(z_limits[1] - z_limits[0])\\n z_middle = np.mean(z_limits)\\n\\n # The plot bounding box is a sphere in the sense of the infinity\\n # norm, hence I call half the max range the plot radius.\\n plot_radius = 0.5*max([x_range, y_range, z_range])\\n\\n ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\\n ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\\n ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])\",\n \"def set_axes_equal(ax):\\n\\n x_limits = ax.get_xlim3d()\\n y_limits = ax.get_ylim3d()\\n z_limits = ax.get_zlim3d()\\n\\n x_range = abs(x_limits[1] - x_limits[0])\\n x_middle = np.mean(x_limits)\\n y_range = abs(y_limits[1] - y_limits[0])\\n y_middle = np.mean(y_limits)\\n z_range = abs(z_limits[1] - z_limits[0])\\n z_middle = np.mean(z_limits)\\n\\n # The plot bounding box is a sphere in the sense of the infinity\\n # norm, hence I call half the max range the plot radius.\\n plot_radius = 0.5*max([x_range, y_range, z_range])\\n\\n ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\\n ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\\n ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])\",\n \"def replot(self,ax):\\n self.XP_Plotter.replot(ax)\\n # theoretical lines\\n self.lines_theory[0].set_xdata(self.xx)\\n self.lines_theory[1].set_xdata(self.xx)\\n self.lines_theory[2].set_xdata(self.xx_itpl)\\n for line in self.lines_theory: \\n ax.draw_artist(line)\",\n \"def setup_axes2(fig, rect,tmin, tmax,zmin,zmax):\\n\\n tr =PolarAxes.PolarTransform()\\n pi = np.pi\\n\\n angle_ticks = [(tmin, '%.2f' % tmin), (0,r'$0$'), (tmax, '%.2f' % tmax)]\\n\\n grid_locator1 = FixedLocator([v for v, s in angle_ticks])\\n tick_formatter1 = DictFormatter(dict(angle_ticks))\\n\\n grid_locator2 = MaxNLocator(4)\\n\\n grid_helper = floating_axes.GridHelperCurveLinear(\\n tr, extremes=(tmax, tmin, zmax, zmin),\\n grid_locator1=grid_locator1,\\n grid_locator2=grid_locator2,\\n tick_formatter1=tick_formatter1,\\n tick_formatter2=None)\\n\\n ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)\\n fig.add_subplot(ax1)\\n\\n # create a parasite axes whose transData in RA, cz\\n aux_ax = ax1.get_aux_axes(tr)\\n\\n aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax\\n ax1.patch.zorder = 0.95 # but this has a side effect that the patch is\\n # drawn twice, and possibly over some other\\n # artists. So, we decrease the zorder a bit to\\n # prevent this.\\n\\n return ax1, aux_ax\",\n \"def getAxisValuesEvent(self): \\n varID = self.myParent.getVar().id\\n axisVar = MV2.array(self.axis)\\n axisVar.setAxis(0, self.axis)\\n axisVar.id = varID +'_' + self.axis.id + '_axis'\\n\\n # Generate teaching command string\\n fileID = 'fid2'\\n teachingCommand = \\\"\\\\n## Getting axis %s\\\\n\\\" % self.axis.id\\n teachingCommand += \\\"%s = MV2.array(%s[\\\\\\\"%s\\\\\\\"].getAxisList(axes = \\\\\\\"%s\\\\\\\")[0][:])\\\\n\\\" % (axisVar.id, fileID, varID, self.axis.id)\\n teachingCommand += \\\"%s.setAxis(0, %s[\\\\\\\"%s\\\\\\\"].getAxisList(axes = \\\\\\\"%s\\\\\\\")[0])\\\\n\\\" % (axisVar.id, fileID, varID, self.axis.id)\\n teachingCommand += \\\"%s.id = \\\\\\\"%s\\\\\\\"\\\\n\\\" % (axisVar.id, axisVar.id)\\n\\n # Record teaching commands associate 'get axis values' and\\n # define a new variable/tab with only the axis' values \\n self.myParent.defineVarAxis(axisVar, teachingCommand)\",\n \"def _handle_setup_axis(self, axis_args):\\n axis_name = axis_args['name']\\n axes_dict = self.server.axes\\n\\n if axis_name not in [name for name, _ in axes_dict.items()]:\\n print \\\"Adding a new axis:\\\", axis_name\\n axis_count = len(axes_dict)\\n newaxis = self.server.figure.add_subplot(axis_count+1, 1, axis_count+1)\\n axes_dict[axis_name] = newaxis\\n axes_dict[axis_name].grid(True)\\n axes_dict[axis_name].set_xlabel(axis_args['x_label'])\\n axes_dict[axis_name].set_ylabel(axis_args['y_label'])\\n # TODO: support *.set_title(\\\"Title\\\")\\n if FLAGS.logy:\\n axes_dict[axis_name].set_yscale('log', nonposy='clip')\\n\\n if axis_count != 0:\\n # Resize other axes if the above wasn't the first.\\n axis_count = len(axes_dict)\\n for row,(name, _) in enumerate(axes_dict.items(), 1):\\n print name, axis_count, row\\n axes_dict[name].change_geometry(axis_count, 1, row)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5527314","0.5408021","0.5342411","0.52576274","0.52193874","0.52078605","0.5200823","0.5182296","0.5143223","0.5039198","0.5026079","0.49834254","0.49665734","0.48400095","0.48353782","0.48336178","0.4820047","0.48099452","0.4761784","0.47465044","0.47106996","0.47098395","0.46774116","0.4657304","0.4640464","0.46337345","0.4628509","0.46209556","0.4620678","0.46194112","0.46124333","0.45943525","0.45860603","0.4582998","0.45708323","0.45626533","0.45330098","0.45313403","0.45307943","0.4524911","0.44937596","0.44860083","0.44727045","0.4461264","0.44475853","0.44473583","0.44396016","0.44342983","0.44277468","0.44272006","0.4427158","0.442668","0.44149682","0.44083515","0.44046718","0.44038078","0.4392888","0.4390588","0.43886656","0.4382994","0.4372816","0.43712586","0.4368655","0.43661246","0.43610275","0.43556568","0.43479714","0.4347063","0.43386325","0.43296254","0.43271124","0.432591","0.43220624","0.43212792","0.43186498","0.4313863","0.43112618","0.43086722","0.43073177","0.430051","0.4295413","0.42931083","0.42869505","0.428444","0.42838046","0.4282509","0.42811838","0.42806685","0.4275882","0.42702356","0.42701015","0.4268128","0.42619005","0.4260127","0.4257969","0.4257969","0.42507812","0.42443797","0.42438138","0.4243142"],"string":"[\n \"0.5527314\",\n \"0.5408021\",\n \"0.5342411\",\n \"0.52576274\",\n \"0.52193874\",\n \"0.52078605\",\n \"0.5200823\",\n \"0.5182296\",\n \"0.5143223\",\n \"0.5039198\",\n \"0.5026079\",\n \"0.49834254\",\n \"0.49665734\",\n \"0.48400095\",\n \"0.48353782\",\n \"0.48336178\",\n \"0.4820047\",\n \"0.48099452\",\n \"0.4761784\",\n \"0.47465044\",\n \"0.47106996\",\n \"0.47098395\",\n \"0.46774116\",\n \"0.4657304\",\n \"0.4640464\",\n \"0.46337345\",\n \"0.4628509\",\n \"0.46209556\",\n \"0.4620678\",\n \"0.46194112\",\n \"0.46124333\",\n \"0.45943525\",\n \"0.45860603\",\n \"0.4582998\",\n \"0.45708323\",\n \"0.45626533\",\n \"0.45330098\",\n \"0.45313403\",\n \"0.45307943\",\n \"0.4524911\",\n \"0.44937596\",\n \"0.44860083\",\n \"0.44727045\",\n \"0.4461264\",\n \"0.44475853\",\n \"0.44473583\",\n \"0.44396016\",\n \"0.44342983\",\n \"0.44277468\",\n \"0.44272006\",\n \"0.4427158\",\n \"0.442668\",\n \"0.44149682\",\n \"0.44083515\",\n \"0.44046718\",\n \"0.44038078\",\n \"0.4392888\",\n \"0.4390588\",\n \"0.43886656\",\n \"0.4382994\",\n \"0.4372816\",\n \"0.43712586\",\n \"0.4368655\",\n \"0.43661246\",\n \"0.43610275\",\n \"0.43556568\",\n \"0.43479714\",\n \"0.4347063\",\n \"0.43386325\",\n \"0.43296254\",\n \"0.43271124\",\n \"0.432591\",\n \"0.43220624\",\n \"0.43212792\",\n \"0.43186498\",\n \"0.4313863\",\n \"0.43112618\",\n \"0.43086722\",\n \"0.43073177\",\n \"0.430051\",\n \"0.4295413\",\n \"0.42931083\",\n \"0.42869505\",\n \"0.428444\",\n \"0.42838046\",\n \"0.4282509\",\n \"0.42811838\",\n \"0.42806685\",\n \"0.4275882\",\n \"0.42702356\",\n \"0.42701015\",\n \"0.4268128\",\n \"0.42619005\",\n \"0.4260127\",\n \"0.4257969\",\n \"0.4257969\",\n \"0.42507812\",\n \"0.42443797\",\n \"0.42438138\",\n \"0.4243142\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71285164"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19894,"cells":{"query":{"kind":"string","value":"From a filename, extracts the first part of the filename as the possible name of a family of files; e.g. from 'ts_Amon_bcccsm11_amip_r1i1p1_197901200812.nc' extract and return 'ts_Amon_bcccsm11_amip_r1i1p1'. To distinguish between the end of a file family name and the beginning of the filespecific part of the filename, we look for an underscore and two numerical digits, e.g. '_19'."},"document":{"kind":"string","value":"def extract_filefamilyname( self, filename ):\n matchobject = re.search( r\"^.*_\\d\\d\", filename )\n if matchobject is None:\n return filename\n else:\n familyname = filename[0:(matchobject.end()-3)]\n return familyname"},"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 reFileName(str_):\n rv = 'None', str_\n m = re.match(r'((?:[a-zA-Z0-9-]){4,})_(.*)$', str_)\n if m:\n rv = m.group(1), m.group(2)\n else:\n m = re.match(r'(\\d+-\\d+)\\.-\\.(.*)$', str_)\n if m:\n rv = m.group(1), m.group(2)\n return rv","def parse_rarefaction_fname(name_string):\r\n\r\n root, ext = os.path.splitext(name_string)\r\n root_list = root.split(\"_\")\r\n iters = int(root_list.pop())\r\n seqs_per_sam = int(root_list.pop())\r\n base_name = \"_\".join(root_list)\r\n return base_name, seqs_per_sam, iters, ext","def parse_filename(cls, filename):\n words = filename.split('_')\n return words[0], int(words[1][1:]), int(words[2])","def _get_aso_id_from_file_name(self, filename: str) -> str:\n id_parts = filename.split('/')\n prefix = id_parts[1]\n suffix = id_parts[-1].split('.')[0].zfill(3)\n if len(suffix) == 5:\n return suffix\n else:\n return prefix + suffix","def extract_filename(str):\n regex = r\"([0-9_-]+).jpg\"\n matches = re.search(regex, str)\n if matches:\n return matches.group(1)","def split_name(filename):\n # *********** My filename are in the format ./CaAl2Si2O8_T3_nvt_a12.5.outcar.msd.dat\n # ******* so I can split their name with _ and take the compound and T from their name\n filename = filename.strip('./')\n temperature = filename.split('_')[1]\n acell = filename.split('.outcar')[0].split('_')[3].strip('a')\n return temperature, acell","def split_name(filename):\n # *********** My filename are in the format ./CaAl2Si2O8_T3_nvt_a12.5.\n # ******* so I can split their name with _ and take the compound and T from their name\n filename = filename.strip('./')\n temperature = str(int(float(filename.split('_')[1].strip('T'))*1000))\n acell = filename.split('_')[3].split('.outcar')[0].strip('a')\n return temperature, acell","def genBaseName(fileName):\n return fileName.split(\"_\")[0].split(\".\")[0]","def get_name_from_filename(filename):\n return filename[:-4]","def splitFilename(filename):\n\n if filename[-4:] == '.rpm':\n filename = filename[:-4]\n \n archIndex = filename.rfind('.')\n arch = filename[archIndex+1:]\n\n relIndex = filename[:archIndex].rfind('-')\n rel = filename[relIndex+1:archIndex]\n\n verIndex = filename[:relIndex].rfind('-')\n ver = filename[verIndex+1:relIndex]\n\n epochIndex = filename.find(':')\n if epochIndex == -1:\n epoch = ''\n else:\n epoch = filename[:epochIndex]\n \n name = filename[epochIndex + 1:verIndex]\n return name, ver, rel, epoch, arch","def get_name_from_file(filename):\n return filename.split(\".\")[0]","def prefix_from_filename(input_file):\n prefix = \"\"\n \n if str(input_file).find(\"medication_bner_\") != -1:\n prefix = \"drugbank\"\n elif str(input_file).find(\"_bc5cdr\") != -1:\n prefix = \"bc5cdr\"\n elif str(input_file).find(\"_bionlp13cg\") != -1:\n prefix = \"bionlp13cg\"\n \n return prefix","def split_file_name(file_path):\n file_name = os.path.splitext(file_path)[0]\n file_name = os.path.split(file_name)[1]\n\n return file_name","def get_fname(a_file):\r\n fname, fext = os.path.splitext(a_file)\r\n return os.path.basename(fname)","def get_fname(a_file):\r\n fname, fext = os.path.splitext(a_file)\r\n return os.path.basename(fname)","def get_fixed_filename(filename):\n new_name = \"\"\n for i, char in enumerate(filename):\n if i + 1 != len(filename):\n previous_character = filename[i - 1]\n next_character = filename[i + 1]\n if char.islower() and next_character.isupper():\n new_name += char + \"_\"\n elif previous_character == \".\":\n new_name += char\n elif char.islower() and not previous_character.isalpha():\n new_name += char.upper()\n else:\n new_name += char\n else:\n new_name += char\n new_name = new_name.replace(\" \", \"_\").replace(\".TXT\", \".txt\")\n return new_name","def decompose_newstyle_name(filename):\n path, parts, ext = _get_fields(filename)\n observatory = parts[0]\n serial = list_get(parts, 3, \"\")\n\n if ext == \".pmap\":\n assert len(parts) in [1,2], \"Invalid .pmap filename \" + repr(filename)\n instrument, filekind = \"\", \"\"\n serial = list_get(parts, 1, \"\")\n elif ext == \".imap\":\n assert len(parts) in [2,3], \"Invalid .imap filename \" + repr(filename)\n instrument = parts[1]\n filekind = \"\"\n serial = list_get(parts, 2, \"\")\n else:\n assert len(parts) in [3,4], \"Invalid filename \" + repr(filename)\n instrument = parts[1]\n filekind = parts[2]\n serial = list_get(parts, 3, \"\")\n\n # Don't include filename in these or it messes up crds.certify unique error tracking.\n\n assert instrument in INSTRUMENTS+[\"\"], \"Invalid instrument \" + repr(instrument)\n assert filekind in FILEKINDS+[\"\"], \"Invalid filekind \" + repr(filekind)\n assert re.match(r\"\\d*\", serial), \"Invalid id field \" + repr(id)\n # extension may vary for upload temporary files.\n\n return path, observatory, instrument, filekind, serial, ext","def guessFilePrefix(self, filename):\n count = 0\n lim = None\n for i in range(len(filename)):\n if filename[i] == \".\":\n break\n\n try:\n int(filename[i])\n\n if lim is None:\n lim = count\n\n except ValueError:\n lim = None\n\n count += 1\n\n if lim is None:\n array = os.path.splitext(filename)\n\n if array[1] == '.gz' or array[1] == '.bz2':\n array = os.path.splitext(array[0])\n\n filename = array[0]\n\n else:\n filename = filename[:lim]\n\n return filename","def extract_file_name(file_path):\n # ファイルパスからファイル名(拡張子含む)を取り出す\n file_name = file_path.split('/')[-1]\n # 拡張子を取り除く\n return file_name.split('.')[0]","def clean_filename(file):\r\n\r\n return file.split('.')[0]","def basefname(fname):\n return os.path.splitext(fname.split(\"\\\\\")[-1])[0]","def get_fixed_filename(filename):\n\n filename = filename.replace(\".TXT\", \".txt\")\n new_name = \"\"\n space_preceding = False\n bracket_preceding = False\n\n for letter in filename:\n if letter.isspace() or letter == \"_\":\n space_preceding = True\n new_name = new_name + \"_\"\n elif letter == \"(\":\n bracket_preceding = True\n elif letter.isupper():\n if new_name != \"\" and not space_preceding and not bracket_preceding:\n new_name = new_name + \"_\"\n if not (letter.isspace() or letter == \"_\"):\n if space_preceding:\n letter = letter.upper()\n space_preceding = False\n new_name = new_name + letter\n\n return new_name","def getFileName(filepath):\n return os.path.splitext(os.path.basename(filepath))[0]","def get_date_from_filename(file_path):\n file_name = basename(file_path)\n name, _ = splitext(file_name)\n _, date = name.split('_')\n\n return date","def extractFileName(fileType, modelName, modelVersion, modelState):\n fileName = '{}_{}_{}'.format(modelName, modelVersion, fileType) if modelState == 'national' else '{}_{}_{}_{}'.format(modelName, modelVersion, modelState, fileType)\n return fileName","def scrub_underscore_suffix(filename):\n scrubbed = re.sub(r\"_[^_]+\\.\", \".\", filename)\n return scrubbed","def get_extension_from_filename(filename):\n return filename[-4:]","def filename_ext(filename):\n base = os.path.basename(filename)\n return os.path.splitext(base)[1][1:]","def get_file_name(filepath: str) -> str:\n\n f = os.path.basename(filepath)\n filename, _ = os.path.splitext(f)\n\n return filename","def get_file_name(file):\n return os.path.splitext(os.path.basename(file))[0]","def filter_filename(self, fname):\r\n return os.path.basename(fname)","def file_name(path):\n return os.path.basename(path).split('.')[0]","def get_fixed_filename(filename):\n initial_changed_name = filename.replace(\" \", \"_\").replace(\".TXT\", \".txt\")\n previous_character = \"\"\n new_name = \"\"\n for i, character in enumerate(initial_changed_name):\n current_character = character\n if previous_character == \"_\" and current_character.islower():\n new_name += current_character.upper()\n elif previous_character == \"(\" and current_character.islower():\n new_name += current_character.upper()\n elif previous_character.islower() and current_character.isupper():\n new_name += \"_{}\".format(current_character)\n else:\n new_name += current_character\n previous_character = character\n return new_name","def valid_file_name(s: str) -> str:\n global UNICODE_FILENAMES, FILESYSTEM_IS_LINUX\n if FILESYSTEM_IS_LINUX:\n s = fix_linux.sub(\"_\", s)\n else:\n s = fix_windows.sub(\"_\", s)\n s = fix_windows_ending.split(s)[0]\n\n if not UNICODE_FILENAMES:\n s = fix_unicode.sub(\"_\", s)\n return s","def get_filename(file_path):\n\n # Get rid of directories and etc\n just_file = os.path.basename(file_path)\n\n # Now we return just the base name\n return os.path.splitext(just_file)[0]","def filepath_name_only(filepath: str) -> str:\n return pathlib.Path(filepath).stem","def format_filename(self, s):\n valid_chars = \"-_ %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\n return filename","def get_name(fname):\n if fname.endswith('.nii.gz'):\n fname = fname.replace('.nii.gz', '')\n\n name_stuff = {}\n tmp = fname.split('_') # tmp is just a placeholder\n elems = tmp[-4:-1] # The elements of the file name in a list\n name_stuff['IC'] = elems[0][2:] # 18\n name_stuff['Scan'] = elems[1][1:] # 3\n name_stuff['Hemi'] = elems[2].upper()\n\n return name_stuff","def get_file_name(file_path):\n full_file_name = file_path.split(os.sep)[-1]\n file_name = full_file_name.split(\".\")[0]\n return file_name","def standardized_name(path, filename):\n path_file = os.path.join(path, filename)\n stat = os.stat(path_file)\n extension = path_file.split('.')[-1]\n creation_time = datetime.fromtimestamp(stat.st_mtime).strftime('%m-%d-%Y_%H:%M:%S')\n return '{}.{}'.format(creation_time, extension)","def interleaved_filename(file_path):\n if not isinstance(file_path, tuple):\n raise OneCodexException(\"Cannot get the interleaved filename without a tuple.\")\n if re.match(\".*[._][Rr][12][_.].*\", file_path[0]):\n return re.sub(\"[._][Rr][12]\", \"\", file_path[0])\n else:\n warnings.warn(\"Paired-end filenames do not match--are you sure they are correct?\")\n return file_path[0]","def find_file_extention(file_name):\n \n index = file_name.rfind(\".\")\n ext = file_name[index:].lower()\n \n return ext","def extract_id(file_path):\n # An example of file path is AlkEthOH_tripos/AlkEthOH_chain_filt1/AlkEthOH_c555.crd\n return os.path.splitext(os.path.basename(file_path))[0][9:]","def get_file_name(filepath): # need pytest\n filename, extension = os.path.splitext(filepath.split('/')[-1])\n return filename, extension","def get_oldname(fname):\n assert isinstance(fname, str), f\"fname is not a string, aborting. fname: {fname}\"\n dirname = path.dirname(fname)\n oldbasename = path.basename(fname)\n if \"GA_\" in oldbasename:\n return fname\n elif (\"_Y_\" in oldbasename) or (\"_I_\" in oldbasename):\n split = oldbasename.split(\"_\")\n split[2] = split[2].split(\".\")[0]\n newbasename = \"_\".join(split)\n return path.join(dirname, newbasename)\n elif \"_S_\" in fname:\n return fname\n else:\n raise NotImplementedError(f\"filetype not supported. fname: {fname}\")","def EightByteFilename(self, filename):\n nameandext = filename.split(\".\")\n filename = (nameandext[0][:7] + \"~\") if len(nameandext[0]) > 8 else nameandext[0]\n extension = (nameandext[1][:3])\n return filename, extension","def station_name(f):\n return f.split('/')[1].split('_')[0]","def get_file_name(path: str) -> str:\n return os.path.splitext(os.path.basename(path))[0]","def get_scriptname(fname):\n base = os.path.basename(fname)\n res = os.path.splitext(base)[0]\n return res","def __clean_filename(filename):\n return \"{}.pdf\".format(filename.split(\"_compress_\", 1)[0])","def _getFileName(self, filePath):\r\n\t\thead, tail = ntpath.split(filePath)\r\n\t\treturn tail or ntpath.basename(head)","def find_qualified_name(filename, max_iterations=5):\n filename = os.path.abspath(filename)\n vc_root = find_vc_root(filename, max_iterations)\n _, name = filename.split(f\"{vc_root}/\")\n if name.endswith(\".py\"):\n name = name[:-3]\n return name.replace(\"/\", \".\")","def parse_filename(filename): # , time_fmt=TIME_INFILE_FMT):\n # Split the name up into its \"blocks\"\n parts = filename.split(\"_\")\n hive_str, rpi_str = parts[1:3]\n day_str = parts[3]\n method = parts[5]\n\n # Parse Hive and RPi number\n hive = int(hive_str[-1])\n rpi = int(rpi_str[-1])\n method = method.strip(\".csv\")\n\n # # Parse timestring into a datetime object\n # dt_naive = datetime.strptime(t_str, time_fmt)\n # dt_utc = pytz.utc.localize(dt_naive)\n\n return hive, rpi, method, day_str","def format_filename(s):\n valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_')\n return filename","def parse_filename(cls, filename):\n #from nose.tools import set_trace; set_trace()\n m = re.match(cls._pattern, os.path.basename(filename))\n basename = m.group(1)\n bandname = cls._bandmap.get(m.group(2), m.group(2))\n return basename, bandname","def fextension(filename):\n filename = os.path.normpath(filename)\n return os.path.splitext(filename)[1]","def extract_file_name(self, input_file):\n self.file_name_with_ext, self.file_name = extract_file_name(input_file)","def format_filename(s):\n valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\n return filename","def format_filename(s):\n valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\n return filename","def format_filename(s):\n valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\n return filename","def get_file_type(filename):\n return filename[filename.rfind('.')+1:].lower()","def filename_from_path(filepath: str) -> str:\n return filepath.split(\"/\")[-1]","def parse_file_name(file_name):\n\n elements = file_name.split(\"_\")\n if file_name.find(\"_VI_\") > 0:\n client = elements[0]\n capture_range = \"R1\"\n condition = elements[2]\n polarization = \"VIS\"\n shot = elements[4]\n modality = \"VIS\"\n else:\n client = elements[0]\n capture_range = elements[1]\n condition = elements[2]\n polarization = elements[3]\n shot = elements[4]\n modality = \"THERMAL\"\n \n return client, capture_range, condition, polarization, shot, modality","def get_script_name ( filename ):\n prio, sepa, name = filename.partition ( '-' )\n if name:\n try:\n prio_int = int ( prio, 10 )\n except ValueError:\n return filename\n else:\n return name\n else:\n return filename","def get_filename_Nd_from_varName(varName, caseName, from_year, model_name, pressure_adjust, to_year):\n n_split = varName.split('_')\n if len(n_split)==3:\n from_diam = int(n_split[0][1:])\n to_diam = int(n_split[-1])\n else:\n from_diam=0\n to_diam = int(n_split[-1])\n filen = get_filename_Nd(caseName, from_year, model_name, pressure_adjust, to_year, from_diam, to_diam)\n return filen","def fix_filename(s):\n t = str(s).translate(TRANS_FILE)\n if t.count('.') > 1:\n for i in range(t.count('.') - 1):\n idot = t.find('.')\n t = \"%s_%s\" % (t[:idot], t[idot+1:])\n return t","def get_file_ext(filename):\n return filename.rsplit('.', 1)[1]","def split_file_name(file, dataset_type='ycb'):\n dirname, filename = osp.split(file)\n filename_without_ext, ext = osp.splitext(filename)\n\n if dataset_type == 'ObjectNet3D':\n category_name = dirname.split(\"/\")[-2]\n idx = dirname.split(\"/\")[-1]\n else: # ycb\n category_name = dirname.split(\"/\")[-1]\n idx = None\n return dirname, filename, category_name, idx","def parse_fname(cmd_args):\n\n # Seasonal accumulation file\n if (cmd_args.period == 99):\n f_name = _parse_fname_season(cmd_args)\n else:\n f_name = _parse_fname_hour(cmd_args)\n\n return f_name","def rootname(filename):\n name = os.path.basename(filename)\n root, ext = os.path.splitext(name)\n while ext:\n root, ext = os.path.splitext(root)\n return root","def format_filename(s: str):\n # from: https://gist.github.com/seanh/93666\n\n valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n filename = ''.join(c for c in s if c in valid_chars)\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\n return filename","def valid_filename(strname):\n import string\n import os\n\n fname_only, fext_only = os.path.splitext(strname)\n valid_chars = \"-_() %s%s\" % (string.ascii_letters, string.digits)\n\n # valid_chars = \"-_.() %s%s\" % (string.ascii_letters, string.digits)\n valid_fname = ''.join(c for c in fname_only if c in valid_chars)\n return valid_fname + fext_only","def GetSequentialFileName(base_name):\n name, ext = os.path.splitext(base_name)\n assert ext == '', 'base_name cannot contain file extension.'\n index = 0\n while True:\n output_name = '%s_%03d' % (name, index)\n if not glob.glob(output_name + '.*'):\n break\n index = index + 1\n return output_name","def get_valid_filename(s):\n s = str(s).strip().replace(' ', '_')\n return re.sub(r'(?u)[^-\\w.]', '', s)","def get_filename(key):\n filename = str(key)\n filename = filename.replace('/', '_')\n filename = filename.replace('InceptionResnetV2_', '')\n\n # remove \"Repeat\" scope from filename\n filename = re_repeat.sub('B', filename)\n\n if re_block8.match(filename):\n # the last block8 has different name with the previous 9 occurrences\n filename = filename.replace('Block8', 'Block8_10')\n elif filename.startswith('Logits'):\n # remove duplicate \"Logits\" scope\n filename = filename.replace('Logits_', '', 1)\n\n # from TF to Keras naming\n filename = filename.replace('_weights', '_kernel')\n filename = filename.replace('_biases', '_bias')\n\n return filename + '.npy'","def guess(filename):\n for marker in [\".stem\",\"stem.\",\".seed\",\"seed.\"]:\n if filename.find(marker)>-1: \n return (filename.replace(marker,\"\"))\n\n if \"/\" in filename:\n index = filename.rfind(\"/\")\n return ( filename[:index+1]+\"generated_\"+filename[index+1:])\n else:\n return ( \"generated_\"+filename )","def parse_file_path(file_path):\n base = Path(file_path)\n return str(base.parents[0]), str(base.stem), str(base.suffix)","def extract_subject_names(file_names):\n return file_names.apply(lambda name: name.split('_')[1])","def safe_filename(filename):\n string = str(filename).strip().replace(\" \", \"_\")\n string = re.sub(r\"(?u)[^-\\w.]\", \"_\", string)\n return re.sub(r\"_+\", \"_\", string)","def get_filename(filename):\n \n return utilities.get_filename(filename)","def filename_strip_ext(filename):\n base = os.path.basename(filename)\n # Strip file extension\n return os.path.splitext(base)[0]","def get_filename(filepath):\n return os.path.basename(filepath)","def just_the_name(path):\n return os.path.splitext(os.path.basename(path))[0]","def getExtension(filename):\n return filename[filename.rfind('.'):]","def extract_file_name_from_source_full_path(source_full_path):\n destination_file_name = os.path.basename(source_full_path)\n return destination_file_name","def getBaseName(filepath):\n return os.path.basename(filepath)","def basename_sans(path):\n return os.path.splitext(os.path.basename(path))[0]","def get_fileext(file_path):\n\n # Get rid of directories and etc\n just_file = os.path.basename(file_path)\n\n # Now we return just the base name\n return os.path.splitext(just_file)[1]","def get_version_filename(filename):\n return re.search(r'\\d+', filename).group(0)","def __return_new_file_name(self, file_name: str, file_path: str):\n\n fastq_runid = re.split('[_.]', file_name) # split on `_` or `.`\n barcode_number = file_path.split(\"/\")[-1] # get the barcode number\n fastq_or_fasta = fastq_runid[-1] # get the .fastq/.fasta file extension\n\n # create the new file name\n new_file_name = \"_\".join(fastq_runid[:3]) # join first three elements\n new_file_name += \"_%s.%s\" % (barcode_number, fastq_or_fasta) # append the barcode number and file extension\n\n return new_file_name","def get_sheet_name(filename):\n filename = os.path.basename(filename)\n filename = os.path.splitext(filename)[0]\n # there are 31 character limitation\n if len(filename) > 31:\n filename = filename[:31]\n return filename","def fix_filename(s):\n t = s.translate(BAD_FILETABLE)\n if t.count('.') > 1:\n for i in range(t.count('.') - 1):\n idot = t.find('.')\n t = \"%s_%s\" % (t[:idot], t[idot+1:])\n return t","def get_file_extension(filename):\n if not filename:\n return \"\"\n\n dotpos = filename.rfind(\".\")\n return filename[dotpos + 1:].lower() if dotpos != -1 else \"\"","def name_sans_ext(self) -> str:\n return os.path.splitext(self.path)[0]","def filepath_name_ext(filepath: str) -> str:\n return pathlib.Path(filepath).name","def name_from_path(path):\n return path[0:-3]","def get_valid_filename(s):\n s = str(s).strip().replace(\" \", \"_\")\n return re.sub(r\"(?u)[^-\\w.]\", \"\", s)","def _get_file_name(url: str) -> str:\n url = url.strip('/')\n result = findall(r'/(\\w+\\.\\w+)[?|$]', url)\n if result:\n return result[-1]\n return url.split('/')[-1]","def get_filename(self) -> str:\n fname = self.url.split(\"/\")[-1]\n if \",\" in fname:\n _fname, _i = fname.split(\",\")\n _split_fname = _fname.split(\".\")\n _name = _split_fname[0]\n _extension = _split_fname[-1]\n return _name + _i + \".\" + _extension\n else:\n return fname","def _splitzipext(self, filename):\n\n if self._iszip(filename):\n return os.path.splitext(filename)\n else:\n return filename, None"],"string":"[\n \"def reFileName(str_):\\n rv = 'None', str_\\n m = re.match(r'((?:[a-zA-Z0-9-]){4,})_(.*)$', str_)\\n if m:\\n rv = m.group(1), m.group(2)\\n else:\\n m = re.match(r'(\\\\d+-\\\\d+)\\\\.-\\\\.(.*)$', str_)\\n if m:\\n rv = m.group(1), m.group(2)\\n return rv\",\n \"def parse_rarefaction_fname(name_string):\\r\\n\\r\\n root, ext = os.path.splitext(name_string)\\r\\n root_list = root.split(\\\"_\\\")\\r\\n iters = int(root_list.pop())\\r\\n seqs_per_sam = int(root_list.pop())\\r\\n base_name = \\\"_\\\".join(root_list)\\r\\n return base_name, seqs_per_sam, iters, ext\",\n \"def parse_filename(cls, filename):\\n words = filename.split('_')\\n return words[0], int(words[1][1:]), int(words[2])\",\n \"def _get_aso_id_from_file_name(self, filename: str) -> str:\\n id_parts = filename.split('/')\\n prefix = id_parts[1]\\n suffix = id_parts[-1].split('.')[0].zfill(3)\\n if len(suffix) == 5:\\n return suffix\\n else:\\n return prefix + suffix\",\n \"def extract_filename(str):\\n regex = r\\\"([0-9_-]+).jpg\\\"\\n matches = re.search(regex, str)\\n if matches:\\n return matches.group(1)\",\n \"def split_name(filename):\\n # *********** My filename are in the format ./CaAl2Si2O8_T3_nvt_a12.5.outcar.msd.dat\\n # ******* so I can split their name with _ and take the compound and T from their name\\n filename = filename.strip('./')\\n temperature = filename.split('_')[1]\\n acell = filename.split('.outcar')[0].split('_')[3].strip('a')\\n return temperature, acell\",\n \"def split_name(filename):\\n # *********** My filename are in the format ./CaAl2Si2O8_T3_nvt_a12.5.\\n # ******* so I can split their name with _ and take the compound and T from their name\\n filename = filename.strip('./')\\n temperature = str(int(float(filename.split('_')[1].strip('T'))*1000))\\n acell = filename.split('_')[3].split('.outcar')[0].strip('a')\\n return temperature, acell\",\n \"def genBaseName(fileName):\\n return fileName.split(\\\"_\\\")[0].split(\\\".\\\")[0]\",\n \"def get_name_from_filename(filename):\\n return filename[:-4]\",\n \"def splitFilename(filename):\\n\\n if filename[-4:] == '.rpm':\\n filename = filename[:-4]\\n \\n archIndex = filename.rfind('.')\\n arch = filename[archIndex+1:]\\n\\n relIndex = filename[:archIndex].rfind('-')\\n rel = filename[relIndex+1:archIndex]\\n\\n verIndex = filename[:relIndex].rfind('-')\\n ver = filename[verIndex+1:relIndex]\\n\\n epochIndex = filename.find(':')\\n if epochIndex == -1:\\n epoch = ''\\n else:\\n epoch = filename[:epochIndex]\\n \\n name = filename[epochIndex + 1:verIndex]\\n return name, ver, rel, epoch, arch\",\n \"def get_name_from_file(filename):\\n return filename.split(\\\".\\\")[0]\",\n \"def prefix_from_filename(input_file):\\n prefix = \\\"\\\"\\n \\n if str(input_file).find(\\\"medication_bner_\\\") != -1:\\n prefix = \\\"drugbank\\\"\\n elif str(input_file).find(\\\"_bc5cdr\\\") != -1:\\n prefix = \\\"bc5cdr\\\"\\n elif str(input_file).find(\\\"_bionlp13cg\\\") != -1:\\n prefix = \\\"bionlp13cg\\\"\\n \\n return prefix\",\n \"def split_file_name(file_path):\\n file_name = os.path.splitext(file_path)[0]\\n file_name = os.path.split(file_name)[1]\\n\\n return file_name\",\n \"def get_fname(a_file):\\r\\n fname, fext = os.path.splitext(a_file)\\r\\n return os.path.basename(fname)\",\n \"def get_fname(a_file):\\r\\n fname, fext = os.path.splitext(a_file)\\r\\n return os.path.basename(fname)\",\n \"def get_fixed_filename(filename):\\n new_name = \\\"\\\"\\n for i, char in enumerate(filename):\\n if i + 1 != len(filename):\\n previous_character = filename[i - 1]\\n next_character = filename[i + 1]\\n if char.islower() and next_character.isupper():\\n new_name += char + \\\"_\\\"\\n elif previous_character == \\\".\\\":\\n new_name += char\\n elif char.islower() and not previous_character.isalpha():\\n new_name += char.upper()\\n else:\\n new_name += char\\n else:\\n new_name += char\\n new_name = new_name.replace(\\\" \\\", \\\"_\\\").replace(\\\".TXT\\\", \\\".txt\\\")\\n return new_name\",\n \"def decompose_newstyle_name(filename):\\n path, parts, ext = _get_fields(filename)\\n observatory = parts[0]\\n serial = list_get(parts, 3, \\\"\\\")\\n\\n if ext == \\\".pmap\\\":\\n assert len(parts) in [1,2], \\\"Invalid .pmap filename \\\" + repr(filename)\\n instrument, filekind = \\\"\\\", \\\"\\\"\\n serial = list_get(parts, 1, \\\"\\\")\\n elif ext == \\\".imap\\\":\\n assert len(parts) in [2,3], \\\"Invalid .imap filename \\\" + repr(filename)\\n instrument = parts[1]\\n filekind = \\\"\\\"\\n serial = list_get(parts, 2, \\\"\\\")\\n else:\\n assert len(parts) in [3,4], \\\"Invalid filename \\\" + repr(filename)\\n instrument = parts[1]\\n filekind = parts[2]\\n serial = list_get(parts, 3, \\\"\\\")\\n\\n # Don't include filename in these or it messes up crds.certify unique error tracking.\\n\\n assert instrument in INSTRUMENTS+[\\\"\\\"], \\\"Invalid instrument \\\" + repr(instrument)\\n assert filekind in FILEKINDS+[\\\"\\\"], \\\"Invalid filekind \\\" + repr(filekind)\\n assert re.match(r\\\"\\\\d*\\\", serial), \\\"Invalid id field \\\" + repr(id)\\n # extension may vary for upload temporary files.\\n\\n return path, observatory, instrument, filekind, serial, ext\",\n \"def guessFilePrefix(self, filename):\\n count = 0\\n lim = None\\n for i in range(len(filename)):\\n if filename[i] == \\\".\\\":\\n break\\n\\n try:\\n int(filename[i])\\n\\n if lim is None:\\n lim = count\\n\\n except ValueError:\\n lim = None\\n\\n count += 1\\n\\n if lim is None:\\n array = os.path.splitext(filename)\\n\\n if array[1] == '.gz' or array[1] == '.bz2':\\n array = os.path.splitext(array[0])\\n\\n filename = array[0]\\n\\n else:\\n filename = filename[:lim]\\n\\n return filename\",\n \"def extract_file_name(file_path):\\n # ファイルパスからファイル名(拡張子含む)を取り出す\\n file_name = file_path.split('/')[-1]\\n # 拡張子を取り除く\\n return file_name.split('.')[0]\",\n \"def clean_filename(file):\\r\\n\\r\\n return file.split('.')[0]\",\n \"def basefname(fname):\\n return os.path.splitext(fname.split(\\\"\\\\\\\\\\\")[-1])[0]\",\n \"def get_fixed_filename(filename):\\n\\n filename = filename.replace(\\\".TXT\\\", \\\".txt\\\")\\n new_name = \\\"\\\"\\n space_preceding = False\\n bracket_preceding = False\\n\\n for letter in filename:\\n if letter.isspace() or letter == \\\"_\\\":\\n space_preceding = True\\n new_name = new_name + \\\"_\\\"\\n elif letter == \\\"(\\\":\\n bracket_preceding = True\\n elif letter.isupper():\\n if new_name != \\\"\\\" and not space_preceding and not bracket_preceding:\\n new_name = new_name + \\\"_\\\"\\n if not (letter.isspace() or letter == \\\"_\\\"):\\n if space_preceding:\\n letter = letter.upper()\\n space_preceding = False\\n new_name = new_name + letter\\n\\n return new_name\",\n \"def getFileName(filepath):\\n return os.path.splitext(os.path.basename(filepath))[0]\",\n \"def get_date_from_filename(file_path):\\n file_name = basename(file_path)\\n name, _ = splitext(file_name)\\n _, date = name.split('_')\\n\\n return date\",\n \"def extractFileName(fileType, modelName, modelVersion, modelState):\\n fileName = '{}_{}_{}'.format(modelName, modelVersion, fileType) if modelState == 'national' else '{}_{}_{}_{}'.format(modelName, modelVersion, modelState, fileType)\\n return fileName\",\n \"def scrub_underscore_suffix(filename):\\n scrubbed = re.sub(r\\\"_[^_]+\\\\.\\\", \\\".\\\", filename)\\n return scrubbed\",\n \"def get_extension_from_filename(filename):\\n return filename[-4:]\",\n \"def filename_ext(filename):\\n base = os.path.basename(filename)\\n return os.path.splitext(base)[1][1:]\",\n \"def get_file_name(filepath: str) -> str:\\n\\n f = os.path.basename(filepath)\\n filename, _ = os.path.splitext(f)\\n\\n return filename\",\n \"def get_file_name(file):\\n return os.path.splitext(os.path.basename(file))[0]\",\n \"def filter_filename(self, fname):\\r\\n return os.path.basename(fname)\",\n \"def file_name(path):\\n return os.path.basename(path).split('.')[0]\",\n \"def get_fixed_filename(filename):\\n initial_changed_name = filename.replace(\\\" \\\", \\\"_\\\").replace(\\\".TXT\\\", \\\".txt\\\")\\n previous_character = \\\"\\\"\\n new_name = \\\"\\\"\\n for i, character in enumerate(initial_changed_name):\\n current_character = character\\n if previous_character == \\\"_\\\" and current_character.islower():\\n new_name += current_character.upper()\\n elif previous_character == \\\"(\\\" and current_character.islower():\\n new_name += current_character.upper()\\n elif previous_character.islower() and current_character.isupper():\\n new_name += \\\"_{}\\\".format(current_character)\\n else:\\n new_name += current_character\\n previous_character = character\\n return new_name\",\n \"def valid_file_name(s: str) -> str:\\n global UNICODE_FILENAMES, FILESYSTEM_IS_LINUX\\n if FILESYSTEM_IS_LINUX:\\n s = fix_linux.sub(\\\"_\\\", s)\\n else:\\n s = fix_windows.sub(\\\"_\\\", s)\\n s = fix_windows_ending.split(s)[0]\\n\\n if not UNICODE_FILENAMES:\\n s = fix_unicode.sub(\\\"_\\\", s)\\n return s\",\n \"def get_filename(file_path):\\n\\n # Get rid of directories and etc\\n just_file = os.path.basename(file_path)\\n\\n # Now we return just the base name\\n return os.path.splitext(just_file)[0]\",\n \"def filepath_name_only(filepath: str) -> str:\\n return pathlib.Path(filepath).stem\",\n \"def format_filename(self, s):\\n valid_chars = \\\"-_ %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\\n return filename\",\n \"def get_name(fname):\\n if fname.endswith('.nii.gz'):\\n fname = fname.replace('.nii.gz', '')\\n\\n name_stuff = {}\\n tmp = fname.split('_') # tmp is just a placeholder\\n elems = tmp[-4:-1] # The elements of the file name in a list\\n name_stuff['IC'] = elems[0][2:] # 18\\n name_stuff['Scan'] = elems[1][1:] # 3\\n name_stuff['Hemi'] = elems[2].upper()\\n\\n return name_stuff\",\n \"def get_file_name(file_path):\\n full_file_name = file_path.split(os.sep)[-1]\\n file_name = full_file_name.split(\\\".\\\")[0]\\n return file_name\",\n \"def standardized_name(path, filename):\\n path_file = os.path.join(path, filename)\\n stat = os.stat(path_file)\\n extension = path_file.split('.')[-1]\\n creation_time = datetime.fromtimestamp(stat.st_mtime).strftime('%m-%d-%Y_%H:%M:%S')\\n return '{}.{}'.format(creation_time, extension)\",\n \"def interleaved_filename(file_path):\\n if not isinstance(file_path, tuple):\\n raise OneCodexException(\\\"Cannot get the interleaved filename without a tuple.\\\")\\n if re.match(\\\".*[._][Rr][12][_.].*\\\", file_path[0]):\\n return re.sub(\\\"[._][Rr][12]\\\", \\\"\\\", file_path[0])\\n else:\\n warnings.warn(\\\"Paired-end filenames do not match--are you sure they are correct?\\\")\\n return file_path[0]\",\n \"def find_file_extention(file_name):\\n \\n index = file_name.rfind(\\\".\\\")\\n ext = file_name[index:].lower()\\n \\n return ext\",\n \"def extract_id(file_path):\\n # An example of file path is AlkEthOH_tripos/AlkEthOH_chain_filt1/AlkEthOH_c555.crd\\n return os.path.splitext(os.path.basename(file_path))[0][9:]\",\n \"def get_file_name(filepath): # need pytest\\n filename, extension = os.path.splitext(filepath.split('/')[-1])\\n return filename, extension\",\n \"def get_oldname(fname):\\n assert isinstance(fname, str), f\\\"fname is not a string, aborting. fname: {fname}\\\"\\n dirname = path.dirname(fname)\\n oldbasename = path.basename(fname)\\n if \\\"GA_\\\" in oldbasename:\\n return fname\\n elif (\\\"_Y_\\\" in oldbasename) or (\\\"_I_\\\" in oldbasename):\\n split = oldbasename.split(\\\"_\\\")\\n split[2] = split[2].split(\\\".\\\")[0]\\n newbasename = \\\"_\\\".join(split)\\n return path.join(dirname, newbasename)\\n elif \\\"_S_\\\" in fname:\\n return fname\\n else:\\n raise NotImplementedError(f\\\"filetype not supported. fname: {fname}\\\")\",\n \"def EightByteFilename(self, filename):\\n nameandext = filename.split(\\\".\\\")\\n filename = (nameandext[0][:7] + \\\"~\\\") if len(nameandext[0]) > 8 else nameandext[0]\\n extension = (nameandext[1][:3])\\n return filename, extension\",\n \"def station_name(f):\\n return f.split('/')[1].split('_')[0]\",\n \"def get_file_name(path: str) -> str:\\n return os.path.splitext(os.path.basename(path))[0]\",\n \"def get_scriptname(fname):\\n base = os.path.basename(fname)\\n res = os.path.splitext(base)[0]\\n return res\",\n \"def __clean_filename(filename):\\n return \\\"{}.pdf\\\".format(filename.split(\\\"_compress_\\\", 1)[0])\",\n \"def _getFileName(self, filePath):\\r\\n\\t\\thead, tail = ntpath.split(filePath)\\r\\n\\t\\treturn tail or ntpath.basename(head)\",\n \"def find_qualified_name(filename, max_iterations=5):\\n filename = os.path.abspath(filename)\\n vc_root = find_vc_root(filename, max_iterations)\\n _, name = filename.split(f\\\"{vc_root}/\\\")\\n if name.endswith(\\\".py\\\"):\\n name = name[:-3]\\n return name.replace(\\\"/\\\", \\\".\\\")\",\n \"def parse_filename(filename): # , time_fmt=TIME_INFILE_FMT):\\n # Split the name up into its \\\"blocks\\\"\\n parts = filename.split(\\\"_\\\")\\n hive_str, rpi_str = parts[1:3]\\n day_str = parts[3]\\n method = parts[5]\\n\\n # Parse Hive and RPi number\\n hive = int(hive_str[-1])\\n rpi = int(rpi_str[-1])\\n method = method.strip(\\\".csv\\\")\\n\\n # # Parse timestring into a datetime object\\n # dt_naive = datetime.strptime(t_str, time_fmt)\\n # dt_utc = pytz.utc.localize(dt_naive)\\n\\n return hive, rpi, method, day_str\",\n \"def format_filename(s):\\n valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_')\\n return filename\",\n \"def parse_filename(cls, filename):\\n #from nose.tools import set_trace; set_trace()\\n m = re.match(cls._pattern, os.path.basename(filename))\\n basename = m.group(1)\\n bandname = cls._bandmap.get(m.group(2), m.group(2))\\n return basename, bandname\",\n \"def fextension(filename):\\n filename = os.path.normpath(filename)\\n return os.path.splitext(filename)[1]\",\n \"def extract_file_name(self, input_file):\\n self.file_name_with_ext, self.file_name = extract_file_name(input_file)\",\n \"def format_filename(s):\\n valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\\n return filename\",\n \"def format_filename(s):\\n valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\\n return filename\",\n \"def format_filename(s):\\n valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\\n return filename\",\n \"def get_file_type(filename):\\n return filename[filename.rfind('.')+1:].lower()\",\n \"def filename_from_path(filepath: str) -> str:\\n return filepath.split(\\\"/\\\")[-1]\",\n \"def parse_file_name(file_name):\\n\\n elements = file_name.split(\\\"_\\\")\\n if file_name.find(\\\"_VI_\\\") > 0:\\n client = elements[0]\\n capture_range = \\\"R1\\\"\\n condition = elements[2]\\n polarization = \\\"VIS\\\"\\n shot = elements[4]\\n modality = \\\"VIS\\\"\\n else:\\n client = elements[0]\\n capture_range = elements[1]\\n condition = elements[2]\\n polarization = elements[3]\\n shot = elements[4]\\n modality = \\\"THERMAL\\\"\\n \\n return client, capture_range, condition, polarization, shot, modality\",\n \"def get_script_name ( filename ):\\n prio, sepa, name = filename.partition ( '-' )\\n if name:\\n try:\\n prio_int = int ( prio, 10 )\\n except ValueError:\\n return filename\\n else:\\n return name\\n else:\\n return filename\",\n \"def get_filename_Nd_from_varName(varName, caseName, from_year, model_name, pressure_adjust, to_year):\\n n_split = varName.split('_')\\n if len(n_split)==3:\\n from_diam = int(n_split[0][1:])\\n to_diam = int(n_split[-1])\\n else:\\n from_diam=0\\n to_diam = int(n_split[-1])\\n filen = get_filename_Nd(caseName, from_year, model_name, pressure_adjust, to_year, from_diam, to_diam)\\n return filen\",\n \"def fix_filename(s):\\n t = str(s).translate(TRANS_FILE)\\n if t.count('.') > 1:\\n for i in range(t.count('.') - 1):\\n idot = t.find('.')\\n t = \\\"%s_%s\\\" % (t[:idot], t[idot+1:])\\n return t\",\n \"def get_file_ext(filename):\\n return filename.rsplit('.', 1)[1]\",\n \"def split_file_name(file, dataset_type='ycb'):\\n dirname, filename = osp.split(file)\\n filename_without_ext, ext = osp.splitext(filename)\\n\\n if dataset_type == 'ObjectNet3D':\\n category_name = dirname.split(\\\"/\\\")[-2]\\n idx = dirname.split(\\\"/\\\")[-1]\\n else: # ycb\\n category_name = dirname.split(\\\"/\\\")[-1]\\n idx = None\\n return dirname, filename, category_name, idx\",\n \"def parse_fname(cmd_args):\\n\\n # Seasonal accumulation file\\n if (cmd_args.period == 99):\\n f_name = _parse_fname_season(cmd_args)\\n else:\\n f_name = _parse_fname_hour(cmd_args)\\n\\n return f_name\",\n \"def rootname(filename):\\n name = os.path.basename(filename)\\n root, ext = os.path.splitext(name)\\n while ext:\\n root, ext = os.path.splitext(root)\\n return root\",\n \"def format_filename(s: str):\\n # from: https://gist.github.com/seanh/93666\\n\\n valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n filename = ''.join(c for c in s if c in valid_chars)\\n filename = filename.replace(' ', '_') # I don't like spaces in filenames.\\n return filename\",\n \"def valid_filename(strname):\\n import string\\n import os\\n\\n fname_only, fext_only = os.path.splitext(strname)\\n valid_chars = \\\"-_() %s%s\\\" % (string.ascii_letters, string.digits)\\n\\n # valid_chars = \\\"-_.() %s%s\\\" % (string.ascii_letters, string.digits)\\n valid_fname = ''.join(c for c in fname_only if c in valid_chars)\\n return valid_fname + fext_only\",\n \"def GetSequentialFileName(base_name):\\n name, ext = os.path.splitext(base_name)\\n assert ext == '', 'base_name cannot contain file extension.'\\n index = 0\\n while True:\\n output_name = '%s_%03d' % (name, index)\\n if not glob.glob(output_name + '.*'):\\n break\\n index = index + 1\\n return output_name\",\n \"def get_valid_filename(s):\\n s = str(s).strip().replace(' ', '_')\\n return re.sub(r'(?u)[^-\\\\w.]', '', s)\",\n \"def get_filename(key):\\n filename = str(key)\\n filename = filename.replace('/', '_')\\n filename = filename.replace('InceptionResnetV2_', '')\\n\\n # remove \\\"Repeat\\\" scope from filename\\n filename = re_repeat.sub('B', filename)\\n\\n if re_block8.match(filename):\\n # the last block8 has different name with the previous 9 occurrences\\n filename = filename.replace('Block8', 'Block8_10')\\n elif filename.startswith('Logits'):\\n # remove duplicate \\\"Logits\\\" scope\\n filename = filename.replace('Logits_', '', 1)\\n\\n # from TF to Keras naming\\n filename = filename.replace('_weights', '_kernel')\\n filename = filename.replace('_biases', '_bias')\\n\\n return filename + '.npy'\",\n \"def guess(filename):\\n for marker in [\\\".stem\\\",\\\"stem.\\\",\\\".seed\\\",\\\"seed.\\\"]:\\n if filename.find(marker)>-1: \\n return (filename.replace(marker,\\\"\\\"))\\n\\n if \\\"/\\\" in filename:\\n index = filename.rfind(\\\"/\\\")\\n return ( filename[:index+1]+\\\"generated_\\\"+filename[index+1:])\\n else:\\n return ( \\\"generated_\\\"+filename )\",\n \"def parse_file_path(file_path):\\n base = Path(file_path)\\n return str(base.parents[0]), str(base.stem), str(base.suffix)\",\n \"def extract_subject_names(file_names):\\n return file_names.apply(lambda name: name.split('_')[1])\",\n \"def safe_filename(filename):\\n string = str(filename).strip().replace(\\\" \\\", \\\"_\\\")\\n string = re.sub(r\\\"(?u)[^-\\\\w.]\\\", \\\"_\\\", string)\\n return re.sub(r\\\"_+\\\", \\\"_\\\", string)\",\n \"def get_filename(filename):\\n \\n return utilities.get_filename(filename)\",\n \"def filename_strip_ext(filename):\\n base = os.path.basename(filename)\\n # Strip file extension\\n return os.path.splitext(base)[0]\",\n \"def get_filename(filepath):\\n return os.path.basename(filepath)\",\n \"def just_the_name(path):\\n return os.path.splitext(os.path.basename(path))[0]\",\n \"def getExtension(filename):\\n return filename[filename.rfind('.'):]\",\n \"def extract_file_name_from_source_full_path(source_full_path):\\n destination_file_name = os.path.basename(source_full_path)\\n return destination_file_name\",\n \"def getBaseName(filepath):\\n return os.path.basename(filepath)\",\n \"def basename_sans(path):\\n return os.path.splitext(os.path.basename(path))[0]\",\n \"def get_fileext(file_path):\\n\\n # Get rid of directories and etc\\n just_file = os.path.basename(file_path)\\n\\n # Now we return just the base name\\n return os.path.splitext(just_file)[1]\",\n \"def get_version_filename(filename):\\n return re.search(r'\\\\d+', filename).group(0)\",\n \"def __return_new_file_name(self, file_name: str, file_path: str):\\n\\n fastq_runid = re.split('[_.]', file_name) # split on `_` or `.`\\n barcode_number = file_path.split(\\\"/\\\")[-1] # get the barcode number\\n fastq_or_fasta = fastq_runid[-1] # get the .fastq/.fasta file extension\\n\\n # create the new file name\\n new_file_name = \\\"_\\\".join(fastq_runid[:3]) # join first three elements\\n new_file_name += \\\"_%s.%s\\\" % (barcode_number, fastq_or_fasta) # append the barcode number and file extension\\n\\n return new_file_name\",\n \"def get_sheet_name(filename):\\n filename = os.path.basename(filename)\\n filename = os.path.splitext(filename)[0]\\n # there are 31 character limitation\\n if len(filename) > 31:\\n filename = filename[:31]\\n return filename\",\n \"def fix_filename(s):\\n t = s.translate(BAD_FILETABLE)\\n if t.count('.') > 1:\\n for i in range(t.count('.') - 1):\\n idot = t.find('.')\\n t = \\\"%s_%s\\\" % (t[:idot], t[idot+1:])\\n return t\",\n \"def get_file_extension(filename):\\n if not filename:\\n return \\\"\\\"\\n\\n dotpos = filename.rfind(\\\".\\\")\\n return filename[dotpos + 1:].lower() if dotpos != -1 else \\\"\\\"\",\n \"def name_sans_ext(self) -> str:\\n return os.path.splitext(self.path)[0]\",\n \"def filepath_name_ext(filepath: str) -> str:\\n return pathlib.Path(filepath).name\",\n \"def name_from_path(path):\\n return path[0:-3]\",\n \"def get_valid_filename(s):\\n s = str(s).strip().replace(\\\" \\\", \\\"_\\\")\\n return re.sub(r\\\"(?u)[^-\\\\w.]\\\", \\\"\\\", s)\",\n \"def _get_file_name(url: str) -> str:\\n url = url.strip('/')\\n result = findall(r'/(\\\\w+\\\\.\\\\w+)[?|$]', url)\\n if result:\\n return result[-1]\\n return url.split('/')[-1]\",\n \"def get_filename(self) -> str:\\n fname = self.url.split(\\\"/\\\")[-1]\\n if \\\",\\\" in fname:\\n _fname, _i = fname.split(\\\",\\\")\\n _split_fname = _fname.split(\\\".\\\")\\n _name = _split_fname[0]\\n _extension = _split_fname[-1]\\n return _name + _i + \\\".\\\" + _extension\\n else:\\n return fname\",\n \"def _splitzipext(self, filename):\\n\\n if self._iszip(filename):\\n return os.path.splitext(filename)\\n else:\\n return filename, None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7018564","0.68886405","0.6759327","0.6749364","0.6716706","0.6699516","0.6672866","0.66605604","0.6640363","0.65921485","0.6585","0.65480256","0.6478625","0.64543766","0.64543766","0.6446561","0.6443001","0.64351195","0.6385604","0.6374533","0.6354233","0.6317038","0.6274813","0.6271444","0.6234476","0.62194896","0.6198998","0.6178173","0.6176048","0.6163876","0.614782","0.61241204","0.6122869","0.6122541","0.61166507","0.61097896","0.61091286","0.6090831","0.6055549","0.6047529","0.60253644","0.6024449","0.6019342","0.60147965","0.60127676","0.60057557","0.5998041","0.59976965","0.5995544","0.5992213","0.59892344","0.59699595","0.5966038","0.5963416","0.595828","0.5939892","0.5929304","0.59277403","0.59277403","0.59277403","0.59260803","0.59236234","0.5916104","0.5907839","0.59072834","0.59033924","0.58938974","0.58851427","0.5884045","0.5881292","0.58675665","0.58583987","0.58580244","0.5855982","0.58518016","0.5850084","0.58500195","0.58475935","0.58443767","0.584229","0.58413035","0.58396965","0.5836801","0.5817545","0.5814941","0.5807015","0.58047056","0.580288","0.58022","0.5800251","0.5796637","0.57916164","0.5782397","0.5781666","0.5779832","0.577226","0.5764716","0.5762668","0.57595617","0.57535225"],"string":"[\n \"0.7018564\",\n \"0.68886405\",\n \"0.6759327\",\n \"0.6749364\",\n \"0.6716706\",\n \"0.6699516\",\n \"0.6672866\",\n \"0.66605604\",\n \"0.6640363\",\n \"0.65921485\",\n \"0.6585\",\n \"0.65480256\",\n \"0.6478625\",\n \"0.64543766\",\n \"0.64543766\",\n \"0.6446561\",\n \"0.6443001\",\n \"0.64351195\",\n \"0.6385604\",\n \"0.6374533\",\n \"0.6354233\",\n \"0.6317038\",\n \"0.6274813\",\n \"0.6271444\",\n \"0.6234476\",\n \"0.62194896\",\n \"0.6198998\",\n \"0.6178173\",\n \"0.6176048\",\n \"0.6163876\",\n \"0.614782\",\n \"0.61241204\",\n \"0.6122869\",\n \"0.6122541\",\n \"0.61166507\",\n \"0.61097896\",\n \"0.61091286\",\n \"0.6090831\",\n \"0.6055549\",\n \"0.6047529\",\n \"0.60253644\",\n \"0.6024449\",\n \"0.6019342\",\n \"0.60147965\",\n \"0.60127676\",\n \"0.60057557\",\n \"0.5998041\",\n \"0.59976965\",\n \"0.5995544\",\n \"0.5992213\",\n \"0.59892344\",\n \"0.59699595\",\n \"0.5966038\",\n \"0.5963416\",\n \"0.595828\",\n \"0.5939892\",\n \"0.5929304\",\n \"0.59277403\",\n \"0.59277403\",\n \"0.59277403\",\n \"0.59260803\",\n \"0.59236234\",\n \"0.5916104\",\n \"0.5907839\",\n \"0.59072834\",\n \"0.59033924\",\n \"0.58938974\",\n \"0.58851427\",\n \"0.5884045\",\n \"0.5881292\",\n \"0.58675665\",\n \"0.58583987\",\n \"0.58580244\",\n \"0.5855982\",\n \"0.58518016\",\n \"0.5850084\",\n \"0.58500195\",\n \"0.58475935\",\n \"0.58443767\",\n \"0.584229\",\n \"0.58413035\",\n \"0.58396965\",\n \"0.5836801\",\n \"0.5817545\",\n \"0.5814941\",\n \"0.5807015\",\n \"0.58047056\",\n \"0.580288\",\n \"0.58022\",\n \"0.5800251\",\n \"0.5796637\",\n \"0.57916164\",\n \"0.5782397\",\n \"0.5781666\",\n \"0.5779832\",\n \"0.577226\",\n \"0.5764716\",\n \"0.5762668\",\n \"0.57595617\",\n \"0.57535225\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7713043"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19895,"cells":{"query":{"kind":"string","value":"Finds and opens the files containing data required for the variable, Applies the reduction function to the data, and returns an MV. When completed, this will treat missing data as such. At present only CFcompliant files are supported."},"document":{"kind":"string","value":"def reduce( self, vid=None ):\n if vid is None:\n vid = self._vid\n rows = self._filetable.find_files( self.variableid, time_range=self.timerange,\n lat_range=self.latrange, lon_range=self.lonrange,\n level_range=self.levelrange )\n if rows==None or len(rows)<=0:\n # this belongs in a log file:\n print \"ERROR no data found for reduced variable\",self.variableid\n print \"in\",self.timerange, self.latrange, self.lonrange, self.levelrange\n print \"filetable is\",self._filetable\n return None\n\n # To make it even easier on the first cut, I won't worry about missing data and\n # anything else inconvenient, and I'll assume CF compliance.\n files = list(set([r.fileid for r in rows]))\n if len(files)>1:\n # Piece together the data from multiple files. That's what cdscan is for...\n # One problem is there may be more than one file family in the same\n # directory! If we see more than one at this point, the user wasn't\n # careful in his specifications. We'll just have to choose one.\n famdict = { f:self.extract_filefamilyname(f) for f in files }\n families = list(set([ famdict[f] for f in files ]))\n families.sort(key=len) # a shorter name is more likely to be what we want\n if len(families)==0:\n print \"ERROR. No data to reduce. files[0]=:\",files[0]\n return None\n elif len(families)>1:\n print \"WARNING: \",len(families),\" file families found, will use the first one:\",families\n fam = families[0]\n\n # We'll run cdscan to combine the multiple files into one logical file.\n # To save (a lot of) time, we'll re-use an xml file if a suitable one already exists.\n # To do this safely, incorporate the file list (names,lengths,dates) into the xml file name.\n famfiles = [f for f in files if famdict[f]==fam]\n famfiles.sort() # improves consistency between runs\n file_list = '-'.join(\n [ f+'size'+str(os.path.getsize(f))+'mtime'+str(os.path.getmtime(f))\\\n for f in famfiles ] )\n csum = hashlib.md5(file_list).hexdigest()\n xml_name = fam+'_cs'+csum+'.xml'\n if os.path.isfile( xml_name ):\n files = [ xml_name ]\n\n if len(files)>1:\n famfiles = [f for f in files if famdict[f]==fam]\n # Normally when we get here, it's because data has been divided by time among\n # several files. So when cdscan puts it all back together, it needs the time\n # units. If the time variable is named 'time' and has a valid 'units'\n # attribute, we're fine; otherwise we're in trouble. But for some AMWG obs\n # data which I have, the time units may be found in the long_name attribute.\n # The -e option will normally be the way to fix it up, but maybe the -r option\n # could be made to work.\n \n # I know of no exception to the rule that all files in the file family keep their\n # units in the same place; so find where they are by checking the first file.\n f = cdms2.open( famfiles[0] )\n time_units = f['time'].units\n if type(time_units) is str and len(time_units)>3:\n # cdscan can get time units from the files; we're good.\n f.close()\n cdscan_line = 'cdscan -q '+'-x '+xml_name+' '+' '.join(famfiles)\n else:\n # cdscan needs to be told what the time units are. I'm betting that all files\n # use the same units. I know of cases where they all have different units (e.g.,\n # GISS) but in all those cases, the units attribute is used properly, so we don't\n # get here.\n # Another problem is that units stuck in the long_name sometimes are\n # nonstandard. So fix them!\n if hasattr(f['time'],'long_name'):\n time_units = f['time'].long_name\n else:\n time_units = 'days' # probably wrong but we can't go on without something\n # Usually when we get here it's a climatology file where time is meaningless.\n f.close()\n if type(time_units) is str and len(time_units)>1 and (\n time_units.find('months')==0 or time_units.find('days')==0 or\n time_units.find('hours')==0 ):\n time_units = fix_time_units( time_units )\n cdscan_line = 'cdscan -q '+'-x '+xml_name+' -e time.units=\"'+time_units+'\" '+\\\n ' '.join(famfiles)\n else:\n print \"WARNING, cannot find time units; will try to continue\",famfiles[0]\n cdscan_line = 'cdscan -q '+'-x '+xml_name+' -e time.units=\"'+time_units+'\" '+\\\n ' '.join(famfiles)\n print \"cdscan_line=\",cdscan_line\n proc = subprocess.Popen([cdscan_line],shell=True)\n proc_status = proc.wait()\n if proc_status!=0: print \"ERROR: cdscan terminated with\",proc_status\n f = cdms2.open( xml_name )\n else:\n # the easy case, just one file has all the data on this variable\n f = cdms2.open(files[0])\n fcf = get_datafile_filefmt(f)\n reduced_data = self._reduction_function( f(self.variableid), vid=vid )\n if reduced_data is not None:\n reduced_data._vid = vid\n f.close()\n return reduced_data"},"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 open_files(self):\n if not self.unbalanced:\n if not self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest.nc')\n return datas\n if self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_valid.nc')\n return datas\n if self.unbalanced:\n if not self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced.nc')\n return datas\n if self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced_valid.nc')\n return datas","def reduce_single_set_data():\n workflow = my_data.get()\n\n # Set reduction parameters\n focus_calib_file = '/SNS/VULCAN/shared/autoreduce/vulcan_foc_all_2bank_11p.cal'\n\n workflow.set_focus_calibration_file(focus_calib_file)\n\n # set up reduction parameters\n outputdir = os.getcwd()\n paramdict = {\n \"Extension\": \"_event.nxs\",\n \"PreserveEvents\": True,\n \"Binning\": -0.001,\n \"OutputDirectory\": outputdir,\n \"NormalizeByCurrent\": False,\n \"FilterBadPulses\": False,\n \"CompressTOFTolerance\": False,\n \"FrequencyLogNames\": \"skf1.speed\",\n \"WaveLengthLogNames\": \"skf12.lambda\",\n }\n\n workflow.set_reduction_parameters(paramdict)\n\n # reduce\n reduction_list = [(80231, True)]\n workflow.set_reduction_flag(file_flag_list=reduction_list, clear_flags=True)\n\n status, ret_obj = workflow.reduce_data_set(norm_by_vanadium=False)\n print('[Message] ', str(ret_obj))\n assert status","def get_model_data_from_files(self, oc):\r\n # Load model related files\r\n model_path = self.config['DATA_PATH'] + self.config['CUSTOMER_NAME'] + '/models/'\r\n\r\n features_file = model_path + self.task + '_' + str(oc) + '_features.txt'\r\n dummies_file = model_path + self.task + '_' + str(oc) + '_dummies.txt'\r\n model_file = model_path + self.task + '_' + str(oc) + '.joblib'\r\n\r\n if os.path.isfile(features_file) and os.path.isfile(dummies_file) and os.path.isfile(model_file):\r\n model = joblib.load(model_file)\r\n features = open(features_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\n').split(self.config['DATA_SEPARATOR'])\r\n dummies = open(dummies_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\n').split(self.config['DATA_SEPARATOR'])\r\n return (model, features, dummies)\r\n return (None, None, None)","def stageData(self,m):\n obs = Variable(filename = self.source,\n variable_name = self.variable,\n alternate_vars = self.alternate_vars)\n if obs.time is None: raise il.NotTemporalVariable()\n self.pruneRegions(obs)\n \n # Try to extract a commensurate quantity from the model\n mod = m.extractTimeSeries(self.variable,\n alt_vars = self.alternate_vars,\n expression = self.derived,\n initial_time = obs.time_bnds[ 0,0],\n final_time = obs.time_bnds[-1,1],\n lats = None if obs.spatial else obs.lat,\n lons = None if obs.spatial else obs.lon)\n obs,mod = il.MakeComparable(obs,mod,\n mask_ref = True,\n clip_ref = True,\n extents = self.extents,\n logstring = \"[%s][%s]\" % (self.longname,m.name))\n \n # Check the order of magnitude of the data and convert to help avoid roundoff errors\n def _reduceRoundoffErrors(var):\n if \"s-1\" in var.unit: return var.convert(var.unit.replace(\"s-1\",\"d-1\"))\n if \"kg\" in var.unit: return var.convert(var.unit.replace(\"kg\" ,\"g\" ))\n return var\n def _getOrder(var):\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\n order = _getOrder(obs)\n count = 0\n while order < -2 and count < 2:\n obs = _reduceRoundoffErrors(obs)\n order = _getOrder(obs)\n count += 1\n \n # convert the model data to the same unit\n mod = mod.convert(obs.unit)\n\n return obs,mod","def apply(self, opened_file):","def load_file_data_from_db(self):\n\n file_objs = self.file_queryset.filter(sip=self.sip, removedtime__isnull=True)\n for file_obj in self._batch_query(file_objs):\n self.file_events = get_file_events(file_obj)\n if not self.file_events:\n return\n try:\n # merge the map_file_data dict with the map_av_data\n mapped_file_info = merge_file_data_dicts(\n map_file_data(file_obj, self.file_events), map_av_data(file_obj)\n )\n self.md_info[\"files\"].append(mapped_file_info)\n self.md_info[\"premis:size\"] = create_package_size(\n mapped_file_info[\"premis:size\"]\n )\n self.md_info[\"amount_of_files\"] += 1\n failed_virus_checks = get_failed_virus_checks(self.file_events)\n if failed_virus_checks:\n self.md_info[\"virus_scan_info\"][\"failed_virus_checks\"].append(\n failed_virus_checks\n )\n passed_virus_checks = get_passed_virus_checks(self.file_events)\n # add info virus_scan_tools if they passed and respect\n # different tools and versions if needed.\n if (\n passed_virus_checks\n and passed_virus_checks\n not in self.md_info[\"virus_scan_info\"][\"virus_scan_tools\"]\n ):\n self.md_info[\"virus_scan_info\"][\"virus_scan_tools\"].append(\n passed_virus_checks\n )\n except KeyError:\n logger.info(\n \"File is no longer present on the filesystem: %s\",\n file_obj.currentlocation,\n )\n continue","def get_data(self): \n self.improvement = []\n self.corrsq = []\n for filename in onlyfiles:\n mst = MST(filename, mypath=mypath)\n mst.estimate_correct_seqences()\n mst.estimate_improvement()\n self.mst.append(mst)\n\n self.corrsq.append(mst.corrsq)\n self.improvement.append(mst.improvement)\n\n\n\n print(f\"cor = {improvement}\")\n print(f\"improvement = {improvement}\")\n print(f\"mittelwert der improvement = {np.mean(improvement)}\")\n print(f\"Standardabweichung der lersteigung = {np.std(improvement)}\")","def get_data(self):\n \n with os.scandir(self.file_path) as collection_of_files:\n files_found = [file.name.split('.')[0] for file in collection_of_files \n if (file.name.split('.')[0].lower().strip() in self._data_requirements.required_file_names \n and file.name.endswith('.csv'))]\n\n self.check_missing_files(files_found)\n \n self._data = DictObjectView(self.read_in_files(files_found))","def get_additional_data_from_files(df, file_description): # file description one of [\"video\", \"eaf\", \"seg\", \"gentle\"]\n if file_description == \"gentle\":\n file_folder = FILE_BASE + \"/gentle/\"\n is_gentle_file = True\n else:\n file_folder = FILE_BASE + \"/original/\"\n is_gentle_file = False\n\n file_df = None\n\n if file_description not in list(FILE_DESCRIPTIONS_TO_EXT.keys()):\n print(\"Unknown file description! Don't know what to do with %s files...\" % file_description)\n return None\n\n else:\n print(\"Load and extract information from %s files...\" % file_description)\n #pbar = tqdm.tqdm(total = len(np.unique(df[\"source_file\"])),desc='Files', position=0,leave=True,file=sys.stdout)\n #file_log = tqdm.tqdm(total=0, position=1, bar_format='{desc}',leave=True,file=sys.stdout)\n print(\"Total files to laod and preprocess: \", len(np.unique(df[\"source_file\"])))\n \n for i,file in enumerate(np.unique(df[\"source_file\"])):\n if i%100 == 0:\n print(\"File: \",i)\n \n filepath = file_folder + get_file_path(file,is_gentle_file=is_gentle_file) + FILE_DESCRIPTIONS_TO_EXT[file_description]\n\n if file_description == \"video\":\n file_i_df = mp4_file_processing.get_word_video_snippet_size(df, filepath)\n elif file_description == \"eaf\":\n speech_annotation_eaf_data, gesture_eaf_data = eaf_file_processing.read_eaf(filepath)\n file_i_df = eaf_file_processing.map_gestures_to_annotation(speech_annotation_eaf_data, gesture_eaf_data, remove_pauses=False)\n file_i_df = eaf_file_processing.binary_encode_gestures(file_i_df, gesture_column=\"gesture\")\n\n elif file_description == \"seg\":\n file_i_df = seg_file_processing.get_seg_file_pos_info(filepath)\n\n elif file_description == \"gentle\":\n file_i_df = gentle_file_processing.get_gentle_file_transcripts(filepath)\n \n else:\n print(\"Unknown file format!!!\")\n return \n\n if file_df is None:\n file_df = file_i_df\n else:\n file_df = pd.concat([file_df, file_i_df], ignore_index=True)\n\n #file_log.set_description_str(f'Processed file: {file}')\n #pbar.update(1)\n #sleep(0.02)\n #file_log.close()\n #pbar.close()\n return file_df","def cmorization(in_dir, out_dir, cfg, cfg_user, start_date, end_date):\n # Run the cmorization\n for (short_name, var) in cfg['variables'].items():\n logger.info(\"CMORizing variable '%s'\", short_name)\n short_name = var['short_name']\n raw_filenames = Path(in_dir).rglob('*.nc')\n filenames = []\n for raw_filename in raw_filenames:\n if re.search(var['file'], str(raw_filename)) is not None:\n filenames.append(raw_filename)\n\n for filename in sorted(filenames):\n\n _extract_variable(short_name, var, cfg, filename, out_dir)","def readExperi(directory,varid,experi,level):\n print('\\n>>> Using readExperi function! \\n')\n \n ### Import modules\n import numpy as np\n from netCDF4 import Dataset\n \n ### Call files\n totaldirectory = directory + experi + '/monthly/'\n filename = totaldirectory + varid + '_1900-2000.nc'\n \n if any([experi == 'FPOL',experi == 'FSUB']):\n directory = '/home/zlabe/green/simu/'\n totaldirectory = directory + experi + '/monthly/'\n filename = totaldirectory + varid + '_1900-2000.nc'\n \n ### Read in Data\n if level == 'surface': # 3d variables\n data = Dataset(filename,'r')\n varq = data.variables['%s' % varid][:,:,:,0]\n data.close()\n \n dataq = Dataset(totaldirectory + 'T2M_1900-2000.nc')\n time = dataq.variables['time'][:]\n lev = 'surface'\n lat = dataq.variables['latitude'][:]\n lon = dataq.variables['longitude'][:]\n dataq.close()\n elif level == 'profile': # 4d variables\n data = Dataset(filename,'r')\n varq = data.variables['%s' % varid][:,:,:,0]\n data.close()\n \n dataq = Dataset(totaldirectory + 'TEMP_1900-2000.nc')\n time = dataq.variables['time'][:]\n lev = dataq.variables['level'][:]\n lat = dataq.variables['latitude'][:]\n lon = dataq.variables['longitude'][:]\n dataq.close()\n else:\n print(ValueError('Selected wrong height - (surface or profile!)!')) \n print('Completed: Read data for *%s* : %s!' % (experi[:4],varid))\n \n ### Reshape to split years and months\n months = 12\n if level == 'surface': # 3d variables\n var = np.reshape(varq,(int(varq.shape[0]/12),months,\n int(lat.shape[0])))\n elif level == 'profile': # 4d variables\n var = np.reshape(varq,(int(varq.shape[0]/12),months,int(lev.shape[0]),\n int(lat.shape[0])))\n else:\n print(ValueError('Selected wrong height - (surface or profile!)!')) \n print('Completed: Reshaped %s array!' % (varid))\n \n ### Convert units\n if varid in ('TEMP','T2M'):\n var = var - 273.15 # Kelvin to degrees Celsius \n print('Completed: Changed units (K to C)!')\n\n print('\\n*Completed: Finished readExperi function!')\n return lat,lon,time,lev,var","def __call__( self, file_contents, regression_var ):\n return super()._process( self.__load( file_contents ), regression_var )","def __call__( self, file_contents, regression_var ):\n return super()._process( self.__load( file_contents ), regression_var )","def _compute_(self, case):\n dic = \"data/sim/{dn}/{rad}/\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"), rad=self.rad)\n fn = \"data/sim/{dn}/{rad}/exp.{cse}.bm({bm}).elv(<elv>).csv\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"),\n rad=self.rad, bm=self.bmnum, cse=case)\n cmd = \"export DIR_MODELS_REF_DAT=/home/shibaji/Collaboration_NCAR/code_rt_sd/pharlap/pharlap_4.1.3/dat;\\\n cd pharlap;\\\n matlab -nodisplay -nodesktop -nosplash -nojvm -r \\\"UT=[{ut}];rad='{rad}';dic='{dic}';bm={bm};\\\n fn='{fn}';cse='{cse}';rt_1D_sen;exit;\\\"\".format(ut=self.event.strftime(\"%Y %m %d %H %S\"), rad=self.rad,\n dic=dic, bm=self.bmnum, fn=fn, cse=case)\n os.system(cmd)\n return","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","def execute(cf):\n\n ##Ports and parameters\n train_set = cf.get_input(\"train_set\") #training set. Typically even_file\n test_set = cf.get_input(\"test_set\") #test set. Typically odd_file\n WM1 = cf.get_input(\"WM1\")\n WM2 = cf.get_input(\"WM2\")\n WM3 = cf.get_input(\"WM3\")\n WM4 = cf.get_input(\"WM4\")\n WM5 = cf.get_input(\"WM5\")\n WM6 = cf.get_input(\"WM6\")\n WM7 = cf.get_input(\"WM7\")\n WM8 = cf.get_input(\"WM8\")\n WM9 = cf.get_input(\"WM9\")\n WM10 = cf.get_input(\"WM10\")\n WM11 = cf.get_input(\"WM11\")\n WM12 = cf.get_input(\"WM12\")\n WM13 = cf.get_input(\"WM13\")\n WM14 = cf.get_input(\"WM14\")\n WM15 = cf.get_input(\"WM15\")\n WM16 = cf.get_input(\"WM16\")\n WM17 = cf.get_input(\"WM17\")\n WM18 = cf.get_input(\"WM18\")\n WM19 = cf.get_input(\"WM19\")\n WM20 = cf.get_input(\"WM20\")\n WMdir = cf.get_input(\"WMdir\")\n WMdir2 = cf.get_input(\"WMdir2\")\n basefreqs = cf.get_input(\"BaseFrequencies\")\n ufemodel_path = cf.get_input(\"UFEmodel\")\n\n bestWM = cf.get_output(\"BestWM\")\n log_file = cf.get_output(\"log_file\")\n interm = cf.get_output(\"intermediate\")\n\n genome = cf.get_parameter('genome', 'string')\n motevo_path = cf.get_parameter('motevo_path', 'string')\n aligned = cf.get_parameter(\"aligned\", \"boolean\")\n\n os.mkdir(interm)\n\n\n\n # Read stuff in\n WMs = [i for i in[WM1, WM2, WM3, WM4, WM5, WM6, WM7, WM8, WM9, WM10, WM11, WM12, WM13, WM14, WM15, WM16, WM17, WM18, WM19, WM20] if i]\n\n if WMdir:\n WMs += [os.path.join(WMdir, wm) for wm in os.listdir(WMdir)]\n\n if WMdir2:\n WMs += [os.path.join(WMdir2, wm) for wm in os.listdir(WMdir2)]\n\n f = open(basefreqs)\n ATfreq = float(f.readline().strip().split()[1])\n GCfreq = float(f.readline().strip().split()[1])\n f.close()\n\n\n # Compute stuff: optimal priors and then likelihood of test set\n optpriors = []\n logliks = []\n\n for i, WM in enumerate(WMs):\n\n wmlen = len(open(WM).readlines())-4\n\n # 1. Fit prior on training set with EM\n tag = 'fitP_%i' %(i+1)\n params, sites, priors, loglikfile = giveMotevoParamFile(genome, wmlen, interm, tag, aligned, ufemodel_path, ATfreq, GCfreq, emprior=1, bgorder=0, bgprior=0.99)\n r = runMotevo(motevo_path, train_set, params, WM, interm, tag)\n if r != 0:\n print 'motevo failed ', tag\n sys.exit(1)\n\n # prior file:\n # WM_name final_prior nr_of_sites density\n # /import/bc2/home/nimwegen/GROUP/hseq_pipeline/severin/Anduril/Pipeline/PipeLineSource/TESTRUN/NRF1_Z2/OUTPUT/NRF1_FgBg-runmotevoPG2_1/Logo 0.016554 635.008 0.251863\n # background 0.983446 37724.8 0.748137\n # UFEwm 0 0 0\n\n optprior = float(open(priors).readlines()[1].split()[1])\n bgprior=(1-optprior)\n print bgprior\n\n # 2. Compute log-likelihood on test set with optimal prior from training set and without EM\n tag = 'compLL_%i' %(i+1)\n params, sites, priors, loglikfile = giveMotevoParamFile(genome, wmlen, interm, tag, aligned, ufemodel_path, ATfreq, GCfreq, emprior=0, bgorder=0, bgprior=bgprior)\n runMotevo(motevo_path, train_set, params, WM, interm, tag)\n\n a = loadtxt(loglikfile, usecols=[1])\n ll = sum(a)\n\n logliks.append(ll)\n optpriors.append(optprior)\n\n print logliks\n\n\n\n #replace name in WM file with bestWM\n lines = open(WMs[argmax(logliks)]).readlines()\n lines[1] = 'NA BestWM\\n'\n bwm = open(bestWM, 'w')\n bwm.write(''.join(lines))\n\n\n l = open(log_file, 'w')\n\n l.write('WM_name\\tWM_path\\tlog_likelihood\\topt_prior\\n')\n\n names = ['WM_%i\\t%s\\t%.4f\\t%s' %(i+1, WMs[i], logliks[i], optpriors[i]) for i in arange(len(WMs))]\n\n l.write('\\n'.join(names))\n l.close()\n\n\n return 0","def solve(ctx):\n my_solver(ctx.obj['filename'])","def get_obs(case, this_varname, this_filename, valid_years, mode_lag, cvdp_file, AMO_cutoff_freq, name_conversion):\n\n # The forced component of both temperature and precipitation are estimated through regressing the local\n # values onto the GM-EM temperature time series, which can be viewed as a proxy for radiative forcing.\n\n # We assume that the forced component of SLP is zero.\n cvdp_loc = '/'.join(cvdp_file.split('/')[:-1])\n gm_em, gm_em_units, time, time_units = forced_trend('tas', cvdp_loc)\n\n if this_varname == 'slp':\n gm_em *= 0\n gm_em += 1 # will replace constant\n\n # Get dataframe of modes\n df = create_mode_df(cvdp_file, AMO_cutoff_freq)\n\n # Add EM, GM time series to it\n df = df.assign(F=gm_em)\n\n # Shift modes in time\n df_shifted = shift_df(df, mode_lag, ['year', 'month', 'season', 'F'])\n\n # Subset to valid years\n subset = np.isin(df_shifted['year'].values, valid_years)\n df_shifted = df_shifted.loc[subset, :]\n\n # Reset the forced trend time series to a mean of zero\n # This allows for the forced trend to be straightforwardly added in later\n F = df_shifted['F'].values\n F -= np.mean(F)\n df_shifted = df_shifted.assign(F=F)\n\n # Load dataset\n if case == 'obs': # Observational data\n ds = xr.open_dataset(this_filename)\n elif 'LE' in case: # CESM data. Allows for multiple runs to be concatenated if desired.\n if this_varname == 'pr': # CESM splits up precipitation into convective and large scale, liquid+ice vs snow\n ds = xr.open_mfdataset(this_filename, combine='nested', concat_dim='time')\n this_filename2 = [f.replace('PRECC', 'PRECL') for f in this_filename]\n ds2 = xr.open_mfdataset(this_filename2, combine='nested', concat_dim='time')\n this_filename3 = [f.replace('PRECC', 'PRECSC') for f in this_filename]\n ds3 = xr.open_mfdataset(this_filename3, combine='nested', concat_dim='time')\n this_filename4 = [f.replace('PRECC', 'PRECSL') for f in this_filename]\n ds4 = xr.open_mfdataset(this_filename4, combine='nested', concat_dim='time')\n # CESM output saved with one day delay, so need to move back\n ds2 = ds2.assign_coords(time=ds2.time-timedelta(days=1))\n ds3 = ds3.assign_coords(time=ds3.time-timedelta(days=1))\n ds4 = ds4.assign_coords(time=ds4.time-timedelta(days=1))\n else:\n ds = xr.open_mfdataset(this_filename, combine='nested', concat_dim='time')\n\n # CESM output saved with one day delay, so need to move back\n ds = ds.assign_coords(time=ds.time-timedelta(days=1))\n\n # Load data\n try:\n lat = ds['latitude'].values\n lon = ds['longitude'].values\n except KeyError:\n lat = ds['lat'].values\n lon = ds['lon'].values\n try:\n X = ds[this_varname]\n X_units = ds[this_varname].units\n except KeyError:\n alt_name = name_conversion[this_varname]\n X = ds[alt_name]\n X_units = ds[alt_name].units\n\n # Pull out values, since we'll be permuting the data / changing units, etc\n # For CESM1-LE precipitation, need to add up convective and large scale\n if name_conversion[this_varname] == 'PRECC':\n X = X.values + ds2.PRECL.values + ds3.PRECSC.values + ds4.PRECSL.values\n else:\n X = X.values\n\n X_time = ds['time']\n if 'units' in ds['time'].attrs: # nonstandard, from BEST\n assert ds['time'].units == 'year A.D.'\n X_year = np.floor(X_time)\n X_month = (np.ceil((X_time - X_year)*12)).astype(int)\n else:\n X_year = ds['time.year']\n X_month = ds['time.month']\n\n # Change units if necessary\n if X_units == 'K':\n # convert to celsius\n X -= 273.15\n X_units = 'deg C'\n elif X_units == 'm/s':\n # convert to mm / day\n X *= 1000*24*60*60 # mm per day\n X_units = 'mm/day'\n elif X_units == 'mm/month': # GPCC, mm total over month\n days_per_month = [calendar.monthrange(int(y), int(m))[1] for y, m in zip(X_year, X_month)]\n X /= np.array(days_per_month)[:, np.newaxis, np.newaxis]\n X_units = 'mm/day'\n\n # Check unit consistency\n if this_varname == 'slp':\n assert X_units == 'Pa'\n if this_varname == 'pr':\n assert X_units == 'mm/day'\n\n if 'climatology' in ds.variables:\n climo = ds['climatology'].values\n # Add climatology to X\n for counter, this_month in enumerate(X_month):\n X[counter, ...] += climo[this_month - 1, ...]\n\n # Permute all data to be time, lat, lon\n lat_idx = np.where(np.isin(X.shape, len(lat)))[0][0]\n lon_idx = np.where(np.isin(X.shape, len(lon)))[0][0]\n time_idx = np.where(np.isin(X.shape, len(X_time)))[0][0]\n\n X = np.transpose(X, (time_idx, lat_idx, lon_idx))\n ntime, nlat, nlon = np.shape(X)\n\n # Subset data\n subset = np.isin(X_year, valid_years)\n X = X[subset, :]\n X_year = X_year[subset]\n X_month = X_month[subset]\n\n # Also need to check if our data spans the full valid period\n subset = np.isin(df_shifted['year'].values, X_year)\n df_shifted = df_shifted.loc[subset, :]\n\n # Check that all dimensions look consistent\n assert len(df_shifted) == np.shape(X)[0]\n\n # Put into dataarray\n time = pd.date_range(start='%04d-%02d' % (X_year[0], X_month[0]),\n freq='M', periods=len(X_year))\n daX = xr.DataArray(data=X,\n dims=('time', 'lat', 'lon'),\n coords={'time': time,\n 'lat': lat,\n 'lon': lon},\n attrs={'units': X_units})\n\n return daX, df_shifted, df","def main(data, setup):\n # input check \n varnames = ('vm_raw', 'vm_raw_theo')\n for varname in varnames:\n if varname not in data.keys():\n raise LookupError('data must contain variable %s.' %s)\n\n # display info message\n chrono = setup['chrono']\n chrono.issue('target velocity: correct for sensor motion...')\n\n # retrieve varialbes\n vnys = data['nqv']\n v_sensor_r = data['v_sensor_r']\n\n # ========== main =================================== #\n for key_raw in ('vm_raw', 'vm_raw_theo'):\n key_c = key_raw.replace('raw', 'raw_c')\n\n # sum\n vm_raw = data[key_raw]\n v_sum = (vm_raw + np.expand_dims(v_sensor_r, 1))\n\n # mod\n data[key_c] = symmod(v_sum, vnys)\n # ==================================================== #\n\n return data","def get_files(self):\n\n # Grab master data - use existing header, remove unhappy columns\n\n self.df_mas_lab_data = pd.read_csv(\n self.master_csv, dtype=str, usecols=self.columns\n )\n\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\n # Physician Office\n facility_type_keep_list = [\"Independent\", \"Hospital\", \"Physician Office\"]\n self.df_mas_lab_data = self.df_mas_lab_data[\n self.df_mas_lab_data[\"FACILITY_TYPE\"].isin(facility_type_keep_list)\n ]\n\n # Make everything a string and remove trailing and leading whitespaces\n self.df_mas_lab_data = self.df_mas_lab_data.astype(str)\n self.df_mas_lab_data = self.df_mas_lab_data.applymap(\n lambda x: x.strip() if isinstance(x, str) else x\n )\n\n print_banner(\"Computing all the Data\")\n print(f\"{len(self.df_mas_lab_data)} original master CLIA labs...\")\n\n # Grab other inputed files to make new data file to compare with\n self.df_new_lab_data = pd.concat(\n [\n pd.read_csv(file, names=self.columns, header=None, dtype=str, usecols=self.columns)\n for file in self.new_files\n ]\n )\n\n # Probably not needed for the new data but just in case:\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\n # Physician Office\n self.df_new_lab_data = self.df_new_lab_data[\n self.df_new_lab_data[\"FACILITY_TYPE\"].isin(facility_type_keep_list)\n ]\n\n # Make everything a string and remove trailing and leading whitespaces\n self.df_new_lab_data = self.df_new_lab_data.astype(str)\n self.df_new_lab_data = self.df_new_lab_data.applymap(\n lambda x: x.strip() if isinstance(x, str) else x\n )\n\n print(f\"{len(self.df_new_lab_data)} inputted CLIA labs for comparison...\")","def _get_model_val(models_name, data_dir, val_source='test'):\n model_val = {}\n for model in models_name:\n mypath = data_dir + '/' + model\n only_files = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n select_files = [val_source in x for x in only_files]\n only_files = list(compress(only_files, select_files))\n if type(only_files) == list:\n for name_file in only_files:\n df_name = name_file.replace('.csv', '')\n model_val[model + '_' + df_name] = pd.read_csv(mypath + '/' + name_file)\n else:\n df_name = only_files.replace('.csv', '')\n model_val[model + '_' + df_name] = pd.read_csv(mypath + '/' + only_files)\n return model_val","def eval(\n self,\n processed_data_dir: Path,\n output_result_dir: Path,\n ) -> NoReturn:\n pass","def s_validation(path_setup=None):\n if path_setup is not None:\n # import validation setup\n fname = os.path.basename(path_setup)\n mname, ext = os.path.splitext(fname)\n val_module = imp.load_source(mname, path_setup)\n jobs, process = val_module.setup_process()\n results_path = '/data-write/RADAR/Validation_FFascetti/'\n for job in jobs:\n results = process.calc(job)\n netcdf_results_manager(results, results_path)","def ReadData( fileName ):\n \n # define column names\n colNames = ['Date','Precip','Max Temp', 'Min Temp','Wind Speed'] #NOTE: I changed the column names because .query() would not work when referencing column names with spaces\n global DataDF #added this line to make the dataframe visible in the variable explorer\n global ReplacedValuesDF #added this line to make the dataframe visible in the variable explorer\n # open and read the file\n DataDF = pd.read_csv(\"DataQualityChecking.txt\",header=None, names=colNames, \n delimiter=r\"\\s+\",parse_dates=[0])\n DataDF = DataDF.set_index('Date')\n \n # define and initialize the missing data dictionary\n ReplacedValuesDF = pd.DataFrame(0, index=[\"1. No Data\",\"2. Gross Error\",\"3. Swapped\",\"4. Range Fail\"], columns=colNames[1:]) #added additional indexed rows to make adding the values later easier\n \n return( DataDF, ReplacedValuesDF )","def exercise_9(path_to_X_data, path_to_w_data):\r\n\r\n print(\"=\"*30)\r\n print(\"Running exercise_9()\")\r\n\r\n #### YOUR CODE HERE ####\r\n # load the X and w data from file into arrays\r\n X = numpy.loadtxt('data/X.txt', delimiter=',')\r\n w = numpy.loadtxt('data/w.txt', delimiter=',')\r\n\r\n print(f'X:\\n{X}')\r\n print(f'w: {w}')\r\n\r\n #### YOUR CODE HERE ####\r\n # Extract the column 0 (x_n1) and column 1 (x_n2) vectors from X\r\n\r\n x_n1 = X[numpy.array([0,1,2,3,4]), 0]\r\n x_n2 = X[numpy.array([0,1,2,3,4]), 1]\r\n\r\n print(f'x_n1: {x_n1}')\r\n print(f'x_n2: {x_n2}')\r\n\r\n #### YOUR CODE HERE ####\r\n w_0 = w[0]\r\n w_1 = w[1]\r\n\r\n scalar_result_0 = w_0 * w_0 * sum(x_n1*x_n1) + 2 * w_0 * w_1 * sum(x_n2 * x_n1) + w_1 * w_1 * sum(x_n2*x_n2)\r\n # Use scalar arithmetic to compute the right-hand side of Exercise 3\r\n # (Exercise 1.3 from FCMA p.35)\r\n # Set the final value to\r\n scalar_result = scalar_result_0\r\n\r\n print(f'scalar_result: {scalar_result}')\r\n\r\n #### YOUR CODE HERE ####\r\n # Now you will compute the same result but using linear algebra operators.\r\n # (i.e., the left-hand of the equation in Exercise 1.3 from FCMA p.35)\r\n # You can compute the values in any linear order you want (but remember,\r\n # linear algebra is *NOT* commutative!), however here will require you to\r\n # first compute the inner term: X-transpose times X (XX), and then\r\n # below you complete the computation by multiplying on the left and right\r\n # by w (wXXw)\r\n X_transpose = numpy.transpose(X)\r\n XX = numpy.dot(X_transpose, X)\r\n\r\n print(f'XX:\\n{XX}')\r\n\r\n #### YOUR CODE HERE ####\r\n # Now you'll complete the computation by multiplying on the left and right\r\n # by w to determine the final value: wXXw\r\n wXX = numpy.dot(w, XX)\r\n wXXw = numpy.dot(wXX, w)\r\n\r\n print(f'wXXw: {wXXw}')\r\n\r\n print(\"DONE exercise_9()\")\r\n\r\n return X, w, x_n1, x_n2, scalar_result, XX, wXXw","def readFiles(opt, path, pathCopyData,minlat, maxlat, minlon, maxlon , variables, estaciones):\n date = '\\d\\d\\d\\d-\\d\\d-\\d\\d'\n dirr = pathCopyData\n patron2 = re.compile(date)\n print(dirr + 'tfile.txt')\n tempfile = df.read_csv(dirr + 'tfile.txt')\n tempbase = df.read_csv(dirr + 'tbase.txt')\n tfile = list(tempfile.values.flatten())\n tbase = list(tempbase.values.flatten())\n tfileCopy = list(tempfile.values.flatten())\n tbaseCopy = list(tempbase.values.flatten())\n l = len(tfile)\n for i in range(l):\n tfil = tfile[i]\n tbas = tbase[i]\n ls = tbas + '/' + tfil\n f = patron2.findall(tfil)\n cadena = clearString(tfil)\n print(cadena)\n try:\n #net = open_netcdf(ls, tfil, cadena, pathCopyData)\n net = Dataset(ls)\n for xs in range(len(estaciones)):\n minlat1 = minlat[xs]\n maxlat1 = maxlat[xs]\n minlon1 = minlon[xs]\n maxlon1 = maxlon[xs]\n estacion = estaciones[xs]\n #checkFile(net, tfil, f[0], opt, path, minlat1, maxlat1, minlon1, maxlon1, variables, estacion)\n var_cut = []\n for i in variables:\n var = net.variables[i][:,int(minlat1):int(maxlat1),int(minlon1):int(maxlon1)]\n #print(LON)\n #print(var)\n #return\n # celda.append(var)\n # result = ne(var, LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\n var_cut.append(var)\n\n for ls in range(len(var_cut)):\n saveData(var_cut[ls], variables[ls], f[0], opt, path, estacion)\n tfileCopy.remove(tfil)\n tbaseCopy.remove(tbas)\n except (OSError, EOFError) as e:\n print(e)\n fdata = df.DataFrame(tfileCopy, columns=['nameFile'])\n fbas = df.DataFrame(tbaseCopy, columns=['nameBase'])\n fdata.to_csv(dirr + 'tfile.txt', encoding='utf-8', index=False)\n fbas.to_csv(dirr + 'tbase.txt', encoding='utf-8', index=False)\n if os.path.exists(pathCopyData + cadena):\n os.remove(pathCopyData + cadena)\n sys.exit()\n # readFiles(1);\n except tarfile.ReadError:\n print('error2')\n # fdata = df.DataFrame(tfile,columns=['nameFile']);\n # fbas = df.DataFrame(tbase,columns=['nameBase']);\n # fdata.to_csv(dirr+'tfile.txt',encoding='utf-8',index=False);\n # fbas.to_csv(dirr+'tbase.txt',encoding='utf-8',index=False);\n # readFiles(1);\n except (KeyError, FileNotFoundError):\n print('ERROR DE LECTURA')","def load_fvcom_files(filepath=None,casename=None,ncname=None,neifile=None):\n\n currdir=os.getcwd()\n os.chdir(filepath)\n\n data=_load_grdfile(casename)\n\n data.update(_load_depfile(casename))\n \n data.update(_load_spgfile(casename))\n\n data.update(_load_obcfile(casename))\n\n data.update(_load_llfiles(casename))\n\n if ncname!=None:\n data.update(_load_nc(ncname))\n\n if neifile!=None:\n data.update(loadnei(neifile))\n\n os.chdir(currdir)\n\n return data","def update_file_vectors(self, audio_file):\n outer_df = defer.Deferred()\n\n def get_file_vector(val):\n # Take all the new PluginOutput objects and generate and\n # apply a single vector to represent the file.\n df = self.mine.calculate_file_vector(audio_file)\n return df\n\n def save_file(vector):\n logger.debug(\"--> Applying vector to %r %r\", audio_file, vector)\n logger.debug(\"--> Saving %r\", audio_file)\n audio_file.vector = vector\n df_s = self.model.save(audio_file)\n return df_s\n\n logger.debug(\"NB: Updating File Vectors for %r\", audio_file)\n df = self.get_vectors_eventually(audio_file)\n df.addCallback(get_file_vector)\n df.addCallback(save_file)\n\n return df","def mover_get_data(lfns,\n path,\n sitename,\n queuename,\n stageinTries,\n inputpoolfcstring=\"xmlcatalog_file:PoolFileCatalog.xml\",\n ub=\"outdated\", # to be removed\n dsname=\"\",\n dsdict={},\n rucio_dataset_dictionary={},\n guids=[],\n analysisJob=False,\n usect=True,\n pinitdir=\"\",\n proxycheck=True,\n spsetup=\"\",\n tokens=[],\n userid=\"\",\n inputDir=\"\",\n jobId=None,\n jobDefId=\"\",\n access_dict=None,\n scope_dict=None,\n workDir=\"\",\n DN=None,\n dbh=None,\n jobPars=\"\",\n cmtconfig=\"\",\n filesizeIn=[],\n checksumIn=[],\n transferType=None,\n experiment=\"\",\n eventService=False,\n sourceSite=\"\"):\n\n tolog(\"Mover get data started\")\n\n statusPFCTurl = None\n pilotErrorDiag = \"\"\n\n # FAX counters (will be reported in jobMetrics; only relevant when FAX has been activated after a stage-in failure)\n N_filesWithoutFAX = 0\n N_filesWithFAX = 0\n bytesWithoutFAX = 0L\n bytesWithFAX = 0L\n\n # FAX control variable, if FAX is used as primary site mover in combination with direct I/O\n usedFAXandDirectIO = False\n\n # The FAX variables above will be stored in a dictionary, to be returned by this function\n FAX_dictionary = {}\n\n # Is the DBRelease file available locally?\n DBReleaseIsAvailable = handleDBRelease(dbh, lfns, jobPars, path)\n\n # Should stage-in be aborted? (if there are only locally available DBRelease files in the stage-in list)\n if abortStageIn(dbh, lfns, DBReleaseIsAvailable):\n return 0, pilotErrorDiag, statusPFCTurl, FAX_dictionary\n\n # Setup the dictionary necessary for all instrumentation\n report = getInitialTracingReport(userid, sitename, dsname, \"get_sm\", analysisJob, jobId, jobDefId, DN)\n\n if stageinTries != 0:\n get_RETRY = min(stageinTries, MAX_NUMBER_OF_RETRIES)\n else:\n get_RETRY = MAX_RETRY\n get_TIMEOUT = 5*3600/get_RETRY\n\n fail = 0\n guidfname = {}\n error = PilotErrors()\n\n region = readpar('region')\n\n # Space tokens currently not used for input files\n # # check if there is are any space tokens\n # _token = getProperSpaceTokenList(token, listSEs, len(lfns))\n\n # Select the correct mover\n copycmd, setup = getCopytool(mode=\"get\")\n\n # Get the sitemover object corresponding to the default copy command\n sitemover = getSiteMover(copycmd, setup)\n\n # Get the experiment object\n thisExperiment = getExperiment(experiment)\n\n # Get the name for the PFC file\n _path = path\n if eventService:\n # Update the path (create the PFC in one level above the payload workdir)\n path = os.path.abspath(os.path.join(path, '..'))\n pfc_name = getPFCName(path, inputpoolfcstring)\n # done with the event server modification (related to the PFC generation), reset the path again\n path = _path\n\n # Build the file info dictionary (use the filesize and checksum from the dispatcher if possible) and create the PFC\n # Format: fileInfoDic[file_nr] = (guid, gpfn, fsize, fchecksum, filetype, copytool)\n # replicas_dic[guid1] = [ replica1, .. ] where replicaN is an object of class replica\n ec, pilotErrorDiag, fileInfoDic, totalFileSize, replicas_dic = \\\n getFileInfo(region, ub, queuename, guids, dsname, dsdict, lfns, pinitdir, analysisJob, tokens, DN, sitemover, error, path, dbh, DBReleaseIsAvailable,\\\n scope_dict, pfc_name=pfc_name, filesizeIn=filesizeIn, checksumIn=checksumIn, thisExperiment=thisExperiment)\n if ec != 0:\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\n\n # Until the Mover PFC file is no longer needed, call the TURL based PFC \"PoolFileCatalogTURL.xml\"\n pfc_name_turl = pfc_name.replace(\".xml\", \"TURL.xml\")\n\n # Create a SURL to space token dictionary\n tokens_dictionary = getSurlTokenDictionary(lfns, tokens)\n\n # Create a TURL based PFC if necessary/requested (i.e. if copy tool should not be used [useCT=False] and\n # if oldPrefix and newPrefix are not already set in copysetup [useSetPrefixes=False])\n ec, pilotErrorDiag, createdPFCTURL, usect = PFC4TURLs(analysisJob, transferType, fileInfoDic, pfc_name_turl, sitemover, sitename, usect, dsdict, eventService, tokens_dictionary, sitename, sourceSite, lfns)\n if ec != 0:\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\n\n # Correct the total file size for the DBRelease file if necessary\n totalFileSize = correctTotalFileSize(totalFileSize, fileInfoDic, lfns, dbh, DBReleaseIsAvailable)\n\n # Only bother with the size checks if the copy tool is to be used (non-direct access mode)\n if usect:\n # Get a proper maxinputsize from schedconfig/default \n _maxinputsize = getMaxInputSize()\n\n # Check the total input file size\n ec, pilotErrorDiag = verifyInputFileSize(totalFileSize, _maxinputsize, error)\n if ec != 0:\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\n\n # Do we have enough local space to stage in all data and run the job?\n ec, pilotErrorDiag = verifyAvailableSpace(sitemover, totalFileSize, path, error)\n if ec != 0:\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\n\n # Get the replica dictionary from file (used when the primary replica can not be staged due to some temporary error)\n replica_dictionary = getReplicaDictionaryFile(path)\n\n # file counters\n N_files_on_tape = 0\n N_root_files = 0\n N_non_root_files = 0\n\n # If FAX is used as a primary site mover then set the default FAX mode to true, otherwise to false (normal mode)\n if copycmd == \"fax\":\n usedFAXMode = True\n else:\n usedFAXMode = False\n\n # Use isOneByOneFileTransfer() to determine if files should be transferred one by one or all at once\n if not sitemover.isOneByOneFileTransfer():\n\n # Note: this mode is used by the aria2c site mover only\n # Normal stage-in is below\n\n tolog(\"All files will be transferred at once\")\n\n # Extract the file info for the first file in the dictionary\n guid, gpfn, lfn, fsize, fchecksum, filetype, copytool = extractInputFileInfo(fileInfoDic[0], lfns)\n file_access = getFileAccess(access_dict, lfn)\n dsname = getDataset(lfn, dsdict)\n\n # Perform stage-in using the sitemover wrapper method\n s, pErrorText = sitemover_get_all_data(sitemover, error, gpfn, lfn, path, fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\n guid=guid, analysisJob=analysisJob, usect=usect, pinitdir=pinitdir, proxycheck=proxycheck,\\\n sitename=sitename, token=None, timeout=get_TIMEOUT, dsname=dsname, userid=userid, report=report,\\\n access=file_access, inputDir=inputDir, jobId=jobId, workDir=workDir, cmtconfig=cmtconfig, lfns=lfns,\\\n experiment=experiment, replicas_dic=replicas_dic, dsdict=dsdict, scope_dict=scope_dict)\n if s != 0:\n tolog('!!WARNING!!2999!! Failed during stage-in of multiple files: %s' % (error.getErrorStr(s)))\n tolog(\"Exit code: %s\" % (s))\n fail = s\n\n # Normal stage-in (one by one file transfers)\n if sitemover.isOneByOneFileTransfer() or fail != 0:\n \n tolog(\"Files will be transferred one by one\")\n\n # Reset any previous failure\n fail = 0\n\n # Loop over all files in the file info dictionary\n number_of_files = len(fileInfoDic.keys())\n tolog(\"Will process %d file(s)\" % (number_of_files))\n for nr in range(number_of_files):\n # Extract the file info from the dictionary\n guid, gpfn, lfn, fsize, fchecksum, filetype, copytool = extractInputFileInfo(fileInfoDic[nr], lfns)\n\n # Has the copycmd/copytool changed? (E.g. due to FAX) If so, update the sitemover object\n if copytool != copycmd:\n copycmd = copytool\n # Get the sitemover object corresponding to the new copy command\n sitemover = getSiteMover(copycmd, setup)\n tolog(\"Site mover object updated since copytool has changed\")\n\n # Update the dataset name\n dsname = getDataset(lfn, dsdict)\n proper_dsname = getDataset(lfn, rucio_dataset_dictionary)\n scope = getFileScope(scope_dict, lfn)\n\n # Update the tracing report with the proper container/dataset name\n report = updateReport(report, gpfn, proper_dsname, fsize, sitemover)\n report['scope'] = scope\n\n # The DBRelease file might already have been handled, go to next file\n if isDBReleaseFile(dbh, lfn) and DBReleaseIsAvailable:\n updateFileState(lfn, workDir, jobId, mode=\"transfer_mode\", state=\"no_transfer\", type=\"input\")\n guidfname[guid] = lfn # needed for verification below\n continue\n else:\n tolog(\"(Not a DBRelease file)\")\n\n tolog(\"Mover is preparing to copy file %d/%d (lfn: %s guid: %s dsname: %s)\" % (nr+1, number_of_files, lfn, guid, dsname))\n tolog('Copying %s to %s (file catalog checksum: \\\"%s\\\", fsize: %s) using %s (%s)' %\\\n (gpfn, path, fchecksum, fsize, sitemover.getID(), sitemover.getSetup()))\n\n # Get the number of replica retries\n get_RETRY_replicas = getNumberOfReplicaRetries(createdPFCTURL, replica_dictionary, guid)\n\n file_access = getFileAccess(access_dict, lfn)\n\n # Loop over get function to allow for multiple get attempts for a file\n will_use_direct_io = False\n get_attempt = 0\n\n #get_RETRY = 1 #2 #PN\n while get_attempt < get_RETRY:\n if get_attempt > 0:\n _rest = 5*60\n tolog(\"(Waiting %d seconds before next stage-in attempt)\" % (_rest))\n sleep(_rest)\n tolog(\"Get attempt %d/%d\" % (get_attempt + 1, get_RETRY))\n replica_number = 0\n replica_transferred = False\n s = 1\n\n # Loop over replicas\n while s != 0 and replica_number < get_RETRY_replicas:\n # Grab the gpfn from the replicas dictionary in case alternative replica stage-in is allowed\n gpfn = getAlternativeReplica(gpfn, guid, replica_number, createdPFCTURL, replica_dictionary)\n\n # Perform stage-in using the sitemover wrapper method\n s, pErrorText, N_files_on_tape, N_root_files, N_non_root_files, replica_transferred, will_use_direct_io = sitemover_get_data(sitemover, error,\\\n get_RETRY, get_RETRY_replicas, get_attempt,\\\n replica_number, N_files_on_tape, N_root_files,\\\n N_non_root_files, gpfn, lfn, path,\\\n fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\n guid=guid, analysisJob=analysisJob, usect=usect,\\\n pinitdir=pinitdir, proxycheck=proxycheck,\\\n sitename=sitename, token=None, timeout=get_TIMEOUT,\\\n dsname=dsname, userid=userid, report=report,\\\n access=file_access, inputDir=inputDir, jobId=jobId,\\\n workDir=workDir, cmtconfig=cmtconfig,\\\n experiment=experiment, scope_dict=scope_dict,\\\n sourceSite=sourceSite)\n # Get out of the multiple replica loop\n if replica_transferred:\n break\n\n # Increase the replica attempt counter in case the previous replica could not be transferred\n replica_number += 1\n\n # Get out of the multiple get attempt loop\n if replica_transferred:\n break\n\n # Increase the get attempt counter in case of failure to transfer the file\n get_attempt += 1\n\n # Increase the successful file transfer counter (used only when reporting FAX transfers)\n if s == 0:\n # note the special case if FAX is the primary site mover (normally FAX is the fallback)\n if sitemover.copyCommand == \"fax\":\n N_filesWithFAX += 1\n bytesWithFAX += long(fsize)\n else:\n # Normal case\n N_filesWithoutFAX += 1\n bytesWithoutFAX += long(fsize)\n\n if s != 0:\n # Normal stage-in failed, now try with FAX if possible\n if error.isPilotFAXErrorCode(s):\n if isFAXAllowed(filetype, gpfn) and transferType != \"fax\" and sitemover.copyCommand != \"fax\": # no point in trying to fallback to fax if the fax transfer above failed\n tolog(\"Normal stage-in failed, will attempt to use FAX\")\n usedFAXMode = True\n\n # Get the FAX site mover\n old_sitemover = sitemover\n sitemover = getSiteMover(\"fax\", \"\")\n\n # Perform stage-in using the sitemover wrapper method\n s, pErrorText, N_files_on_tape, N_root_files, N_non_root_files, replica_transferred, will_use_direct_io = sitemover_get_data(sitemover, error,\\\n get_RETRY, get_RETRY_replicas, get_attempt, replica_number,\\\n N_files_on_tape, N_root_files, N_non_root_files,\\\n gpfn, lfn, path,\\\n fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\n guid=guid, analysisJob=analysisJob, usect=usect,\\\n pinitdir=pinitdir, proxycheck=proxycheck,\\\n sitename=sitename, token=None, timeout=get_TIMEOUT,\\\n dsname=dsname, userid=userid, report=report,\\\n access=file_access, inputDir=inputDir, jobId=jobId,\\\n workDir=workDir, cmtconfig=cmtconfig, experiment=experiment)\n if replica_transferred:\n tolog(\"FAX site mover managed to transfer file from remote site (resetting error code to zero)\")\n pilotErrorDiag = \"\"\n s = 0\n\n # Increase the successful FAX transfer counter\n N_filesWithFAX += 1\n bytesWithFAX += long(fsize)\n else:\n tolog(\"FAX site mover also failed to transfer file from remote site, giving up\")\n\n # restore the old sitemover\n del sitemover\n sitemover = old_sitemover\n else:\n tolog(\"(Not an error code eligible for FAX fail-over)\")\n\n if s != 0:\n tolog('!!FAILED!!2999!! Failed to transfer %s: %s (%s)' % (os.path.basename(gpfn), s, error.getErrorStr(s)))\n tolog(\"Exit code: %s\" % (s))\n\n # report corrupt file to consistency server if needed\n if s == error.ERR_GETADMISMATCH or s == error.ERR_GETMD5MISMATCH or s == error.ERR_GETWRONGSIZE or s == error.ERR_NOSUCHFILE:\n reportFileCorruption(gpfn, sitemover)\n\n # exception for object stores\n if (gpfn.startswith(\"s3:\") or 'objectstore' in gpfn) and '.log.tgz' in gpfn:\n tolog(\"!!FAILED!!2999!! Failed to transfer a log file from S3 objectstore. Will skip it and continue the job.\")\n else:\n fail = s\n break\n\n # Build the dictionary used to create the PFC for the TRF\n # In the case of FAX, use the global paths if direct access is to be used for the particlar file\n if usedFAXMode and will_use_direct_io:\n # The site mover needed here is the FAX site mover since the global file path methods are defined there only\n old_sitemover = sitemover\n sitemover = getSiteMover(\"fax\", \"\")\n guidfname[guid] = sitemover.findGlobalFilePath(lfn, dsname, sitename, sourceSite)\n\n # Restore the old sitemover\n del sitemover\n sitemover = old_sitemover\n\n # If FAX is used as a primary site mover, in combination with direct access, set the usedFAXandDirectIO flag\n # this will later be used to update the run command (e.g. --lfcHost is not needed etc)\n if copycmd == \"fax\":\n usedFAXandDirectIO = True\n else:\n guidfname[guid] = lfn # local_file_name\n\n if fail == 0:\n # Make sure the PFC has the correct number of files\n fail, pilotErrorDiag = verifyPFCIntegrity(guidfname, lfns, dbh, DBReleaseIsAvailable, error)\n\n # Now that the Mover PFC file is no longer needed, back it up and rename the TURL based PFC if it exists\n # (the original PFC is no longer needed. Move it away, and then create the PFC for the trf/runAthena)\n # backupPFC4Mover(pfc_name)\n\n # Create a standard PFC with SURLs if needed (basically this is default)\n # note: if FAX was used as a primary site mover in combination with direct I/O, then the SURLs will actually be TURLs\n # but there is no need to use the special TURL creation method PFC4TURL used above (FAX will have returned the TURLs instead)\n createStandardPFC4TRF(createdPFCTURL, pfc_name_turl, pfc_name, guidfname)\n\n tolog(\"Number of identified root files : %d\" % (N_root_files))\n tolog(\"Number of transferred non-root files: %d\" % (N_non_root_files))\n\n if usedFAXMode:\n tolog(\"Number of files without FAX : %d (normal transfers)\" % (N_filesWithoutFAX))\n tolog(\"Number of files with FAX : %d (successful FAX transfers)\" % (N_filesWithFAX))\n tolog(\"Bytes without FAX : %d (normal transfers)\" % (bytesWithoutFAX))\n tolog(\"Bytes with FAX : %d (successful FAX transfers)\" % (bytesWithFAX))\n\n if N_files_on_tape > 0:\n tolog(\"!!WARNING!!2999!! Number of skipped files: %d (not staged)\" % (N_files_on_tape))\n if N_root_files == 0:\n # This should only happen for user jobs\n tolog(\"Mover get_data failed since no root files could be transferred\")\n fail = error.ERR_NOSTAGEDFILES\n else:\n tolog(\"Mover get_data finished (partial)\")\n else:\n if fail == 0:\n tolog(\"Get successful\")\n tolog(\"Mover get_data finished\")\n else:\n tolog(\"Mover get_data finished (failed)\")\n tolog(\"Will return exit code = %d, pilotErrorDiag = %s\" % (fail, pilotErrorDiag)) \n\n # Now populate the FAX dictionary before finishing\n FAX_dictionary = getFAXDictionary(N_filesWithoutFAX, N_filesWithFAX, bytesWithoutFAX, bytesWithFAX, usedFAXandDirectIO)\n\n return fail, pilotErrorDiag, statusPFCTurl, FAX_dictionary","def loadScalarField(self):\n\n\t\tif self.beta is None:\n\t\t\traise ForcingException(\"Must supply concentration response factor\")\n\n\t\tif self._mortality_fname is None or self._mortality_var is None:\n\t\t\traise ForcingException(\"Must supply mortality file\")\n\n\t\tif self._pop_fname is None or self._pop_var is None:\n\t\t\traise ForcingException(\"Must supply population file\")\n\n\t\t# This is optional\n\t\t#if self.vsl is None:\n\t\t#\traise ForcingException(\"Must specify statistical value of life (in millions)\")\n\n\t\t# Open the mortality file\n\t\ttry:\n\t\t\tmortality = DataFile(self._mortality_fname, mode='r', open=True)\n\t\texcept IOError as ex:\n\t\t\tForcing.error(\"Error! Cannot open mortality file %s. File exists? %r\"%(self._mortality_fname, os.path.isfile(self._mortality_fname)))\n\t\t\traise\n\n\t\t# Check dimensions\n\t\tif not (mortality.dimensions['COL'] == self.ni and mortality.dimensions['ROW'] == self.nj):\n\t\t\traise ValueError(\"Error, dimensions in mortality file %s do not match domain.\"%self._mortality_fname)\n\n\t\t# Read the field\n\t\ttry:\n\t\t\t# dims are TSTEP, LAY, ROW, COL.. so skip TSTEP and LAY\n\t\t\t# this should be made more general, or the file should be made better.\n\t\t\tmfld = mortality.variables[self._mortality_var][0][0]\n\t\texcept IOError as e:\n\t\t\traise e\n\t\texcept IndexError as e:\n\t\t\traise ForcingFileDimensionException(\"Mortality NetCDF file seems to have incompatible dimensions. Currently require shape (TSTEP, LAY, ROW, COL). This is marked to be improved, as the data does not vary with time or layer.\")\n\n\t\t# Close the file\n\t\tif self._pop_fname != self._pop_fname:\n\t\t\tmortality.close()\n\n\t\t\t# Open the population file\n\t\t\ttry:\n\t\t\t\tpop = DataFile(self._pop_fname, mode='r', open=True)\n\t\t\texcept IOError as ex:\n\t\t\t\tForcing.error(\"Error! Cannot open population file %s\"%(self._pop_fname))\n\t\t\t\traise\n\n\t\t\t# Check dimensions\n\t\t\tif not (pop.dimensions['COL'] == self.ni and pop.dimensions['ROW'] == self.nj):\n\t\t\t\traise ValueError(\"Error, dimensions in population file %s do not match domain.\"%self._pop_fname)\n\t\telse:\n\t\t\t# Same file?\n\t\t\tpop = mortality\n\n\t\t# Read the field\n\t\ttry:\n\t\t\t# dims are TSTEP, LAY, ROW, COL.. so skip TSTEP and LAY\n\t\t\tpfld = pop.variables[self._pop_var][0][0]\n\t\texcept IOError as e:\n\t\t\traise e\n\t\texcept IndexError as e:\n\t\t\traise ForcingFileDimensionException(\"Population NetCDF file seems to have incompatible dimensions. Currently require shape (TSTEP, LAY, ROW, COL). This is marked to be improved, as the data does not vary with time or layer.\")\n\n\n\t\tpop.close()\n\n\t\t# Debug, remember, when debugging this against plotted data or fortran\n\t\t# code: values like (70,70) started at index 1 whereas we started at\n\t\t# index 0, so (70,70)=(69,69)\n\t\t#print \"[j=%d,i=%d] = mfld * mfld_scale * pfld * self.beta / 365 = %e %e %e %e %e = %e\"%(self.debug_j, self.debug_i, mfld[self.debug_j,self.debug_i], (10.**-4), pfld[self.debug_j,self.debug_i], self.beta, 365.0, mfld[self.debug_j,self.debug_i]*(10.**-4)*pfld[self.debug_j,self.debug_i]*self.beta/365.0)\n\n\t\t# (mfld * pfld) is element wise multiplication, not matrix multiplication\n\t\t# Take leap years into account?\n\t\tForcing.debug(\"[TODO]: Leap years are not yet accounted for.\")\n\t\tself.timeInvariantScalarMultiplcativeFld = mfld * self.mort_scale / 365.0 * pfld * self.beta\n\t\tif self.vsl is not None:\n\t\t\tself.timeInvariantScalarMultiplcativeFld = self.timeInvariantScalarMultiplcativeFld * self.vsl","def FSC2(input_dir, num_reps=50, min_sims=100000, max_ecm=20, calc_CI=False, numcores=1, scratch_mb='200', time_scratch=\"01:50:00\", mem=\"200\", print1=False, overwrite=\"None\", fsc2_path=\"/storage/plzen1/home/holcovam/programs/fsc26_linux64/fsc26\"):\n Data_Files = []\n tpl_files = []\n est_files = []\n CI_Data_Files = []\n shlist = []\n\n if input_dir.endswith(\"/\") is False:\n input_dir += \"/\"\n\n for path in os.listdir(input_dir):\n if os.path.isdir(input_dir + path) and path.startswith(\"FSC2input\"):\n samp_name = path.split(\"_\")[1]\n #folder_name = samp_name\n if samp_name + \"_DSFS.obs\" in os.listdir(input_dir + path):\n for i in range(0, num_reps):\n new_file = open(input_dir + path + \"/\" + samp_name + str(i) + \"_DSFS.obs\", 'w')\n with open(input_dir + path + \"/\" + samp_name + \"_DSFS.obs\") as data_file:\n for line in data_file:\n new_file.write(line)\n new_file.close()\n Data_Files.append(input_dir + path + \"/\" + samp_name + str(i) + \"_DSFS.obs\")\n else:\n print(\"Did not find input data file for: \", samp_name)\n if calc_CI == \"True\":\n num_files = 0\n for file in os.listdir(input_dir + path):\n if file.endswith(\"_DSFS.obs\") and file.split(\"_\")[-2].split(\".\")[-1][0:3] == \"rep\" and file != samp_name + \"_DSFS.obs\":\n for i in range(0, num_reps):\n new_file = open(input_dir + path + \"/\" + samp_name + file.split(\"_\")[-2].split(\".\")[-1].split(\"_\")[0]+ \"_\" + str(i) + \"_DSFS.obs\", 'w')\n with open(input_dir + path + \"/\" + file) as data_file:\n for line in data_file:\n new_file.write(line)\n new_file.close()\n CI_Data_Files.append(input_dir + path + \"/\" + samp_name + file.split(\"_\")[-2].split(\".\")[-1].split(\"_\")[0]+ \"_\" + str(i) + \"_DSFS.obs\")\n num_files += 1\n if len(CI_Data_Files) < 1:\n print(\"Did not find bootstrap replicates for: \", samp_name)\n else:\n print(\"Found \", num_files, \" replicate dsfs files for CI calculation for \", samp_name)\n if path.endswith(\".tpl\"):\n tpl_files.append(path)\n est_files.append(path.split(\".\")[0])\n if len(tpl_files) == 0:\n print(\"Did not find any tpl files!! Aborting!!\")\n else:\n if calc_CI == \"True\":\n Data_Files = CI_Data_Files\n for file in Data_Files:\n name = file.split(\"_DSFS\")[0]\n samp_name = name.split(\"/\")[-1]\n folder_name = samp_name [0:11]\n for tpl in tpl_files:\n tpl_name = tpl.split(\".tpl\")[0]\n if os.path.isdir(name + \"_\" + tpl_name) is False or overwrite == \"hard\":\n new_tpl = open(name + \"_\" + tpl_name + \".tpl\", 'w')\n new_data = open(name + \"_\" + tpl_name + \"_DSFS.obs\", 'w')\n\n with open(file, 'r') as data:\n for i, line in enumerate(data):\n if i == 1:\n pop_info = line.strip(\"\\n\").strip(\"\\t\").split(\"\\t\")\n pop_num = int(pop_info[0])\n samp_nums = pop_info[-pop_num:]\n new_data.write(line)\n with open(input_dir + tpl, 'r') as template:\n samp_num_lines = pop_num + 4\n for i, line in enumerate(template):\n if i < samp_num_lines:\n new_tpl.write(line)\n elif i == samp_num_lines:\n for num in samp_nums:\n new_tpl.write(num + \"\\n\")\n elif i >= samp_num_lines + len(samp_nums):\n new_tpl.write(line)\n new_est = open(name + \"_\" + tpl_name + \".est\", 'w')\n try:\n with open(input_dir + tpl_name + \".est\") as est:\n for line in est:\n new_est.write(line)\n except FileNotFoundError:\n print(\"Did not find est file for: \", tpl)\n #folder_name = samp_name ''.join(i for i in s if not i.isdigit())\n shname = name + \"_\" + tpl_name + \".sh\"\n shfile5 = open(shname, 'w')\n shfile5.write('#!/bin/bash -e\\n' +\n '#PBS -N '+samp_name+'\\n' +\n '#PBS -l walltime='+str(time_scratch)+'\\n' +\n '#PBS -l select=1:ncpus='+str(numcores)+':mem='+str(mem)+'mb:scratch_local='+str(scratch_mb)+'mb\\n' +\n '#PBS -m abe\\n' +\n '#PBS -j oe\\n\\n' +\n 'module add python-3.4.1-gcc\\n'+\n 'module add python34-modules-gcc\\n'+\n 'trap \\'clean_scratch\\' TERM EXIT\\n'+\n 'if [ ! -d \"$SCRATCHDIR\" ] ; then echo \"Scratch not created!\" 1>&2; exit 1; fi \\n' +\n 'DATADIR=\"/storage/plzen1/home/holcovam/ScanTools\"\\n' +\n 'cp $DATADIR/'+ input_dir + \"FSC2input_\" + folder_name+ \"/\" + samp_name + \"_\" + tpl_name + '* $SCRATCHDIR || exit 1\\n'+\n 'cp '+fsc2_path+' $SCRATCHDIR || exit 1\\n'+\n 'cd $SCRATCHDIR || exit 2\\n' +\n 'echo data loaded at `date`\\n\\n' +\n 'chmod +x fsc26 \\n' +\n #'ls -l \\n' +\n './fsc26 -t ' + samp_name + \"_\" + tpl_name + '.tpl -e ' + samp_name + \"_\" + tpl_name + '.est -n ' + str(min_sims) + ' -u -d -q -L ' + str(max_ecm) + ' -M \\n' + \n 'rm seed.txt \\n'+\n 'rm fsc26\\n'+\n 'rm *DSFS.obs\\n'+\n 'rm *.sh\\n'+\n 'rm *.tpl \\n'+\n 'rm *.est \\n'+\n #'ls -l \\n' +\n 'cp $SCRATCHDIR/*.par $DATADIR/'+ input_dir + \"FSC2input_\" + folder_name+' || exit 1\\n'+\n 'rm *.par \\n'+\n 'cp -r $SCRATCHDIR/* $DATADIR/'+input_dir+' || export CLEAN_SCRATCH=false\\n'+\n 'printf \"\\\\nFinished\\\\n\\\\n\"\\n')\n shfile5.close()\n shlist.append(shname)\n\n############IF PROBLEM WITH EXCESS OF NONCONVERGED CHAINS, COPY /home/majda/alpine/fastsimcoal2/afterWPSG/scripts/notConverged.py here ###################\n\n else:\n print(\"Output for \" + samp_name + \"_\" + tpl_name + \" already exists. Use hard_overwrite = True to overwrite.\")\n return shlist","def science_reduction(input_file):\n #name of the planet\n planet = input_file['exoplanet']\n #set original directory\n original_path = os.getcwd()\n save_path = input_file['save_path']\n data_path = input_file['data_path']\n #Change your directory to data diretory\n os.chdir(data_path)\n #list all flat images\n exoplanet = glob.glob(planet+'*.fits')\n print '\\nLoading exoplanet images \\nTotal of '+planet+'*.fits files = ',len(exoplanet),'\\nFiles = \\n'\n print exoplanet\n #if save_path exist, continue; if not, create.\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n #create a list of bias images and copy images to save_path\n print '\\nCopy science images to save_path directory to main reduction: ....'\n os.system('cp '+planet+'*.fits '+save_path)\n print '\\n .... done. \\n'\n #change to save_path\n os.chdir(save_path)\n #create the names for exoplanet science mages with bias subtracted\n bexoplanet = []\n for i in exoplanet:\n bexoplanet.append('B'+i)\n #verify if previous superbias exist\n if os.path.isfile('B'+i) == True:\n os.system('rm B'+i)\n print '\\n Will be create this images: \\n'\n print bexoplanet\n #exoplanet = string.join(exoplanet,',') #create the list string of exoplanet science images\n #bexoplanet = string.join(bexoplanet,',')#create the list string of bexoplanet science images\n print '\\nSubtracting superbias.fits from all '+planet+'*.fits images ....\\n'\n for i in range(len(exoplanet)):\n iraf.imarith(exoplanet[i],'-','superbias.fits',bexoplanet[i])\n use.update_progress((i+1.)/len(bexoplanet))\n print '\\n.... cleaning '+planet+'*.fits images\\n'\n os.system('rm '+planet+'*.fits')\n print '\\n Statistics of B'+planet+'*.fits images: \\n'\n for i in range(len(bexoplanet)):\n iraf.imstat(bexoplanet[i])\n print '\\nFlatfielding the B'+planet+'*.fits ....\\n'\n #create the names for exoplanet science images with bias subtracted and flatfielding\n abexoplanet = []\n for i in bexoplanet:\n abexoplanet.append('A'+i)\n #verify if previous superbias exist\n if os.path.isfile('A'+i) == True:\n os.system('rm A'+i)\n print '\\n Will be create this images: \\n'\n print abexoplanet\n #flatifielding images\n for i in range(len(abexoplanet)):\n iraf.imarith(bexoplanet[i],'/','superflat.fits',abexoplanet[i])\n use.update_progress((i+1.)/len(abexoplanet))\n # print '\\n.... cleaning B'+planet+'*.fits images\\n'\n # os.system('rm B'+planet+'*.fits')\n print '\\n Statistics of AB'+planet+'*.fits images: \\n'\n for i in range(len(abexoplanet)):\n iraf.imstat(abexoplanet[i])\n os.chdir(original_path) #change to save_path\n return","def mri_dixon_analysis(data_objects, working_dir, settings):\n\n logger.info(\"Running Dixon analysis Calculation\")\n logger.info(\"Using settings: %s\", settings)\n\n output_objects = []\n\n fat_obj = None\n water_obj = None\n for data_obj in data_objects:\n\n if data_obj.meta_data[\"image_type\"] == \"fat\":\n fat_obj = data_obj\n\n if data_obj.meta_data[\"image_type\"] == \"water\":\n water_obj = data_obj\n\n if fat_obj is None or water_obj is None:\n logger.error(\"Both Fat and Water Images are required\")\n return []\n\n # Read the image series\n fat_load_path = fat_obj.path\n if fat_obj.type == \"DICOM\":\n fat_load_path = sitk.ImageSeriesReader().GetGDCMSeriesFileNames(fat_obj.path)\n fat_img = sitk.ReadImage(fat_load_path)\n\n water_load_path = water_obj.path\n if water_obj.type == \"DICOM\":\n water_load_path = sitk.ImageSeriesReader().GetGDCMSeriesFileNames(water_obj.path)\n water_img = sitk.ReadImage(water_load_path)\n\n # Cast to float for calculation\n fat_img = sitk.Cast(fat_img, sitk.sitkFloat32)\n water_img = sitk.Cast(water_img, sitk.sitkFloat32)\n\n # Let's do the calcuation using NumPy\n fat_arr = sitk.GetArrayFromImage(fat_img)\n water_arr = sitk.GetArrayFromImage(water_img)\n\n # Do the calculation\n divisor = water_arr + fat_arr\n fat_fraction_arr = (fat_arr * 100) / divisor\n fat_fraction_arr[divisor == 0] = 0 # Sets those voxels which were divided by zero to 0\n water_fraction_arr = (water_arr * 100) / divisor\n water_fraction_arr[divisor == 0] = 0 # Sets those voxels which were divided by zero to 0\n\n fat_fraction_img = sitk.GetImageFromArray(fat_fraction_arr)\n water_fraction_img = sitk.GetImageFromArray(water_fraction_arr)\n\n fat_fraction_img.CopyInformation(fat_img)\n water_fraction_img.CopyInformation(water_img)\n\n # Create the output Data Objects and add it to output_ob\n fat_fraction_file = os.path.join(working_dir, \"fat.nii.gz\")\n sitk.WriteImage(fat_fraction_img, fat_fraction_file)\n water_fraction_file = os.path.join(working_dir, \"water.nii.gz\")\n sitk.WriteImage(water_fraction_img, water_fraction_file)\n\n fat_data_object = DataObject(type=\"FILE\", path=fat_fraction_file, parent=fat_obj)\n output_objects.append(fat_data_object)\n\n water_data_object = DataObject(type=\"FILE\", path=water_fraction_file, parent=water_obj)\n output_objects.append(water_data_object)\n\n return output_objects","def open_file(file_path):\r\n\r\n global vector_X\r\n global training_data_matrix\r\n global row_number_of_data_matrix\r\n global single_row\r\n\r\n global training_g1_list\r\n global training_g2_list\r\n global training_g3_list\r\n\r\n global test_g1_list\r\n global test_g2_list\r\n global test_g3_list\r\n\r\n # open file\r\n with open(file_path, \"r\") as csvfile:\r\n\r\n line_number = 0\r\n index_of_training_matrix = 0\r\n\r\n # read all rows of csv file\r\n reader = csv.reader(csvfile)\r\n\r\n next(reader, None) # skip the headers\r\n\r\n for row in reader:\r\n\r\n row = row[0]\r\n\r\n # read line split by comma and convert into float numbers\r\n single_row = [float(x) for x in row.split(\";\")]\r\n\r\n # take the first 20% of the data as test data\r\n # and the remaining as the training data\r\n if line_number < row_number_of_test_data_matrix:\r\n\r\n test_data_matrix[line_number] = [1.0] + single_row[:-3]\r\n\r\n test_g1_list[line_number] = single_row[-3]\r\n test_g2_list[line_number] = single_row[-2]\r\n test_g3_list[line_number] = single_row[-1]\r\n\r\n else:\r\n training_data_matrix[index_of_training_matrix] = [1.0] + single_row[:-3]\r\n\r\n training_g1_list[index_of_training_matrix] = single_row[-3]\r\n training_g2_list[index_of_training_matrix] = single_row[-2]\r\n training_g3_list[index_of_training_matrix] = single_row[-1]\r\n\r\n index_of_training_matrix += 1\r\n\r\n if line_number == (row_number_of_data_matrix - 1):\r\n break\r\n\r\n line_number += 1\r\n\r\n return test_data_matrix, training_data_matrix, \\\r\n test_g1_list, test_g2_list, test_g3_list, \\\r\n training_g1_list, training_g2_list, training_g3_list","def _compute_(self):\n dic = \"data/sim/{dn}/{rad}/\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"), rad=self.rad)\n fbgc = \"data/sim/{dn}/{rad}/exp.bgc.bm({bm}).elv(<elv>).csv\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"), \n rad=self.rad, bm=self.bmnum)\n fflare = \"data/sim/{dn}/{rad}/exp.flare.bm({bm}).elv(<elv>).csv\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"),\n rad=self.rad, bm=self.bmnum)\n cmd = \"export DIR_MODELS_REF_DAT=/home/shibaji/Collaboration_NCAR/code_rt_sd/pharlap/pharlap_4.1.3/dat;\\\n cd pharlap;\\\n matlab -nodisplay -nodesktop -nosplash -nojvm -r \\\"UT=[{ut}];rad='{rad}';dic='{dic}';fbgc='{fbgc}';bm={bm};\\\n fflare='{fflare}';rt_1D_sim;exit;\\\"\".format(ut=self.event.strftime(\"%Y %m %d %H %S\"), rad=self.rad,\n dic=dic, bm=self.bmnum, fbgc=fbgc, fflare=fflare)\n os.system(cmd)\n return","def main():\n\n\t# Script arguments... \n\t\"\"\" If running as standalone, hardcode theWorkspace and inFile \"\"\"\n\ttheWorkspace = arcpy.GetParameterAsText(0)\n\tif not theWorkspace:\n\t\ttheWorkspace = r\"d:\\_dataTest\"\n\ttheWorkspace = r\"d:\\_dataTest\"\n\tarcpy.env.workspace = theWorkspace\n\tarcpy.env.overwriteOutput = True\n\toutWorkspace = os.path.join(theWorkspace, \"_repair\")\n\n\tinFile = arcpy.GetParameterAsText(1)\n\tif not inFile:\n\t\tinFile = \"updateMultipleSourcePaths.csv\"\n\t#inFile = \"FixSource4.csv\"\n\t#inFile = os.path.join(theWorkspace, inFile) + \".csv\"\n\t# opens the infile.csv, read only; then creates tuple of inFile\n\t#f = open(inFile, \"r\") \n\t#update_list = [tuple(line.strip().split(\",\") for line in f)]\n\n\n\tmxd = None\n\toutMXDName = \"none\"\n\tnewPath = []\n\t# makes sure the .csv file exists\n\tif arcpy.Exists(inFile):\n\t\tmyMsgs (\"Repair source list: \" + inFile)\n\t\t# walks thru the workspace to create list of files \n\t\tfor root, dirs, files in os.walk(theWorkspace): \n\t\t\tif root == outWorkspace:\n\t\t\t\tprint(\"heh now\")\n\t\t\t\tpass\n\t\t\t# creates list of .mxd's and works thru them\n\t\t\tmxdList = arcpy.ListFiles(\"*.mxd\")\n\t\t\tfor fileName in mxdList:\n\t\t\t\tfullPath = os.path.join(root, fileName) \n\t\t\t\tmxd = arcpy.mapping.MapDocument(fullPath)\n\t\t\t\tmyMsgs (\"*** Processing mxd: \" + fullPath)\n\t\t\t\t#mxd.findAndReplaceWorkspacePaths(\"v:\\\\\", \"\\\\\\\\dfg.alaska.local\\\\gis\\\\Anchorage\\\\gisshare\\\\\", validate=False)\n\t\t\t\t#mxd.findAndReplaceWorkspacePaths(\"t:\\\\\", \"\\\\\\\\dfg.alaska.local\\\\gis\\\\Anchorage\\\\GISStaff\\\\\", validate=False)\n\t\t\t\t#mxd.findAndReplaceWorkspacePaths(\"u:\\\\\", \"\\\\\\\\dfg.alaska.local\\\\gis\\\\Anchorage\\\\GISStaff\\\\\", validate=False)\n\t\t\t\t# New output mxd....\n\t\t\t\tbasename, extension = os.path.splitext(fileName)\n\t\t\t\toutMXDName = os.path.join(outWorkspace, (str(basename) + \"_fix.mxd\"))\n\t\t\t\t# create list of the tables since they are handle differently\n\t\t\t\ttheTables = arcpy.mapping.ListTableViews(mxd)\n\t\t\t\t# Loops thru layers, checks for broken links and tries to repai\n\t\t\t\tlyrList = arcpy.mapping.ListLayers(mxd)\n\t\t\t\tfor lyr in lyrList:\n\t\t\t\t\tif lyr.isBroken:\n\t\t\t\t\t\tif lyr.isGroupLayer or (\"Events\" in lyr.name):\n\t\t\t\t\t\t\tprint(\"...skipping group or event\")\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t#print(lyr.isServiceLayer)\n\t\t\t\t\t\tif lyr.isServiceLayer:\n\t\t\t\t\t\t\tif lyr.supports(\"SERVICEPROPERTIES\"):\n\t\t\t\t\t\t\t\tcnt = 0\n\t\t\t\t\t\t\t\tfor i, j in lyr.serviceProperties.iteritems():\n\t\t\t\t\t\t\t\t\tif cnt == 2:\n\t\t\t\t\t\t\t\t\t\tdataSource = str(j)\n\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\t\tcnt += 1 \n\t\t\t\t\t\t\t\tprint(\"sees this as service....using findAndReplsWorkspacePath\")\n\t\t\t\t\t\t\t\tnewPath = findUpdatePath(inFile, dataSource)\n\t\t\t\t\t\t\t\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tprint(\"--> a service layer but no SERVICE PROPOERTIES\")\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tprint(lyr.dataSource)\n\t\t\t\t\t\t\tnewPath = findUpdatePath(inFile, lyr.dataSource)\n\t\t\t\t\t\t\tnewDSPath, newDSName = os.path.split(newPath[0])\n\t\t\t\t\t\t\tprint(\"..newDSPAth \" + newDSPath)\n\t\t\t\t\t\t\tprint(\"..newDSName \" + newDSName)\n\t\t\t\t\t\t\tsameType = newPath[1]\n\t\t\t\t\t\t\tprint(\" same type? \" + str(sameType))\n\t\t\t\t\t\t\tcvrList = [r\"\\arc\", r\"\\polygon\", r\"\\region\", r\"\\point\", r\"\\tic\" ]\n\t\t\t\t\t\t\t#print newDSPath\n\t\t\t\t\t\t\tif newPath == \"no match\":\n\t\t\t\t\t\t\t\tprint(\"...no match to: \" + lyr.dataSource)\n\t\t\t\t\t\t\t\tnewPath[0] = \"not found\"\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\telif lyr.supports(\"dataSource\") and lyr.supports(\"datasetName\"):\n\t\t\t\t\t\t\t\tif lyr in theTables:\n\t\t\t\t\t\t\t\t\tprint(\"thinks its a table....using findAndReplsWorkspacePath\")\n\t\t\t\t\t\t\t\t\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False) \n\t\t\t\t\t\t\t\telif lyr.isRasterLayer:\n\t\t\t\t\t\t\t\t\tprint(\"thinks its a raster....using findAndReplsWorkspacePath\")\n\t\t\t\t\t\t\t\t\t#lyr.replaceDataSource(newPath, \"RASTER_WORKSPACE\", lyr.datasetName, False)\n\t\t\t\t\t\t\t\t\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False)\n\t\t\t\t\t\t\t\telif lyr.supports(\"dataSource\") and lyr.supports(\"datasetName\"):\n\t\t\t\t\t\t\t\t\tif not sameType and newPath[1] == \"gdb\":\n\t\t\t\t\t\t\t\t\t\tprint(\"..................moving to fgdb\")\n\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"FILEGDB_WORKSPACE\", newDSName, False) \n\t\t\t\t\t\t\t\t\telif r\".shp\" in lyr.dataSource:\n\t\t\t\t\t\t\t\t\t\tprint(\"thinks its a shape\")\n\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"SHAPEFILE_WORKSPACE\", lyr.datasetName, False)\n\t\t\t\t\t\t\t\t\telif r\".sde\" in lyr.dataSource:\n\t\t\t\t\t\t\t\t\t\tprint(\"thinks its a sde\")\n\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"SDE_Workspace\", lyr.datasetName, False)\n\t\t\t\t\t\t\t\t\telif r\".mdb\" in lyr.dataSource:\n\t\t\t\t\t\t\t\t\t\tprint(\"thinks its a pgdb\")\n\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"ACCESS_WORKSPACE\", lyr.datasetName, False)\n\t\t\t\t\t\t\t\t\telif r\".gdb\" in lyr.dataSource:\n\t\t\t\t\t\t\t\t\t\tprint(\"thinks its a fgdb\")\n\n\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"FILEGDB_WORKSPACE\", lyr.datasetName, False)\n\t\t\t\t\t\t\t\t\telif sameType:\n\t\t\t\t\t\t\t\t\t\tfor cvr in cvrList:\n\t\t\t\t\t\t\t\t\t\t\tif cvr in lyr.dataSource:\n\t\t\t\t\t\t\t\t\t\t\t\tprint(\"to WS sametype is True\")\n\t\t\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"ARCINFO_WORKSPACE\", newDSName, False)\n\t\t\t\t\t\t\t\t\telif not sameType:\n\t\t\t\t\t\t\t\t\t\tfor cvr in cvrList:\n\n\t\t\t\t\t\t\t\t\t\t\tlyr.replaceDataSource(newDSPath, \"FILEGDB_WORKSPACE\", newDSName, False)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\"\"\"else:\n newPath[0] = \"not found\" \"\"\"\n\t\t\t\t\t\t\tprint(\" **** the new data source: \" + newPath[0])\n\t\t\t\t\t\t\tprint(\"\")\n\n\t\t\t\tprint(outMXDName)\n\t\t\t\t#mxd.saveACopy(outMXDName, '10.1')\n\t\t\tif arcpy.Exists(outMXDName):\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\toutMXDName.save()\n\t\t\t\telse:\n mxd.saveACopy(outMXDName, '10.1')\n\t\t\t\tdel mxd\n\telse:\n\t\tmyMsgs (\"Repair source list: \" + inFile + \" does not exit.\")\n\n\tmyMsgs('!!! Success !!! ')","def check_idealised_files(ifile, ofile):\n\n # check that the 4 week forcing file exists\n if not os.path.isfile(ifile): # create file if it doesn't exist\n params = InForcings().defparams\n params.doy = random.randrange(92, 275) # random day within GS\n InForcings().run(ifile, params, Ndays=7*4)\n\n # check that the output file from the reference model exists\n if not os.path.isfile(ofile):\n df1, __ = read_csv(ifile)\n\n # add the soil moisture profile to the input data\n df1['sw'], df1['Ps'] = soil_water(df1, os.path.basename(ofile)\n .split('_')[1])\n df1['Ps_pd'] = df1['Ps'].copy() # pre-dawn soil water potential\n df1['Ps_pd'].where(df1['PPFD'] <= 50., np.nan, inplace=True)\n\n # fixed value for the wind speed\n df1['u'] = df1['u'].iloc[0]\n\n # non time-sensitive: last valid propagated until next valid\n df1.fillna(method='ffill', inplace=True)\n\n __ = hrun(ofile, df1, len(df1.index), 'Farquhar', models=['Medlyn'],\n inf_gb=True)\n\n return","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 file_checker():\n\n PATH_RELEASE1_IDEN = os.getcwd()+'/archive_all_2014-10/'\n PATH_RELEASE1_UNIDE = None\n #PATH_RELEASE1_UNIDE = os.getcwd()+'/archive_all_2014-10/'\n\n PATH_RELEASE2_IDEN = os.getcwd()+'/archive_all_2016-10/archive_identified_2016-10/'\n PATH_RELEASE2_UNIDE = os.getcwd() + '/archive_all_2016-10/archive_unidentified_2016-10/'\n\n\n #From here don't change anything.\n #This global function finds the .mgf files in paths\n list_of_files_release1_ide = glob.glob(PATH_RELEASE1_IDEN+'*.mgf')\n list_of_files_release1_unide = None #REMOVE THIS PART AND UNCOMMENT NEXT LINE IN NEXT RELEASES.\n\n #list_of_files_release1_unid = glob.glob(PATH_RELEASE1_UNID'+*.mgf')\n\n list_of_files_release2_ide = glob.glob(PATH_RELEASE2_IDEN+'*.mgf')\n list_of_files_release2_unide = glob.glob(PATH_RELEASE2_UNIDE+'*.mgf')\n\n\n #Check if exist cache folder. If not will make it. \n #RELEASE 1 \n if not os.path.exists(PATH_RELEASE1_IDEN+'cache'):\n os.makedirs(PATH_RELEASE1_IDEN+'cache')\n\n # if not os.path.exists(PATH_RELEASE1_UNIDE'+cache'):\n # os.makedirs(PATH_RELEASE1_UNIDE'+cache')\n\n #RELEASE2\n if not os.path.exists(PATH_RELEASE2_IDEN+'cache'):\n os.makedirs(PATH_RELEASE2_IDEN+'cache')\n\n if not os.path.exists(PATH_RELEASE2_UNIDE+'cache'):\n os.makedirs(PATH_RELEASE2_UNIDE+'cache')\n \n\n return PATH_RELEASE1_IDEN, \\\n PATH_RELEASE2_IDEN, \\\n PATH_RELEASE2_UNIDE, \\\n list_of_files_release1_ide, \\\n list_of_files_release2_ide, \\\n list_of_files_release2_unide","def processdata(path = os.getcwd(), mode = 'train'):\n # ind_vector: raw counts of ngrams occurring in each industry.\n # example: ('consultant', 'consultant'): 112, ('business', 'analyst'): 106, ('operations', 'manager'): 98, ('network', 'network'): 97, ('director', 'of'): 93, ('account', 'director'): 86, ('co', 'ordinator'): 82, ('product', 'product'): 79, ('it', 'it'): 77, ('programme', 'manager'): 77\n ind_vectors = pickle_load('ind_vectors.data')\n i_features = pickle_load('i_features.data')\n if mode == 'train':\n if not (ind_vectors and i_features): # False if the files weren't there.\n ind_vectors, i_features = gather_and_save_vectors(path)\n else: \n ind_vectors, i_features = gather_and_save_vectors(path,ind_vectors,i_features)\n elif mode != 'test':\n print('Usage: mode parameter should be either \"train\" or \"test\".')\n return None\n return ind_vectors, i_features","def READ_DEFINE_AND_PROCESS_EVERYTHING(basedir, in__dir):\n\n import sys, ast, multiprocessing\n import pandas as pd\n import numpy as np\n\n # Output dictionanry\n dc = {}\n \n # Read command line arguments\n try:\n y_var = dc['y_var'] = str(sys.argv[1]) \n y_area = dc['y_area'] = str(sys.argv[2])\n experiment = dc['experiment'] = str(sys.argv[3])\n X_source = dc['X_source'] = str(sys.argv[4]) \n except:\n y_var = dc['y_var'] = 'T2M'\n y_area = dc['y_area'] = 'scandi'\n experiment = dc['experiment'] = 'CONTROL'\n X_source = dc['X_source'] = 'ERA-20C'\n \n # Define details \n if(experiment=='CUTFIRSTYRS'): \n yr1 = dc['yr1'] = '1945' \n else:\n yr1 = dc['yr1'] = '1915' #'1900' \n \n yr2 = dc['yr2'] = '2010'\n \n \n rstate = dc['rstate'] = 70 \n n_folds = dc['n_folds'] = 5\n p_smpl = dc['p_smpl'] = 0.50\n p_feat = dc['p_feat'] = 0.33\n n_smpls = dc['n_smpls'] = 1000\n tst_len = dc['tst_len'] = 25\n\n ncomps_sst = dc['ncomps_sst'] = 5\n ncomps_snc = dc['ncomps_snc'] = 3\n ncomps_gpt = dc['ncomps_gpt'] = 3\n\n if(experiment=='NO_LAGS'):\n lags_sst = dc['lags_sst'] = (1,)\n lags_snc = dc['lags_snc'] = (1,)\n lags_gpt = dc['lags_gpt'] = (1,)\n else:\n lags_sst = dc['lags_sst'] = (1,2,3,4,5)\n lags_snc = dc['lags_snc'] = (1,2)\n lags_gpt = dc['lags_gpt'] = (1,2)\n \n \n \n n_jobs = dc['n_jobs'] = np.min([28, int(0.9*(multiprocessing.cpu_count()))])\n seasons = dc['seasons'] = ('DJF', 'MAM' ,'JJA', 'SON')\n\n # Define training and test periods\n all_yrs = dc['all_yrs'] = list(np.arange(int(yr1),int(yr2)+1))\n tst_yrs = dc['tst_yrs'] = all_yrs[-tst_len:] \n trn_yrs = dc['trn_yrs'] = list(np.array(all_yrs)[~np.isin(all_yrs,tst_yrs)])\n\n # Define a skeleton for naming output files \n basename = dc['basename'] = 'fittings_'+experiment+'_HadCRUT4-'+y_var+ \\\n '_nsmpls'+str(n_smpls)+'_ntestyrs'+str(tst_len)+ \\\n '_'+X_source+'-SST'+str(ncomps_sst)+'-'+str(lags_sst[-1])+ \\\n '_'+X_source+'-GPT'+str(ncomps_gpt)+'-'+str(lags_gpt[-1])+ \\\n '_'+yr1+'-'+yr2+'_'+y_area\n\n # Variables, form: 'name_of_variable': ['domain', n_comps, lags, year_range]\n X_var_definitions = dc['X_var_definitions'] = {\n 'SST': ['global', ncomps_sst, lags_sst, trn_yrs, all_yrs, X_source],\n 'GPT': ['norhem', ncomps_gpt, lags_gpt, trn_yrs, all_yrs, X_source],\n #'SNC': ['norhem', ncomps_snc, lags_snc, trn_yrs, all_yrs, X_source],\n }\n \n # Optional variables from https://climexp.knmi.nl/, form: 'name_of_index': [lags]\n X_clxp_definitions = dc['X_clxp_definitions'] = {\n #'M1i':(1,), 'M2i':(1,), 'M3i':(1,), \n #'M4i':(1,), 'M5i':(1,), 'M6i':(1,),\n #'NAO':(1,), 'NINO12':(1,), 'NINO3':(1,), 'NINO34':(1,), 'NINO4',:(1,),\n #'AMO1':(1,), 'AMO2':(1,), 'PDO1':(1,), 'PDO2':(1,), 'SOI',:(1,),\n }\n\n # Read and preprocess the predictand data using xarray etc.\n y_eur, Y, cl, tr = dc['y_eur'], dc['Y'], dc['Y_clim'], dc['Y_trend'] = \\\n read_manipulate_Y_data(y_var, in__dir, {}, {}, all_yrs, all_yrs, y_area)\n\n # Read and preprocess the raw predictor data using xarray etc.\n X_vars, cl, tr = dc['X_vars'], dc['X_clim'], dc['X_trnd'] = \\\n read_manipulate_X_data(in__dir, X_var_definitions, {}, {})\n\n\n if(experiment=='INCLPERSIS'): \n include_persistence=True\n else:\n include_persistence=False\n\n # Compress raw data with PCA, apply lagging, and create a Pandas dataframe \n X,p,ei,er = dc['X'], dc['X_PCAs'], dc['X_EIGs'], dc['X_ERRs'] = prepare_X_array(Y, \n y_var, X_vars, {}, X_var_definitions, X_clxp_definitions, include_persistence=include_persistence)\n\n if(experiment=='FOLLAND'):\n # Folland et al. 2012, Hall et al. 2017\n for i,vrb in enumerate(X.columns):\n if((vrb[0:4] == 'SST1')|(vrb[0:4] == 'sst1')):\n X[vrb] = StandardScaler().fit_transform(X[vrb][:,np.newaxis])\n X[vrb][ np.abs(X[vrb]) < 1 ] = 0\n X[vrb][ X[vrb] < -1 ] = -1\n X[vrb][ X[vrb] > 1.75 ] = 0\n X[vrb][ X[vrb] > 1 ] = 1\n print(X[vrb])\n\n # Extract variable names\n vrbl_names = dc['vrbl_names'] = X.columns\n \n return dc","def get_data(found_file, created_file):\n\n try:\n fh_f = fits.open(found_file)\n print('Found file has: ', fh_f.info())\n except Exception:\n print(' FATAL ERROR: Unable to open found file ', found_file)\n\n try:\n fh_c = fits.open(created_file)\n print('Created file has: ', fh_c.info())\n except Exception:\n print(' FATAL ERROR: Unable to open created file ', created_file)\n\n try:\n data_f = fh_f['SCI'].data\n except Exception:\n print(' FATAL ERROR: data for found data was expected in SCI extension')\n\n try:\n data_c = fh_c['SCI'].data\n except Exception:\n try:\n data_c = fh_c[0].data\n except Exception:\n print(' FATAL ERROR: created data expected in either SCI or 0 extensions')\n\n return fh_f, fh_c, data_f, data_c","def scalable(file_name=None, function_name=None, recover=None, omega=None, r=2, tol=1e-8, maxiter=100, init='random',\n printitn=0):\n\n # User Interface\n if file_name is None:\n file_name = raw_input(\"Please input the file_name of the data: \\n\")\n print(\"\\n\")\n\n if function_name is None:\n function_name = raw_input(\"Please choose the method you want to use to recover data(Input one number):\\n\"\n \" 1. Distributed CP(ALS) 2.Distributed CP(ADMM) 3. DisTenC 0.Exit \\n\")\n print(\"\\n\")\n #if recover is None:\n # recover = raw_input(\"If there are missing values in the file? (Input one number)\\n\"\n # \"1.Yes, recover it 2.No, just decompose (Missing entries in the original tensor will be replaced by 0) 0.Exit\\n\")\n\n # Use pandas package to load data\n## if file_name[-3:] == 'csv':\n# dat1 = pd.read_csv(file_name, delimiter=';')\n\n # Data preprocessing\n # First: create Sptensor\n# dat = dat1.values\n# sha = dat.shape\n# subs = dat[:, range(sha[1] - 1)]\n# subs = subs - 1\n# vals = dat[:, sha[1] - 1]\n# vals = vals.reshape(len(vals), 1)\n# siz = np.max(subs, 0)\n# siz = np.int32(siz + 1)\n# X1 = pyten.tenclass.Sptensor(subs, vals, siz)\n\n # Second: create Tensor object and find missing data\n# X = X1.totensor()\n# Ori = X.data\n# lstnan = np.isnan(X.data)\n# X.data = np.nan_to_num(X.data)\n\n # Construct omega\n #output = 1 # An output indicate flag. (Decompose: 1, Recover:2)\n Ori = None\n #if type(omega) != np.ndarray:\n # # if True in lstnan:\n # omega = X.data * 0 + 1\n # omega[lstnan] = 0\n # if recover == '1':\n # output = 2\n\n # Choose method to recover or decompose\n if type(function_name) == str:\n if function_name == '1' or function_name == 'D_cp_als':\n Dals = pyten.method.TensorDecompositionALS()\n Dals.dir_data = file_name\n Dals.rank = r\n Dals.run()\n Dals.maxIter = maxiter\n Dals.tol = tol\n\n ######\n Final = Dals.ktensor\n Rec = None\n full = Final.totensor()\n ######\n\n elif function_name == '2' or function_name == 'D_ADMM':\n Dadmm = pyten.method.DistTensorADMM()\n Dadmm.dir_data = file_name\n Dadmm.rank = r\n Dadmm.run()\n Dadmm.maxIter = maxiter\n Dadmm.tol = tol\n\n ######\n Final = Dadmm.ktensor\n Rec = None\n full = Final.totensor()\n ######\n\n elif function_name == '3' or function_name == 'D_ADMM_C':\n DadmmC = pyten.method.DistTensorCompletionADMM()\n DadmmC.dir_data = file_name\n DadmmC.rank = r\n DadmmC.run()\n DadmmC.maxIter = maxiter\n DadmmC.tol = tol\n\n ######\n Final = DadmmC.ktensor\n #Rec = Final.totensor().data * omega + X.data * (1 - omega)\n full = Final.totensor()\n Rec = full\n ######\n\n elif function_name == '0':\n print 'Successfully Exit'\n return None, None, None, None\n else:\n raise ValueError('No Such Method')\n\n else:\n raise TypeError('No Such Method')\n\n # Output Result\n # [nv, nd] = subs.shape\n if function_name == 1 or function_name == 2:\n newsubs = full.tosptensor().subs\n tempvals = full.tosptensor().vals\n newfilename = file_name[:-4] + '_Decomposite' + file_name[-4:]\n #print \"\\n\" + \"The original Tensor is: \"\n #print X1\n print \"\\n\" + \"The Decomposed Result is: \"\n print Final\n else:\n newsubs = Rec.tosptensor().subs\n tempvals = Rec.tosptensor().vals\n newfilename = file_name[:-4] + '_Recover' + file_name[-4:]\n #print \"\\n\" + \"The original Tensor is: \"\n #print Ori\n print \"\\n\" + \"The Recovered Tensor is: \"\n print Rec.data\n\n # Return result\n return Ori, full, Final, Rec","def load_data(data_fn,variables_fn,URL,VariableSet,Drop_extra=True):\r\n \r\n #If the data file exists locally, load it using pandas\r\n breakhere=1\r\n try: df = pd.read_csv(data_fn)\r\n except: \r\n #If the data file does not exist locally, download and save locally, then open\r\n print('Downloading data file (~430mb)')\r\n urllib.request.urlretrieve(URL,data_fn)\r\n print('Download Complete')\r\n df = pd.read_csv(data_fn)\r\n \r\n print('\\n************\\nNOTE RE: MIXED TYPE WARNING - These variables contain:')\r\n print(' 294 - HQ ID of person providing most of the information for this form')\r\n print(' 295 - HQ ID of 1st Other providing information for this form')\r\n print(' 701 - HF2 Cross wave ID (xwaveid) - 0001')\r\n print(' 702 - HF2 Cross wave ID (xwaveid) - 0002')\r\n print('These variables are not used in this project so the mixed type warning can be ignored\\n************')\r\n \r\n #Read the variables descriptor file\r\n variables = pd.read_csv(variables_fn)\r\n \r\n #extract the name of the response variable\r\n responseVar = variables['Variable'][variables['Response']=='y'].values[0]\r\n \r\n if Drop_extra:\r\n #Store the current number of recores\r\n NumRecords = df.shape[0]\r\n #remove entries with negative response variables (non-responding person, N/A, not asked, etc)\r\n DataSubset = pd.DataFrame(df[df[responseVar]>-1])\r\n #Notify the user how of how many records were dropped\r\n print('\\n{} records dropped due to lack of response variable (non-responding person, N/A, etc)'.format(NumRecords-DataSubset.shape[0]))\r\n \r\n #Extract the variable names for the variable set being analyzed\r\n KeepVars = variables['Variable'][variables[VariableSet]=='y']\r\n \r\n #Keep only the variables in the variable set\r\n DataSubset = DataSubset[KeepVars]\r\n \r\n else:\r\n #Return all variables and records\r\n DataSubset = df\r\n \r\n return DataSubset,variables,responseVar","def main():\n\n\t# Parse the file\n\tmem_file = advanced_analysis('../data_1/mempages.dat.out')","def multiple_files_analysis(lower_wavelength, upper_wavelength, CCD_height, CCD_width, CCD_height_corr, CCD_width_corr, file_paths, file_path_corr_data, progress_update):\r\n \r\n all_files_data = []\r\n FWHM_data = []\r\n central_energy_data = []\r\n counter = 1\r\n\r\n for file_path in file_paths:\r\n analysis = QDot_Spectroscopy(file_path=r\"{}\".format(file_path), meas_corr_curve_file_path=r\"{}\".format(file_path_corr_data), lower_wavelength=lower_wavelength, upper_wavelength=upper_wavelength, CCD_height=CCD_height, CCD_width=CCD_width, CCD_height_corr=CCD_height_corr , CCD_width_corr=CCD_width_corr)\r\n\r\n twod_map_raw = analysis.matrix_map(bkg_reduction=False, data_correction=False)\r\n twod_map_no_bkg = analysis.matrix_map(bkg_reduction=True, data_correction=False)\r\n twod_map_raw_corr = analysis.matrix_map(bkg_reduction=False, data_correction=True)\r\n twod_map_no_bkg_corr = analysis.matrix_map(bkg_reduction=True, data_correction=True)\r\n Q_Dot_plot_data, fit_statistics = analysis.gaussian_fit()\r\n\r\n file_analysis = [twod_map_raw, twod_map_no_bkg, twod_map_raw_corr, twod_map_no_bkg_corr, Q_Dot_plot_data, fit_statistics]\r\n all_files_data.append(file_analysis)\r\n\r\n # Creates a histogram from the collected FWHM and central energy data from all the analyzed datafales containing quantumdots\r\n for FWHM_value in fit_statistics['FWHM'].to_numpy():\r\n FWHM_data.append(FWHM_value)\r\n for CE_value in fit_statistics['Centre'].to_numpy():\r\n central_energy_data.append(CE_value)\r\n\r\n progress_update.emit(counter * 100/len(file_paths))\r\n counter += 1\r\n \r\n return all_files_data, FWHM_data, central_energy_data","def ExecuteInstanceReadingFromFileAux_Functionality(pickled_model,pickled_project_parameters,current_analysis_stage,random_variable,previous_computational_time,mapping_flag,pickled_mapping_reference_model,print_to_file,filename,open_mp_threads):\n\n start_time = time.time()\n # unpickle model and build Kratos Model object\n serialized_model = pickle.loads(pickled_model)\n current_model = KratosMultiphysics.Model()\n serialized_model.Load(\"ModelSerialization\",current_model)\n del(serialized_model)\n # unpickle parameters and build Kratos Parameters object\n serialized_project_parameters = pickle.loads(pickled_project_parameters)\n current_project_parameters = KratosMultiphysics.Parameters()\n serialized_project_parameters.Load(\"ParametersSerialization\",current_project_parameters)\n del(serialized_project_parameters)\n # constructor analysis stage\n simulation = current_analysis_stage(current_model,current_project_parameters,random_variable)\n # add filename flag print_to_file is true\n if (print_to_file):\n simulation.filename = filename\n # add flag if current index is maximum index: always True\n simulation.is_current_index_maximum_index = True\n # mapping if in current finest level (always true) and mapping flag is true\n # otherwise standard behavior\n if (mapping_flag is True):\n # unpickle mapping reference model and build Kratos Model object\n serialized_mapping_reference_model = pickle.loads(pickled_mapping_reference_model)\n mapping_reference_model = KratosMultiphysics.Model()\n serialized_mapping_reference_model.Load(\"ModelSerialization\",mapping_reference_model)\n del(serialized_mapping_reference_model)\n # send reference model to analysis stage for mapping and set mapping flag to true\n simulation.mapping_reference_model = mapping_reference_model\n simulation.mapping = True\n simulation.Run()\n # mapping if in current finest level and mapping flag is true\n # otherwise standard qoi evaluation\n if (mapping_flag is True):\n qoi = simulation.MappingAndEvaluateQuantityOfInterest()\n else:\n qoi = simulation.EvaluateQuantityOfInterest()\n del(simulation)\n end_time = time.time()\n computational_time = previous_computational_time + open_mp_threads*(end_time-start_time) # multiply by open mp threads to consider real machine cost\n return qoi,computational_time","def testApplyingExternalFile(self):\n tree_external = CoalescenceTree(os.path.join(\"output\", \"data_3_44_2.db\"))\n tree_external.set_speciation_parameters(\n 0.0001, metacommunity_option=os.path.join(\"sample\", \"nse_reference.db\"), metacommunity_reference=1\n )\n tree_external.apply()","def test_CFCalculation_txt_files():\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\n\n #Make sure new script produces the same result as old one\n expected_results = [\n CFCoefficient(l=2,\n m=0,\n spin_up=-419.7891726292168,\n spin_down=-414.7152560307904,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=4,\n m=0,\n spin_up=-35.92607948104669,\n spin_down=-26.384951772020756,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=6, m=0, spin_up=6.522900740505054, spin_down=5.488104692050172, unit='K', convention='Stevens')\n ]\n\n cf = CFCalculation(reference_radius='cdn')\n cf.readPot('files/cf_calculation/VKS.2.0.dat',\n 'files/cf_calculation/VKS.4.0.dat',\n 'files/cf_calculation/VKS.6.0.dat',\n lm=[(2, 0), (4, 0), (6, 0)])\n cf.readCDN('files/cf_calculation/Nd.dat', header=3)\n cf.cdn['RMT'] = 3.138049652\n results = cf.performIntegration()\n\n assert results == expected_results","def init_analysis(session, args):\r\n path = os.path.join(session.abs_path,'{}_{}_{}_{}'.format(args[12],args[13],args[14],args[15]))\r\n session.case = Case(path, session.method)\r\n case = session.case\r\n if args[0].split('#')[0]=='R':\r\n args[7]= -args[7]\r\n\r\n case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[6], args[7]))\r\n\r\n case.file_U.set_field('boundaryField',\r\n {'inlet': {'type': 'freestream',\r\n 'freestreamValue': 'uniform ({} {} 0)'.format(args[6], args[7])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'fixedValue', 'value':'uniform (0 0 0)'},\r\n 'extrados': {'type': 'fixedValue', 'value':'uniform (0 0 0)'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\r\n case.file_p.set_field('boundaryField',\r\n {'inlet': {'type': 'freestreamPressure'},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\r\n session.case.file_T.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[11])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'slip'},\r\n 'extrados': {'type': 'slip'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n \"\"\"\r\n\r\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[6], args[7]))\r\n session.case.file_U.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue',\r\n 'value': 'uniform ({} {} 0)'.format(args[6], args[7])},\r\n 'outlet': {'type': 'inletOutlet','inletValue':'uniform ({} {} 0)'.format(args[6], args[7]),\r\n 'value':'uniform ({} {} 0)'.format(args[6], args[7])},\r\n 'intrados': {'type': 'noSlip'},\r\n 'extrados': {'type': 'noSlip'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\r\n session.case.file_p.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\r\n session.case.file_T.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue','value':'uniform {}'.format(args[11])},\r\n 'outlet': {'type': 'inletOutlet','inletValue':'uniform {}'.format(args[11]),'value':'uniform {}'.format(args[11])},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n \"\"\"\r\n \"\"\"\r\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[7], args[6]))\r\n session.case.file_U.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue',\r\n 'value': 'uniform ({} {} 0)'.format(args[7], args[6])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'noSlip'},\r\n 'extrados': {'type': 'noSlip'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\r\n session.case.file_p.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\r\n session.case.file_T.set_field('boundaryField',\r\n {'inlet': {'type': 'zeroGradient'},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n \"\"\"\r\n \"\"\"\r\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[5], args[6]))\r\n session.case.file_U.set_field('boundaryField',\r\n {'inlet': {'type': 'fixedValue', 'value': 'uniform ({} {} 0)'.format(args[5], args[6])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'noSlip'},\r\n 'extrados': {'type': 'noSlip'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_p.set_field('boundaryField', {'inlet': {'type': 'fixedValue','value':'uniform {}'.format(args[9])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[9]))\r\n\r\n session.case.file_T.set_field('boundaryField', {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\r\n 'outlet': {'type': 'zeroGradient'},\r\n 'intrados': {'type': 'zeroGradient'},\r\n 'extrados': {'type': 'zeroGradient'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n session.case.file_T.set_field('internalField','uniform 300')\r\n\r\n session.case.file_nut.set_field('boundaryField', {'inlet':{'type':'calculated', 'value':'uniform 0'},\r\n 'outlet':{'type':'calculated', 'value':'uniform 0'},\r\n 'intrados': {'type': 'nutkWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 0'},\r\n 'extrados': {'type': 'nutkWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 0'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_k.set_field('internalField', 'uniform 1')\r\n session.case.file_k.set_field('boundaryField', {\r\n 'inlet': {'type': 'turbulentIntensityKineticEnergyInlet', 'intensity': '0.05', 'value': 'uniform 1'},\r\n 'outlet': {'type': 'inletOutlet', 'inletValue': 'uniform 1', 'value': 'uniform 1'},\r\n 'intrados': {'type': 'kqRWallFunction','value':'uniform 1'},\r\n 'extrados': {'type': 'kqRWallFunction','value':'uniform 1'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n\r\n session.case.file_epsilon.set_field('boundaryField', {'inlet': {'type': 'turbulentMixingLengthDissipationRateInlet', 'mixingLength': '0.005', 'value': 'uniform 200'},\r\n 'outlet': {'type': 'inletOutlet', 'inletValue': 'uniform 200', 'value': 'uniform 200'},\r\n 'intrados': {'type': 'epsilonWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 200'},\r\n 'extrados': {'type': 'epsilonWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 200'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n session.case.file_epsilon.set_field('internalField', 'uniform 200')\r\n\r\n session.case.file_alphat.set_field('boundaryField', {'inlet':{'type':'calculated', 'value':'uniform 0'},\r\n 'outlet':{'type':'calculated', 'value':'uniform 0'},\r\n 'intrados': {'type': 'compressible::alphatWallFunction', 'Prt':'0.85', 'value':'uniform 0'},\r\n 'extrados': {'type': 'compressible::alphatWallFunction', 'Prt':'0.85', 'value':'uniform 0'},\r\n 'top_down': {'type': 'empty'},\r\n 'cyclic_in_1': {'type': 'cyclic'},\r\n 'cyclic_in_2': {'type': 'cyclic'},\r\n 'cyclic_out_1': {'type': 'cyclic'},\r\n 'cyclic_out_2': {'type': 'cyclic'}})\r\n \"\"\"\r\n session.case.file_controlDict.set_field('endTime', '10000')\r\n session.case.file_controlDict.set_field('startFrom', 'latestTime')\r\n session.case.file_controlDict.set_field('functions', {\"#includeFunc\":\"MachNo\"})\r\n session.case.file_turbulenceProperties.set_field('simulationType', 'laminar')\r\n session.case.interacting(100)\r\n sim = session.case.simulation(\"open40\") # Build files\r\n sim.limit_write = 50\r\n sim.block_mesh(string=write_block_mesh(args[1], args[2], args[3], args[4], args[5], session.mesh))\r\n sim.check_mesh()\r\n\r\n result_dict={\"T\": 0, \"p\":0, \"Theta\":0, \"z\":0, \"profile\":args[14]}\r\n\r\n def _function(container, args):\r\n current_time = container['current_time']\r\n if float(current_time)>=0.000015:\r\n print('Parsing results')\r\n sim.foamToVTK()\r\n results = sim.get_last_results('outlet')\r\n result_U = results.GetCellData('U')\r\n result_p = results.GetCellData('p')\r\n result_T = results.GetCellData('T')\r\n theta = 0.0\r\n z = 0.0\r\n p=0.0\r\n t=0.0\r\n U_length = len(result_U)\r\n p_length = len(result_p)\r\n t_length = len(result_T)\r\n for i,j,k in zip(result_p, result_T, result_U):\r\n p+= float(i[0])/p_length\r\n t+= float(j[0])/t_length\r\n theta += float(k[1])/U_length\r\n z += float(k[0])/U_length\r\n\r\n args[\"T\"] = t\r\n args[\"p\"] = p\r\n args[\"Theta\"] = theta\r\n args[\"z\"] = z\r\n return True\r\n return False\r\n \r\n #sim.run(_function, result_dict)\r\n #result_dict = {'T': 195.38959999999997, 'z': 429.3120571428572, 'p': 74001.90285714286, 'Theta': -207.19442857142855, 'profile': 0}\r\n\r\n print('Sending results')\r\n if args[0].split('#')[0]=='R':\r\n result_dict['Theta']= -result_dict['Theta']\r\n\r\n session.socket_design.send({'new_data':result_dict})","def evaluate_hmdb51_fusion():\n vlen = 0\n ob_suffix = '-max.feat.npy.gz'\n fv_suffix = '_fv.npy.gz'\n ob_root = '/home/syq/research_final/data/features/ob_hmdb51_pooled_python/'\n fv_root = '/home/syq/research_final/data/dense-traj/fv_hmdb51_python/'\n hmdb_splits = 'testTrainMulti_7030_splits/'\n categories = os.listdir(fv_root)\n weight = 1.0\n weights = [i / 20.0 for i in range(21)]\n acc_to_weights = {}\n\n for weight in weights:\n print \"Weight: %.2f\" % weight\n accs = np.zeros(3)\n for splitnum in range(1,4):\n ts = time.time()\n trainfiles, testfiles = hmdb51_splits.loadsplit(categories,\n hmdb_splits,\n splitnum)\n print 'Have %d train files' % len(trainfiles)\n print 'Have %d test files' % len(testfiles)\n\n if not vlen:\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(trainfiles[0][0][:-4],\n ob_suffix)),\"rb\")\n vlen_ob = len(np.load(fp))\n fp.close()\n print \"OB vector length is %d\" % vlen_ob\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(trainfiles[0][0][:-4],\n fv_suffix)),\"rb\")\n vlen_fv = len(np.load(fp))\n fp.close()\n print \"IDTFV vector length is %d\" % vlen_fv\n\n Dtrain_ob = np.zeros( (len(trainfiles),vlen_ob), np.float32 )\n Dtrain_fv = np.zeros( (len(trainfiles),vlen_fv), np.float32 )\n\n Ytrain = np.ones ( (len(trainfiles) )) * -1000\n\n for fi,f in enumerate(trainfiles):\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\n ob_suffix)),\"rb\")\n Dtrain_ob[fi][:] = np.load(fp)\n fp.close()\n Ytrain[fi] = f[1]\n\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\n fv_suffix)),\"rb\")\n Dtrain_fv[fi][:] = np.load(fp)\n fp.close()\n\n Dtest_ob = np.zeros( (len(testfiles),vlen_ob), np.float32 )\n Dtest_fv = np.zeros( (len(testfiles),vlen_fv), np.float32 )\n\n Ytest = np.ones ( (len(testfiles) )) * -1000\n\n for fi,f in enumerate(testfiles):\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\n ob_suffix)),\"rb\")\n Dtest_ob[fi][:] = np.load(fp)\n fp.close()\n Ytest[fi] = f[1]\n\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\n fv_suffix)),\"rb\")\n Dtest_fv[fi][:] = np.load(fp)\n fp.close()\n\n \"\"\"\n Early fusion\n Dtrain = np.hstack((Dtrain_ob, Dtrain_fv))\n Dtest = np.hstack((Dtest_ob, Dtest_fv))\n\n clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\n acc = clf.fit(Dtrain, Ytrain).score(Dtest, Ytest)\n \"\"\"\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\n\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\n cache_size=1000,\n kernel='linear',\n probability=True),\n n_jobs=-1)\n\n # Get probabilities for late fusion\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\n\n # Scale decision values b/w 0 and 1\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\n Dtest_fv = preprocessing.normalize(Dtest_fv)\n Dtest_ob = preprocessing.normalize(Dtest_ob)\n\n # Late fusion\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\n latefusion_clf.fit(scores_train, Ytrain)\n\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\n acc = latefusion_clf.score(scores_test, Ytest)\n print 'Fold', splitnum, 'late fusion acc', acc\n print \"Train & testing time %.3f\" % (time.time() - ts)\n accs[splitnum-1] = acc\n acc_to_weights[weight] = accs\n\n print \"Mean accuracy: %.3f\" % accs.mean()\n with open(\"hmdb51_weight_gridsearch.txt\", \"w\") as f:\n for weight, accs in acc_to_weights.items():\n f.write(str(weight) + str(accs) + '\\n')\n return acc_to_weights\n\n \"\"\"\n with open('fv_hmdb51_accs.txt', 'w') as f:\n f.write(\"%s\\nMean:%.3f\" % (str(accs), np.mean(accs)))\n \"\"\"","def FS1Year(inputFolderPath = './Formatted Files Without Missing', outputFolderPath = './Feature Selection'):\n\tfileList = []\n\tfor root, dirs, files in os.walk(inputFolderPath): \n\t for afile in files:\n\t \tfileList.append(afile)\n\n\ttargetList = [2704,2707,2713,2716,2718,808,811,1954]\n\t# targetList = [1994,1997,2003,2006,2008,807,810,1953]\n\tyearList = [(1998,2015),(2005,2015),(2005,2015),(2005,2015),(2005,2015),(1960,2014),(1961,2014),(2002,2012)]\n\n\n\tfor i in range(len(targetList)):\n\t\t# i = 0\n\t\trows = []\n\t\tfor year in range(yearList[i][0],yearList[i][1]+1):\n\t\t\t# print str(year) + '-' + str(targetList[i]) \n\t\t\tregex = re.compile(\"(\"+ str(year) +\").*\")\n\t\t\tfiles = [m.group(0) for l in fileList for m in [regex.search(l)] if m and len(l) == 28]\n\t\t\t# print files\n\t\t\t# call([\"java\",\"-jar\",\"MINE.jar\",\"./New Formatted Files/\"+files[0],str(targetList[i]+1),\"cv=0.5\"])\n\t\t\t\n\n\t\t\t# load the CSV file as a numpy matrix\n\t\t\t# dataset = np.loadtxt('./New Formatted Files/'+files[0], delimiter=\",\", skiprows=1, usecols=tuple(range(1,3240)))\n\t\t\t# dataset = np.genfromtxt('./New Formatted Files/'+files[0], delimiter=\",\", names=True, autostrip=True, max_rows=10, missing_values=np.nan, usecols=tuple(range(1,30)))\n\t\t\twith open(inputFolderPath+'/'+files[0],'rb') as f:\n\t\t\t reader = csv.reader(f)\n\t\t\t header = next(reader)\n\t\t\t num_cols = len(header)\n\t\t\t # print header\n\t\t\t print i\n\t\t\t target_idx = [idx for idx, item in enumerate(header) if item.startswith(str(targetList[i]).zfill(4))]\n\t\t\t if len(target_idx) > 0:\n\t\t\t \ttarget = target_idx[0]-1\n\t\t\t \tprint ('OK',year, targetList[i], inputFolderPath+'/'+files[0])\n\t\t\t else:\n\t\t\t \tprint (year, targetList[i], inputFolderPath+'/'+files[0])\n\t\t\t \tbreak\n\t\t\t f.close()\n\t\t\tdataset = np.genfromtxt(inputFolderPath+'/'+files[0], delimiter=\",\", skip_header=1, autostrip=True, missing_values=np.nan, usecols=tuple(range(1,num_cols)))\n\t\t\t# print (dataset.shape)\n\t\t\tX = np.concatenate((dataset[:,0:target],dataset[:,target+1:dataset.shape[1]]),axis=1)\n\t\t\t# X = np.concatenate((dataset[:,0:2],dataset[:,3:dataset.shape[1]),axis=1)\n\t\t\ty = dataset[:,target]\n\t\t\t# print tuple(range(1,3240))\n\t\t\t# print dataset.dtype.names[0]\n\t\t\t# print dataset.dtype.names[-1]\n\t\t\t# print dataset[0]\n\t\t\timp = Imputer(missing_values='NaN', strategy='median', axis=0)\n\t\t\timputedX = imp.fit_transform(X,y)\n\t\t\timputedX = np.array([imputedX[j] for j in range(imputedX.shape[0]) if not np.isnan(y[j])])\n\t\t\tdeleteMissingY = np.array([x1 for x1 in y if not np.isnan(x1)])\n\t\t\t# print dataset[0]\n\t\t\t# print (imputedX.shape, y.shape)\n\t\t\t# print (imputedX.shape, deleteMissingY.shape)\n\t\t\t# print (np.any(np.isnan(imputedX)), np.all(np.isfinite(imputedX)))\n\t\t\t# imputedX_new = SelectKBest(chi2, k=10).fit_transform(imputedX, y)\n\t\t\tk = 30\n\t\t\tselection = SelectKBest(f_regression, k=k)\n\t\t\timputedX_new = selection.fit_transform(imputedX, deleteMissingY)\n\t\t\t# print (len(selection.get_support()), len(header[1:target+1]+header[target+2:]))\n\t\t\tselectedFeatures = [[item, selection.scores_[idx], selection.pvalues_[idx]] for idx, item in enumerate(header[1:target+1]+header[target+2:]) if selection.get_support()[idx]]\n\t\t\tselectedFeatures.sort(key=lambda x: x[1], reverse=True)\n\t\t\t# for sf in selectedFeatures:\n\t\t\t# \tprint sf\n\t\t\t# print selection.scores_\n\t\t\t# print selection.get_support()\n\t\t\t# print (imputedX_new.shape, y.shape)\n\t\t\t# print (imputedX_new.shape, deleteMissingY.shape)\n\t\t\t# print imputedX[0,1994]\n\t\t\t# print dataset['3137_Estimates_and_projections_of_the_total_population_by_sex_age_and_rural__urban_areasSexTotal_10year_age_bands__2534_Geographical_coverage__National_Thousands_Persons__ILO']\n\t\t\t# print dataset\n\t\t\t# separate the data from the target attributes\n\t\t\t# X = np.concatenate((imputedDataset[:,0:7],imputedDataset[:,0:7]),axis=1)\n\t\t\t# y = imputedDataset[:,8]\n\t\t\trows.append([year, 'score', 'p-value'])\n\t\t\trows.extend(selectedFeatures)\n\t\t\trows.append(['', '', ''])\n\t\t\t# print 'Hey'\n\n\t\tfilename = outputFolderPath+'/'+('Indicator%d - k%d - %s.csv' % (targetList[i], k, 'f_regression'))\n\t\twith open(filename,'wb') as w:\n\t\t\ta = csv.writer(w, delimiter = ',')\n\t\t\ta.writerows(rows)\n\t\tw.close()","def analysis():\n global prediction\n\n json_path = os.path.join(basedir, 'static', 'data', 'tmp_json')\n # csv_path = os.path.join(basedir, 'static', 'data', 'csv')\n # if not os.path.exists(csv_path):\n # os.mkdir(csv_path)\n\n if os.name == 'nt':\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf.dir'))\n video_file = Path(os.path.join(json_path, 'facial_data.shlf.dir'))\n else:\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf'))\n video_file = Path(os.path.join(json_path, 'facial_data.shlf'))\n\n # Files exists\n if audio_file.is_file() and video_file.is_file():\n with shelve.open(os.path.join(json_path, 'facial_data.shlf')) as shelf:\n emotion_data = shelf['emotion_data']\n microexpression_data = shelf['micro_expression_data']\n blink_data = shelf['blink_data']\n\n with shelve.open(os.path.join(json_path, 'audio_data.shlf')) as shelf:\n mean_energy = shelf['mean_energy']\n max_pitch_amp = shelf['max_pitch_amp']\n vowel_duration = shelf['vowel_duration']\n pitch_contour = shelf['pitch_contour']\n\n else:\n emotion_data = None\n microexpression_data = None\n blink_data = None\n mean_energy = None\n max_pitch_amp = None\n vowel_duration = None\n pitch_contour = None\n\n # Training Files (choose one)\n # soc_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_soc.txt')\n # niko_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_niko.txt')\n # vero_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_vero.txt')\n\n # txt_file = soc_file\n\n # train_data = []\n\n # for cases where one parameter has more elements\n # for i in range(min(len(blink_data), len(microexpression_data), len(mean_energy))):\n # train_data.append(0)\n\n # train_file = open(txt_file)\n\n # for line in train_file:\n # index1 = int((int(line[4]) * 600) + ((int(line[5]) * 60) + (int(line[7]) * 10) + int(line[8])) / 2)\n # index2 = int((int(line[10]) * 600) + ((int(line[11]) * 60) + (int(line[13]) * 10) + int(line[14])) / 2)\n # if line[0] == 'F':\n # train_data[index1] = 1\n # train_data[index2] = 1\n\n # with open(os.path.join(csv_path, 'train.csv'), 'w', newline='') as csv_file:\n # writer = csv.writer(csv_file)\n # writer.writerow(['Time Interval', 'Micro-expressions', 'Blinks',\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency',\n # 'False/True'])\n\n # # for cases where one parameter has more elements than another\n # for index in range(min(len(mean_energy), len(blink_data), len(microexpression_data))):\n # writer.writerow([index, microexpression_data[index], blink_data[index],\n # mean_energy[index], max_pitch_amp[index], vowel_duration[index], pitch_contour[index],\n # train_data[index]])\n\n # finalresults = [['Time Interval', 'Micro-expressions', 'Blinks',\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency' ]]\n final_results = []\n\n for index in range((min(len(mean_energy), len(blink_data), len(microexpression_data)))):\n final_results.append([microexpression_data[index], blink_data[index],\n mean_energy[index], max_pitch_amp[index], vowel_duration[index],\n pitch_contour[index]])\n\n prediction[0] = predict(final_results)\n\n return render_template('analysis.html', mean_energy=mean_energy, max_pitch_amp=max_pitch_amp,\n vowel_duration=vowel_duration, pitch_contour=pitch_contour, blink_data=blink_data,\n microexpression_data=microexpression_data, emotion_data=emotion_data)","def compute_functions(file_name,E_max,E_min,gamma,gamma_k):\n\n file = open(file_name,'r')\n data = file.readlines()\n file.close()\n\n print \"Computing functions\"\n all_lor = []\n for fila in data[2:]:\n vals = map(eval,fila.split())\n if(len(vals)>1):\n if(vals[1]>E_min and vals[1] < E_max):\n ek = vals[1]\n weight = 0\n for j in range(2,len(vals)):\n weight += vals[j]\n A = get_func(vals[0],vals[1],weight,gamma,gamma_k)\n all_lor.append(A)\n\n return all_lor","def read(source_name, variable_name, url, res_key, headers,\n out_path='original_data', start_from_user=None, end_from_user=None):\n data_set = pd.DataFrame()\n\n variable_dir = os.path.join(out_path, source_name, variable_name)\n\n logger.info('reading %s - %s', source_name, variable_name)\n\n files_existing = sum([len(files) for r, d, files in os.walk(variable_dir)])\n files_success = 0\n\n # Check if there are folders for variable_name\n if not os.path.exists(variable_dir):\n logger.warning('folder not found for %s, %s',\n source_name, variable_name)\n return data_set\n\n # For each file downloaded for that variable\n for container in os.listdir(variable_dir):\n # Skip this file if period covered excluded by user\n if start_from_user:\n # Filecontent is too old\n if start_from_user > yaml.load(container.split('_')[1]):\n continue # go to next container\n\n if end_from_user:\n # Filecontent is too recent\n if end_from_user < yaml.load(container.split('_')[0]):\n continue # go to next container\n\n files = os.listdir(os.path.join(variable_dir, container))\n\n # Check if there is only one file per folder\n if len(files) == 0:\n logger.warning('found no file in %s %s %s',\n source_name, variable_name, container)\n continue\n\n elif len(files) > 1:\n logger.warning('found more than one file in %s %s %s',\n source_name, variable_name, container)\n continue\n\n filepath = os.path.join(variable_dir, container, files[0])\n\n # Check if file is not empty\n if os.path.getsize(filepath) < 128:\n logger.warning('%s \\n file is smaller than 128 Byte, which means it is probably empty',\n filepath)\n else:\n logger.debug('reading data:\\n\\t '\n 'Source: %s\\n\\t '\n 'Variable: %s\\n\\t '\n 'Filename: %s',\n source_name, variable_name, files[0])\n\n update_progress(files_success, files_existing)\n\n if source_name == 'OPSD':\n data_to_add = read_opsd(filepath, url, headers)\n elif source_name == 'CEPS':\n data_to_add = read_ceps(filepath, variable_name, url, headers)\n elif source_name == 'ENTSO-E Data Portal':\n #save_stdout = sys.stdout\n #sys.stdout = open('trash', 'w')\n data_to_add = read_entso_e_portal(filepath, url, headers)\n #sys.stdout = save_stdout\n elif source_name == 'Energinet.dk':\n data_to_add = read_energinet_dk(filepath, url, headers)\n elif source_name == 'Elia':\n data_to_add = read_elia(filepath, variable_name, url, headers)\n elif source_name == 'PSE':\n data_to_add = read_pse(filepath, variable_name, url, headers)\n elif source_name == 'RTE':\n data_to_add = read_rte(filepath, variable_name, url, headers)\n elif source_name == 'Svenska Kraftnaet':\n data_to_add = read_svenska_kraftnaet(\n filepath, variable_name, url, headers)\n elif source_name == '50Hertz':\n data_to_add = read_hertz(filepath, variable_name, url, headers)\n elif source_name == 'Amprion':\n data_to_add = read_amprion(\n filepath, variable_name, url, headers)\n elif source_name == 'TenneT':\n data_to_add = read_tennet(\n filepath, variable_name, url, headers)\n elif source_name == 'TransnetBW':\n data_to_add = read_transnetbw(\n filepath, variable_name, url, headers)\n\n if data_set.empty:\n data_set = data_to_add\n else:\n data_set = data_set.combine_first(data_to_add)\n\n files_success += 1\n update_progress(files_success, files_existing)\n\n if data_set.empty:\n logger.warning('returned empty DataFrame for %s, %s',\n source_name, variable_name)\n return data_set\n\n # Reindex with a new index that is sure to be continous in order to later\n # expose gaps in the data.\n no_gaps = pd.DatetimeIndex(start=data_set.index[0],\n end=data_set.index[-1],\n freq=res_key)\n data_set = data_set.reindex(index=no_gaps)\n\n # Cut off the data outside of [start_from_user:end_from_user]\n # First, convert userinout to UTC time\n if start_from_user:\n start_from_user = (\n pytz.timezone('Europe/Brussels')\n .localize(datetime.combine(start_from_user, time()))\n .astimezone(pytz.timezone('UTC')))\n\n if end_from_user:\n end_from_user = (\n pytz.timezone('Europe/Brussels')\n .localize(datetime.combine(end_from_user, time()))\n .astimezone(pytz.timezone('UTC'))) - timedelta(minutes=int(res_key[:2]))\n\n # Then cut off the data_set\n data_set = data_set.loc[start_from_user:end_from_user, :]\n\n return data_set","def process(self):\n\n if len(self.files) == self._file_ptr:\n raise pipeline.PipelineStopIteration\n\n # Collect garbage to remove any prior CorrData objects\n gc.collect()\n\n # Fetch and remove the first item in the list\n file_ = self.files[self._file_ptr]\n self._file_ptr += 1\n\n # Set up product selection\n # NOTE: this probably doesn't work with stacked data\n prod_sel = None\n if self.only_autos:\n rd = andata.CorrReader(file_)\n prod_sel = np.array(\n [ii for (ii, pp) in enumerate(rd.prod) if pp[0] == pp[1]]\n )\n\n # Load file\n if (\n isinstance(self.freq_sel, slice)\n and (prod_sel is None)\n and (self.datasets is None)\n ):\n self.log.info(\n \"Reading file %i of %i. (%s) [fast io]\",\n self._file_ptr,\n len(self.files),\n file_,\n )\n ts = andata.CorrData.from_acq_h5_fast(\n file_, freq_sel=self.freq_sel, comm=self.comm\n )\n else:\n self.log.info(\n \"Reading file %i of %i. (%s) [slow io]\",\n self._file_ptr,\n len(self.files),\n file_,\n )\n ts = andata.CorrData.from_acq_h5(\n file_,\n datasets=self.datasets,\n distributed=True,\n comm=self.comm,\n freq_sel=self.freq_sel,\n prod_sel=prod_sel,\n )\n\n # Store file name\n ts.attrs[\"filename\"] = file_\n\n # Use a simple incrementing string as the tag\n if \"tag\" not in ts.attrs:\n tag = \"file%03i\" % self._file_ptr\n ts.attrs[\"tag\"] = tag\n\n # Add a weight dataset if needed\n if \"vis_weight\" not in ts.flags:\n weight_dset = ts.create_flag(\n \"vis_weight\",\n shape=ts.vis.shape,\n dtype=np.uint8,\n distributed=True,\n distributed_axis=0,\n )\n weight_dset.attrs[\"axis\"] = ts.vis.attrs[\"axis\"]\n\n # Set weight to maximum value (255), unless the vis value is\n # zero which presumably came from missing data. NOTE: this may have\n # a small bias\n weight_dset[:] = np.where(ts.vis[:] == 0.0, 0, 255)\n\n # Return timestream\n if self.use_draco_container:\n ts = containers.CHIMETimeStream.from_corrdata(ts)\n\n return ts","def run(self, input_files, input_metadata, output_files):\n try:\n # Set and check execution directory. If not exists the directory will be created.\n execution_path = os.path.abspath(self.configuration.get('execution', '.'))\n execution_parent_dir = os.path.dirname(execution_path)\n if not os.path.isdir(execution_parent_dir):\n os.makedirs(execution_parent_dir)\n\n # Update working directory to execution path\n os.chdir(execution_path)\n logger.debug(\"Execution path: {}\".format(execution_path))\n\n # Set file names for output files (with random name if not predefined)\n for key in output_files.keys():\n if output_files[key] is not None:\n pop_output_path = os.path.abspath(output_files[key])\n self.populable_outputs[key] = pop_output_path\n output_files[key] = pop_output_path\n else:\n errstr = \"The output_file[{}] can not be located. Please specify its expected path.\".format(key)\n logger.error(errstr)\n raise Exception(errstr)\n\n logger.debug(\"Init execution of the Machine Learning Model generation\")\n # Prepare file paths\n for key in input_files.keys():\n if key == 'radiomic_features':\n dataset = input_files[key]\n elif key == 'ML_technique':\n ml = input_files[key]\n else:\n logger.debug('Unrecognized input file key {}'.format(key))\n continue\n\n\n\n output_metadata = {}\n for key in output_files.keys():\n \n logger.info('VRE_ML: Iterating over Key {}'.format(key))\n\n \n if os.path.isfile(output_files[key]):\n meta = Metadata()\n meta.file_path = output_files[key] # Set file_path for output files\n \n logger.info('VRE_ML: Update metadata with key {} and value {}'.format(key, meta.file_path))\n\n meta.data_type = 'tool_statistics'\n meta.file_type = 'PDF'\n\n # Set sources for output files\n meta.sources = [output_files[key]+'.pdf']\n # Generate model\n generate_model.run(dataset=dataset,output_files[key]+'.pdf')\n\n # Append new element in output metadata\n logger.info('VRE_ML: Update metadata with key {} and value {}'.format(key, meta.file_path))\n output_metadata.update({key: meta})\n\n else:\n logger.warning(\"Output {} not found. Path {} not exists\".format(key, output_files[key]))\n\n logger.debug(\"Output metadata created\")\n\n return output_files, output_metadata\n\n except Exception:\n errstr = \"VRE ML RUNNER pipeline failed. See logs\"\n logger.fatal(errstr)\n raise Exception(errstr)","def execute( self, dataToResolve = None ):\n\n # Define local configuration options present at every site\n localSEList = self.configuration['LocalSEList']\n self.jobID = self.configuration.get( 'JobID' )\n allReplicas = self.configuration.get( 'AllReplicas', False )\n if allReplicas:\n self.log.info( 'All replicas will be used in the resolution' )\n\n if dataToResolve:\n self.log.verbose( 'Data to resolve passed directly to InputDataByProtocol module' )\n self.inputData = dataToResolve # e.g. list supplied by another module\n\n self.inputData = [x.replace( 'LFN:', '' ) for x in self.inputData]\n self.log.verbose( 'InputData requirement to be resolved by protocol is:\\n%s' % '\\n'.join( self.inputData ) )\n\n # First make a check in case replicas have been removed or are not accessible\n # from the local site (remove these from consideration for local protocols)\n replicas = self.fileCatalogResult['Value']['Successful']\n self.log.debug( 'File Catalogue result is:\\n%s' % str( replicas ) )\n\n # First get the preferred replica:\n requestedProtocol = self.configuration.get( 'Protocol', '' )\n result = self.__resolveReplicas( localSEList, replicas, requestedProtocol = requestedProtocol )\n if not result['OK']:\n return result\n success = result['Value']['Successful']\n if not allReplicas:\n bestReplica = {}\n for lfn in success:\n bestReplica[lfn] = success[lfn][0]\n return S_OK( {'Successful': bestReplica, 'Failed':result['Value']['Failed']} )\n\n # If all replicas are requested, get results for other SEs\n seList = set()\n localSESet = set( localSEList )\n for lfn in replicas.keys():\n extraSEs = set( replicas[lfn] ) - localSESet\n # If any extra SE, add it to the set, othewise don't consider that file\n if extraSEs:\n seList.update( extraSEs )\n else:\n replicas.pop( lfn )\n seList -= self.metaKeys\n\n if seList:\n requestedProtocol = self.configuration.get( 'RemoteProtocol', '' )\n result = self.__resolveReplicas( seList, replicas, ignoreTape = True, requestedProtocol = requestedProtocol )\n if not result['OK']:\n return result\n for lfn in result['Value']['Successful']:\n success.setdefault( lfn, [] ).extend( result['Value']['Successful'][lfn] )\n # Only consider failed the files that are not successful as well\n failed = [lfn for lfn in result['Value']['Failed'] if lfn not in success]\n return S_OK( {'Successful': success, 'Failed':failed} )","def _evaluate_reduced_potential(self, system, trajectory, file_path,\n compute_resources, subset_energy_corrections=None):\n from simtk import unit as simtk_unit\n\n integrator = openmm.VerletIntegrator(0.1 * simtk_unit.femtoseconds)\n\n platform = setup_platform_with_resources(compute_resources, True)\n openmm_context = openmm.Context(system, integrator, platform)\n\n potentials = np.zeros(trajectory.n_frames, dtype=np.float64)\n reduced_potentials = np.zeros(trajectory.n_frames, dtype=np.float64)\n\n temperature = pint_quantity_to_openmm(self.thermodynamic_state.temperature)\n beta = 1.0 / (simtk_unit.BOLTZMANN_CONSTANT_kB * temperature)\n\n pressure = pint_quantity_to_openmm(self.thermodynamic_state.pressure)\n\n for frame_index in range(trajectory.n_frames):\n\n positions = trajectory.xyz[frame_index]\n box_vectors = trajectory.openmm_boxes(frame_index)\n\n if self.enable_pbc:\n openmm_context.setPeriodicBoxVectors(*box_vectors)\n\n openmm_context.setPositions(positions)\n\n state = openmm_context.getState(getEnergy=True)\n\n unreduced_potential = state.getPotentialEnergy() / simtk_unit.AVOGADRO_CONSTANT_NA\n\n if pressure is not None and self.enable_pbc:\n unreduced_potential += pressure * state.getPeriodicBoxVolume()\n\n potentials[frame_index] = state.getPotentialEnergy().value_in_unit(simtk_unit.kilojoule_per_mole)\n reduced_potentials[frame_index] = unreduced_potential * beta\n\n potentials *= unit.kilojoule / unit.mole\n reduced_potentials *= unit.dimensionless\n\n if subset_energy_corrections is not None:\n potentials += subset_energy_corrections\n\n statistics_array = StatisticsArray()\n statistics_array[ObservableType.ReducedPotential] = reduced_potentials\n statistics_array[ObservableType.PotentialEnergy] = potentials\n statistics_array.to_pandas_csv(file_path)","def _m4_file_analysis(self, fin):\n # imp.reload(m4_macros_analysis)\n raw_data = fin.read()\n\n mylexer = m4_macros_analysis.M4Lexer()\n mylexer.build()\n lexer = mylexer.clone()\n generator = mylexer.get_token_iter(raw_data, lexer=lexer)\n cache_generator = m4_macros_analysis.CacheGenerator(generator, origin_data=raw_data)\n\n self._m4_analyzer.functions_analyze(cache_generator, fin.name)","def evaluate(self):\n for v in _INNVAR_EXPR.findall(self.expr):\n if v not in self.m_globals and v not in self.m_file_caches:\n try:\n self.m_file_caches[v] = model.load_file(self.strip_var(v))\n except IOError:\n raise LineProcessError('Undefined variable: \"%s\"' % self.strip_var(v))\n return self._eval()","def main(opts):\n if opts.list_vars:\n list_vars()\n if not os.path.exists(opts.original):\n print(\"ERROR: Could not find \" + opts.original)\n exit()\n if not os.path.exists(opts.interp):\n print(\"ERROR: Could not find \" + opts.interp)\n exit()\n data_functs = { 'a' : read_exp_a,\n 'c' : read_exp_c,\n 'f' : read_exp_f}\n orig_exp = os.path.basename(opts.original)[4]\n interp_exp = os.path.basename(opts.interp)[4]\n if not orig_exp == interp_exp and orig_exp in ['a','c','f']:\n print(\"ERROR: Data files not the same experiment!\")\n exit()\n data_functs[orig_exp](opts.original, opts.interp, opts.var)","def analyzeViSDEMData(dict):\n \n if 'path_in' in dict:\n path_in = dict['path_in']\n else:\n print(\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\") \n return\n \n path_out_default = '../colordeficiency-data/' \n if 'path_out' in dict:\n path_out = dict['path_out']\n else:\n print(\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \"+str(path_out_default))\n path_out = path_out_default\n \n if 'round' in dict:\n round = dict['round']\n else:\n print(\"Error: You have to chose a round first.\")\n \n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\n \n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\n if round == 1:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids.csv\")\n elif round == 2:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids_2.csv\")\n \n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\";\")\n \n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\n observer_ids = os.path.join(path,\"observer_ids.csv\")\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\";\")\n \n # 1. Step: Read all the XLSX data in the path\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\n dataArray = pandas.DataFrame()\n i=1\n for xlsx_file in xlsx_files:\n sys.stdout.write(xlsx_file)\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\n \n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\n \n if \"2. Session\" in extraDataDict:\n sessionID = int(extraDataDict['2. Session'])\n newDataArray['session_id'] = sessionID\n \n if 'group' in extraDataDict:\n obsGroup = str(extraDataDict['group'])\n newDataArray['obsGroup'] = obsGroup\n \n if '0. Participant ID' in extraDataDict:\n obsID = int(extraDataDict['0. Participant ID'])\n \n newDataArray['observer_id'] = obsID\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\n \n dataArray = pandas.concat([dataArray, newDataArray])\n sys.stdout.write(' . ')\n if (i%5)==0: sys.stdout.write('\\n')\n i+=1\n sys.stdout.write('\\n')\n \n # 2. Step: Adapt values to programstandards\n for item in settings.colDefLong2ID:\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\n \n for item in settings.dalt2ID:\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\n \n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\n \n \n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\n 'coldef_type': 'coldef_type',\n 'resp.corr_raw': 'is_correct',\n 'resp.rt_raw': 'resp_time',\n 'stimFile': 'filepath'})\n dataArray = dataArray.reset_index()\n \n # Adding set_id, motive_id and variant_id to each file\n for index, row in dataArray.iterrows():\n path_tmp = row['filepath']\n filename = os.path.basename(path_tmp).split('.')[0]\n dict_tmp = getStatsFromFilename(filename)\n imgID_tmp = int(dict_tmp['img_id'])\n \n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\n \n dataArray.at[index,'image_id'] = imgID_tmp\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\n\n dataArray.image_id = dataArray.image_id.astype(int)\n dataArray.set_id = dataArray.set_id.astype(int)\n dataArray.motive_id = dataArray.motive_id.astype(int)\n dataArray.variant_id = dataArray.variant_id.astype(int)\n dataArray.is_correct = dataArray.is_correct.astype(bool)\n \n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\n \n # 3. Saving data to file\n try:\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\";\")\n sys.stdout.write(\"Success: ViSDEM data successfully saved in '\"+str(path_out)+\"'.\\n\")\n except Exception as e:\n print(e)","def main():\n \n lookupslocation = 'C:\\\\Users\\\\gwilliams\\\\Desktop\\\\Python Experiments\\\\work projects\\\\FaresIndexSourceData\\\\regulated_fares_data\\\\'\n destination = 'C:\\\\Users\\\\gwilliams\\\\Desktop\\\\Python Experiments\\\\work projects\\\\FaresIndexSourceData\\\\regulated_fares_data\\\\comparison output\\\\'\n lookupfileslist, count = getdata(lookupslocation)\n\n print(f\"there are {count} files found.\")\n\n newlookup = lookupfileslist[0]\n oldlookup = lookupfileslist[1]\n\n #join new to old // old to new\n new_uniquevalues = pd.merge(left=newlookup,right=oldlookup,how='left',\n left_on=['orig','dest','route','ticket'],right_on=['orig','dest','route','ticket'])\n\n old_uniquevalues = pd.merge(left=newlookup,right=oldlookup,how='right',\n left_on=['orig','dest','route','ticket'],right_on=['orig','dest','route','ticket'])\n\n print(\"These are values unique to new lookup\") \n new_uniquevalues = new_uniquevalues[new_uniquevalues.ticketa.isnull()==True]\n exportfile(new_uniquevalues,destination,'unique_new_values',1)\n\n print(\"These are values unique to old lookup\")\n old_uniquevalues = old_uniquevalues[old_uniquevalues.new_flag.isnull()==True]\n exportfile(old_uniquevalues,destination,'unique_old_values',1)","def read_files(self):\n\n self.selecteddata = []\n try:\n for itemnum in self.selected:\n dfileent = self.indexdata[itemnum]\n fname = dfileent[0]\n if not os.path.isabs(fname): fname = os.path.join(self.indexdir, fname)\n ddata = self.dfparser.parsefile(fname)\n if self.doppleradj.isChecked(): ddata = doppler.apply_doppler_array(ddata, dfileent[3])\n self.selecteddata.append(ddata)\n self.warningmsg.setText(\"\")\n except datafile.Datafile_error as e:\n self.warningmsg.setText(e.args[0] + \" file \" + e.filename + \" line \" + e.linenumber + \" col \" + e.colnumber)\n self.selected = []\n self.selecteddata = []","def parse(self, **kwargs):\n if 'qcschema' in self.node.inputs:\n input_method = 'qcschema'\n if 'psiapi' in self.node.inputs:\n input_method = 'psiapi'\n output_filename = PSI4_FILENAMES[input_method]['output']\n\n # Check that folder content is as expected\n files_retrieved = self.retrieved.list_object_names()\n files_expected = [output_filename]\n # Note: set(A) <= set(B) checks whether A is a subset of B\n if not set(files_expected) <= set(files_retrieved):\n self.logger.error(\"Found files '{}', expected to find '{}'\".format(\n files_retrieved, files_expected))\n return self.exit_codes.ERROR_MISSING_OUTPUT_FILES\n\n # add outputs\n self.logger.info(\"Parsing '{}'\".format(output_filename))\n with self.retrieved.open(output_filename, 'rb') as handle:\n\n if input_method == 'psiapi':\n log_node = SinglefileData(file=handle,\n filename=output_filename)\n\n elif input_method == 'qcschema':\n output_dict = json.loads(handle.read())\n if not output_dict['success']:\n return self.exit_codes.ERROR_CALCULATION_FAILED\n\n # remove stdout (don't want to store unparsed files in the database)\n log_node = SinglefileData(\n # note: in python3.9 with AiiDA 2.0 this can be simplified to\n # file=io.StrinIO(''.join(output_dict['stdout'])),\n file=io.BytesIO(\n bytes(''.join(output_dict['stdout']),\n encoding='utf8')),\n filename=PSI4_FILENAMES['qcschema']['output'])\n output_dict.pop('stdout')\n\n self.out('qcschema', orm.Dict(dict=output_dict))\n\n self.out('stdout', log_node)\n\n return ExitCode(0)","def _clean_datafile_set(self):\n file_list = self._meta['sets']['data file']['items']\n for item in file_list[:]:\n collection = item.split('@')[0]\n variable = item.split('@')[1]\n if not variable in self:\n file_list.remove(item)\n elif collection == 'masks':\n for s in self._get_source_ref(variable):\n while s in file_list:\n file_list.remove(s)\n elif self._is_array_item(variable):\n parent = self.parents(variable)[0]\n if not parent in file_list:\n idx = file_list.index(item)\n file_list[idx] = parent\n while item in file_list:\n file_list.remove(item)\n f_list = []\n for item in file_list:\n if not item in f_list: f_list.append(item)\n self._meta['sets']['data file']['items'] = f_list\n return None","def read_pfile(self, filename:str, filemode:str='vcnmodel.v0', vscale:float=1e-3, iscale:float=1e-9, plot=False):\n \n\n # r = df['Results'][0]\n #\n # if plot:\n # P = PH.Plotter((1, 1), figsize=(6, 4))\n # cell_ax = list(P.axdict.keys())[0]\n # for trial in range(len(df['Results'])):\n # ds = df['Results'][trial]\n # k0 = list(df['Results'][trial].keys())[0]\n # dx = ds[k0]['monitor']\n # P.axdict[cell_ax].plot(dx['time'], dx['postsynapticV'], linewidth=1.0)\n # P.axdict[cell_ax].set_xlim(0., 150.)\n # P.axdict[cell_ax].set_ylim(-200., 50.)\n # PH.calbar(P.axdict[cell_ax], calbar=[120., -95., 25., 20.], axesoff=True, orient='left',\n # unitNames={'x': 'ms', 'y': 'mV'}, font='Arial', fontsize=8)\n #\n # # mpl.savefig(outfile)\n # mpl.show()\n # print(list(df.keys()))\n # print('\\nbasename: ', df['basename'])\n # print('\\nruninfo: ', df['runInfo'])\n \"\"\"\n The runInfo dictionary holds somethign like this:\n runinfo: {'folder': PosixPath('VCN_Cells/VCN_c08/Simulations/IV'), 'fileName': 'Normal', 'runName': 'Run', \n 'manipulation': 'Canonical', 'preMode': 'cc', 'postMode': 'cc', 'TargetCellType': 'Bushy', \n 'electrodeSection': 'soma', 'dendriticElectrodeSection': 'dendrite', \n 'dendriticSectionDistance': 100.0, 'celsius': 37, 'nStim': 1, \n 'stimFreq': 200.0, 'stimInj': {'pulse': [-1.0, 2.01, 0.2]}, \n 'stimDur': 100.0, 'stimDelay': 5.0, 'stimPost': 3.0, \n 'vnStim': 1, 'vstimFreq': 200.0, 'vstimInj': 50, \n 'vstimDur': 50.0, 'vstimDelay': 2.0, 'vstimPost': 3.0, 'vstimHolding': -60, \n 'gif_i0': 0.0, 'gif_sigma': 0.5, 'gif_fmod': 0.2, 'gif_tau': 3.0, \n 'gif_dur': 10.0, 'gif_skew': 0.0, \n 'runTime': 'Wed Oct 9 13:05:54 2019', \n 'inFile': None, 'inFileRep': 1, 'spikeTimeList': {}, \n 'v_init': -61.0, 'useSaveState': True, 'tstop': 8.0, 'filename': 'VCN_c08_pulse_'}\n \"\"\"\n # print('\\nmodelPars: ', df['modelPars'])\n \"\"\"\n The modelPars dict holds the following:\n modelPars: {'species': 'mouse', 'cellClass': 'bushy', 'modelType': 'II', \n 'modelName': 'mGBC', 'soma': True, 'axon': False, \n 'dendrites': False, 'pumps': False, 'hillock': False, \n 'initialsegment': False, 'myelinatedaxon': False, \n 'unmyelinatedaxon': False, 'na': 'nav11', 'ttx': False, \n 'name': 'bushy', 'morphology': 'VCN_Cells/VCN_c08/Morphology/VCN_c08.hoc', \n 'temperature': 34.0}\n \n Note 10/28/2019 changed structure so that runInfo and modelPars are both \n subdictionaries of Params (filemode is 'vcnmodel.v0')\n ... and undone later, so that all are top-level (filemode is 'vcnmodel.v1')\n \"\"\"\n with open(filename, 'rb') as fh:\n df = FPM.pickle_load(fh)\n if filemode in ['vcnmodel.v0']:\n print(f\"Reading model file in version v0:, with {len(df['Results']):4d} trials\")\n elif filemode in ['vcnmodel.v1']:\n print(f\"Reading model file in version v1:, with {len(df['Results']):4d} trials\")\n else:\n raise ValueError(f'Unknown file mode: {filemode:s}')\n # print('\\nrpfile v0: File keys: ', df.keys())\n #\n # print('\\nrpfile v0: basename: ', df['basename'])\n mtime = Path(filename).stat().st_mtime\n timestamp_str = datetime.datetime.fromtimestamp(mtime).strftime('%Y-%m-%d-%H:%M')\n if filemode == 'vcnmodel.v0':\n # print(df['Params'].keys())\n try:\n dinfo = df['Params']['runInfo']\n except:\n try:\n dinfo = df['runInfo']\n except:\n raise ValueError (\"Cannot read the file in v0 mode?\")\n run_protocol = df['Params']['runProtocol']\n if isinstance(dinfo, Params):\n dinfo = dinfo.todict()\n dur = dinfo['stimDur']\n delay = dinfo['stimDelay']\n mode = dinfo['postMode'].upper()\n ntr = len(df['Results'])\n # print(df.keys())\n # print('runinfo: ', df['runInfo'])\n # print('Params: ', df['Params'].keys())\n # print('dinfo: ', dinfo)\n if 'dt' in df['Params'].keys():\n self.rate = df['Params']['dt']\n else:\n self.rate = df['Params'].dt\n V = [[]]*ntr\n I = [[]]*ntr\n for i in range(len(df['Results'])):\n fk = list(df['Results'][i].keys())[0]\n dfx = df['Results'][i][fk]['monitor']\n timebase = dfx['time']\n V[i] = dfx['postsynapticV']*vscale\n I[i] = dfx['i_stim0']*iscale\n else:\n dinfo = df['runInfo']\n x = dir(dinfo)\n if 'stimVC' not in x: # create fields for missing values from older versions of files.\n dinfo.stimVC = None\n # print('rpfile v0: dinfo: ', dinfo)\n mode = dinfo.postMode.upper()\n dur = dinfo.stimDur\n delay = dinfo.stimDelay\n mode = dinfo.postMode\n print(\"Keys found in file: \", df.keys())\n print('Mode: ', mode)\n try:\n self.rate = df['Params'].dt # old version, now separated IC and VC\n except:\n if mode == 'VC':\n self.rate = df['Params'].dtVC\n elif mode == \"CC\":\n self.rate = df['Params'].dtIC\n else:\n raise ValueError(\"Cannot find rate for data mode: \", mode)\n\n run_protocol = dinfo.runProtocol\n if dinfo.runProtocol in ['runIV', 'initIV', 'testIV']:\n ntr = len(df['Results'])\n V = [[]]*ntr\n I = [[]]*ntr\n for ii, i in enumerate(df['Results'].keys()):\n dfx = df['Results'][i]['monitor']\n timebase = dfx['time']\n V[ii] = np.array(dfx['postsynapticV'])*vscale\n I[ii] = np.array(dfx['i_stim0'])*iscale\n elif dinfo.runProtocol in ['runVC', 'initVC', 'testVC']:\n dur = dinfo.vstimDur # msec\n delay = dinfo.vstimDelay # msec\n ntr = len(df['Results'])\n V = [[]]*ntr\n I = [[]]*ntr\n for ii, i in enumerate(df['Results'].keys()):\n dfx = df['Results'][i]['monitor']\n timebase = dfx['time']\n V[ii] = np.array(dfx['postsynapticV'])*vscale\n I[ii] = np.array(dfx['postsynapticI'])*iscale\n \n elif dinfo.runProtocol in ['initAN', 'runANPSTH', 'runANIO', 'runANSingles']:\n\n # two ways data can be organized, so try both\n try: # cnmodel_models simulations\n ntr = len(df['Results'])\n V = [[]]*ntr\n I = [[]]*ntr\n for j in list(df['Results'].keys()):\n dfx = df['Results'][j]\n timebase = dfx['time']\n V[j] = np.array(dfx['somaVoltage'])*vscale\n I[j] = np.zeros_like(V[j])\n except: # vcnmodel simulatipns\n ntr = len(df[\"Results\"]['somaVoltage'])\n V = [[]]*ntr\n I = [[]]*ntr\n for j in range(ntr):\n timebase = df['Results']['time']\n V[j] = np.array(df['Results']['somaVoltage'][j])*vscale\n I[j] = np.zeros_like(V[j])\n\n V = np.array(V)\n I = np.array(I)\n # print('V shape: ', V.shape, 'I shape: ', I.shape, ' timebase: ', timebase.shape, V.shape[1]*self.rate, np.max(timebase))\n # exit()\n\n if run_protocol in ['runVC', 'initVC', 'testVC']:\n self.MC.set_clamps(dmode=mode, time=timebase, data=I, cmddata=V, tstart_tdur=[delay, dur])\n else:\n self.MC.set_clamps(dmode=mode, time=timebase, data=V, cmddata=I, tstart_tdur=[delay, dur])\n self.MC.getClampData()","def objectivefunctions(filelist, observationdatafile, distancefilename, root):\r\n global hydrograph, simulation_timestep, sim_time, P_prime\r\n P_prime = []\r\n for trialfile in filelist:\r\n hydrograph = []\r\n sim_time = []\r\n with Simulation(trialfile) as sim:\r\n node_object = Nodes(sim)\r\n root_location = node_object[root]\r\n simulation_timestep = time_difference.total_seconds()\r\n sim.step_advance(simulation_timestep)\r\n for step in sim:\r\n sim_time.append(sim.current_time)\r\n hydrograph.append(root_location.total_inflow)\r\n objFunc = [normalizedpeakerror(), normalizedvolumeerror(), nashsutcliffe(), NED(trialfile)]\r\n P_prime.append(objFunc)\r\n return objFunc","def get_311_data():\n # reading in data and saving to separate DFs\n source = spark.read.csv(\"source.csv\", sep=\",\", header=True, inferSchema=True)\n case = spark.read.csv(\"case.csv\", sep=\",\", header=True, inferSchema=True)\n dept = spark.read.csv(\"dept.csv\", sep=\",\", header=True, inferSchema=True)\n\n # returning DFs\n return source, case, dept","def readin (filename, hdu=0, non_std_fits=False,\n text_comments='#', text_skiprows=0, get_data=False, verbose=False,\n apply_WCS_rv=False):\n multi_order_txt = False\n use_naxis2='all'\n use_naxis3='all'\n \n \n preferred_wlsoln=None # !! need to fix this\n # !! should also be able to input wavelength solution?\n \n if preferred_wlsoln is not None: preferred_wlsoln = wlsolvefxn.get_func_name(preferred_wlsoln)\n \n #### check if file exists ####### #############\n if not os.path.exists(filename): raise IOError(\"File does not exist:'\"+filename+\"'\")\n\n\n #### check if file is text############# \n np_kwargs = {'comments':text_comments,\n 'skiprows':text_skiprows}\n is_text_file, txt_data = check_for_txt_format(filename,**np_kwargs)\n\n #### if it is a text file ######################\n if is_text_file:\n spec_obj = readin_txt(filename,txt_data,get_data) \n return spec_obj \n\n #### now check how it behaves as a fits file\n if non_std_fits: hdulist = pyfits.open(filename)\n else:\n # give standard pyfits readin a try\n try: hdulist = pyfits.open(filename)\n except: raise IOError(\"PYFITS DOES NOT LIKE THE FILE YOU GAVE ('\"+filename+\"'), TO SEE WHAT ERROR IT GIVES TRY: hdulist = pyfits.open('\"+filename+\"')\")\n\n\n #### open up fits file ##############################\n hdulist = pyfits.open(filename)\n\n # select which header unit ot use\n if len(hdulist) > 1: \n hdu = int(hdu)\n hdu = np.clip(hdu,0,len(hdulist)-1)\n else: hdu = 0\n\n # specify the current header unit\n header_unit = hdulist[hdu]\n prihdr = header_unit.header\n\n # can display some useful information \n if verbose: \n print \"=\"*60\n print (hdulist.info(),'\\n')\n if len(hdulist) > 1:\n print \"=\"*20+\" USING HEADER: \"+\"=\"*20\n print repr(hdulist[hdu])\n\n ##### fill in the data class\n # not get header info of relevance\n simple = query_fits_header(prihdr,'SIMPLE',noval=False)\n xtension = query_fits_header(prihdr,'XTENSION')\n if simple.found:\n if not simple.val: print \"HeadsUp: Header Keyword SIMPLE is False, you may encounter unexpected behavior\"\n else:\n if not xtension.found: print \"HeadsUp: No extension keyword found in headers, you may encounter unexpected behavior\"\n \n \n #### read in important information from header, if present\n ibits = query_fits_header(prihdr,'BITPIX') # how many bits per pixel in the data? Not currently necessary, numpy will adapt\n \n naxis = query_fits_header(prihdr,'NAXIS' ,noval=0) # how many dimenstions?\n naxis1 = query_fits_header(prihdr,'NAXIS1',noval=0) # number of points per order\n naxis2 = query_fits_header(prihdr,'NAXIS2',noval=0) # number of orders\n naxis3 = query_fits_header(prihdr,'NAXIS3',noval=0) # number of different spectra\n\n apformat = query_fits_header(prihdr,'APFORMAT')\n if apformat.found: print \"WARNING: I'M NOT SURE HOW TO DEAL WITH APFORMAT VALUES\" # !! though I think it's just the spec files\n\n if not naxis.found: raise IOError(\"ERROR: Keyword NAXIS not found\")\n\n bzero = query_fits_header(prihdr,\"BZERO\",noval=0)\n bscale = query_fits_header(prihdr,\"BSCALE\",noval=1)\n\n ###### read in data ##############################################\n data = header_unit.data\n\n if data is None:\n wl, data, inv_var = np.zeros(3).reshape((3,1))\n if get_data: return (wl,data,inv_var)\n else: return eyeSpec_spec(wl,data,inv_var,header_unit.header)\n else:\n # check that data matches up with at least one of the dimensions\n if data.ndim != naxis.val: raise ValueError(\"Dimension of data \"+str(data.ndim)+\" does not match keyword naxis \"+str(naxis.val))\n \n statement = 'Dimension does not match data.shape = '+str(data.shape)+\" fits file (naxis1, naxis2, naxis3) \"+str(tuple([naxis1.val,naxis2.val,naxis3.val]))\n if data.ndim == 1: \n assert data.shape == (naxis1.val,) , statement\n data = data.reshape((1,1,)+data.shape)\n \n elif data.ndim == 2: \n assert data.shape == (naxis2.val, naxis1.val), statement\n data = data.reshape((1,)+data.shape) \n \n elif data.ndim == 3: \n assert data.shape == (naxis3.val, naxis2.val, naxis1.val), statement\n \n ##### Determine the which data is useful \n # which orders to read in \n nband = np.arange(data.shape[0])+1\n nord = np.arange(data.shape[1])+1\n\n \n ##### Calculate the wavelengths for the data\n # set up wavelength and inverse_variance\n wl = np.ones(data.shape)\n \n # get the wavelength coefficients\n wlcoeff = wlsoln_coeff_from_header(header_unit.header, apply_WCS_rv, preferred_wlsoln)\n \n # the same wavelength solution is applied to all bands so just pick the first and broadcast\n band = 0\n priv_info = {}\n \n # go through all the orders\n do_progress = True\n progressive_pt = 1 # this will advance and be used when there is no wavelength solution\n for i in xrange(len(nord)):\n order_i = nord[i]\n\n # get the coefficients and function type \n equ_type = wlcoeff.get_equation_type()\n if equ_type in ['none',None,'no solution'] and do_progress: \n coeff = [progressive_pt,1]\n equ_type = 'pts'\n else: coeff = wlcoeff.get_coeffs(order_i)\n \n # pts[0] = 1 :: this was definitely the right thing to do for SPECTRE's 1-D output but may not be for other equations, may need pts[0]=0, this may be for bzero,bscale\n pts = np.arange(len(wl[0][i]))+1 \n # apply function\n wl[0][i] = wlsolvefxn(pts, coeff, equ_type) \n \n progressive_pt += len(pts)\n \n for j in xrange(len(nband)): \n band_j = nband[j]\n if (band_j,order_i) not in priv_info: priv_info[(band_j,order_i)] = {} \n # record the private information\n priv_info[(band_j,order_i)]['disp']= [coeff, equ_type]\n priv_info[(band_j,order_i)]['rv'] = [0] \n priv_info[(band_j,order_i)]['disp extr'] = deepcopy(wlcoeff.extra)\n \n # now propogate the solution to the other bands\n stdwl = wl[0]\n for i in xrange(1,len(nband)): wl[i] = stdwl \n \n inv_var = np.ones(data.shape)\n #=================================================================#\n # return the data .OR. go on and create the spec_obj\n if get_data: return (wl, data, inv_var)\n\n #=================================================================# \n spec_obj = eyeSpec_spec(wl,data,inv_var,header_unit.header)\n # set up private information\n priv_info['filename'] = filename\n spec_obj.filename = filename\n \n bands = np.array(np.arange(1,len(data)+1),dtype=str)\n band_info = {}\n i = -1\n for key in prihdr.keys():\n if key[:6] != 'BANDID': continue\n if i < len(bands):\n i+=1\n bands[i] = prihdr[key]\n band_info[key] = prihdr[key]\n else: raise IOError(\"MORE BANDID KEYWORDS IN HEADER THAN FIRST DIMENSION OF DATA\") \n\n # add band info if available:\n if len(band_info) != 0: priv_info['bandids'] = band_info\n else: priv_info['bandids'] = None\n \n # match up the private info created during read in to the spec_obj\n for key in priv_info: spec_obj._private_info[key] = priv_info[key]\n \n # map fits value => acutal index\n # spec_obj._bands = {}\n # spec_obj._orders = {}\n # for i in range(len(nspec)): spec_obj._bands[nspec[i]] = i\n # for i in range(len(nord)): spec_obj._orders[nord[i]] = i\n # \n \n if 7 in nband: spec_obj.set_band(6) # this is where Magellian data stores it's object data, i.e. BANDID7 which is index 6\n\n if len(hdulist) > 1: spec_obj.hdrlist = [h.header for h in hdulist]\n \n return spec_obj","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n # use the func to insert data from these files to database's fact and dim tables\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def load_function(self):\n self._fn = from_pickle(\n read_from_disk(os.path.join(self.location, FNCT_NM))\n )\n\n if self.farmer is not None:\n if self.farmer.fn is None:\n self.farmer.fn = self._fn\n else:\n # TODO: check equality?\n raise XYZError(\n \"Trying to load this Crop's function, {}, from \"\n \"disk but its farmer already has a function \"\n \"set: {}.\".format(self._fn, self.farmer.fn)\n )","def calc(main_system,dir_db,dir_def,xlfile,mu_limit,functional=\"GGA\",soc=False,logfile=None):\n \n ## set up logging\n if logfile:\n myLogger = logging.setup_logging(logfile)\n else:\n myLogger = logging.setup_logging()\n\n\n ## load list of dataframes from sheets from excel file \n df = pd.read_excel(os.path.join(dir_def,xlfile),sheet_name=None)\n \n \n ## find initdef.json file\n if osutils.check_file_exists(dir_def,\"initdef\") == True:\n for file in os.listdir(dir_def): \n if file.startswith(\"initdef\"):\n file_initdef = file\n ## get species i and ni from initdefect.json file \n with open(os.path.join(dir_def,file_initdef), 'r') as file:\n initdef = json.loads(file.read())\n species_list, ni_list = [],[]\n for defect in initdef:\n species, ni = get_i_ni(initdef[defect])\n species_list += species\n ni_list += ni\n myLogger.info(\"Atoms added/removed: \" + \\\n \", \".join([str(n)+\"*\"+i for n,i in zip(ni_list,species_list)]))\n\n \n for q in [qi for qi in df.keys()]:\n \n ## get the relevant chemical potentials\n found_mu = True\n for species in species_list:\n mu = \"mu_%s_%s\"%(species,mu_limit)\n \n ## check if the relevant database entry exists\n if osutils.check_file_exists(dir_db,\"%s.json\"%species) == True:\n dbentry_file = \"%s.json\"%species\n with open(os.path.join(dir_db, dbentry_file), 'r') as file:\n mater = json.loads(file.read())\n ## search for appropriate mu entry\n mu_key = \"mu\"\n for key in mater[functional].keys():\n if key.startswith(\"mu_%s\"%mu_limit):\n mu_key = key\n myLogger.info(\"Using chemical potential \" + mu_key + \" from \" + dbentry_file) \n ## input the corresponding mus into the dataframe\n df[q][mu] = mater[functional][mu_key]\n \n else:\n myLogger.info(\"Cannot find the database entry for \" + species)\n found_mu = False\n \n \n ## get the VBMs\n ## check if the relevant database entry exists\n if osutils.check_file_exists(dir_db,\"%s.json\"%main_system) == True:\n dbentry_file = \"%s.json\"%(main_system)\n with open(os.path.join(dir_db, dbentry_file), 'r') as file:\n mater = json.loads(file.read()) \n \n ## input the VBMs corresponding to each vacuum spacing into the dataframe\n for rowind in df[q].index.values:\n vac = df[q].loc[rowind].vacuum\n if vac in mater[functional].keys():\n df[q].at[rowind,'VBM'] = mater[functional][vac][\"VBM\"]\n else:\n myLogger.info(\"Cannot find the VBM entry for \" + vac) \n \n ## Finally, we can compute the uncorrected defect formation energy:\n ## Eform = Etot(def) - Etot(pristine) - sum(n_i*mu_i) + q*E_Fermi\n if found_mu:\n ## proceed if chemical potentials and VBMs have been correctly entered\n sum_mu = 0\n for n,species in zip(ni_list,species_list):\n mu = \"mu_%s_%s\"%(species,mu_limit)\n sum_mu += n * df[q][mu]\n if q == 'charge_0': \n colname = \"E_form_corr\"\n else:\n colname = \"E_form_uncorr\"\n df[q][colname] = df[q].loc[:,'E_def'] \\\n - df[q].loc[:,'E_bulk'] \\\n - sum_mu \\\n + int(q.split(\"_\")[-1]) * df[q].loc[:,'VBM'] \n \n else:\n myLogger.info(\"Cannot find the database entry for \" + main_system)\n\n\n ## write the updated excel file\n writer = pd.ExcelWriter(os.path.join(dir_def,xlfile))\n for q in df.keys(): \n df[q].to_excel(writer, q, index=False)\n writer.save()","def apply(self):\n\n sc = SparkContext(appName=\"Model Applier\")\n sqlContext = SQLContext(sc)\n\n # Add model and supporting files to SparkContext\n for item in self.model_location_dict.items():\n ModelApplier.add_files_to_context(item[1], sc)\n\n partition_processor = self.get_partition_processor()\n infile = sc.textFile(self.input_location)\n header_line = infile.first()\n infile = infile.filter(lambda x: x != header_line)\n\n result = infile.mapPartitions(partition_processor).flatMap(lambda x: x)\n print('result.class', result.__class__)\n\n result = result.map(lambda (x, a, y, segment, model_version):\n (int(x), float(a), float(y), segment, model_version))\n sqlContext.createDataFrame(result).saveAsParquetFile(self.output_location)","def analyze_data(inputFileList, **kwargs):\n OBSKEY = 'OBSTYPE'\n MTKEY = 'MTFLAG'\n SCNKEY = 'SCAN_TYP'\n FILKEY = 'FILTER'\n FILKEY1 = 'FILTER1'\n FILKEY2 = 'FILTER2'\n APKEY = 'APERTURE'\n TARKEY = 'TARGNAME'\n EXPKEY = 'EXPTIME'\n FGSKEY = 'FGSLOCK'\n CHINKEY = 'CHINJECT'\n\n acsFiltNameList = [FILKEY1, FILKEY2]\n\n catalog = None # Astrometric catalog used for alignment\n catalogSources = 0 # Number of astrometric catalog sources determined based upon coordinate overlap with image WCS\n foundSources = 0 # Number of sources detected in images\n matchSources = 0 # Number of sources cross matched between astrometric catalog and detected in image\n rms_x = -1.0\n rms_y = -1.0\n rms_ra = -1.0\n rms_dec = -1.0\n chisq_x = -1.0\n chisq_y = -1.0\n completed = False # If true, there was no exception and the processing completed all logic\n dateObs = None # Human readable date\n mjdutc = -1.0 # MJD UTC start of exposure\n fgslock = None\n processMsg = None\n status = 9999\n compromised = 0\n headerletFile = None\n\n fit_rms = -1.0\n total_rms = -1.0\n datasetKey = -1.0\n\n namesArray = ('imageName', 'instrument', 'detector', 'filter', 'aperture', 'obstype',\n 'subarray', 'dateObs', 'mjdutc', 'doProcess', 'processMsg', 'catalog', 'foundSources',\n 'catalogSources','matchSources', 'rms_x', 'rms_y', 'rms_ra', 'rms_dec', 'completed',\n 'fit_rms', 'total_rms', 'datasetKey', 'status', 'headerletFile')\n dataType = ('S20', 'S20', 'S20', 'S20', 'S20', 'S20', 'b', 'S20', 'f8', 'b', 'S30',\n 'S20', 'i4', 'i4', 'i4', 'f8', 'f8', 'f8', 'f8', 'b', 'f8', 'f8', 'i8', 'i4', 'S30')\n\n # Create an astropy table\n outputTable = Table(names=namesArray,dtype=dataType)\n\n # Loop over the list of images to determine viability for alignment processing\n #\n # Capture the data characteristics before any evaluation so the information is\n # available for the output table regardless of which keyword is used to \n # to determine the data is not viable for alignment.\n\n for inputFile in inputFileList:\n\n header_hdu = 0\n header_data = getheader(inputFile, header_hdu)\n\n # Keywords to use potentially for downstream analysis\n instrume = (header_data['INSTRUME']).upper()\n detector = (header_data['DETECTOR']).upper()\n subarray = header_data['SUBARRAY']\n dateObs = header_data['DATE-OBS']\n mjdutc = header_data['EXPSTART']\n\n # Obtain keyword values for analysis of viability\n obstype = (header_data[OBSKEY]).upper()\n mtflag = (header_data[MTKEY]).upper()\n \n scan_typ = ''\n if instrume == 'WFC3':\n scan_typ = (header_data[SCNKEY]).upper()\n\n sfilter = ''\n if instrume == 'WFC3':\n sfilter = (header_data[FILKEY]).upper()\n # Concatenate the two ACS filter names together with an underscore\n # If the filter name is blank, skip it\n if instrume == 'ACS':\n for filtname in acsFiltNameList:\n\n # The filter keyword value could be zero or more blank spaces \n # Strip off any leading or trailing blanks\n if len(header_data[filtname].upper().strip()) > 0:\n\n # If the current filter variable already has some content,\n # need to append an underscore before adding more text\n if len(sfilter) > 0:\n sfilter += '_'\n sfilter += header_data[filtname].upper().strip()\n\n aperture = (header_data[APKEY]).upper()\n targname = (header_data[TARKEY]).upper()\n exptime = header_data[EXPKEY]\n fgslock = (header_data[FGSKEY]).upper()\n\n chinject = 'NONE'\n if instrume == 'WFC3' and detector == 'UVIS':\n chinject = (header_data[CHINKEY]).upper()\n\n # Determine if the image has one of these conditions. The routine\n # will exit processing upon the first satisfied condition.\n\n noProcKey = None\n noProcValue = None\n doProcess = True\n # Imaging vs spectroscopic or coronagraphic\n if obstype != 'IMAGING':\n noProcKey = OBSKEY\n noProcValue = obstype \n\n # Moving target\n elif mtflag == 'T':\n noProcKey = MTKEY\n noProcValue = mtflag \n\n # Bostrophidon without or with dwell (WFC3 only)\n elif any ([scan_typ == 'C', scan_typ == 'D']):\n noProcKey = SCNKEY\n noProcValue = scan_typ\n\n # Filter which does not begin with: 'F'(F###), 'C'(CLEAR), 'N'(N/A), and is not blank\n # The sfilter variable may be the concatenation of two filters (F160_CLEAR)\n elif sfilter[0] != 'F' and sfilter[0] != '' and sfilter[0] != 'C' and sfilter[0] != 'N': \n noProcKey = FILKEY\n noProcValue = sfilter\n\n elif '_' in sfilter:\n pos = sfilter.index('_')\n pos += 1\n\n if sfilter[pos] != 'F' and sfilter[pos] != '' and sfilter[pos] != 'C' and sfilter[pos] != 'N': \n noProcKey = FILKEY\n noProcValue = sfilter\n\n # Ramp, polarizer, grism, or prism \n elif any (x in aperture for x in ['RAMP', 'POL', 'GRISM', '-REF', 'PRISM']):\n noProcKey = APKEY\n noProcValue = aperture \n\n # Calibration target\n elif any (x in targname for x in ['DARK', 'TUNG', 'BIAS', 'FLAT', 'DEUT', 'EARTH-CAL']):\n noProcKey = TARKEY\n noProcValue = targname\n\n # Exposure time of effectively zero\n elif math.isclose(exptime, 0.0, abs_tol=1e-5):\n noProcKey = EXPKEY\n noProcValue = exptime \n\n # Commanded FGS lock\n elif any (x in fgslock for x in ['GY', 'COARSE']):\n noProcKey = FGSKEY\n noProcValue = fgslock\n\n # Charge injection mode\n elif chinject != 'NONE':\n noProcKey = CHINKEY\n noProcValue = chinject\n\n # If noProcKey is set to a keyword, then this image has been found to not be viable for\n # alignment purposes.\n if (noProcKey is not None):\n if (noProcKey != FGSKEY):\n doProcess = False\n msgType = Messages.NOPROC.value\n else:\n msgType = Messages.WARN.value\n\n processMsg = noProcKey + '=' + str(noProcValue)\n\n # Issue message to log file for this data indicating no processing to be done or \n # processing should be allowed, but there may be some issue with the result (e.g., \n # GYROS mode so some drift)\n generate_msg(inputFile, msgType, noProcKey, noProcValue)\n\n # Populate a row of the table\n outputTable.add_row([inputFile, instrume, detector, sfilter, aperture, obstype,\n subarray, dateObs, mjdutc, doProcess, processMsg, catalog, \n foundSources, catalogSources, matchSources, rms_x, rms_y, \n rms_ra, rms_dec, completed, fit_rms, total_rms, datasetKey,\n status, headerletFile])\n #outputTable.pprint(max_width=-1)\n\n return(outputTable)","def run_analysis(self):\n\n self._apply_loads_to_framat_model()\n\n # ----- Run the FramAT analysis -----\n results = standard_run(args=StdRunArgs(filename=self.own_files['model_file'], verbose=True))\n self.last_solution = results\n\n # ----- Share loads -----\n logger.info(\"Sharing loads...\")\n frame = results['frame']\n self.shared.structure.def_fields = frame.deformation.get_displacement_fields(frame, n_sup=1000)","def CollectingData(boundaries, target_lon, target_lat, files, basepath, \\\n CAMS_path, apply_land_sea_mask, use_wind_rotations, \\\n incorporate_cams):\n # Setting the time of starting the script\n start = datetime.now()\n \n # Reading daily csv files for specified area and day as np.arrays\n daily_data = {}\n for i, file in enumerate(files): \n # Reading daily csv's as input array\n daily_data[i] = inpt.CSVtoArray(file, boundaries, target_lon, target_lat)\n \n # Remove background, by CAMS observations\n if incorporate_cams:\n dates = [daily_data[i]['day'], daily_data[i]['month'], daily_data[i]['year']]\n bbox = [daily_data[i]['lat_min'], daily_data[i]['lat_max'], daily_data[i]['lon_min'], daily_data[i]['lon_max']]\n xres = int((110 * (bbox[3]-bbox[2])) / len(daily_data[i]['CO_ppb'][0]))\n yres = int((110 * (bbox[1]-bbox[0])) / len(daily_data[i]['CO_ppb']))\n cams_arr = cams.FetchCams(CAMS_path, dates, bbox, xres, yres)\n daily_data[i]['CO_excl_background'] = daily_data[i]['CO_ppb'] - cams_arr\n \n # Filter measurements taken above the oceans (higher uncertainty)\n if apply_land_sea_mask:\n daily_data[i]['CO_ppb'] = mask.land_sea_mask(daily_data[i]['CO_ppb'], boundaries)\n daily_data[i]['count_t'] = mask.land_sea_mask(daily_data[i]['count_t'], boundaries)\n \n # collect meteodata via ECMWF CDS API:\n if use_wind_rotations:\n u_wind, v_wind = wind.FetchWindData(daily_data[i], pressure=700, timerange=6, basepath=basepath)\n daily_data[i]['u_wind'] = u_wind\n daily_data[i]['v_wind'] = v_wind\n \n print('Total time elapsed reading data: {}'.format(datetime.now()-start))\n\n return daily_data","def try_blackbox_reduce (filename):\n\n try:\n filename_reduced = blackbox_reduce (filename)\n except:\n filename_reduced = None\n raise WrapException()\n\n return filename_reduced","def retrieve_additional_files(input_qchem, data_fchk, work_dir, scratch_read_level=0):\n\n additional_data = {}\n\n natom = len(input_qchem.molecule.get_coordinates())\n file_list = os.listdir(work_dir)\n\n # OLD_DIMENSIONS\n if '819.0' in file_list:\n with open(work_dir + '819.0', 'r') as f:\n data = np.fromfile(f, dtype=np.int32)\n norb_alpha, norb_beta = data[0:2]\n norb = norb_alpha\n nbas = norb # assumption\n else:\n norb = np.shape(data_fchk['coefficients']['alpha'])[0]\n nbas = np.shape(data_fchk['coefficients']['alpha'])[1]\n\n\n # MO_COEFS (Already in fchk) in internal order\n if '53.0' in file_list and 'coefficients' in data_fchk:\n with open(work_dir + '53.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n mo_alpha = data[:norb*nbas].reshape(-1, norb).tolist()\n mo_beta = data[norb*nbas: 2*norb_beta*nbas].reshape(-1, norb_beta).tolist()\n # additional_data['coefficients_internal'] = {'alpha': mo_alpha, 'beta': mo_beta}\n\n # obtain the order indices between fchk order and Q-Chem internal order of basis functions\n diff_square = get_sdm(data_fchk['coefficients']['alpha'], mo_alpha)\n\n # get non-repeating indices\n indices = []\n for row in diff_square.T:\n for i in np.argsort(row):\n if i not in indices:\n indices.append(int(i))\n break\n\n # indices = np.argmin(diff_square, axis=0).tolist()\n\n # store q-chem index order for later use (e.g guess)\n data_fchk['coefficients']['qchem_order'] = indices\n else:\n indices = list(range(nbas))\n\n # FOCK_MATRIX\n if '58.0' in file_list:\n with open(work_dir + '58.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n fock_alpha = data[:nbas*nbas].reshape(-1, nbas)\n fock_beta = data[nbas*nbas: 2*nbas*nbas].reshape(-1, nbas)\n\n # set basis functions in fchk order\n fock_alpha = fock_alpha[:, indices]\n fock_alpha = fock_alpha[indices, :]\n fock_beta = fock_beta[:, indices]\n fock_beta = fock_beta[indices, :]\n\n additional_data['fock_matrix'] = {'alpha': fock_alpha.tolist(), 'beta': fock_beta.tolist()}\n\n if scratch_read_level == -1:\n # FILE_ENERGY (Not really worth to read it)\n if '99.0' in file_list:\n with open(work_dir + '99.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n\n # FILE_DENSITY_MATRIX (Already in fchk)\n if '54.0' in file_list:\n with open(work_dir + '54.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n density_alpha = data[:nbas*nbas].reshape(-1, nbas)\n density_beta = data[nbas*nbas: 2*nbas*nbas].reshape(-1, nbas)\n # set basis functions in fchk order\n density_alpha = density_alpha[:, indices]\n density_alpha = density_alpha[indices, :]\n density_beta = density_beta[:, indices]\n density_beta = density_beta[indices, :]\n additional_data['scf_density_internal'] = {'alpha': density_alpha.tolist(), 'beta': density_beta.tolist()}\n\n # HESSIAN_MATRIX\n if '132.0' in file_list:\n with open(work_dir + '132.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n hessian = data.reshape(-1, natom*3)\n additional_data['hessian'] = hessian.tolist()\n\n # AO_INTS_DEBUG\n if '21.0' in file_list:\n with open(work_dir + '21.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n ao_integrals = data.reshape(-1, nbas, nbas, nbas)\n\n # set basis functions in fchk order\n ao_integrals = ao_integrals[:, :, :, indices]\n ao_integrals = ao_integrals[:, :, indices, :]\n ao_integrals = ao_integrals[:, indices, :, :]\n ao_integrals = ao_integrals[indices, :, :, :]\n\n additional_data['ao_integrals'] = ao_integrals.tolist()\n\n if scratch_read_level > 0:\n # FILE_RAS_AMP\n if '704.0' in file_list:\n with open(work_dir + '705.0', 'r') as f:\n ras_energies = np.fromfile(f, dtype=float)\n n_ras_roots = len(ras_energies)\n\n with open(work_dir + '704.0', 'r') as f:\n data = np.fromfile(f, dtype=float)\n ras_amplitudes = data.reshape(n_ras_roots, -1)\n additional_data['ras_amplitudes'] = ras_amplitudes.tolist()\n\n return additional_data","def fill_nan(data, fm, filename):\r\n print(\"fill Nan begining...\")\r\n\r\n # fill categorical variable\r\n categorical_variable_fill = pd.read_excel(\"./data/VariableFill.xlsx\", dtype={'Name': str, 'Value': float})\r\n categorical_features = categorical_variable_fill['Variable'].values\r\n categorical_variable_fill.set_index('Variable', inplace=True)\r\n for cat_col in categorical_features:\r\n data[cat_col].fillna(categorical_variable_fill.loc[cat_col, 'Fill'], inplace=True)\r\n\r\n # fill continue variable\r\n columns_name = list(data.columns.values)\r\n feature_name = list(fm.keys())\r\n\r\n for col in columns_name:\r\n if col in feature_name:\r\n for i in range(len(data)):\r\n # 填充空值\r\n if np.isnan(data.loc[i, col]):\r\n if len(fm[col]) == 4:\r\n data.loc[i, col] = uniform(fm[col]['low'], fm[col]['up'], 1)\r\n data.loc[i, col+'Grade2'] = fm[col]['grade2']\r\n else:\r\n if data.loc[i, 'Gender'] == 1:\r\n data.loc[i, col] = uniform(fm[col]['F']['low'], fm[col]['F']['up'], 1)\r\n data.loc[i, col+'Grade2'] = fm[col]['F']['grade2']\r\n elif data.loc[i, 'Gender'] == 0:\r\n data.loc[i, col] = uniform(fm[col]['M']['low'], fm[col]['M']['up'], 1)\r\n data.loc[i, col + 'Grade2'] = fm[col]['M']['grade2']\r\n\r\n data.to_csv('./data/'+filename+'processed_data.csv', index=False)\r\n print(\"fill Nan finished! processed data is saved in ./data/processed_data.csv\")\r\n return data","def execute(self):\n try:\n spark_context = self.spark.sparkContext\n spark_context.addFile(self.location)\n return self.spark.read.format(self.file_format) \\\n .load(SparkFiles.get(self.location.split('/')[-1]))\n except AnalysisException as exp:\n raise","def run(self, data_file: Optional[str] = None):\n\n \n\n # Pandas DF of 'list' files\n #cpd_list_df = pd.read_csv(self.cpd_list, low_memory=False, sep='\\t')\n #path_list_df = pd.read_csv(self.path_list, low_memory=False, sep='\\t')\n #rn_list_df = pd.read_csv(self.rn_list, low_memory=False, sep='\\t')\n #ko_list_df = pd.read_csv(self.ko_list, low_memory=False, sep='\\t')\n #cpd_to_chebi_df = pd.read_csv(self.cpd2chebi, low_memory=False, sep='\\t')\n\n # Pandas DF of 'kegg-*.tsv' files\n \n path_df = self.prune_columns(pd.read_csv(self.full_path, low_memory=False, sep='\\t', usecols=['ENTRY', 'NAME', 'DBLINKS']), 'path')\n rn_df = self.prune_columns(pd.read_csv(self.full_rn, low_memory=False, sep='\\t', usecols=['ENTRY', 'DEFINITION', 'EQUATION', 'DBLINKS']), 'rn')\n ko_df = self.prune_columns(pd.read_csv(self.full_ko, low_memory=False, sep='\\t', usecols=['ENTRY', 'DEFINITION', 'DBLINKS']), 'ko')\n \n ## **********************************************************************\n # Establishing 1-to-1 relation between KO and XRefs (['DBLINKS'] column)\n ##***********************************************************************\n\n # Explode DBLINKS in ko_df to separate rows\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).split('|'))\n ko_df = ko_df.explode('DBLINKS')\n\n #ko_df['ID'] = ko_df['ID'].apply(lambda row : 'ko:'+str(row))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).replace('RN: ', 'KEGG.REACTION:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('COG: ', 'COG:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('GO: ', 'GO:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('TC: ', 'tcdb:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('CAZy: ', 'cazy:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('UniProt: ', 'uniprot:'))\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row: str(row).split(' '))\n # Add prefixes to all DBLINKS\n ko_df['DBLINKS'] = ko_df['DBLINKS'] \\\n .apply(lambda row: [str(row[0])]+[str(row[0])\n .split(':')[0] + ':'+ x \\\n for x in row \\\n if not str(x).startswith(str(row[0]).split(':')[0]+ ':')])\n\n ko_df['DBLINKS'] = ['|'.join(map(str, l)) for l in ko_df['DBLINKS']]\n # Roll up to consolidated rows\n ko_df = ko_df.groupby(['ID', 'DESCRIPTION'], as_index=False).agg({'DBLINKS': lambda x: '|'.join(x)})\n ##########################################################################\n\n node_dict: dict = defaultdict(int)\n edge_dict: dict = defaultdict(int)\n\n df_dict = {\n 'pathway': path_df,\n 'rn': rn_df,\n 'ko': ko_df\n }\n\n node_dict, edge_dict = self.post_data(self.path_cpd_link, node_dict, edge_dict, df_dict, 'w')\n node_dict, edge_dict = self.post_data(self.rn_cpd_link, node_dict, edge_dict, df_dict, 'a')\n node_dict, edge_dict = self.post_data(self.path_rn_link, node_dict, edge_dict, df_dict, 'a')\n node_dict, edge_dict = self.post_data(self.path_ko_link, node_dict, edge_dict, df_dict, 'a')\n node_dict, edge_dict = self.post_data(self.rn_ko_link, node_dict, edge_dict, df_dict, 'a')\n \n\n return None","def FLargeFile(inputFile = 'New_2006-2013_FilteredColsTargetMissingBlank.csv', outputFolderPath = './Feature Selection 2006-2013'):\n\ttargetList = [2704,2707,2713,2716,2718,808,811,835]\n\twith open(inputFile,'rb') as f:\n\t reader = csv.reader(f)\n\t header = next(reader)\n\t num_cols = len(header)\n\t f.close()\n\tdataset = np.genfromtxt(inputFile, delimiter=\",\", skip_header=1, autostrip=True, missing_values=np.nan, usecols=tuple(range(1,num_cols)))\n\n\tfor target in range(len(targetList)):\n\t\tX = dataset[:,8:dataset.shape[1]]\n\t\ty = dataset[:,target]\n\t\t\n\t\tnewX = np.array([X[j] for j in range(X.shape[0]) if not np.isnan(y[j])])\n\t\tdeleteMissingY = np.array([x1 for x1 in y if not np.isnan(x1)])\n\n\t\tk = newX.shape[1]\n\t\tselection = SelectKBest(f_regression, k=k)\n\t\timputedX_new = selection.fit_transform(newX, deleteMissingY)\n\n\t\tselectedFeatures = [[item, selection.scores_[idx], selection.pvalues_[idx]] for idx, item in enumerate(header[9:]) if selection.get_support()[idx]]\n\t\tselectedFeatures.sort(key=lambda x: x[1], reverse=True)\n\n\t\trows = []\n\t\trows.append([targetList[target], 'score', 'p-value'])\n\t\trows.extend(selectedFeatures)\n\n\t\tfilename = outputFolderPath+'/'+('AllYear - Indicator%d - k%d - %s.csv' % (targetList[target], k, 'f_regression'))\n\t\twriteCSV(filename,rows)","def load_data():\n\t\t# load the data\n\t\tDATPATH = \"../data/\"\n\t\t#fnino = DATPATH + \"nino3.csv\" # 1871-2000\n\t\tfnino = DATPATH + \"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\" # 1871-2016\n\t\t#fnino = DATPATH + \"nino34.long.data\"\n\t\t#nc_data_nino3 = netCDF4.Dataset(fnino)\n\t\t#nino3_load = nc_data_nino3.variables['tas'][:]\n\t\t#dnino = nino3_load.flatten()\n\n\t\tdnino = np.genfromtxt(fnino, delimiter=\",\", dtype=float).flatten()\n\t\t#fismr = DATPATH + \"ismr.csv\" # 1871-2000\n\t\t#fismr = DATPATH + \"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\" # 1871-2016\n\t\tfismr = DATPATH + \"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\" # 1871-2016\n\t\tdismr = np.genfromtxt(fismr, delimiter=\",\", dtype=float).flatten()\n\t\t#fvolc = DATPATH + \"robock.txt\" # 1871-2000\n\t\tfvolc = DATPATH + \"sigl.txt\" # 1871-2016\n\t\tdvolc = np.genfromtxt(fvolc, delimiter=\",\", dtype=float).flatten()\n\n\t\tfvolc_source = DATPATH + \"volc_source_850_1850.csv\" # 1871-2016\n\t\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\",\", dtype=float).flatten()\n\t\t# simple check for data consistency\n\t\tassert dnino.shape == dismr.shape, \"Data sets are unequal!\"\n\t\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \"Data sets are unequal\"\n\t\treturn dnino, dismr, dvolc, dvolc_source","def test_filter_maf_file_cols_full(self):\n input_maf = os.path.join(DATA_SETS['Proj_08390_G']['MAF_DIR'], \"Sample1.Sample2.muts.maf\")\n\n with TemporaryDirectory() as tmpdir:\n input_json = {\n \"input_file\": {\n \"class\": \"File\",\n \"path\": input_maf\n },\n \"output_filename\": \"output.maf\"\n }\n\n output_json, output_dir = run_cwl(\n testcase = self,\n tmpdir = tmpdir,\n input_json = input_json,\n cwl_file = cwl_file)\n\n expected_output = {\n 'output_file': {\n 'location': 'file://' + os.path.join(output_dir, 'output.maf'),\n 'basename': 'output.maf',\n 'class': 'File',\n 'checksum': 'sha1$a2f5b9f1533fd443b41561ca718ffca62ab45f36',\n 'size': 2710681,\n 'path': os.path.join(output_dir, 'output.maf')\n }\n }\n self.assertDictEqual(output_json, expected_output)\n\n # validate number of lines output\n with open(output_json['output_file']['path']) as fin:\n output_maf_lines = len(fin.readlines())\n self.assertEqual(output_maf_lines, 12518)\n\n # validate file contents\n comments, mutations = load_mutations(output_json['output_file']['path'])\n\n self.assertEqual(len(mutations), 12514)\n\n for key in mutations[0].keys():\n self.assertTrue(key in cols_to_keep)\n\n # make sure there are fewer than or equal to the number of columns in new output as there are entries to keep \n self.assertTrue( len(mutations[0].keys()) <= len(cols_to_keep) )","def read_data(path_to_file, survey):\n if survey == 'eco':\n columns = ['name', 'radeg', 'dedeg', 'cz', 'grpcz', 'absrmag', \n 'logmstar', 'logmgas', 'grp', 'grpn', 'logmh', 'logmh_s', \n 'fc', 'grpmb', 'grpms']\n\n # 13878 galaxies\n eco_buff = pd.read_csv(path_to_file,delimiter=\",\", header=0, \\\n usecols=columns)\n\n # 6456 galaxies \n catl = eco_buff.loc[(eco_buff.cz.values >= 3000) & \\\n (eco_buff.cz.values <= 7000) & (eco_buff.absrmag.values <= -17.33) &\\\n (eco_buff.logmstar.values >= 8.9)]\n\n volume = 151829.26 # Survey volume without buffer [Mpc/h]^3\n cvar = 0.125\n z_median = np.median(catl.grpcz.values) / (3 * 10**5)\n \n elif survey == 'resolvea' or survey == 'resolveb':\n columns = ['name', 'radeg', 'dedeg', 'cz', 'grpcz', 'absrmag', \n 'logmstar', 'logmgas', 'grp', 'grpn', 'grpnassoc', 'logmh', \n 'logmh_s', 'fc', 'grpmb', 'grpms', 'f_a', 'f_b']\n # 2286 galaxies\n resolve_live18 = pd.read_csv(path_to_file, delimiter=\",\", header=0, \\\n usecols=columns)\n\n if survey == 'resolvea':\n catl = resolve_live18.loc[(resolve_live18.f_a.values == 1) & \\\n (resolve_live18.grpcz.values > 4500) & \\\n (resolve_live18.grpcz.values < 7000) & \\\n (resolve_live18.absrmag.values < -17.33) & \\\n (resolve_live18.logmstar.values >= 8.9)]\n\n\n volume = 13172.384 # Survey volume without buffer [Mpc/h]^3\n cvar = 0.30\n z_median = np.median(resolve_live18.grpcz.values) / (3 * 10**5)\n \n elif survey == 'resolveb':\n # 487 - cz, 369 - grpcz\n catl = resolve_live18.loc[(resolve_live18.f_b.values == 1) & \\\n (resolve_live18.grpcz.values > 4500) & \\\n (resolve_live18.grpcz.values < 7000) & \\\n (resolve_live18.absrmag.values < -17) & \\\n (resolve_live18.logmstar.values >= 8.7)]\n\n volume = 4709.8373 # *2.915 #Survey volume without buffer [Mpc/h]^3\n cvar = 0.58\n z_median = np.median(resolve_live18.grpcz.values) / (3 * 10**5)\n\n return catl,volume,cvar,z_median","def routines(args, infile):\n\n # -- Open the tarfile\n tar = tarfile.open(infile)\n\n # -- Set the model year string\n fyear = str(infile.split(\"/\")[-1].split(\".\")[0])\n print(\"Processing \" + fyear)\n\n # -- Get list of components to process\n comps = args.component\n\n # -- Atmospheric Fields\n modules = {\n \"atmos_month\": \"Atmos\",\n \"atmos_co2_month\": \"Atmos\",\n \"atmos_month_aer\": \"AtmosAer\",\n \"aerosol_month_cmip\": \"AeroCMIP\",\n }\n if any(comp in comps for comp in [\"atmos\", \"all\"]):\n averagers.cubesphere.xr_average(fyear, tar, modules)\n\n # -- Land Fields\n modules = {\"land_month\": \"Land\"}\n if any(comp in comps for comp in [\"land\", \"all\"]):\n averagers.land_lm4.xr_average(fyear, tar, modules)\n\n # -- Ice\n modules = {\"ice_month\": \"Ice\"}\n if any(comp in comps for comp in [\"ice\", \"all\"]):\n averagers.ice.xr_average(fyear, tar, modules)\n\n # -- Ocean\n fname = f\"{fyear}.ocean_scalar_annual.nc\"\n if any(comp in comps for comp in [\"ocean\", \"all\"]):\n if tar_member_exists(tar, fname):\n print(f\"{fyear}.ocean_scalar_annual.nc\")\n fdata = nctools.extract_from_tar(tar, fname, ncfile=True)\n extract_ocean_scalar.mom6(fdata, fyear, \"./\")\n fdata.close()\n\n # -- OBGC\n modules = {\n \"ocean_cobalt_sfc\": \"OBGC\",\n \"ocean_cobalt_misc\": \"OBGC\",\n \"ocean_cobalt_tracers_year\": \"OBGC\",\n \"ocean_cobalt_tracers_int\": \"OBGC\",\n \"ocean_bling\": \"OBGC\",\n \"ocean_bling_cmip6_omip_2d\": \"OBGC\",\n \"ocean_bling_cmip6_omip_rates_year_z\": \"OBGC\",\n \"ocean_bling_cmip6_omip_sfc\": \"OBGC\",\n \"ocean_bling_cmip6_omip_tracers_month_z\": \"OBGC\",\n \"ocean_bling_cmip6_omip_tracers_year_z\": \"OBGC\",\n }\n if any(comp in comps for comp in [\"obgc\", \"all\"]):\n averagers.tripolar.xr_average(fyear, tar, modules)\n\n # -- AMOC\n if any(comp in comps for comp in [\"amoc\", \"all\"]):\n diags.amoc.mom6_amoc(fyear, tar)\n\n # -- Close out the tarfile handle\n tar.close()\n\n # -- Do performance timing\n #try:\n # infile = infile.replace(\"/history/\", \"/ascii/\")\n # infile = infile.replace(\".nc.tar\", \".ascii_out.tar\")\n # label = \"Timing\"\n # if os.path.exists(infile):\n # diags.fms.timing(infile, fyear, \"./\", label)\n #except RuntimeError:\n # pass","def ffi(ccd=1, camera=1, sector=1, size=150, local_directory='', producing_mask=False):\n input_files = glob(f'{local_directory}ffi/*{camera}-{ccd}-????-?_ffic.fits')\n print('camera: ' + str(camera) + ' ccd: ' + str(ccd) + ' num of files: ' + str(len(input_files)))\n time = []\n quality = []\n cadence = []\n flux = np.empty((len(input_files), 2048, 2048), dtype=np.float32)\n for i, file in enumerate(tqdm(input_files)):\n try:\n with fits.open(file, mode='denywrite', memmap=False) as hdul:\n quality.append(hdul[1].header['DQUALITY'])\n cadence.append(hdul[0].header['FFIINDEX'])\n flux[i] = hdul[1].data[0:2048, 44:2092]\n time.append((hdul[1].header['TSTOP'] + hdul[1].header['TSTART']) / 2)\n\n except:\n print(f'Corrupted file {file}, download again ...')\n response = requests.get(\n f'https://mast.stsci.edu/api/v0.1/Download/file/?uri=mast:TESS/product/{os.path.basename(file)}')\n open(file, 'wb').write(response.content)\n with fits.open(file, mode='denywrite', memmap=False) as hdul:\n quality.append(hdul[1].header['DQUALITY'])\n cadence.append(hdul[0].header['FFIINDEX'])\n flux[i] = hdul[1].data[0:2048, 44:2092]\n time.append((hdul[1].header['TSTOP'] + hdul[1].header['TSTART']) / 2)\n time_order = np.argsort(np.array(time))\n time = np.array(time)[time_order]\n flux = flux[time_order, :, :]\n quality = np.array(quality)[time_order]\n cadence = np.array(cadence)[time_order]\n # mask = np.array([True] * 2048 ** 2).reshape(2048, 2048)\n # for i in range(len(time)):\n # mask[np.where(flux[i] > np.percentile(flux[i], 99.95))] = False\n # mask[np.where(flux[i] < np.median(flux[i]) / 2)] = False\n\n if producing_mask:\n median_flux = np.median(flux, axis=0)\n mask = background_mask(im=median_flux)\n mask /= ndimage.median_filter(mask, size=51)\n np.save(f'{local_directory}mask/mask_sector{sector:04d}_cam{camera}_ccd{ccd}.npy', mask)\n return\n # load mask\n mask = pkg_resources.resource_stream(__name__, f'background_mask/median_mask.fits')\n mask = fits.open(mask)[0].data[(camera - 1) * 4 + (ccd - 1), :]\n mask = np.repeat(mask.reshape(1, 2048), repeats=2048, axis=0)\n bad_pixels = np.zeros(np.shape(flux[0]))\n med_flux = np.median(flux, axis=0)\n bad_pixels[med_flux > 0.8 * np.nanmax(med_flux)] = 1\n bad_pixels[med_flux < 0.2 * np.nanmedian(med_flux)] = 1\n bad_pixels[np.isnan(med_flux)] = 1\n\n x_b, y_b = np.where(bad_pixels)\n for i in range(len(x_b)):\n if x_b[i] < 2047:\n bad_pixels[x_b[i] + 1, y_b[i]] = 1\n if x_b[i] > 0:\n bad_pixels[x_b[i] - 1, y_b[i]] = 1\n if y_b[i] < 2047:\n bad_pixels[x_b[i], y_b[i] + 1] = 1\n if y_b[i] > 0:\n bad_pixels[x_b[i], y_b[i] - 1] = 1\n\n mask = np.ma.masked_array(mask, mask=bad_pixels)\n mask = np.ma.masked_equal(mask, 0)\n\n for i in range(10):\n hdul = fits.open(input_files[np.where(np.array(quality) == 0)[0][i]])\n wcs = WCS(hdul[1].header)\n if wcs.axis_type_names == ['RA', 'DEC']:\n break\n\n exposure = int((hdul[0].header['TSTOP'] - hdul[0].header['TSTART']) * 86400)\n\n # 95*95 cuts with 2 pixel redundant, (22*22 cuts)\n # try 77*77 with 4 redundant, (28*28 cuts)\n os.makedirs(f'{local_directory}source/{camera}-{ccd}/', exist_ok=True)\n for i in trange(14): # 22\n for j in range(14): # 22\n source_path = f'{local_directory}source/{camera}-{ccd}/source_{i:02d}_{j:02d}.pkl'\n source_exists = exists(source_path)\n if source_exists and os.path.getsize(source_path) > 0:\n # print(f'{source_path} exists. ')\n pass\n else:\n with open(source_path, 'wb') as output:\n source = Source(x=i * (size - 4), y=j * (size - 4), flux=flux, mask=mask, sector=sector,\n time=time, size=size, quality=quality, wcs=wcs, camera=camera, ccd=ccd,\n exposure=exposure, cadence=cadence)\n pickle.dump(source, output, pickle.HIGHEST_PROTOCOL)","def evaluate(self):\n errors_found = 0\n\n # Test if destination exists and is a directory\n if not os.path.isdir(os.path.expandvars(self.path_destination)):\n message.alert(\n f\"FILE [{self.name}]: '{self.path_destination}' destination path is not a known directory.\"\n )\n errors_found += 1\n\n # Test if sudo is really needed if the file's\n # destination is in a directory owned by the current user\n if os.getenv(\"HOME\") in os.path.expandvars(self.path_destination) and self.sudo:\n message.alert(\n f\"FILE [{self.name}]: Sudo use may be unnecessary as {self.path_destination} is in your home path.\"\n )\n errors_found += 1\n\n # Test if source is a directory\n if self.path_source is not None:\n if not os.path.isdir(os.path.expandvars(self.path_source)):\n message.alert(\n f\"FILE [{self.name}]: '{self.path_source}' source path is not a known directory.\"\n )\n errors_found += 1\n\n if not os.path.isfile(\n os.path.join(os.path.expandvars(self.path_source), self.name)\n ):\n message.alert(\n f\"FILE [{self.name}] at PATH: [{self.path_source}] does not exist.\"\n )\n errors_found += 1\n\n # Check expected types\n if not isinstance(self.comments, list):\n message.alert(\n f\"FILE [{self.name}]: Type mismatch, comments attribute is of type '{type(self.comments)}' instead of 'list'\"\n )\n errors_found += 1\n\n return errors_found","def evaluate(self, x, path):\n\n # Read the modestats file as CSV\n mode_stats_paths = glob.glob(\"%s/*modestats.txt\" % path)\n df = pd.read_csv(mode_stats_paths[0], sep = \"\\t\")\n\n car_share = df[\"car\"].values[-1] # Share of car trips\n pt_share = df[\"pt\"].values[-1] # Share of pt trips\n\n # We construct a vector holding the *state* of the simulation. This is not\n # used by most simulators, but important, for instance, for Opdyts!\n state = [car_share, pt_share]\n\n # Here we construct an objective value. Here, we want to minimize\n # the quadratic error between the observed and reference mode shares for\n # car and public transport.\n objective = np.sqrt((car_share - self.car_reference)**2 + (pt_share - self.pt_reference)**2)\n\n # Return state and objective\n return objective, state","def residuals(x, y, filename):\n empirical_data = y\n #print(x)\n # call convert function\n\n ans = (empirical_data - run_model(x, filename))/empirical_data * 100\n #print(ans)\n return ans","def compute_contrast_sphere_offline(path_raw,path_reduced,path_output,debug=True):\r\n try:\r\n if not type(path_raw) is PosixPath:\r\n path_raw = Path(path_raw)\r\n if type(path_reduced) is PosixPath:\r\n path_reduced = Path(path_reduced)\r\n if not type(path_raw) is PosixPath:\r\n path_output = Path(path_output) \r\n for path in [path_raw,path_reduced]:\r\n if not path.exists():\r\n print('The input path {0:s} does not exists. Returning'.format(str(path)))\r\n return\r\n if not path_output.exists():\r\n path_output.mkdir()\r\n except:\r\n print(sys.exc_info()[0])\r\n \r\n \r\n #%% Step 0 : \r\n # Load all raw frames and list the original filename, along with the type \r\n # and archive names\r\n\r\n raw_files = []\r\n raw_archive_names = []\r\n raw_dpr_types = []\r\n \r\n files_sphere_raw = sorted(path_raw.glob('SPHERE*IRDIS*OBS*fits'))\r\n for file in files_sphere_raw:\r\n try:\r\n h=fits.getheader(file)\r\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR'] and 'IRDIS' in h['HIERARCH ESO SEQ ARM']: \r\n raw_files.append(files_sphere_raw)\r\n raw_archive_names.append(h['ARCFILE'])\r\n raw_dpr_types.append(h['HIERACH ESO DPR TYPE'])\r\n except:\r\n continue\r\n \r\n\r\n #%% Step 1 : \r\n \r\n # You look for all reduced frames that correspond to \r\n # coronagraphic data with PRO.CATG as \r\n # - IRD_SCIENCE_DBI_LEFT_CUBE \r\n # - IRD_SCIENCE_DBI_RIGHT_CUBE\r\n # - IRD_STAR_CENTER\r\n \r\n files_sphere_reduced = sorted(path_reduced.glob('r.SPHER*.fits'))\r\n reduced_files_dbi_left = [] \r\n raw_files_dbi_left = [] # careful !! This is not the raw file name as saved in raw/date/\r\n \r\n reduced_files_dbi_right = []\r\n raw_files_dbi_right = []\r\n \r\n for file in files_sphere_reduced:\r\n try:\r\n h=fits.getheader(file)\r\n # check whether this is a coronagraphic frame\r\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR']:\r\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_LEFT_CUBE':\r\n reduced_files_dbi_left.append(file)\r\n raw_files_dbi_left.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\r\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_RIGHT_CUBE':\r\n reduced_files_dbi_right.append(file)\r\n raw_files_dbi_right.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\r\n except:\r\n continue\r\n\r\n \r\n \r\n #%% Step 2: \r\n # You isolate for each raw frames one single reduced left and right cube \r\n # (currently the pipeline does multiple reductions of the same raw cube for \r\n # an unknown reason, we need to get rid of the duplicates here).\r\n \r\n unique_reduced_files_dbi_left,indices = np.unique(reduced_files_dbi_left,return_index=True)\r\n unique_raw_files_dbi_left = [raw_files_dbi_left[i] for i in indices]\r\n \r\n unique_reduced_files_dbi_right,indices = np.unique(reduced_files_dbi_right,return_index=True)\r\n unique_raw_files_dbi_right = [raw_files_dbi_right[i] for i in indices]\r\n \r\n \r\n #%% Step 3\r\n # You extract DIT, NDIT, NAXIS3, coronagraph name:\r\n # Lyot stop: HIERARCH ESO INS1 OPTI1 NAME\r\n # Lyot mask: HIERARCH ESO INS4 OPTI11 NAME\r\n # coro combination name: HIERARCH ESO INS COMB ICOR\r\n # along with the ND filter and the IRDIS filter from each RAW frame.\r\n # Also extract all info that will be useful later for the analysis:\r\n # star name and magnitude, airmass, seeing, coherence time, telescope Seeing...)\r\n # This is important to do that on each raw frame on not on each reduced frame\r\n # as the keywords are changed by the pipeline and unreliable.\r\n \r\n \r\n \r\n #%% Step 4\r\n # Assoiate each FLUX with a CORONAGRAPHIC image\r\n \r\n \r\n \r\n #%% Step 5\r\n # Work on the Flux frame first:\r\n # - Detect the central star\r\n # - measure the FWHM, validate that this is the star by checking the FWHM\r\n # (should be the diffraction limit)\r\n # - aperture photometry on the star using a diameter of 1 lambda/D \r\n # - divide the flux by the DIT and correct by the ND transmission: this\r\n # gives you the star reference flux\r\n \r\n \r\n #%% Step 6\r\n # Work on the coronographic frame now:\r\n # - Detect the coronagraphic center.\r\n # - compute the contrast (using the standard deviation of many apertures \r\n # place at a given separation, using for instance the python module VIP)\r\n\r\n\r\n #%% Step 7:\r\n # Divide the azinuthal standard deviations by the star reference flux to obtain\r\n # the contrast as a function of radius. \r\n # Plot the result and save in a csv file along with all relevant parameters \r\n # for the analysis (coronagraph name, star magnitude, airmass, seeing, coherence time)\r","def potentials(path_to_units, path_to_eez, path_to_shared_coast,\n path_to_electricity_yield_pv_prio, path_to_electricity_yield_wind_prio,\n path_to_eligibility_categories, path_to_land_cover, path_to_protected_areas,\n path_to_result, scenario, config):\n with rasterio.open(path_to_eligibility_categories, \"r\") as src:\n eligibility_categories = src.read(1)\n with rasterio.open(path_to_electricity_yield_pv_prio, \"r\") as src:\n transform = src.transform\n electricity_yield_pv_prio = src.read(1)\n with rasterio.open(path_to_electricity_yield_wind_prio, \"r\") as src:\n electricity_yield_wind_prio = src.read(1)\n with rasterio.open(path_to_land_cover, \"r\") as src:\n land_cover = src.read(1)\n with rasterio.open(path_to_protected_areas, \"r\") as src:\n protected_areas = src.read(1)\n with fiona.open(path_to_units, \"r\") as src:\n unit_ids = [feature[\"properties\"][\"id\"] for feature in src]\n unit_geometries = [feature[\"geometry\"] for feature in src]\n with fiona.open(path_to_eez, \"r\") as src:\n eez_ids = [feature[\"properties\"][\"id\"] for feature in src]\n eez_geometries = [feature[\"geometry\"] for feature in src]\n shared_coasts = pd.read_csv(path_to_shared_coast, index_col=0)\n\n electricity_yield_pv_prio, electricity_yield_wind_prio = apply_scenario_config(\n potential_pv_prio=electricity_yield_pv_prio,\n potential_wind_prio=electricity_yield_wind_prio,\n categories=eligibility_categories,\n land_cover=land_cover,\n protected_areas=protected_areas,\n scenario_config=config[\"scenarios\"][scenario]\n )\n electricity_yield_pv_prio, electricity_yield_wind_prio = decide_between_pv_and_wind(\n potential_pv_prio=electricity_yield_pv_prio,\n potential_wind_prio=electricity_yield_wind_prio,\n electricity_yield_pv_prio=electricity_yield_pv_prio,\n electricity_yield_wind_prio=electricity_yield_wind_prio,\n eligibility_categories=eligibility_categories\n )\n\n onshore_potentials = pd.DataFrame(\n index=unit_ids,\n data={\n potential: potentials_per_shape(\n eligibilities=potential.eligible_on,\n potential_map=(electricity_yield_pv_prio if \"pv\" in str(potential).lower()\n else electricity_yield_wind_prio),\n eligibility_categories=eligibility_categories,\n shapes=unit_geometries,\n transform=transform\n )\n for potential in Potential.onshore()\n }\n )\n offshore_eez_potentials = pd.DataFrame(\n index=eez_ids,\n data={\n potential: potentials_per_shape(\n eligibilities=potential.eligible_on,\n potential_map=(electricity_yield_pv_prio if \"pv\" in str(potential).lower()\n else electricity_yield_wind_prio),\n eligibility_categories=eligibility_categories,\n shapes=eez_geometries,\n transform=transform\n )\n for potential in Potential.offshore()\n }\n )\n offshore_potentials = pd.DataFrame(\n data=shared_coasts.dot(offshore_eez_potentials),\n columns=Potential.offshore()\n )\n potentials = pd.concat([onshore_potentials, offshore_potentials], axis=1)\n potentials.index.name = \"id\"\n potentials.to_csv(\n path_to_result,\n header=True,\n index=True\n )","def test_solution_usage(self, test_data):\n for finput in test_data[\"EKFSLAM.EKFSLAM.Fx\"][:1]:\n params = finput\n\n solution.used[\"EKFSLAM.EKFSLAM.Fx\"] = False\n\n EKFSLAM.EKFSLAM.Fx(**params)\n\n assert not solution.used[\"EKFSLAM.EKFSLAM.Fx\"], \"The function uses the solution\"","def find_constants(open_path):\n\n if not os.path.exists(MODEL_FILE):\n easygui.msgbox(\"There are no models to use to classify the data. Please train algorithm first.\")\n return\n\n clf = joblib.load(MODEL_FILE)\n\n if is_empty_model(clf):\n easygui.msgbox(\"The model has not been fitted yet. Please fit data to the model.\")\n return\n\n while True:\n file = easygui.fileopenbox('Please locate csv file', 'Specify File', default=open_path, filetypes='*.csv')\n\n if file:\n open_path = \"{0:s}\\*.csv\".format(os.path.dirname(file))\n\n file_data = get_data(file)\n\n legacy_log = is_valid_log(file_data, visualize.LEGACY_COLUMNS)\n current_log = is_valid_log(file_data)\n\n if legacy_log or current_log:\n if legacy_log and not current_log:\n easygui.msgbox(\"Because this log is missing information that makes it optimal \"\n \"for manipulating the data efficiently results may be inaccurate\")\n\n # TODO make it so that when closing the figure using the GUI it reopens normally\n plot = ConstantViewer(clf)\n plot.graph(file_data)\n plot.show()\n else:\n\n easygui.msgbox(\n \"The file {0:s} is not a valid file.\".format(os.path.basename(file)))\n else:\n break\n\n plt.close(\"all\")\n return open_path","def extract_all_lazy():\n\n\t#Construct filepaths: Data COMP_INFO_1\n\tdata_ci1_name = \"DATA_2016_COMP_INFO_1.csv\"\n\tdata_ci1_fullname = os.path.join(files_location, data_ci1_name)\n\t#Data COMP_INFO_2\n\tdata_ci2_name = \"DATA_2016_COMP_INFO_2.csv\"\n\tdata_ci2_fullname = os.path.join(files_location, data_ci2_name)\n\t#Data PROPERTY INFO\n\tdata_pi_name = \"DATA_2016_PROPERTY_INFO_ST.csv\"\n\tdata_pi_fullname = os.path.join(files_location, data_pi_name)\n\t#Data General Info\n\tdata_gi_name = \"DATA_2016_GENERAL_INFO.csv\"\n\tdata_gi_fullname = os.path.join(files_location, data_gi_name)\n\n\t#Read & Process COMP_INFO\n\tdata_ci1 = pd.read_csv(data_ci1_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\n\tdata_ci2 = pd.read_csv(data_ci2_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\n\n\tdata_ci = data_ci1.append(data_ci2)\n\tdata_ci['QUESTION'] = data_ci['QUESTION'].replace(constants.ci_mapping)\n\t# Take only the survey questions mapped\n\tdata_ci = data_ci[data_ci['QUESTION'].isin(constants.ci_mapping.values())]\n\tdata_ci = data_ci.set_index(['PROPERTY_CODE','PROPERTY_NAME','JOB_CODE','POSITION'])\n\tdata_ci = data_ci.pivot(columns=\"QUESTION\")\n\tdata_ci.columns = [\"_\".join(pair) for pair in data_ci.columns]\n\tdata_ci = data_ci.reset_index()\n\n\t#Read & Process Property Info data\n\tdata_pi = pd.read_csv(data_pi_fullname, usecols = constants.keep_columns_PI, encoding='ISO-8859-1')\n\t#survey_type_transformed = transform.surveytype_categorical(data_pi)\n\t#data_pi = pd.merge(data_pi, survey_type_transformed, on=['PROPERTY_CODE'])\n\n\t#Read & Process General Info\n\tdata_gi = pd.read_csv(data_gi_fullname, skiprows = 2, usecols = constants.keep_columns_GI, encoding='ISO-8859-1')\n\tdata_gi['QUESTION'] = data_gi['QUESTION'].replace(constants.gi_mapping)\n\t# Take onl the survey questions mapped\n\tdata_gi = data_gi[data_gi['QUESTION'].isin(constants.gi_mapping.values())]\n\tdata_gi = data_gi.set_index(['PROPERTY_CODE','PROPERTY_NAME'])\n\tdata_gi = data_gi.pivot(columns=\"QUESTION\")\n\tdata_gi.columns = [\"_\".join(pair) for pair in data_gi.columns]\n\tdata_gi = data_gi.reset_index()\n\n\t#This frame needs to be reworked\n\td_ci = pd.merge(data_gi, data_pi, on = ['PROPERTY_CODE','PROPERTY_NAME'])\n\td_ci = pd.merge(d_ci, data_ci, on = ['PROPERTY_CODE','PROPERTY_NAME'],suffixes= ['_ci','_gi'])\n\n\t#Observations by Dimensions to determine top X markets\n\t#Can this be in a better position?\n\td_ci = d_ci[~(d_ci['PROPERTY_NAME'].isin(constants.del_rows_property_name))]\n\td_ci['POSITION'] = d_ci['POSITION'].astype(str)\n\n\tpayload = {}\n\tpayload['gi'] = data_gi\n\tpayload['pi'] = data_pi\n\tpayload['ci'] = data_ci\n\tpayload['d_ci'] = d_ci\n\n\treturn payload","def on_menu_criteria_file(self, event):\n if self.data_model == 3:\n dlg = wx.FileDialog(\n self, message=\"choose a file in MagIC Data Model 3.0 format\",\n defaultDir=self.WD,\n defaultFile=\"criteria.txt\",\n style=wx.FD_OPEN | wx.FD_CHANGE_DIR\n )\n else:\n dlg = wx.FileDialog(\n self, message=\"choose a file in a MagIC Data Model 2.5 pmagpy format\",\n defaultDir=self.WD,\n defaultFile=\"pmag_criteria.txt\",\n # wildcard=wildcard,\n style=wx.FD_OPEN | wx.FD_CHANGE_DIR\n )\n\n if self.show_dlg(dlg) == wx.ID_OK:\n criteria_file = dlg.GetPath()\n self.GUI_log.write(\n \"-I- Read new criteria file: %s\\n\" % criteria_file)\n dlg.Destroy()\n replace_acceptance_criteria = pmag.initialize_acceptance_criteria(\n data_model=self.data_model)\n try:\n if self.data_model == 3:\n self.read_criteria_file(criteria_file)\n replace_acceptance_criteria = self.acceptance_criteria\n # replace_acceptance_criteria=pmag.read_criteria_from_file(criteria_file,replace_acceptance_criteria,data_model=self.data_model)\n # # just to see if file exists\n print(replace_acceptance_criteria)\n else:\n replace_acceptance_criteria = pmag.read_criteria_from_file(\n criteria_file, replace_acceptance_criteria, data_model=self.data_model) # just to see if file exists\n except Exception as ex:\n print('-W-', ex)\n dlg1 = wx.MessageDialog(\n self, caption=\"Error:\", message=\"error in reading file\", style=wx.OK)\n result = self.show_dlg(dlg1)\n if result == wx.ID_OK:\n dlg1.Destroy()\n return\n self.add_thellier_gui_criteria()\n self.read_criteria_file(criteria_file)\n # check if some statistics are in the new criteria but not in old. If\n # yes, add to self.preferences['show_statistics_on_gui']\n crit_list_not_in_pref = []\n for crit in list(self.acceptance_criteria.keys()):\n if self.acceptance_criteria[crit]['category'] == \"IE-SPEC\":\n if self.acceptance_criteria[crit]['value'] != -999:\n short_crit = crit.split('specimen_')[-1]\n if short_crit not in self.preferences['show_statistics_on_gui']:\n print(\"-I- statistic %s is not in your preferences\" % crit)\n self.preferences['show_statistics_on_gui'].append(\n short_crit)\n crit_list_not_in_pref.append(crit)\n if len(crit_list_not_in_pref) > 0:\n stat_list = \":\".join(crit_list_not_in_pref)\n dlg1 = wx.MessageDialog(self, caption=\"WARNING:\",\n message=\"statistics '%s' is in the imported criteria file but not in your appearence preferences.\\nThis statistic will not appear on the gui panel.\\n The program will exit after saving new acceptance criteria, and it will be added automatically the next time you open it \" % stat_list,\n style=wx.OK | wx.ICON_INFORMATION)\n self.show_dlg(dlg1)\n dlg1.Destroy()\n\n dia = thellier_gui_dialogs.Criteria_Dialog(\n None, self.acceptance_criteria, self.preferences, title='Acceptance Criteria')\n dia.Center()\n result = self.show_dlg(dia)\n if result == wx.ID_OK: # Until the user clicks OK, show the message\n self.On_close_criteria_box(dia)\n if len(crit_list_not_in_pref) > 0:\n dlg1 = wx.MessageDialog(self, caption=\"WARNING:\",\n message=\"Exiting now! When you restart the gui all the new statistics will be added.\",\n style=wx.OK | wx.ICON_INFORMATION)\n self.show_dlg(dlg1)\n dlg1.Destroy()\n self.on_menu_exit(None)\n # self.Destroy()\n # sys.exit()\n\n if result == wx.ID_CANCEL: # Until the user clicks OK, show the message\n for crit in crit_list_not_in_pref:\n short_crit = crit.split('specimen_')[-1]\n self.preferences['show_statistics_on_gui'].remove(short_crit)","def get_clean_data(path = 'ucr_offenses_known_monthly_1960_2016_dta/', \n identifier_variables = ['fips_state_county_code', 'state', 'date', 'year', 'zip_code', 'month'], \n crime_category = ['act_aggravated_assault', 'act_simple_assault', 'act_murder', 'act_robbery_total', \n 'act_manslaughter', 'act_theft_total', 'act_mtr_vhc_theft_total', 'act_burglary_total', 'act_rape_total'], \n start_year = 1980, end_year = 2009, selected_area = 'all'):\n all_df = []\n for i in get_filenames(start_year, end_year):\n file = path + i\n print(file)\n each_df = pd.read_stata(file)\n each_df = each_df[identifier_variables + crime_category]\n each_df = each_df[each_df['fips_state_county_code'] == '06001']\n each_df['zipcode'] = each_df['zip_code'].apply(lambda x: str(x)[0:5])\n #split Alameda into West and East Alameda according to zip code\n if selected_area == 'east':\n each_df = each_df[(each_df['zipcode'] == '94550') | (each_df['zipcode'] == '94566') | \n (each_df['zipcode'] == '94586') | (each_df['zipcode'] == '94568') | \n (each_df['zipcode'] == '94588') | (each_df['zipcode'] == '94551')]\n elif selected_area == 'west':\n each_df = each_df[(each_df['zipcode'] != '94550') & (each_df['zipcode'] != '94566') & \n (each_df['zipcode'] != '94586') & (each_df['zipcode'] != '94568') & \n (each_df['zipcode'] != '94588') & (each_df['zipcode'] != '94551') &\n (each_df['zipcode'] != '0') & (each_df['zipcode'] != '0.0') & \n (each_df['zipcode'] != 'not r') & (each_df['zipcode'] != 'missi')]\n each_df.loc[:, 'YearMonth'] = [int(re.sub('-', '', date)[0:6]) for date in each_df.loc[:, 'date']]\n #sum up amount of crimes taken place in each category for each month\n each_df = each_df.groupby(['YearMonth'])[crime_category].sum()\n each_df['crime_sum'] = each_df.sum(axis = 1)\n each_df = each_df['crime_sum'].reset_index()\n all_df.append(each_df)\n df = pd.concat(all_df).fillna(0)\n df = df.sort_values('YearMonth').reset_index()\n #split variable 'YearMonth\" into two variables 'year' and \"month' for Poission regression\n del df['index']\n df['year'] = df['YearMonth'].apply(lambda x: str(x)[:4])\n df['month'] = df['YearMonth'].apply(lambda x: str(x)[4:])\n if selected_area == 'east':\n df.to_csv('east_alameda_crime.csv')\n elif selected_area == 'west':\n df.to_csv('west_alameda_crime.csv')\n else:\n df.to_csv('all_alameda_crime.csv')\n return(df)","def read_input(self):\n try:\n path = tkFileDialog.askdirectory()\n if not path: # User the cancelled dialog box so bug out\n return False\n # Search the user-provided path for all the input files.\n foundall, missing = self.files.locate_input(path)\n # If any are missing show the user and error message\n # with the missing files listed.\n if not foundall:\n # Give indentation and numbered bullets to the missing names\n missing = [' {}) {}'.format(i, name)\n for i, name in enumerate(sorted(missing), 1)]\n missing.insert(0, 'The following files were not found:')\n missing.append('Nothing was modified')\n tkMessageBox.showerror('Error', '\\n'.join(missing))\n return False\n # Files were successfully located.\n # Read contents of gain/voltage files.\n # This must come first, as it also sets the row and column numbers.\n with self.files.open_file('GAIN_LARGE') as file:\n largegains = file.readlines()\n for x in NORTH_LARGE, SOUTH_LARGE:\n self.detectors[x].set_voltages(largegains)\n with self.files.open_file('GAIN_SMALL') as file:\n smallgains = file.readlines()\n for x in NORTH_SMALL, SOUTH_SMALL:\n self.detectors[x].set_voltages(smallgains)\n # Set QT information\n qtdirname = os.path.dirname(self.files['QT1'])\n self.qt = qt.System(qtdirname)\n for det in self.detectors.itervalues():\n det.set_qt(self.qt)\n # Now that the detector information is complete,\n # let's keep a copy of the initial detector state.\n # This is required for when we make a ROOT\n # tree with initial and final information.\n self.initial = copy.deepcopy(self.detectors)\n except IOError as err:\n tkMessageBox.askyesno('I/O error', str(err))\n self.image_window.canvas.focus_set()"],"string":"[\n \"def open_files(self):\\n if not self.unbalanced:\\n if not self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest.nc')\\n return datas\\n if self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_valid.nc')\\n return datas\\n if self.unbalanced:\\n if not self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced.nc')\\n return datas\\n if self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced_valid.nc')\\n return datas\",\n \"def reduce_single_set_data():\\n workflow = my_data.get()\\n\\n # Set reduction parameters\\n focus_calib_file = '/SNS/VULCAN/shared/autoreduce/vulcan_foc_all_2bank_11p.cal'\\n\\n workflow.set_focus_calibration_file(focus_calib_file)\\n\\n # set up reduction parameters\\n outputdir = os.getcwd()\\n paramdict = {\\n \\\"Extension\\\": \\\"_event.nxs\\\",\\n \\\"PreserveEvents\\\": True,\\n \\\"Binning\\\": -0.001,\\n \\\"OutputDirectory\\\": outputdir,\\n \\\"NormalizeByCurrent\\\": False,\\n \\\"FilterBadPulses\\\": False,\\n \\\"CompressTOFTolerance\\\": False,\\n \\\"FrequencyLogNames\\\": \\\"skf1.speed\\\",\\n \\\"WaveLengthLogNames\\\": \\\"skf12.lambda\\\",\\n }\\n\\n workflow.set_reduction_parameters(paramdict)\\n\\n # reduce\\n reduction_list = [(80231, True)]\\n workflow.set_reduction_flag(file_flag_list=reduction_list, clear_flags=True)\\n\\n status, ret_obj = workflow.reduce_data_set(norm_by_vanadium=False)\\n print('[Message] ', str(ret_obj))\\n assert status\",\n \"def get_model_data_from_files(self, oc):\\r\\n # Load model related files\\r\\n model_path = self.config['DATA_PATH'] + self.config['CUSTOMER_NAME'] + '/models/'\\r\\n\\r\\n features_file = model_path + self.task + '_' + str(oc) + '_features.txt'\\r\\n dummies_file = model_path + self.task + '_' + str(oc) + '_dummies.txt'\\r\\n model_file = model_path + self.task + '_' + str(oc) + '.joblib'\\r\\n\\r\\n if os.path.isfile(features_file) and os.path.isfile(dummies_file) and os.path.isfile(model_file):\\r\\n model = joblib.load(model_file)\\r\\n features = open(features_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\\\n').split(self.config['DATA_SEPARATOR'])\\r\\n dummies = open(dummies_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\\\n').split(self.config['DATA_SEPARATOR'])\\r\\n return (model, features, dummies)\\r\\n return (None, None, None)\",\n \"def stageData(self,m):\\n obs = Variable(filename = self.source,\\n variable_name = self.variable,\\n alternate_vars = self.alternate_vars)\\n if obs.time is None: raise il.NotTemporalVariable()\\n self.pruneRegions(obs)\\n \\n # Try to extract a commensurate quantity from the model\\n mod = m.extractTimeSeries(self.variable,\\n alt_vars = self.alternate_vars,\\n expression = self.derived,\\n initial_time = obs.time_bnds[ 0,0],\\n final_time = obs.time_bnds[-1,1],\\n lats = None if obs.spatial else obs.lat,\\n lons = None if obs.spatial else obs.lon)\\n obs,mod = il.MakeComparable(obs,mod,\\n mask_ref = True,\\n clip_ref = True,\\n extents = self.extents,\\n logstring = \\\"[%s][%s]\\\" % (self.longname,m.name))\\n \\n # Check the order of magnitude of the data and convert to help avoid roundoff errors\\n def _reduceRoundoffErrors(var):\\n if \\\"s-1\\\" in var.unit: return var.convert(var.unit.replace(\\\"s-1\\\",\\\"d-1\\\"))\\n if \\\"kg\\\" in var.unit: return var.convert(var.unit.replace(\\\"kg\\\" ,\\\"g\\\" ))\\n return var\\n def _getOrder(var):\\n return np.log10(np.abs(var.data).clip(1e-16)).mean()\\n order = _getOrder(obs)\\n count = 0\\n while order < -2 and count < 2:\\n obs = _reduceRoundoffErrors(obs)\\n order = _getOrder(obs)\\n count += 1\\n \\n # convert the model data to the same unit\\n mod = mod.convert(obs.unit)\\n\\n return obs,mod\",\n \"def apply(self, opened_file):\",\n \"def load_file_data_from_db(self):\\n\\n file_objs = self.file_queryset.filter(sip=self.sip, removedtime__isnull=True)\\n for file_obj in self._batch_query(file_objs):\\n self.file_events = get_file_events(file_obj)\\n if not self.file_events:\\n return\\n try:\\n # merge the map_file_data dict with the map_av_data\\n mapped_file_info = merge_file_data_dicts(\\n map_file_data(file_obj, self.file_events), map_av_data(file_obj)\\n )\\n self.md_info[\\\"files\\\"].append(mapped_file_info)\\n self.md_info[\\\"premis:size\\\"] = create_package_size(\\n mapped_file_info[\\\"premis:size\\\"]\\n )\\n self.md_info[\\\"amount_of_files\\\"] += 1\\n failed_virus_checks = get_failed_virus_checks(self.file_events)\\n if failed_virus_checks:\\n self.md_info[\\\"virus_scan_info\\\"][\\\"failed_virus_checks\\\"].append(\\n failed_virus_checks\\n )\\n passed_virus_checks = get_passed_virus_checks(self.file_events)\\n # add info virus_scan_tools if they passed and respect\\n # different tools and versions if needed.\\n if (\\n passed_virus_checks\\n and passed_virus_checks\\n not in self.md_info[\\\"virus_scan_info\\\"][\\\"virus_scan_tools\\\"]\\n ):\\n self.md_info[\\\"virus_scan_info\\\"][\\\"virus_scan_tools\\\"].append(\\n passed_virus_checks\\n )\\n except KeyError:\\n logger.info(\\n \\\"File is no longer present on the filesystem: %s\\\",\\n file_obj.currentlocation,\\n )\\n continue\",\n \"def get_data(self): \\n self.improvement = []\\n self.corrsq = []\\n for filename in onlyfiles:\\n mst = MST(filename, mypath=mypath)\\n mst.estimate_correct_seqences()\\n mst.estimate_improvement()\\n self.mst.append(mst)\\n\\n self.corrsq.append(mst.corrsq)\\n self.improvement.append(mst.improvement)\\n\\n\\n\\n print(f\\\"cor = {improvement}\\\")\\n print(f\\\"improvement = {improvement}\\\")\\n print(f\\\"mittelwert der improvement = {np.mean(improvement)}\\\")\\n print(f\\\"Standardabweichung der lersteigung = {np.std(improvement)}\\\")\",\n \"def get_data(self):\\n \\n with os.scandir(self.file_path) as collection_of_files:\\n files_found = [file.name.split('.')[0] for file in collection_of_files \\n if (file.name.split('.')[0].lower().strip() in self._data_requirements.required_file_names \\n and file.name.endswith('.csv'))]\\n\\n self.check_missing_files(files_found)\\n \\n self._data = DictObjectView(self.read_in_files(files_found))\",\n \"def get_additional_data_from_files(df, file_description): # file description one of [\\\"video\\\", \\\"eaf\\\", \\\"seg\\\", \\\"gentle\\\"]\\n if file_description == \\\"gentle\\\":\\n file_folder = FILE_BASE + \\\"/gentle/\\\"\\n is_gentle_file = True\\n else:\\n file_folder = FILE_BASE + \\\"/original/\\\"\\n is_gentle_file = False\\n\\n file_df = None\\n\\n if file_description not in list(FILE_DESCRIPTIONS_TO_EXT.keys()):\\n print(\\\"Unknown file description! Don't know what to do with %s files...\\\" % file_description)\\n return None\\n\\n else:\\n print(\\\"Load and extract information from %s files...\\\" % file_description)\\n #pbar = tqdm.tqdm(total = len(np.unique(df[\\\"source_file\\\"])),desc='Files', position=0,leave=True,file=sys.stdout)\\n #file_log = tqdm.tqdm(total=0, position=1, bar_format='{desc}',leave=True,file=sys.stdout)\\n print(\\\"Total files to laod and preprocess: \\\", len(np.unique(df[\\\"source_file\\\"])))\\n \\n for i,file in enumerate(np.unique(df[\\\"source_file\\\"])):\\n if i%100 == 0:\\n print(\\\"File: \\\",i)\\n \\n filepath = file_folder + get_file_path(file,is_gentle_file=is_gentle_file) + FILE_DESCRIPTIONS_TO_EXT[file_description]\\n\\n if file_description == \\\"video\\\":\\n file_i_df = mp4_file_processing.get_word_video_snippet_size(df, filepath)\\n elif file_description == \\\"eaf\\\":\\n speech_annotation_eaf_data, gesture_eaf_data = eaf_file_processing.read_eaf(filepath)\\n file_i_df = eaf_file_processing.map_gestures_to_annotation(speech_annotation_eaf_data, gesture_eaf_data, remove_pauses=False)\\n file_i_df = eaf_file_processing.binary_encode_gestures(file_i_df, gesture_column=\\\"gesture\\\")\\n\\n elif file_description == \\\"seg\\\":\\n file_i_df = seg_file_processing.get_seg_file_pos_info(filepath)\\n\\n elif file_description == \\\"gentle\\\":\\n file_i_df = gentle_file_processing.get_gentle_file_transcripts(filepath)\\n \\n else:\\n print(\\\"Unknown file format!!!\\\")\\n return \\n\\n if file_df is None:\\n file_df = file_i_df\\n else:\\n file_df = pd.concat([file_df, file_i_df], ignore_index=True)\\n\\n #file_log.set_description_str(f'Processed file: {file}')\\n #pbar.update(1)\\n #sleep(0.02)\\n #file_log.close()\\n #pbar.close()\\n return file_df\",\n \"def cmorization(in_dir, out_dir, cfg, cfg_user, start_date, end_date):\\n # Run the cmorization\\n for (short_name, var) in cfg['variables'].items():\\n logger.info(\\\"CMORizing variable '%s'\\\", short_name)\\n short_name = var['short_name']\\n raw_filenames = Path(in_dir).rglob('*.nc')\\n filenames = []\\n for raw_filename in raw_filenames:\\n if re.search(var['file'], str(raw_filename)) is not None:\\n filenames.append(raw_filename)\\n\\n for filename in sorted(filenames):\\n\\n _extract_variable(short_name, var, cfg, filename, out_dir)\",\n \"def readExperi(directory,varid,experi,level):\\n print('\\\\n>>> Using readExperi function! \\\\n')\\n \\n ### Import modules\\n import numpy as np\\n from netCDF4 import Dataset\\n \\n ### Call files\\n totaldirectory = directory + experi + '/monthly/'\\n filename = totaldirectory + varid + '_1900-2000.nc'\\n \\n if any([experi == 'FPOL',experi == 'FSUB']):\\n directory = '/home/zlabe/green/simu/'\\n totaldirectory = directory + experi + '/monthly/'\\n filename = totaldirectory + varid + '_1900-2000.nc'\\n \\n ### Read in Data\\n if level == 'surface': # 3d variables\\n data = Dataset(filename,'r')\\n varq = data.variables['%s' % varid][:,:,:,0]\\n data.close()\\n \\n dataq = Dataset(totaldirectory + 'T2M_1900-2000.nc')\\n time = dataq.variables['time'][:]\\n lev = 'surface'\\n lat = dataq.variables['latitude'][:]\\n lon = dataq.variables['longitude'][:]\\n dataq.close()\\n elif level == 'profile': # 4d variables\\n data = Dataset(filename,'r')\\n varq = data.variables['%s' % varid][:,:,:,0]\\n data.close()\\n \\n dataq = Dataset(totaldirectory + 'TEMP_1900-2000.nc')\\n time = dataq.variables['time'][:]\\n lev = dataq.variables['level'][:]\\n lat = dataq.variables['latitude'][:]\\n lon = dataq.variables['longitude'][:]\\n dataq.close()\\n else:\\n print(ValueError('Selected wrong height - (surface or profile!)!')) \\n print('Completed: Read data for *%s* : %s!' % (experi[:4],varid))\\n \\n ### Reshape to split years and months\\n months = 12\\n if level == 'surface': # 3d variables\\n var = np.reshape(varq,(int(varq.shape[0]/12),months,\\n int(lat.shape[0])))\\n elif level == 'profile': # 4d variables\\n var = np.reshape(varq,(int(varq.shape[0]/12),months,int(lev.shape[0]),\\n int(lat.shape[0])))\\n else:\\n print(ValueError('Selected wrong height - (surface or profile!)!')) \\n print('Completed: Reshaped %s array!' % (varid))\\n \\n ### Convert units\\n if varid in ('TEMP','T2M'):\\n var = var - 273.15 # Kelvin to degrees Celsius \\n print('Completed: Changed units (K to C)!')\\n\\n print('\\\\n*Completed: Finished readExperi function!')\\n return lat,lon,time,lev,var\",\n \"def __call__( self, file_contents, regression_var ):\\n return super()._process( self.__load( file_contents ), regression_var )\",\n \"def __call__( self, file_contents, regression_var ):\\n return super()._process( self.__load( file_contents ), regression_var )\",\n \"def _compute_(self, case):\\n dic = \\\"data/sim/{dn}/{rad}/\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"), rad=self.rad)\\n fn = \\\"data/sim/{dn}/{rad}/exp.{cse}.bm({bm}).elv(<elv>).csv\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"),\\n rad=self.rad, bm=self.bmnum, cse=case)\\n cmd = \\\"export DIR_MODELS_REF_DAT=/home/shibaji/Collaboration_NCAR/code_rt_sd/pharlap/pharlap_4.1.3/dat;\\\\\\n cd pharlap;\\\\\\n matlab -nodisplay -nodesktop -nosplash -nojvm -r \\\\\\\"UT=[{ut}];rad='{rad}';dic='{dic}';bm={bm};\\\\\\n fn='{fn}';cse='{cse}';rt_1D_sen;exit;\\\\\\\"\\\".format(ut=self.event.strftime(\\\"%Y %m %d %H %S\\\"), rad=self.rad,\\n dic=dic, bm=self.bmnum, fn=fn, cse=case)\\n os.system(cmd)\\n return\",\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 execute(cf):\\n\\n ##Ports and parameters\\n train_set = cf.get_input(\\\"train_set\\\") #training set. Typically even_file\\n test_set = cf.get_input(\\\"test_set\\\") #test set. Typically odd_file\\n WM1 = cf.get_input(\\\"WM1\\\")\\n WM2 = cf.get_input(\\\"WM2\\\")\\n WM3 = cf.get_input(\\\"WM3\\\")\\n WM4 = cf.get_input(\\\"WM4\\\")\\n WM5 = cf.get_input(\\\"WM5\\\")\\n WM6 = cf.get_input(\\\"WM6\\\")\\n WM7 = cf.get_input(\\\"WM7\\\")\\n WM8 = cf.get_input(\\\"WM8\\\")\\n WM9 = cf.get_input(\\\"WM9\\\")\\n WM10 = cf.get_input(\\\"WM10\\\")\\n WM11 = cf.get_input(\\\"WM11\\\")\\n WM12 = cf.get_input(\\\"WM12\\\")\\n WM13 = cf.get_input(\\\"WM13\\\")\\n WM14 = cf.get_input(\\\"WM14\\\")\\n WM15 = cf.get_input(\\\"WM15\\\")\\n WM16 = cf.get_input(\\\"WM16\\\")\\n WM17 = cf.get_input(\\\"WM17\\\")\\n WM18 = cf.get_input(\\\"WM18\\\")\\n WM19 = cf.get_input(\\\"WM19\\\")\\n WM20 = cf.get_input(\\\"WM20\\\")\\n WMdir = cf.get_input(\\\"WMdir\\\")\\n WMdir2 = cf.get_input(\\\"WMdir2\\\")\\n basefreqs = cf.get_input(\\\"BaseFrequencies\\\")\\n ufemodel_path = cf.get_input(\\\"UFEmodel\\\")\\n\\n bestWM = cf.get_output(\\\"BestWM\\\")\\n log_file = cf.get_output(\\\"log_file\\\")\\n interm = cf.get_output(\\\"intermediate\\\")\\n\\n genome = cf.get_parameter('genome', 'string')\\n motevo_path = cf.get_parameter('motevo_path', 'string')\\n aligned = cf.get_parameter(\\\"aligned\\\", \\\"boolean\\\")\\n\\n os.mkdir(interm)\\n\\n\\n\\n # Read stuff in\\n WMs = [i for i in[WM1, WM2, WM3, WM4, WM5, WM6, WM7, WM8, WM9, WM10, WM11, WM12, WM13, WM14, WM15, WM16, WM17, WM18, WM19, WM20] if i]\\n\\n if WMdir:\\n WMs += [os.path.join(WMdir, wm) for wm in os.listdir(WMdir)]\\n\\n if WMdir2:\\n WMs += [os.path.join(WMdir2, wm) for wm in os.listdir(WMdir2)]\\n\\n f = open(basefreqs)\\n ATfreq = float(f.readline().strip().split()[1])\\n GCfreq = float(f.readline().strip().split()[1])\\n f.close()\\n\\n\\n # Compute stuff: optimal priors and then likelihood of test set\\n optpriors = []\\n logliks = []\\n\\n for i, WM in enumerate(WMs):\\n\\n wmlen = len(open(WM).readlines())-4\\n\\n # 1. Fit prior on training set with EM\\n tag = 'fitP_%i' %(i+1)\\n params, sites, priors, loglikfile = giveMotevoParamFile(genome, wmlen, interm, tag, aligned, ufemodel_path, ATfreq, GCfreq, emprior=1, bgorder=0, bgprior=0.99)\\n r = runMotevo(motevo_path, train_set, params, WM, interm, tag)\\n if r != 0:\\n print 'motevo failed ', tag\\n sys.exit(1)\\n\\n # prior file:\\n # WM_name final_prior nr_of_sites density\\n # /import/bc2/home/nimwegen/GROUP/hseq_pipeline/severin/Anduril/Pipeline/PipeLineSource/TESTRUN/NRF1_Z2/OUTPUT/NRF1_FgBg-runmotevoPG2_1/Logo 0.016554 635.008 0.251863\\n # background 0.983446 37724.8 0.748137\\n # UFEwm 0 0 0\\n\\n optprior = float(open(priors).readlines()[1].split()[1])\\n bgprior=(1-optprior)\\n print bgprior\\n\\n # 2. Compute log-likelihood on test set with optimal prior from training set and without EM\\n tag = 'compLL_%i' %(i+1)\\n params, sites, priors, loglikfile = giveMotevoParamFile(genome, wmlen, interm, tag, aligned, ufemodel_path, ATfreq, GCfreq, emprior=0, bgorder=0, bgprior=bgprior)\\n runMotevo(motevo_path, train_set, params, WM, interm, tag)\\n\\n a = loadtxt(loglikfile, usecols=[1])\\n ll = sum(a)\\n\\n logliks.append(ll)\\n optpriors.append(optprior)\\n\\n print logliks\\n\\n\\n\\n #replace name in WM file with bestWM\\n lines = open(WMs[argmax(logliks)]).readlines()\\n lines[1] = 'NA BestWM\\\\n'\\n bwm = open(bestWM, 'w')\\n bwm.write(''.join(lines))\\n\\n\\n l = open(log_file, 'w')\\n\\n l.write('WM_name\\\\tWM_path\\\\tlog_likelihood\\\\topt_prior\\\\n')\\n\\n names = ['WM_%i\\\\t%s\\\\t%.4f\\\\t%s' %(i+1, WMs[i], logliks[i], optpriors[i]) for i in arange(len(WMs))]\\n\\n l.write('\\\\n'.join(names))\\n l.close()\\n\\n\\n return 0\",\n \"def solve(ctx):\\n my_solver(ctx.obj['filename'])\",\n \"def get_obs(case, this_varname, this_filename, valid_years, mode_lag, cvdp_file, AMO_cutoff_freq, name_conversion):\\n\\n # The forced component of both temperature and precipitation are estimated through regressing the local\\n # values onto the GM-EM temperature time series, which can be viewed as a proxy for radiative forcing.\\n\\n # We assume that the forced component of SLP is zero.\\n cvdp_loc = '/'.join(cvdp_file.split('/')[:-1])\\n gm_em, gm_em_units, time, time_units = forced_trend('tas', cvdp_loc)\\n\\n if this_varname == 'slp':\\n gm_em *= 0\\n gm_em += 1 # will replace constant\\n\\n # Get dataframe of modes\\n df = create_mode_df(cvdp_file, AMO_cutoff_freq)\\n\\n # Add EM, GM time series to it\\n df = df.assign(F=gm_em)\\n\\n # Shift modes in time\\n df_shifted = shift_df(df, mode_lag, ['year', 'month', 'season', 'F'])\\n\\n # Subset to valid years\\n subset = np.isin(df_shifted['year'].values, valid_years)\\n df_shifted = df_shifted.loc[subset, :]\\n\\n # Reset the forced trend time series to a mean of zero\\n # This allows for the forced trend to be straightforwardly added in later\\n F = df_shifted['F'].values\\n F -= np.mean(F)\\n df_shifted = df_shifted.assign(F=F)\\n\\n # Load dataset\\n if case == 'obs': # Observational data\\n ds = xr.open_dataset(this_filename)\\n elif 'LE' in case: # CESM data. Allows for multiple runs to be concatenated if desired.\\n if this_varname == 'pr': # CESM splits up precipitation into convective and large scale, liquid+ice vs snow\\n ds = xr.open_mfdataset(this_filename, combine='nested', concat_dim='time')\\n this_filename2 = [f.replace('PRECC', 'PRECL') for f in this_filename]\\n ds2 = xr.open_mfdataset(this_filename2, combine='nested', concat_dim='time')\\n this_filename3 = [f.replace('PRECC', 'PRECSC') for f in this_filename]\\n ds3 = xr.open_mfdataset(this_filename3, combine='nested', concat_dim='time')\\n this_filename4 = [f.replace('PRECC', 'PRECSL') for f in this_filename]\\n ds4 = xr.open_mfdataset(this_filename4, combine='nested', concat_dim='time')\\n # CESM output saved with one day delay, so need to move back\\n ds2 = ds2.assign_coords(time=ds2.time-timedelta(days=1))\\n ds3 = ds3.assign_coords(time=ds3.time-timedelta(days=1))\\n ds4 = ds4.assign_coords(time=ds4.time-timedelta(days=1))\\n else:\\n ds = xr.open_mfdataset(this_filename, combine='nested', concat_dim='time')\\n\\n # CESM output saved with one day delay, so need to move back\\n ds = ds.assign_coords(time=ds.time-timedelta(days=1))\\n\\n # Load data\\n try:\\n lat = ds['latitude'].values\\n lon = ds['longitude'].values\\n except KeyError:\\n lat = ds['lat'].values\\n lon = ds['lon'].values\\n try:\\n X = ds[this_varname]\\n X_units = ds[this_varname].units\\n except KeyError:\\n alt_name = name_conversion[this_varname]\\n X = ds[alt_name]\\n X_units = ds[alt_name].units\\n\\n # Pull out values, since we'll be permuting the data / changing units, etc\\n # For CESM1-LE precipitation, need to add up convective and large scale\\n if name_conversion[this_varname] == 'PRECC':\\n X = X.values + ds2.PRECL.values + ds3.PRECSC.values + ds4.PRECSL.values\\n else:\\n X = X.values\\n\\n X_time = ds['time']\\n if 'units' in ds['time'].attrs: # nonstandard, from BEST\\n assert ds['time'].units == 'year A.D.'\\n X_year = np.floor(X_time)\\n X_month = (np.ceil((X_time - X_year)*12)).astype(int)\\n else:\\n X_year = ds['time.year']\\n X_month = ds['time.month']\\n\\n # Change units if necessary\\n if X_units == 'K':\\n # convert to celsius\\n X -= 273.15\\n X_units = 'deg C'\\n elif X_units == 'm/s':\\n # convert to mm / day\\n X *= 1000*24*60*60 # mm per day\\n X_units = 'mm/day'\\n elif X_units == 'mm/month': # GPCC, mm total over month\\n days_per_month = [calendar.monthrange(int(y), int(m))[1] for y, m in zip(X_year, X_month)]\\n X /= np.array(days_per_month)[:, np.newaxis, np.newaxis]\\n X_units = 'mm/day'\\n\\n # Check unit consistency\\n if this_varname == 'slp':\\n assert X_units == 'Pa'\\n if this_varname == 'pr':\\n assert X_units == 'mm/day'\\n\\n if 'climatology' in ds.variables:\\n climo = ds['climatology'].values\\n # Add climatology to X\\n for counter, this_month in enumerate(X_month):\\n X[counter, ...] += climo[this_month - 1, ...]\\n\\n # Permute all data to be time, lat, lon\\n lat_idx = np.where(np.isin(X.shape, len(lat)))[0][0]\\n lon_idx = np.where(np.isin(X.shape, len(lon)))[0][0]\\n time_idx = np.where(np.isin(X.shape, len(X_time)))[0][0]\\n\\n X = np.transpose(X, (time_idx, lat_idx, lon_idx))\\n ntime, nlat, nlon = np.shape(X)\\n\\n # Subset data\\n subset = np.isin(X_year, valid_years)\\n X = X[subset, :]\\n X_year = X_year[subset]\\n X_month = X_month[subset]\\n\\n # Also need to check if our data spans the full valid period\\n subset = np.isin(df_shifted['year'].values, X_year)\\n df_shifted = df_shifted.loc[subset, :]\\n\\n # Check that all dimensions look consistent\\n assert len(df_shifted) == np.shape(X)[0]\\n\\n # Put into dataarray\\n time = pd.date_range(start='%04d-%02d' % (X_year[0], X_month[0]),\\n freq='M', periods=len(X_year))\\n daX = xr.DataArray(data=X,\\n dims=('time', 'lat', 'lon'),\\n coords={'time': time,\\n 'lat': lat,\\n 'lon': lon},\\n attrs={'units': X_units})\\n\\n return daX, df_shifted, df\",\n \"def main(data, setup):\\n # input check \\n varnames = ('vm_raw', 'vm_raw_theo')\\n for varname in varnames:\\n if varname not in data.keys():\\n raise LookupError('data must contain variable %s.' %s)\\n\\n # display info message\\n chrono = setup['chrono']\\n chrono.issue('target velocity: correct for sensor motion...')\\n\\n # retrieve varialbes\\n vnys = data['nqv']\\n v_sensor_r = data['v_sensor_r']\\n\\n # ========== main =================================== #\\n for key_raw in ('vm_raw', 'vm_raw_theo'):\\n key_c = key_raw.replace('raw', 'raw_c')\\n\\n # sum\\n vm_raw = data[key_raw]\\n v_sum = (vm_raw + np.expand_dims(v_sensor_r, 1))\\n\\n # mod\\n data[key_c] = symmod(v_sum, vnys)\\n # ==================================================== #\\n\\n return data\",\n \"def get_files(self):\\n\\n # Grab master data - use existing header, remove unhappy columns\\n\\n self.df_mas_lab_data = pd.read_csv(\\n self.master_csv, dtype=str, usecols=self.columns\\n )\\n\\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\\n # Physician Office\\n facility_type_keep_list = [\\\"Independent\\\", \\\"Hospital\\\", \\\"Physician Office\\\"]\\n self.df_mas_lab_data = self.df_mas_lab_data[\\n self.df_mas_lab_data[\\\"FACILITY_TYPE\\\"].isin(facility_type_keep_list)\\n ]\\n\\n # Make everything a string and remove trailing and leading whitespaces\\n self.df_mas_lab_data = self.df_mas_lab_data.astype(str)\\n self.df_mas_lab_data = self.df_mas_lab_data.applymap(\\n lambda x: x.strip() if isinstance(x, str) else x\\n )\\n\\n print_banner(\\\"Computing all the Data\\\")\\n print(f\\\"{len(self.df_mas_lab_data)} original master CLIA labs...\\\")\\n\\n # Grab other inputed files to make new data file to compare with\\n self.df_new_lab_data = pd.concat(\\n [\\n pd.read_csv(file, names=self.columns, header=None, dtype=str, usecols=self.columns)\\n for file in self.new_files\\n ]\\n )\\n\\n # Probably not needed for the new data but just in case:\\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\\n # Physician Office\\n self.df_new_lab_data = self.df_new_lab_data[\\n self.df_new_lab_data[\\\"FACILITY_TYPE\\\"].isin(facility_type_keep_list)\\n ]\\n\\n # Make everything a string and remove trailing and leading whitespaces\\n self.df_new_lab_data = self.df_new_lab_data.astype(str)\\n self.df_new_lab_data = self.df_new_lab_data.applymap(\\n lambda x: x.strip() if isinstance(x, str) else x\\n )\\n\\n print(f\\\"{len(self.df_new_lab_data)} inputted CLIA labs for comparison...\\\")\",\n \"def _get_model_val(models_name, data_dir, val_source='test'):\\n model_val = {}\\n for model in models_name:\\n mypath = data_dir + '/' + model\\n only_files = [f for f in listdir(mypath) if isfile(join(mypath, f))]\\n select_files = [val_source in x for x in only_files]\\n only_files = list(compress(only_files, select_files))\\n if type(only_files) == list:\\n for name_file in only_files:\\n df_name = name_file.replace('.csv', '')\\n model_val[model + '_' + df_name] = pd.read_csv(mypath + '/' + name_file)\\n else:\\n df_name = only_files.replace('.csv', '')\\n model_val[model + '_' + df_name] = pd.read_csv(mypath + '/' + only_files)\\n return model_val\",\n \"def eval(\\n self,\\n processed_data_dir: Path,\\n output_result_dir: Path,\\n ) -> NoReturn:\\n pass\",\n \"def s_validation(path_setup=None):\\n if path_setup is not None:\\n # import validation setup\\n fname = os.path.basename(path_setup)\\n mname, ext = os.path.splitext(fname)\\n val_module = imp.load_source(mname, path_setup)\\n jobs, process = val_module.setup_process()\\n results_path = '/data-write/RADAR/Validation_FFascetti/'\\n for job in jobs:\\n results = process.calc(job)\\n netcdf_results_manager(results, results_path)\",\n \"def ReadData( fileName ):\\n \\n # define column names\\n colNames = ['Date','Precip','Max Temp', 'Min Temp','Wind Speed'] #NOTE: I changed the column names because .query() would not work when referencing column names with spaces\\n global DataDF #added this line to make the dataframe visible in the variable explorer\\n global ReplacedValuesDF #added this line to make the dataframe visible in the variable explorer\\n # open and read the file\\n DataDF = pd.read_csv(\\\"DataQualityChecking.txt\\\",header=None, names=colNames, \\n delimiter=r\\\"\\\\s+\\\",parse_dates=[0])\\n DataDF = DataDF.set_index('Date')\\n \\n # define and initialize the missing data dictionary\\n ReplacedValuesDF = pd.DataFrame(0, index=[\\\"1. No Data\\\",\\\"2. Gross Error\\\",\\\"3. Swapped\\\",\\\"4. Range Fail\\\"], columns=colNames[1:]) #added additional indexed rows to make adding the values later easier\\n \\n return( DataDF, ReplacedValuesDF )\",\n \"def exercise_9(path_to_X_data, path_to_w_data):\\r\\n\\r\\n print(\\\"=\\\"*30)\\r\\n print(\\\"Running exercise_9()\\\")\\r\\n\\r\\n #### YOUR CODE HERE ####\\r\\n # load the X and w data from file into arrays\\r\\n X = numpy.loadtxt('data/X.txt', delimiter=',')\\r\\n w = numpy.loadtxt('data/w.txt', delimiter=',')\\r\\n\\r\\n print(f'X:\\\\n{X}')\\r\\n print(f'w: {w}')\\r\\n\\r\\n #### YOUR CODE HERE ####\\r\\n # Extract the column 0 (x_n1) and column 1 (x_n2) vectors from X\\r\\n\\r\\n x_n1 = X[numpy.array([0,1,2,3,4]), 0]\\r\\n x_n2 = X[numpy.array([0,1,2,3,4]), 1]\\r\\n\\r\\n print(f'x_n1: {x_n1}')\\r\\n print(f'x_n2: {x_n2}')\\r\\n\\r\\n #### YOUR CODE HERE ####\\r\\n w_0 = w[0]\\r\\n w_1 = w[1]\\r\\n\\r\\n scalar_result_0 = w_0 * w_0 * sum(x_n1*x_n1) + 2 * w_0 * w_1 * sum(x_n2 * x_n1) + w_1 * w_1 * sum(x_n2*x_n2)\\r\\n # Use scalar arithmetic to compute the right-hand side of Exercise 3\\r\\n # (Exercise 1.3 from FCMA p.35)\\r\\n # Set the final value to\\r\\n scalar_result = scalar_result_0\\r\\n\\r\\n print(f'scalar_result: {scalar_result}')\\r\\n\\r\\n #### YOUR CODE HERE ####\\r\\n # Now you will compute the same result but using linear algebra operators.\\r\\n # (i.e., the left-hand of the equation in Exercise 1.3 from FCMA p.35)\\r\\n # You can compute the values in any linear order you want (but remember,\\r\\n # linear algebra is *NOT* commutative!), however here will require you to\\r\\n # first compute the inner term: X-transpose times X (XX), and then\\r\\n # below you complete the computation by multiplying on the left and right\\r\\n # by w (wXXw)\\r\\n X_transpose = numpy.transpose(X)\\r\\n XX = numpy.dot(X_transpose, X)\\r\\n\\r\\n print(f'XX:\\\\n{XX}')\\r\\n\\r\\n #### YOUR CODE HERE ####\\r\\n # Now you'll complete the computation by multiplying on the left and right\\r\\n # by w to determine the final value: wXXw\\r\\n wXX = numpy.dot(w, XX)\\r\\n wXXw = numpy.dot(wXX, w)\\r\\n\\r\\n print(f'wXXw: {wXXw}')\\r\\n\\r\\n print(\\\"DONE exercise_9()\\\")\\r\\n\\r\\n return X, w, x_n1, x_n2, scalar_result, XX, wXXw\",\n \"def readFiles(opt, path, pathCopyData,minlat, maxlat, minlon, maxlon , variables, estaciones):\\n date = '\\\\d\\\\d\\\\d\\\\d-\\\\d\\\\d-\\\\d\\\\d'\\n dirr = pathCopyData\\n patron2 = re.compile(date)\\n print(dirr + 'tfile.txt')\\n tempfile = df.read_csv(dirr + 'tfile.txt')\\n tempbase = df.read_csv(dirr + 'tbase.txt')\\n tfile = list(tempfile.values.flatten())\\n tbase = list(tempbase.values.flatten())\\n tfileCopy = list(tempfile.values.flatten())\\n tbaseCopy = list(tempbase.values.flatten())\\n l = len(tfile)\\n for i in range(l):\\n tfil = tfile[i]\\n tbas = tbase[i]\\n ls = tbas + '/' + tfil\\n f = patron2.findall(tfil)\\n cadena = clearString(tfil)\\n print(cadena)\\n try:\\n #net = open_netcdf(ls, tfil, cadena, pathCopyData)\\n net = Dataset(ls)\\n for xs in range(len(estaciones)):\\n minlat1 = minlat[xs]\\n maxlat1 = maxlat[xs]\\n minlon1 = minlon[xs]\\n maxlon1 = maxlon[xs]\\n estacion = estaciones[xs]\\n #checkFile(net, tfil, f[0], opt, path, minlat1, maxlat1, minlon1, maxlon1, variables, estacion)\\n var_cut = []\\n for i in variables:\\n var = net.variables[i][:,int(minlat1):int(maxlat1),int(minlon1):int(maxlon1)]\\n #print(LON)\\n #print(var)\\n #return\\n # celda.append(var)\\n # result = ne(var, LON, LAT, LONsize, LATsize, minlat, maxlat, minlon, maxlon)\\n var_cut.append(var)\\n\\n for ls in range(len(var_cut)):\\n saveData(var_cut[ls], variables[ls], f[0], opt, path, estacion)\\n tfileCopy.remove(tfil)\\n tbaseCopy.remove(tbas)\\n except (OSError, EOFError) as e:\\n print(e)\\n fdata = df.DataFrame(tfileCopy, columns=['nameFile'])\\n fbas = df.DataFrame(tbaseCopy, columns=['nameBase'])\\n fdata.to_csv(dirr + 'tfile.txt', encoding='utf-8', index=False)\\n fbas.to_csv(dirr + 'tbase.txt', encoding='utf-8', index=False)\\n if os.path.exists(pathCopyData + cadena):\\n os.remove(pathCopyData + cadena)\\n sys.exit()\\n # readFiles(1);\\n except tarfile.ReadError:\\n print('error2')\\n # fdata = df.DataFrame(tfile,columns=['nameFile']);\\n # fbas = df.DataFrame(tbase,columns=['nameBase']);\\n # fdata.to_csv(dirr+'tfile.txt',encoding='utf-8',index=False);\\n # fbas.to_csv(dirr+'tbase.txt',encoding='utf-8',index=False);\\n # readFiles(1);\\n except (KeyError, FileNotFoundError):\\n print('ERROR DE LECTURA')\",\n \"def load_fvcom_files(filepath=None,casename=None,ncname=None,neifile=None):\\n\\n currdir=os.getcwd()\\n os.chdir(filepath)\\n\\n data=_load_grdfile(casename)\\n\\n data.update(_load_depfile(casename))\\n \\n data.update(_load_spgfile(casename))\\n\\n data.update(_load_obcfile(casename))\\n\\n data.update(_load_llfiles(casename))\\n\\n if ncname!=None:\\n data.update(_load_nc(ncname))\\n\\n if neifile!=None:\\n data.update(loadnei(neifile))\\n\\n os.chdir(currdir)\\n\\n return data\",\n \"def update_file_vectors(self, audio_file):\\n outer_df = defer.Deferred()\\n\\n def get_file_vector(val):\\n # Take all the new PluginOutput objects and generate and\\n # apply a single vector to represent the file.\\n df = self.mine.calculate_file_vector(audio_file)\\n return df\\n\\n def save_file(vector):\\n logger.debug(\\\"--> Applying vector to %r %r\\\", audio_file, vector)\\n logger.debug(\\\"--> Saving %r\\\", audio_file)\\n audio_file.vector = vector\\n df_s = self.model.save(audio_file)\\n return df_s\\n\\n logger.debug(\\\"NB: Updating File Vectors for %r\\\", audio_file)\\n df = self.get_vectors_eventually(audio_file)\\n df.addCallback(get_file_vector)\\n df.addCallback(save_file)\\n\\n return df\",\n \"def mover_get_data(lfns,\\n path,\\n sitename,\\n queuename,\\n stageinTries,\\n inputpoolfcstring=\\\"xmlcatalog_file:PoolFileCatalog.xml\\\",\\n ub=\\\"outdated\\\", # to be removed\\n dsname=\\\"\\\",\\n dsdict={},\\n rucio_dataset_dictionary={},\\n guids=[],\\n analysisJob=False,\\n usect=True,\\n pinitdir=\\\"\\\",\\n proxycheck=True,\\n spsetup=\\\"\\\",\\n tokens=[],\\n userid=\\\"\\\",\\n inputDir=\\\"\\\",\\n jobId=None,\\n jobDefId=\\\"\\\",\\n access_dict=None,\\n scope_dict=None,\\n workDir=\\\"\\\",\\n DN=None,\\n dbh=None,\\n jobPars=\\\"\\\",\\n cmtconfig=\\\"\\\",\\n filesizeIn=[],\\n checksumIn=[],\\n transferType=None,\\n experiment=\\\"\\\",\\n eventService=False,\\n sourceSite=\\\"\\\"):\\n\\n tolog(\\\"Mover get data started\\\")\\n\\n statusPFCTurl = None\\n pilotErrorDiag = \\\"\\\"\\n\\n # FAX counters (will be reported in jobMetrics; only relevant when FAX has been activated after a stage-in failure)\\n N_filesWithoutFAX = 0\\n N_filesWithFAX = 0\\n bytesWithoutFAX = 0L\\n bytesWithFAX = 0L\\n\\n # FAX control variable, if FAX is used as primary site mover in combination with direct I/O\\n usedFAXandDirectIO = False\\n\\n # The FAX variables above will be stored in a dictionary, to be returned by this function\\n FAX_dictionary = {}\\n\\n # Is the DBRelease file available locally?\\n DBReleaseIsAvailable = handleDBRelease(dbh, lfns, jobPars, path)\\n\\n # Should stage-in be aborted? (if there are only locally available DBRelease files in the stage-in list)\\n if abortStageIn(dbh, lfns, DBReleaseIsAvailable):\\n return 0, pilotErrorDiag, statusPFCTurl, FAX_dictionary\\n\\n # Setup the dictionary necessary for all instrumentation\\n report = getInitialTracingReport(userid, sitename, dsname, \\\"get_sm\\\", analysisJob, jobId, jobDefId, DN)\\n\\n if stageinTries != 0:\\n get_RETRY = min(stageinTries, MAX_NUMBER_OF_RETRIES)\\n else:\\n get_RETRY = MAX_RETRY\\n get_TIMEOUT = 5*3600/get_RETRY\\n\\n fail = 0\\n guidfname = {}\\n error = PilotErrors()\\n\\n region = readpar('region')\\n\\n # Space tokens currently not used for input files\\n # # check if there is are any space tokens\\n # _token = getProperSpaceTokenList(token, listSEs, len(lfns))\\n\\n # Select the correct mover\\n copycmd, setup = getCopytool(mode=\\\"get\\\")\\n\\n # Get the sitemover object corresponding to the default copy command\\n sitemover = getSiteMover(copycmd, setup)\\n\\n # Get the experiment object\\n thisExperiment = getExperiment(experiment)\\n\\n # Get the name for the PFC file\\n _path = path\\n if eventService:\\n # Update the path (create the PFC in one level above the payload workdir)\\n path = os.path.abspath(os.path.join(path, '..'))\\n pfc_name = getPFCName(path, inputpoolfcstring)\\n # done with the event server modification (related to the PFC generation), reset the path again\\n path = _path\\n\\n # Build the file info dictionary (use the filesize and checksum from the dispatcher if possible) and create the PFC\\n # Format: fileInfoDic[file_nr] = (guid, gpfn, fsize, fchecksum, filetype, copytool)\\n # replicas_dic[guid1] = [ replica1, .. ] where replicaN is an object of class replica\\n ec, pilotErrorDiag, fileInfoDic, totalFileSize, replicas_dic = \\\\\\n getFileInfo(region, ub, queuename, guids, dsname, dsdict, lfns, pinitdir, analysisJob, tokens, DN, sitemover, error, path, dbh, DBReleaseIsAvailable,\\\\\\n scope_dict, pfc_name=pfc_name, filesizeIn=filesizeIn, checksumIn=checksumIn, thisExperiment=thisExperiment)\\n if ec != 0:\\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\\n\\n # Until the Mover PFC file is no longer needed, call the TURL based PFC \\\"PoolFileCatalogTURL.xml\\\"\\n pfc_name_turl = pfc_name.replace(\\\".xml\\\", \\\"TURL.xml\\\")\\n\\n # Create a SURL to space token dictionary\\n tokens_dictionary = getSurlTokenDictionary(lfns, tokens)\\n\\n # Create a TURL based PFC if necessary/requested (i.e. if copy tool should not be used [useCT=False] and\\n # if oldPrefix and newPrefix are not already set in copysetup [useSetPrefixes=False])\\n ec, pilotErrorDiag, createdPFCTURL, usect = PFC4TURLs(analysisJob, transferType, fileInfoDic, pfc_name_turl, sitemover, sitename, usect, dsdict, eventService, tokens_dictionary, sitename, sourceSite, lfns)\\n if ec != 0:\\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\\n\\n # Correct the total file size for the DBRelease file if necessary\\n totalFileSize = correctTotalFileSize(totalFileSize, fileInfoDic, lfns, dbh, DBReleaseIsAvailable)\\n\\n # Only bother with the size checks if the copy tool is to be used (non-direct access mode)\\n if usect:\\n # Get a proper maxinputsize from schedconfig/default \\n _maxinputsize = getMaxInputSize()\\n\\n # Check the total input file size\\n ec, pilotErrorDiag = verifyInputFileSize(totalFileSize, _maxinputsize, error)\\n if ec != 0:\\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\\n\\n # Do we have enough local space to stage in all data and run the job?\\n ec, pilotErrorDiag = verifyAvailableSpace(sitemover, totalFileSize, path, error)\\n if ec != 0:\\n return ec, pilotErrorDiag, statusPFCTurl, FAX_dictionary\\n\\n # Get the replica dictionary from file (used when the primary replica can not be staged due to some temporary error)\\n replica_dictionary = getReplicaDictionaryFile(path)\\n\\n # file counters\\n N_files_on_tape = 0\\n N_root_files = 0\\n N_non_root_files = 0\\n\\n # If FAX is used as a primary site mover then set the default FAX mode to true, otherwise to false (normal mode)\\n if copycmd == \\\"fax\\\":\\n usedFAXMode = True\\n else:\\n usedFAXMode = False\\n\\n # Use isOneByOneFileTransfer() to determine if files should be transferred one by one or all at once\\n if not sitemover.isOneByOneFileTransfer():\\n\\n # Note: this mode is used by the aria2c site mover only\\n # Normal stage-in is below\\n\\n tolog(\\\"All files will be transferred at once\\\")\\n\\n # Extract the file info for the first file in the dictionary\\n guid, gpfn, lfn, fsize, fchecksum, filetype, copytool = extractInputFileInfo(fileInfoDic[0], lfns)\\n file_access = getFileAccess(access_dict, lfn)\\n dsname = getDataset(lfn, dsdict)\\n\\n # Perform stage-in using the sitemover wrapper method\\n s, pErrorText = sitemover_get_all_data(sitemover, error, gpfn, lfn, path, fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\\\\n guid=guid, analysisJob=analysisJob, usect=usect, pinitdir=pinitdir, proxycheck=proxycheck,\\\\\\n sitename=sitename, token=None, timeout=get_TIMEOUT, dsname=dsname, userid=userid, report=report,\\\\\\n access=file_access, inputDir=inputDir, jobId=jobId, workDir=workDir, cmtconfig=cmtconfig, lfns=lfns,\\\\\\n experiment=experiment, replicas_dic=replicas_dic, dsdict=dsdict, scope_dict=scope_dict)\\n if s != 0:\\n tolog('!!WARNING!!2999!! Failed during stage-in of multiple files: %s' % (error.getErrorStr(s)))\\n tolog(\\\"Exit code: %s\\\" % (s))\\n fail = s\\n\\n # Normal stage-in (one by one file transfers)\\n if sitemover.isOneByOneFileTransfer() or fail != 0:\\n \\n tolog(\\\"Files will be transferred one by one\\\")\\n\\n # Reset any previous failure\\n fail = 0\\n\\n # Loop over all files in the file info dictionary\\n number_of_files = len(fileInfoDic.keys())\\n tolog(\\\"Will process %d file(s)\\\" % (number_of_files))\\n for nr in range(number_of_files):\\n # Extract the file info from the dictionary\\n guid, gpfn, lfn, fsize, fchecksum, filetype, copytool = extractInputFileInfo(fileInfoDic[nr], lfns)\\n\\n # Has the copycmd/copytool changed? (E.g. due to FAX) If so, update the sitemover object\\n if copytool != copycmd:\\n copycmd = copytool\\n # Get the sitemover object corresponding to the new copy command\\n sitemover = getSiteMover(copycmd, setup)\\n tolog(\\\"Site mover object updated since copytool has changed\\\")\\n\\n # Update the dataset name\\n dsname = getDataset(lfn, dsdict)\\n proper_dsname = getDataset(lfn, rucio_dataset_dictionary)\\n scope = getFileScope(scope_dict, lfn)\\n\\n # Update the tracing report with the proper container/dataset name\\n report = updateReport(report, gpfn, proper_dsname, fsize, sitemover)\\n report['scope'] = scope\\n\\n # The DBRelease file might already have been handled, go to next file\\n if isDBReleaseFile(dbh, lfn) and DBReleaseIsAvailable:\\n updateFileState(lfn, workDir, jobId, mode=\\\"transfer_mode\\\", state=\\\"no_transfer\\\", type=\\\"input\\\")\\n guidfname[guid] = lfn # needed for verification below\\n continue\\n else:\\n tolog(\\\"(Not a DBRelease file)\\\")\\n\\n tolog(\\\"Mover is preparing to copy file %d/%d (lfn: %s guid: %s dsname: %s)\\\" % (nr+1, number_of_files, lfn, guid, dsname))\\n tolog('Copying %s to %s (file catalog checksum: \\\\\\\"%s\\\\\\\", fsize: %s) using %s (%s)' %\\\\\\n (gpfn, path, fchecksum, fsize, sitemover.getID(), sitemover.getSetup()))\\n\\n # Get the number of replica retries\\n get_RETRY_replicas = getNumberOfReplicaRetries(createdPFCTURL, replica_dictionary, guid)\\n\\n file_access = getFileAccess(access_dict, lfn)\\n\\n # Loop over get function to allow for multiple get attempts for a file\\n will_use_direct_io = False\\n get_attempt = 0\\n\\n #get_RETRY = 1 #2 #PN\\n while get_attempt < get_RETRY:\\n if get_attempt > 0:\\n _rest = 5*60\\n tolog(\\\"(Waiting %d seconds before next stage-in attempt)\\\" % (_rest))\\n sleep(_rest)\\n tolog(\\\"Get attempt %d/%d\\\" % (get_attempt + 1, get_RETRY))\\n replica_number = 0\\n replica_transferred = False\\n s = 1\\n\\n # Loop over replicas\\n while s != 0 and replica_number < get_RETRY_replicas:\\n # Grab the gpfn from the replicas dictionary in case alternative replica stage-in is allowed\\n gpfn = getAlternativeReplica(gpfn, guid, replica_number, createdPFCTURL, replica_dictionary)\\n\\n # Perform stage-in using the sitemover wrapper method\\n s, pErrorText, N_files_on_tape, N_root_files, N_non_root_files, replica_transferred, will_use_direct_io = sitemover_get_data(sitemover, error,\\\\\\n get_RETRY, get_RETRY_replicas, get_attempt,\\\\\\n replica_number, N_files_on_tape, N_root_files,\\\\\\n N_non_root_files, gpfn, lfn, path,\\\\\\n fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\\\\n guid=guid, analysisJob=analysisJob, usect=usect,\\\\\\n pinitdir=pinitdir, proxycheck=proxycheck,\\\\\\n sitename=sitename, token=None, timeout=get_TIMEOUT,\\\\\\n dsname=dsname, userid=userid, report=report,\\\\\\n access=file_access, inputDir=inputDir, jobId=jobId,\\\\\\n workDir=workDir, cmtconfig=cmtconfig,\\\\\\n experiment=experiment, scope_dict=scope_dict,\\\\\\n sourceSite=sourceSite)\\n # Get out of the multiple replica loop\\n if replica_transferred:\\n break\\n\\n # Increase the replica attempt counter in case the previous replica could not be transferred\\n replica_number += 1\\n\\n # Get out of the multiple get attempt loop\\n if replica_transferred:\\n break\\n\\n # Increase the get attempt counter in case of failure to transfer the file\\n get_attempt += 1\\n\\n # Increase the successful file transfer counter (used only when reporting FAX transfers)\\n if s == 0:\\n # note the special case if FAX is the primary site mover (normally FAX is the fallback)\\n if sitemover.copyCommand == \\\"fax\\\":\\n N_filesWithFAX += 1\\n bytesWithFAX += long(fsize)\\n else:\\n # Normal case\\n N_filesWithoutFAX += 1\\n bytesWithoutFAX += long(fsize)\\n\\n if s != 0:\\n # Normal stage-in failed, now try with FAX if possible\\n if error.isPilotFAXErrorCode(s):\\n if isFAXAllowed(filetype, gpfn) and transferType != \\\"fax\\\" and sitemover.copyCommand != \\\"fax\\\": # no point in trying to fallback to fax if the fax transfer above failed\\n tolog(\\\"Normal stage-in failed, will attempt to use FAX\\\")\\n usedFAXMode = True\\n\\n # Get the FAX site mover\\n old_sitemover = sitemover\\n sitemover = getSiteMover(\\\"fax\\\", \\\"\\\")\\n\\n # Perform stage-in using the sitemover wrapper method\\n s, pErrorText, N_files_on_tape, N_root_files, N_non_root_files, replica_transferred, will_use_direct_io = sitemover_get_data(sitemover, error,\\\\\\n get_RETRY, get_RETRY_replicas, get_attempt, replica_number,\\\\\\n N_files_on_tape, N_root_files, N_non_root_files,\\\\\\n gpfn, lfn, path,\\\\\\n fsize=fsize, spsetup=spsetup, fchecksum=fchecksum,\\\\\\n guid=guid, analysisJob=analysisJob, usect=usect,\\\\\\n pinitdir=pinitdir, proxycheck=proxycheck,\\\\\\n sitename=sitename, token=None, timeout=get_TIMEOUT,\\\\\\n dsname=dsname, userid=userid, report=report,\\\\\\n access=file_access, inputDir=inputDir, jobId=jobId,\\\\\\n workDir=workDir, cmtconfig=cmtconfig, experiment=experiment)\\n if replica_transferred:\\n tolog(\\\"FAX site mover managed to transfer file from remote site (resetting error code to zero)\\\")\\n pilotErrorDiag = \\\"\\\"\\n s = 0\\n\\n # Increase the successful FAX transfer counter\\n N_filesWithFAX += 1\\n bytesWithFAX += long(fsize)\\n else:\\n tolog(\\\"FAX site mover also failed to transfer file from remote site, giving up\\\")\\n\\n # restore the old sitemover\\n del sitemover\\n sitemover = old_sitemover\\n else:\\n tolog(\\\"(Not an error code eligible for FAX fail-over)\\\")\\n\\n if s != 0:\\n tolog('!!FAILED!!2999!! Failed to transfer %s: %s (%s)' % (os.path.basename(gpfn), s, error.getErrorStr(s)))\\n tolog(\\\"Exit code: %s\\\" % (s))\\n\\n # report corrupt file to consistency server if needed\\n if s == error.ERR_GETADMISMATCH or s == error.ERR_GETMD5MISMATCH or s == error.ERR_GETWRONGSIZE or s == error.ERR_NOSUCHFILE:\\n reportFileCorruption(gpfn, sitemover)\\n\\n # exception for object stores\\n if (gpfn.startswith(\\\"s3:\\\") or 'objectstore' in gpfn) and '.log.tgz' in gpfn:\\n tolog(\\\"!!FAILED!!2999!! Failed to transfer a log file from S3 objectstore. Will skip it and continue the job.\\\")\\n else:\\n fail = s\\n break\\n\\n # Build the dictionary used to create the PFC for the TRF\\n # In the case of FAX, use the global paths if direct access is to be used for the particlar file\\n if usedFAXMode and will_use_direct_io:\\n # The site mover needed here is the FAX site mover since the global file path methods are defined there only\\n old_sitemover = sitemover\\n sitemover = getSiteMover(\\\"fax\\\", \\\"\\\")\\n guidfname[guid] = sitemover.findGlobalFilePath(lfn, dsname, sitename, sourceSite)\\n\\n # Restore the old sitemover\\n del sitemover\\n sitemover = old_sitemover\\n\\n # If FAX is used as a primary site mover, in combination with direct access, set the usedFAXandDirectIO flag\\n # this will later be used to update the run command (e.g. --lfcHost is not needed etc)\\n if copycmd == \\\"fax\\\":\\n usedFAXandDirectIO = True\\n else:\\n guidfname[guid] = lfn # local_file_name\\n\\n if fail == 0:\\n # Make sure the PFC has the correct number of files\\n fail, pilotErrorDiag = verifyPFCIntegrity(guidfname, lfns, dbh, DBReleaseIsAvailable, error)\\n\\n # Now that the Mover PFC file is no longer needed, back it up and rename the TURL based PFC if it exists\\n # (the original PFC is no longer needed. Move it away, and then create the PFC for the trf/runAthena)\\n # backupPFC4Mover(pfc_name)\\n\\n # Create a standard PFC with SURLs if needed (basically this is default)\\n # note: if FAX was used as a primary site mover in combination with direct I/O, then the SURLs will actually be TURLs\\n # but there is no need to use the special TURL creation method PFC4TURL used above (FAX will have returned the TURLs instead)\\n createStandardPFC4TRF(createdPFCTURL, pfc_name_turl, pfc_name, guidfname)\\n\\n tolog(\\\"Number of identified root files : %d\\\" % (N_root_files))\\n tolog(\\\"Number of transferred non-root files: %d\\\" % (N_non_root_files))\\n\\n if usedFAXMode:\\n tolog(\\\"Number of files without FAX : %d (normal transfers)\\\" % (N_filesWithoutFAX))\\n tolog(\\\"Number of files with FAX : %d (successful FAX transfers)\\\" % (N_filesWithFAX))\\n tolog(\\\"Bytes without FAX : %d (normal transfers)\\\" % (bytesWithoutFAX))\\n tolog(\\\"Bytes with FAX : %d (successful FAX transfers)\\\" % (bytesWithFAX))\\n\\n if N_files_on_tape > 0:\\n tolog(\\\"!!WARNING!!2999!! Number of skipped files: %d (not staged)\\\" % (N_files_on_tape))\\n if N_root_files == 0:\\n # This should only happen for user jobs\\n tolog(\\\"Mover get_data failed since no root files could be transferred\\\")\\n fail = error.ERR_NOSTAGEDFILES\\n else:\\n tolog(\\\"Mover get_data finished (partial)\\\")\\n else:\\n if fail == 0:\\n tolog(\\\"Get successful\\\")\\n tolog(\\\"Mover get_data finished\\\")\\n else:\\n tolog(\\\"Mover get_data finished (failed)\\\")\\n tolog(\\\"Will return exit code = %d, pilotErrorDiag = %s\\\" % (fail, pilotErrorDiag)) \\n\\n # Now populate the FAX dictionary before finishing\\n FAX_dictionary = getFAXDictionary(N_filesWithoutFAX, N_filesWithFAX, bytesWithoutFAX, bytesWithFAX, usedFAXandDirectIO)\\n\\n return fail, pilotErrorDiag, statusPFCTurl, FAX_dictionary\",\n \"def loadScalarField(self):\\n\\n\\t\\tif self.beta is None:\\n\\t\\t\\traise ForcingException(\\\"Must supply concentration response factor\\\")\\n\\n\\t\\tif self._mortality_fname is None or self._mortality_var is None:\\n\\t\\t\\traise ForcingException(\\\"Must supply mortality file\\\")\\n\\n\\t\\tif self._pop_fname is None or self._pop_var is None:\\n\\t\\t\\traise ForcingException(\\\"Must supply population file\\\")\\n\\n\\t\\t# This is optional\\n\\t\\t#if self.vsl is None:\\n\\t\\t#\\traise ForcingException(\\\"Must specify statistical value of life (in millions)\\\")\\n\\n\\t\\t# Open the mortality file\\n\\t\\ttry:\\n\\t\\t\\tmortality = DataFile(self._mortality_fname, mode='r', open=True)\\n\\t\\texcept IOError as ex:\\n\\t\\t\\tForcing.error(\\\"Error! Cannot open mortality file %s. File exists? %r\\\"%(self._mortality_fname, os.path.isfile(self._mortality_fname)))\\n\\t\\t\\traise\\n\\n\\t\\t# Check dimensions\\n\\t\\tif not (mortality.dimensions['COL'] == self.ni and mortality.dimensions['ROW'] == self.nj):\\n\\t\\t\\traise ValueError(\\\"Error, dimensions in mortality file %s do not match domain.\\\"%self._mortality_fname)\\n\\n\\t\\t# Read the field\\n\\t\\ttry:\\n\\t\\t\\t# dims are TSTEP, LAY, ROW, COL.. so skip TSTEP and LAY\\n\\t\\t\\t# this should be made more general, or the file should be made better.\\n\\t\\t\\tmfld = mortality.variables[self._mortality_var][0][0]\\n\\t\\texcept IOError as e:\\n\\t\\t\\traise e\\n\\t\\texcept IndexError as e:\\n\\t\\t\\traise ForcingFileDimensionException(\\\"Mortality NetCDF file seems to have incompatible dimensions. Currently require shape (TSTEP, LAY, ROW, COL). This is marked to be improved, as the data does not vary with time or layer.\\\")\\n\\n\\t\\t# Close the file\\n\\t\\tif self._pop_fname != self._pop_fname:\\n\\t\\t\\tmortality.close()\\n\\n\\t\\t\\t# Open the population file\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tpop = DataFile(self._pop_fname, mode='r', open=True)\\n\\t\\t\\texcept IOError as ex:\\n\\t\\t\\t\\tForcing.error(\\\"Error! Cannot open population file %s\\\"%(self._pop_fname))\\n\\t\\t\\t\\traise\\n\\n\\t\\t\\t# Check dimensions\\n\\t\\t\\tif not (pop.dimensions['COL'] == self.ni and pop.dimensions['ROW'] == self.nj):\\n\\t\\t\\t\\traise ValueError(\\\"Error, dimensions in population file %s do not match domain.\\\"%self._pop_fname)\\n\\t\\telse:\\n\\t\\t\\t# Same file?\\n\\t\\t\\tpop = mortality\\n\\n\\t\\t# Read the field\\n\\t\\ttry:\\n\\t\\t\\t# dims are TSTEP, LAY, ROW, COL.. so skip TSTEP and LAY\\n\\t\\t\\tpfld = pop.variables[self._pop_var][0][0]\\n\\t\\texcept IOError as e:\\n\\t\\t\\traise e\\n\\t\\texcept IndexError as e:\\n\\t\\t\\traise ForcingFileDimensionException(\\\"Population NetCDF file seems to have incompatible dimensions. Currently require shape (TSTEP, LAY, ROW, COL). This is marked to be improved, as the data does not vary with time or layer.\\\")\\n\\n\\n\\t\\tpop.close()\\n\\n\\t\\t# Debug, remember, when debugging this against plotted data or fortran\\n\\t\\t# code: values like (70,70) started at index 1 whereas we started at\\n\\t\\t# index 0, so (70,70)=(69,69)\\n\\t\\t#print \\\"[j=%d,i=%d] = mfld * mfld_scale * pfld * self.beta / 365 = %e %e %e %e %e = %e\\\"%(self.debug_j, self.debug_i, mfld[self.debug_j,self.debug_i], (10.**-4), pfld[self.debug_j,self.debug_i], self.beta, 365.0, mfld[self.debug_j,self.debug_i]*(10.**-4)*pfld[self.debug_j,self.debug_i]*self.beta/365.0)\\n\\n\\t\\t# (mfld * pfld) is element wise multiplication, not matrix multiplication\\n\\t\\t# Take leap years into account?\\n\\t\\tForcing.debug(\\\"[TODO]: Leap years are not yet accounted for.\\\")\\n\\t\\tself.timeInvariantScalarMultiplcativeFld = mfld * self.mort_scale / 365.0 * pfld * self.beta\\n\\t\\tif self.vsl is not None:\\n\\t\\t\\tself.timeInvariantScalarMultiplcativeFld = self.timeInvariantScalarMultiplcativeFld * self.vsl\",\n \"def FSC2(input_dir, num_reps=50, min_sims=100000, max_ecm=20, calc_CI=False, numcores=1, scratch_mb='200', time_scratch=\\\"01:50:00\\\", mem=\\\"200\\\", print1=False, overwrite=\\\"None\\\", fsc2_path=\\\"/storage/plzen1/home/holcovam/programs/fsc26_linux64/fsc26\\\"):\\n Data_Files = []\\n tpl_files = []\\n est_files = []\\n CI_Data_Files = []\\n shlist = []\\n\\n if input_dir.endswith(\\\"/\\\") is False:\\n input_dir += \\\"/\\\"\\n\\n for path in os.listdir(input_dir):\\n if os.path.isdir(input_dir + path) and path.startswith(\\\"FSC2input\\\"):\\n samp_name = path.split(\\\"_\\\")[1]\\n #folder_name = samp_name\\n if samp_name + \\\"_DSFS.obs\\\" in os.listdir(input_dir + path):\\n for i in range(0, num_reps):\\n new_file = open(input_dir + path + \\\"/\\\" + samp_name + str(i) + \\\"_DSFS.obs\\\", 'w')\\n with open(input_dir + path + \\\"/\\\" + samp_name + \\\"_DSFS.obs\\\") as data_file:\\n for line in data_file:\\n new_file.write(line)\\n new_file.close()\\n Data_Files.append(input_dir + path + \\\"/\\\" + samp_name + str(i) + \\\"_DSFS.obs\\\")\\n else:\\n print(\\\"Did not find input data file for: \\\", samp_name)\\n if calc_CI == \\\"True\\\":\\n num_files = 0\\n for file in os.listdir(input_dir + path):\\n if file.endswith(\\\"_DSFS.obs\\\") and file.split(\\\"_\\\")[-2].split(\\\".\\\")[-1][0:3] == \\\"rep\\\" and file != samp_name + \\\"_DSFS.obs\\\":\\n for i in range(0, num_reps):\\n new_file = open(input_dir + path + \\\"/\\\" + samp_name + file.split(\\\"_\\\")[-2].split(\\\".\\\")[-1].split(\\\"_\\\")[0]+ \\\"_\\\" + str(i) + \\\"_DSFS.obs\\\", 'w')\\n with open(input_dir + path + \\\"/\\\" + file) as data_file:\\n for line in data_file:\\n new_file.write(line)\\n new_file.close()\\n CI_Data_Files.append(input_dir + path + \\\"/\\\" + samp_name + file.split(\\\"_\\\")[-2].split(\\\".\\\")[-1].split(\\\"_\\\")[0]+ \\\"_\\\" + str(i) + \\\"_DSFS.obs\\\")\\n num_files += 1\\n if len(CI_Data_Files) < 1:\\n print(\\\"Did not find bootstrap replicates for: \\\", samp_name)\\n else:\\n print(\\\"Found \\\", num_files, \\\" replicate dsfs files for CI calculation for \\\", samp_name)\\n if path.endswith(\\\".tpl\\\"):\\n tpl_files.append(path)\\n est_files.append(path.split(\\\".\\\")[0])\\n if len(tpl_files) == 0:\\n print(\\\"Did not find any tpl files!! Aborting!!\\\")\\n else:\\n if calc_CI == \\\"True\\\":\\n Data_Files = CI_Data_Files\\n for file in Data_Files:\\n name = file.split(\\\"_DSFS\\\")[0]\\n samp_name = name.split(\\\"/\\\")[-1]\\n folder_name = samp_name [0:11]\\n for tpl in tpl_files:\\n tpl_name = tpl.split(\\\".tpl\\\")[0]\\n if os.path.isdir(name + \\\"_\\\" + tpl_name) is False or overwrite == \\\"hard\\\":\\n new_tpl = open(name + \\\"_\\\" + tpl_name + \\\".tpl\\\", 'w')\\n new_data = open(name + \\\"_\\\" + tpl_name + \\\"_DSFS.obs\\\", 'w')\\n\\n with open(file, 'r') as data:\\n for i, line in enumerate(data):\\n if i == 1:\\n pop_info = line.strip(\\\"\\\\n\\\").strip(\\\"\\\\t\\\").split(\\\"\\\\t\\\")\\n pop_num = int(pop_info[0])\\n samp_nums = pop_info[-pop_num:]\\n new_data.write(line)\\n with open(input_dir + tpl, 'r') as template:\\n samp_num_lines = pop_num + 4\\n for i, line in enumerate(template):\\n if i < samp_num_lines:\\n new_tpl.write(line)\\n elif i == samp_num_lines:\\n for num in samp_nums:\\n new_tpl.write(num + \\\"\\\\n\\\")\\n elif i >= samp_num_lines + len(samp_nums):\\n new_tpl.write(line)\\n new_est = open(name + \\\"_\\\" + tpl_name + \\\".est\\\", 'w')\\n try:\\n with open(input_dir + tpl_name + \\\".est\\\") as est:\\n for line in est:\\n new_est.write(line)\\n except FileNotFoundError:\\n print(\\\"Did not find est file for: \\\", tpl)\\n #folder_name = samp_name ''.join(i for i in s if not i.isdigit())\\n shname = name + \\\"_\\\" + tpl_name + \\\".sh\\\"\\n shfile5 = open(shname, 'w')\\n shfile5.write('#!/bin/bash -e\\\\n' +\\n '#PBS -N '+samp_name+'\\\\n' +\\n '#PBS -l walltime='+str(time_scratch)+'\\\\n' +\\n '#PBS -l select=1:ncpus='+str(numcores)+':mem='+str(mem)+'mb:scratch_local='+str(scratch_mb)+'mb\\\\n' +\\n '#PBS -m abe\\\\n' +\\n '#PBS -j oe\\\\n\\\\n' +\\n 'module add python-3.4.1-gcc\\\\n'+\\n 'module add python34-modules-gcc\\\\n'+\\n 'trap \\\\'clean_scratch\\\\' TERM EXIT\\\\n'+\\n 'if [ ! -d \\\"$SCRATCHDIR\\\" ] ; then echo \\\"Scratch not created!\\\" 1>&2; exit 1; fi \\\\n' +\\n 'DATADIR=\\\"/storage/plzen1/home/holcovam/ScanTools\\\"\\\\n' +\\n 'cp $DATADIR/'+ input_dir + \\\"FSC2input_\\\" + folder_name+ \\\"/\\\" + samp_name + \\\"_\\\" + tpl_name + '* $SCRATCHDIR || exit 1\\\\n'+\\n 'cp '+fsc2_path+' $SCRATCHDIR || exit 1\\\\n'+\\n 'cd $SCRATCHDIR || exit 2\\\\n' +\\n 'echo data loaded at `date`\\\\n\\\\n' +\\n 'chmod +x fsc26 \\\\n' +\\n #'ls -l \\\\n' +\\n './fsc26 -t ' + samp_name + \\\"_\\\" + tpl_name + '.tpl -e ' + samp_name + \\\"_\\\" + tpl_name + '.est -n ' + str(min_sims) + ' -u -d -q -L ' + str(max_ecm) + ' -M \\\\n' + \\n 'rm seed.txt \\\\n'+\\n 'rm fsc26\\\\n'+\\n 'rm *DSFS.obs\\\\n'+\\n 'rm *.sh\\\\n'+\\n 'rm *.tpl \\\\n'+\\n 'rm *.est \\\\n'+\\n #'ls -l \\\\n' +\\n 'cp $SCRATCHDIR/*.par $DATADIR/'+ input_dir + \\\"FSC2input_\\\" + folder_name+' || exit 1\\\\n'+\\n 'rm *.par \\\\n'+\\n 'cp -r $SCRATCHDIR/* $DATADIR/'+input_dir+' || export CLEAN_SCRATCH=false\\\\n'+\\n 'printf \\\"\\\\\\\\nFinished\\\\\\\\n\\\\\\\\n\\\"\\\\n')\\n shfile5.close()\\n shlist.append(shname)\\n\\n############IF PROBLEM WITH EXCESS OF NONCONVERGED CHAINS, COPY /home/majda/alpine/fastsimcoal2/afterWPSG/scripts/notConverged.py here ###################\\n\\n else:\\n print(\\\"Output for \\\" + samp_name + \\\"_\\\" + tpl_name + \\\" already exists. Use hard_overwrite = True to overwrite.\\\")\\n return shlist\",\n \"def science_reduction(input_file):\\n #name of the planet\\n planet = input_file['exoplanet']\\n #set original directory\\n original_path = os.getcwd()\\n save_path = input_file['save_path']\\n data_path = input_file['data_path']\\n #Change your directory to data diretory\\n os.chdir(data_path)\\n #list all flat images\\n exoplanet = glob.glob(planet+'*.fits')\\n print '\\\\nLoading exoplanet images \\\\nTotal of '+planet+'*.fits files = ',len(exoplanet),'\\\\nFiles = \\\\n'\\n print exoplanet\\n #if save_path exist, continue; if not, create.\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n #create a list of bias images and copy images to save_path\\n print '\\\\nCopy science images to save_path directory to main reduction: ....'\\n os.system('cp '+planet+'*.fits '+save_path)\\n print '\\\\n .... done. \\\\n'\\n #change to save_path\\n os.chdir(save_path)\\n #create the names for exoplanet science mages with bias subtracted\\n bexoplanet = []\\n for i in exoplanet:\\n bexoplanet.append('B'+i)\\n #verify if previous superbias exist\\n if os.path.isfile('B'+i) == True:\\n os.system('rm B'+i)\\n print '\\\\n Will be create this images: \\\\n'\\n print bexoplanet\\n #exoplanet = string.join(exoplanet,',') #create the list string of exoplanet science images\\n #bexoplanet = string.join(bexoplanet,',')#create the list string of bexoplanet science images\\n print '\\\\nSubtracting superbias.fits from all '+planet+'*.fits images ....\\\\n'\\n for i in range(len(exoplanet)):\\n iraf.imarith(exoplanet[i],'-','superbias.fits',bexoplanet[i])\\n use.update_progress((i+1.)/len(bexoplanet))\\n print '\\\\n.... cleaning '+planet+'*.fits images\\\\n'\\n os.system('rm '+planet+'*.fits')\\n print '\\\\n Statistics of B'+planet+'*.fits images: \\\\n'\\n for i in range(len(bexoplanet)):\\n iraf.imstat(bexoplanet[i])\\n print '\\\\nFlatfielding the B'+planet+'*.fits ....\\\\n'\\n #create the names for exoplanet science images with bias subtracted and flatfielding\\n abexoplanet = []\\n for i in bexoplanet:\\n abexoplanet.append('A'+i)\\n #verify if previous superbias exist\\n if os.path.isfile('A'+i) == True:\\n os.system('rm A'+i)\\n print '\\\\n Will be create this images: \\\\n'\\n print abexoplanet\\n #flatifielding images\\n for i in range(len(abexoplanet)):\\n iraf.imarith(bexoplanet[i],'/','superflat.fits',abexoplanet[i])\\n use.update_progress((i+1.)/len(abexoplanet))\\n # print '\\\\n.... cleaning B'+planet+'*.fits images\\\\n'\\n # os.system('rm B'+planet+'*.fits')\\n print '\\\\n Statistics of AB'+planet+'*.fits images: \\\\n'\\n for i in range(len(abexoplanet)):\\n iraf.imstat(abexoplanet[i])\\n os.chdir(original_path) #change to save_path\\n return\",\n \"def mri_dixon_analysis(data_objects, working_dir, settings):\\n\\n logger.info(\\\"Running Dixon analysis Calculation\\\")\\n logger.info(\\\"Using settings: %s\\\", settings)\\n\\n output_objects = []\\n\\n fat_obj = None\\n water_obj = None\\n for data_obj in data_objects:\\n\\n if data_obj.meta_data[\\\"image_type\\\"] == \\\"fat\\\":\\n fat_obj = data_obj\\n\\n if data_obj.meta_data[\\\"image_type\\\"] == \\\"water\\\":\\n water_obj = data_obj\\n\\n if fat_obj is None or water_obj is None:\\n logger.error(\\\"Both Fat and Water Images are required\\\")\\n return []\\n\\n # Read the image series\\n fat_load_path = fat_obj.path\\n if fat_obj.type == \\\"DICOM\\\":\\n fat_load_path = sitk.ImageSeriesReader().GetGDCMSeriesFileNames(fat_obj.path)\\n fat_img = sitk.ReadImage(fat_load_path)\\n\\n water_load_path = water_obj.path\\n if water_obj.type == \\\"DICOM\\\":\\n water_load_path = sitk.ImageSeriesReader().GetGDCMSeriesFileNames(water_obj.path)\\n water_img = sitk.ReadImage(water_load_path)\\n\\n # Cast to float for calculation\\n fat_img = sitk.Cast(fat_img, sitk.sitkFloat32)\\n water_img = sitk.Cast(water_img, sitk.sitkFloat32)\\n\\n # Let's do the calcuation using NumPy\\n fat_arr = sitk.GetArrayFromImage(fat_img)\\n water_arr = sitk.GetArrayFromImage(water_img)\\n\\n # Do the calculation\\n divisor = water_arr + fat_arr\\n fat_fraction_arr = (fat_arr * 100) / divisor\\n fat_fraction_arr[divisor == 0] = 0 # Sets those voxels which were divided by zero to 0\\n water_fraction_arr = (water_arr * 100) / divisor\\n water_fraction_arr[divisor == 0] = 0 # Sets those voxels which were divided by zero to 0\\n\\n fat_fraction_img = sitk.GetImageFromArray(fat_fraction_arr)\\n water_fraction_img = sitk.GetImageFromArray(water_fraction_arr)\\n\\n fat_fraction_img.CopyInformation(fat_img)\\n water_fraction_img.CopyInformation(water_img)\\n\\n # Create the output Data Objects and add it to output_ob\\n fat_fraction_file = os.path.join(working_dir, \\\"fat.nii.gz\\\")\\n sitk.WriteImage(fat_fraction_img, fat_fraction_file)\\n water_fraction_file = os.path.join(working_dir, \\\"water.nii.gz\\\")\\n sitk.WriteImage(water_fraction_img, water_fraction_file)\\n\\n fat_data_object = DataObject(type=\\\"FILE\\\", path=fat_fraction_file, parent=fat_obj)\\n output_objects.append(fat_data_object)\\n\\n water_data_object = DataObject(type=\\\"FILE\\\", path=water_fraction_file, parent=water_obj)\\n output_objects.append(water_data_object)\\n\\n return output_objects\",\n \"def open_file(file_path):\\r\\n\\r\\n global vector_X\\r\\n global training_data_matrix\\r\\n global row_number_of_data_matrix\\r\\n global single_row\\r\\n\\r\\n global training_g1_list\\r\\n global training_g2_list\\r\\n global training_g3_list\\r\\n\\r\\n global test_g1_list\\r\\n global test_g2_list\\r\\n global test_g3_list\\r\\n\\r\\n # open file\\r\\n with open(file_path, \\\"r\\\") as csvfile:\\r\\n\\r\\n line_number = 0\\r\\n index_of_training_matrix = 0\\r\\n\\r\\n # read all rows of csv file\\r\\n reader = csv.reader(csvfile)\\r\\n\\r\\n next(reader, None) # skip the headers\\r\\n\\r\\n for row in reader:\\r\\n\\r\\n row = row[0]\\r\\n\\r\\n # read line split by comma and convert into float numbers\\r\\n single_row = [float(x) for x in row.split(\\\";\\\")]\\r\\n\\r\\n # take the first 20% of the data as test data\\r\\n # and the remaining as the training data\\r\\n if line_number < row_number_of_test_data_matrix:\\r\\n\\r\\n test_data_matrix[line_number] = [1.0] + single_row[:-3]\\r\\n\\r\\n test_g1_list[line_number] = single_row[-3]\\r\\n test_g2_list[line_number] = single_row[-2]\\r\\n test_g3_list[line_number] = single_row[-1]\\r\\n\\r\\n else:\\r\\n training_data_matrix[index_of_training_matrix] = [1.0] + single_row[:-3]\\r\\n\\r\\n training_g1_list[index_of_training_matrix] = single_row[-3]\\r\\n training_g2_list[index_of_training_matrix] = single_row[-2]\\r\\n training_g3_list[index_of_training_matrix] = single_row[-1]\\r\\n\\r\\n index_of_training_matrix += 1\\r\\n\\r\\n if line_number == (row_number_of_data_matrix - 1):\\r\\n break\\r\\n\\r\\n line_number += 1\\r\\n\\r\\n return test_data_matrix, training_data_matrix, \\\\\\r\\n test_g1_list, test_g2_list, test_g3_list, \\\\\\r\\n training_g1_list, training_g2_list, training_g3_list\",\n \"def _compute_(self):\\n dic = \\\"data/sim/{dn}/{rad}/\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"), rad=self.rad)\\n fbgc = \\\"data/sim/{dn}/{rad}/exp.bgc.bm({bm}).elv(<elv>).csv\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"), \\n rad=self.rad, bm=self.bmnum)\\n fflare = \\\"data/sim/{dn}/{rad}/exp.flare.bm({bm}).elv(<elv>).csv\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"),\\n rad=self.rad, bm=self.bmnum)\\n cmd = \\\"export DIR_MODELS_REF_DAT=/home/shibaji/Collaboration_NCAR/code_rt_sd/pharlap/pharlap_4.1.3/dat;\\\\\\n cd pharlap;\\\\\\n matlab -nodisplay -nodesktop -nosplash -nojvm -r \\\\\\\"UT=[{ut}];rad='{rad}';dic='{dic}';fbgc='{fbgc}';bm={bm};\\\\\\n fflare='{fflare}';rt_1D_sim;exit;\\\\\\\"\\\".format(ut=self.event.strftime(\\\"%Y %m %d %H %S\\\"), rad=self.rad,\\n dic=dic, bm=self.bmnum, fbgc=fbgc, fflare=fflare)\\n os.system(cmd)\\n return\",\n \"def main():\\n\\n\\t# Script arguments... \\n\\t\\\"\\\"\\\" If running as standalone, hardcode theWorkspace and inFile \\\"\\\"\\\"\\n\\ttheWorkspace = arcpy.GetParameterAsText(0)\\n\\tif not theWorkspace:\\n\\t\\ttheWorkspace = r\\\"d:\\\\_dataTest\\\"\\n\\ttheWorkspace = r\\\"d:\\\\_dataTest\\\"\\n\\tarcpy.env.workspace = theWorkspace\\n\\tarcpy.env.overwriteOutput = True\\n\\toutWorkspace = os.path.join(theWorkspace, \\\"_repair\\\")\\n\\n\\tinFile = arcpy.GetParameterAsText(1)\\n\\tif not inFile:\\n\\t\\tinFile = \\\"updateMultipleSourcePaths.csv\\\"\\n\\t#inFile = \\\"FixSource4.csv\\\"\\n\\t#inFile = os.path.join(theWorkspace, inFile) + \\\".csv\\\"\\n\\t# opens the infile.csv, read only; then creates tuple of inFile\\n\\t#f = open(inFile, \\\"r\\\") \\n\\t#update_list = [tuple(line.strip().split(\\\",\\\") for line in f)]\\n\\n\\n\\tmxd = None\\n\\toutMXDName = \\\"none\\\"\\n\\tnewPath = []\\n\\t# makes sure the .csv file exists\\n\\tif arcpy.Exists(inFile):\\n\\t\\tmyMsgs (\\\"Repair source list: \\\" + inFile)\\n\\t\\t# walks thru the workspace to create list of files \\n\\t\\tfor root, dirs, files in os.walk(theWorkspace): \\n\\t\\t\\tif root == outWorkspace:\\n\\t\\t\\t\\tprint(\\\"heh now\\\")\\n\\t\\t\\t\\tpass\\n\\t\\t\\t# creates list of .mxd's and works thru them\\n\\t\\t\\tmxdList = arcpy.ListFiles(\\\"*.mxd\\\")\\n\\t\\t\\tfor fileName in mxdList:\\n\\t\\t\\t\\tfullPath = os.path.join(root, fileName) \\n\\t\\t\\t\\tmxd = arcpy.mapping.MapDocument(fullPath)\\n\\t\\t\\t\\tmyMsgs (\\\"*** Processing mxd: \\\" + fullPath)\\n\\t\\t\\t\\t#mxd.findAndReplaceWorkspacePaths(\\\"v:\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\dfg.alaska.local\\\\\\\\gis\\\\\\\\Anchorage\\\\\\\\gisshare\\\\\\\\\\\", validate=False)\\n\\t\\t\\t\\t#mxd.findAndReplaceWorkspacePaths(\\\"t:\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\dfg.alaska.local\\\\\\\\gis\\\\\\\\Anchorage\\\\\\\\GISStaff\\\\\\\\\\\", validate=False)\\n\\t\\t\\t\\t#mxd.findAndReplaceWorkspacePaths(\\\"u:\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\dfg.alaska.local\\\\\\\\gis\\\\\\\\Anchorage\\\\\\\\GISStaff\\\\\\\\\\\", validate=False)\\n\\t\\t\\t\\t# New output mxd....\\n\\t\\t\\t\\tbasename, extension = os.path.splitext(fileName)\\n\\t\\t\\t\\toutMXDName = os.path.join(outWorkspace, (str(basename) + \\\"_fix.mxd\\\"))\\n\\t\\t\\t\\t# create list of the tables since they are handle differently\\n\\t\\t\\t\\ttheTables = arcpy.mapping.ListTableViews(mxd)\\n\\t\\t\\t\\t# Loops thru layers, checks for broken links and tries to repai\\n\\t\\t\\t\\tlyrList = arcpy.mapping.ListLayers(mxd)\\n\\t\\t\\t\\tfor lyr in lyrList:\\n\\t\\t\\t\\t\\tif lyr.isBroken:\\n\\t\\t\\t\\t\\t\\tif lyr.isGroupLayer or (\\\"Events\\\" in lyr.name):\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"...skipping group or event\\\")\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t#print(lyr.isServiceLayer)\\n\\t\\t\\t\\t\\t\\tif lyr.isServiceLayer:\\n\\t\\t\\t\\t\\t\\t\\tif lyr.supports(\\\"SERVICEPROPERTIES\\\"):\\n\\t\\t\\t\\t\\t\\t\\t\\tcnt = 0\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i, j in lyr.serviceProperties.iteritems():\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif cnt == 2:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdataSource = str(j)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcnt += 1 \\n\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"sees this as service....using findAndReplsWorkspacePath\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tnewPath = findUpdatePath(inFile, dataSource)\\n\\t\\t\\t\\t\\t\\t\\t\\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"--> a service layer but no SERVICE PROPOERTIES\\\")\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tprint(lyr.dataSource)\\n\\t\\t\\t\\t\\t\\t\\tnewPath = findUpdatePath(inFile, lyr.dataSource)\\n\\t\\t\\t\\t\\t\\t\\tnewDSPath, newDSName = os.path.split(newPath[0])\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"..newDSPAth \\\" + newDSPath)\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"..newDSName \\\" + newDSName)\\n\\t\\t\\t\\t\\t\\t\\tsameType = newPath[1]\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\" same type? \\\" + str(sameType))\\n\\t\\t\\t\\t\\t\\t\\tcvrList = [r\\\"\\\\arc\\\", r\\\"\\\\polygon\\\", r\\\"\\\\region\\\", r\\\"\\\\point\\\", r\\\"\\\\tic\\\" ]\\n\\t\\t\\t\\t\\t\\t\\t#print newDSPath\\n\\t\\t\\t\\t\\t\\t\\tif newPath == \\\"no match\\\":\\n\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"...no match to: \\\" + lyr.dataSource)\\n\\t\\t\\t\\t\\t\\t\\t\\tnewPath[0] = \\\"not found\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\telif lyr.supports(\\\"dataSource\\\") and lyr.supports(\\\"datasetName\\\"):\\n\\t\\t\\t\\t\\t\\t\\t\\tif lyr in theTables:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a table....using findAndReplsWorkspacePath\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False) \\n\\t\\t\\t\\t\\t\\t\\t\\telif lyr.isRasterLayer:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a raster....using findAndReplsWorkspacePath\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#lyr.replaceDataSource(newPath, \\\"RASTER_WORKSPACE\\\", lyr.datasetName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.findAndReplaceWorkspacePath(lyr.dataSource, newPath, False)\\n\\t\\t\\t\\t\\t\\t\\t\\telif lyr.supports(\\\"dataSource\\\") and lyr.supports(\\\"datasetName\\\"):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif not sameType and newPath[1] == \\\"gdb\\\":\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"..................moving to fgdb\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"FILEGDB_WORKSPACE\\\", newDSName, False) \\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif r\\\".shp\\\" in lyr.dataSource:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a shape\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"SHAPEFILE_WORKSPACE\\\", lyr.datasetName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif r\\\".sde\\\" in lyr.dataSource:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a sde\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"SDE_Workspace\\\", lyr.datasetName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif r\\\".mdb\\\" in lyr.dataSource:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a pgdb\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"ACCESS_WORKSPACE\\\", lyr.datasetName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif r\\\".gdb\\\" in lyr.dataSource:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"thinks its a fgdb\\\")\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"FILEGDB_WORKSPACE\\\", lyr.datasetName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif sameType:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfor cvr in cvrList:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif cvr in lyr.dataSource:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"to WS sametype is True\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"ARCINFO_WORKSPACE\\\", newDSName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telif not sameType:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfor cvr in cvrList:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlyr.replaceDataSource(newDSPath, \\\"FILEGDB_WORKSPACE\\\", newDSName, False)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t\\\"\\\"\\\"else:\\n newPath[0] = \\\"not found\\\" \\\"\\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\" **** the new data source: \\\" + newPath[0])\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"\\\")\\n\\n\\t\\t\\t\\tprint(outMXDName)\\n\\t\\t\\t\\t#mxd.saveACopy(outMXDName, '10.1')\\n\\t\\t\\tif arcpy.Exists(outMXDName):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\toutMXDName.save()\\n\\t\\t\\t\\telse:\\n mxd.saveACopy(outMXDName, '10.1')\\n\\t\\t\\t\\tdel mxd\\n\\telse:\\n\\t\\tmyMsgs (\\\"Repair source list: \\\" + inFile + \\\" does not exit.\\\")\\n\\n\\tmyMsgs('!!! Success !!! ')\",\n \"def check_idealised_files(ifile, ofile):\\n\\n # check that the 4 week forcing file exists\\n if not os.path.isfile(ifile): # create file if it doesn't exist\\n params = InForcings().defparams\\n params.doy = random.randrange(92, 275) # random day within GS\\n InForcings().run(ifile, params, Ndays=7*4)\\n\\n # check that the output file from the reference model exists\\n if not os.path.isfile(ofile):\\n df1, __ = read_csv(ifile)\\n\\n # add the soil moisture profile to the input data\\n df1['sw'], df1['Ps'] = soil_water(df1, os.path.basename(ofile)\\n .split('_')[1])\\n df1['Ps_pd'] = df1['Ps'].copy() # pre-dawn soil water potential\\n df1['Ps_pd'].where(df1['PPFD'] <= 50., np.nan, inplace=True)\\n\\n # fixed value for the wind speed\\n df1['u'] = df1['u'].iloc[0]\\n\\n # non time-sensitive: last valid propagated until next valid\\n df1.fillna(method='ffill', inplace=True)\\n\\n __ = hrun(ofile, df1, len(df1.index), 'Farquhar', models=['Medlyn'],\\n inf_gb=True)\\n\\n return\",\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 file_checker():\\n\\n PATH_RELEASE1_IDEN = os.getcwd()+'/archive_all_2014-10/'\\n PATH_RELEASE1_UNIDE = None\\n #PATH_RELEASE1_UNIDE = os.getcwd()+'/archive_all_2014-10/'\\n\\n PATH_RELEASE2_IDEN = os.getcwd()+'/archive_all_2016-10/archive_identified_2016-10/'\\n PATH_RELEASE2_UNIDE = os.getcwd() + '/archive_all_2016-10/archive_unidentified_2016-10/'\\n\\n\\n #From here don't change anything.\\n #This global function finds the .mgf files in paths\\n list_of_files_release1_ide = glob.glob(PATH_RELEASE1_IDEN+'*.mgf')\\n list_of_files_release1_unide = None #REMOVE THIS PART AND UNCOMMENT NEXT LINE IN NEXT RELEASES.\\n\\n #list_of_files_release1_unid = glob.glob(PATH_RELEASE1_UNID'+*.mgf')\\n\\n list_of_files_release2_ide = glob.glob(PATH_RELEASE2_IDEN+'*.mgf')\\n list_of_files_release2_unide = glob.glob(PATH_RELEASE2_UNIDE+'*.mgf')\\n\\n\\n #Check if exist cache folder. If not will make it. \\n #RELEASE 1 \\n if not os.path.exists(PATH_RELEASE1_IDEN+'cache'):\\n os.makedirs(PATH_RELEASE1_IDEN+'cache')\\n\\n # if not os.path.exists(PATH_RELEASE1_UNIDE'+cache'):\\n # os.makedirs(PATH_RELEASE1_UNIDE'+cache')\\n\\n #RELEASE2\\n if not os.path.exists(PATH_RELEASE2_IDEN+'cache'):\\n os.makedirs(PATH_RELEASE2_IDEN+'cache')\\n\\n if not os.path.exists(PATH_RELEASE2_UNIDE+'cache'):\\n os.makedirs(PATH_RELEASE2_UNIDE+'cache')\\n \\n\\n return PATH_RELEASE1_IDEN, \\\\\\n PATH_RELEASE2_IDEN, \\\\\\n PATH_RELEASE2_UNIDE, \\\\\\n list_of_files_release1_ide, \\\\\\n list_of_files_release2_ide, \\\\\\n list_of_files_release2_unide\",\n \"def processdata(path = os.getcwd(), mode = 'train'):\\n # ind_vector: raw counts of ngrams occurring in each industry.\\n # example: ('consultant', 'consultant'): 112, ('business', 'analyst'): 106, ('operations', 'manager'): 98, ('network', 'network'): 97, ('director', 'of'): 93, ('account', 'director'): 86, ('co', 'ordinator'): 82, ('product', 'product'): 79, ('it', 'it'): 77, ('programme', 'manager'): 77\\n ind_vectors = pickle_load('ind_vectors.data')\\n i_features = pickle_load('i_features.data')\\n if mode == 'train':\\n if not (ind_vectors and i_features): # False if the files weren't there.\\n ind_vectors, i_features = gather_and_save_vectors(path)\\n else: \\n ind_vectors, i_features = gather_and_save_vectors(path,ind_vectors,i_features)\\n elif mode != 'test':\\n print('Usage: mode parameter should be either \\\"train\\\" or \\\"test\\\".')\\n return None\\n return ind_vectors, i_features\",\n \"def READ_DEFINE_AND_PROCESS_EVERYTHING(basedir, in__dir):\\n\\n import sys, ast, multiprocessing\\n import pandas as pd\\n import numpy as np\\n\\n # Output dictionanry\\n dc = {}\\n \\n # Read command line arguments\\n try:\\n y_var = dc['y_var'] = str(sys.argv[1]) \\n y_area = dc['y_area'] = str(sys.argv[2])\\n experiment = dc['experiment'] = str(sys.argv[3])\\n X_source = dc['X_source'] = str(sys.argv[4]) \\n except:\\n y_var = dc['y_var'] = 'T2M'\\n y_area = dc['y_area'] = 'scandi'\\n experiment = dc['experiment'] = 'CONTROL'\\n X_source = dc['X_source'] = 'ERA-20C'\\n \\n # Define details \\n if(experiment=='CUTFIRSTYRS'): \\n yr1 = dc['yr1'] = '1945' \\n else:\\n yr1 = dc['yr1'] = '1915' #'1900' \\n \\n yr2 = dc['yr2'] = '2010'\\n \\n \\n rstate = dc['rstate'] = 70 \\n n_folds = dc['n_folds'] = 5\\n p_smpl = dc['p_smpl'] = 0.50\\n p_feat = dc['p_feat'] = 0.33\\n n_smpls = dc['n_smpls'] = 1000\\n tst_len = dc['tst_len'] = 25\\n\\n ncomps_sst = dc['ncomps_sst'] = 5\\n ncomps_snc = dc['ncomps_snc'] = 3\\n ncomps_gpt = dc['ncomps_gpt'] = 3\\n\\n if(experiment=='NO_LAGS'):\\n lags_sst = dc['lags_sst'] = (1,)\\n lags_snc = dc['lags_snc'] = (1,)\\n lags_gpt = dc['lags_gpt'] = (1,)\\n else:\\n lags_sst = dc['lags_sst'] = (1,2,3,4,5)\\n lags_snc = dc['lags_snc'] = (1,2)\\n lags_gpt = dc['lags_gpt'] = (1,2)\\n \\n \\n \\n n_jobs = dc['n_jobs'] = np.min([28, int(0.9*(multiprocessing.cpu_count()))])\\n seasons = dc['seasons'] = ('DJF', 'MAM' ,'JJA', 'SON')\\n\\n # Define training and test periods\\n all_yrs = dc['all_yrs'] = list(np.arange(int(yr1),int(yr2)+1))\\n tst_yrs = dc['tst_yrs'] = all_yrs[-tst_len:] \\n trn_yrs = dc['trn_yrs'] = list(np.array(all_yrs)[~np.isin(all_yrs,tst_yrs)])\\n\\n # Define a skeleton for naming output files \\n basename = dc['basename'] = 'fittings_'+experiment+'_HadCRUT4-'+y_var+ \\\\\\n '_nsmpls'+str(n_smpls)+'_ntestyrs'+str(tst_len)+ \\\\\\n '_'+X_source+'-SST'+str(ncomps_sst)+'-'+str(lags_sst[-1])+ \\\\\\n '_'+X_source+'-GPT'+str(ncomps_gpt)+'-'+str(lags_gpt[-1])+ \\\\\\n '_'+yr1+'-'+yr2+'_'+y_area\\n\\n # Variables, form: 'name_of_variable': ['domain', n_comps, lags, year_range]\\n X_var_definitions = dc['X_var_definitions'] = {\\n 'SST': ['global', ncomps_sst, lags_sst, trn_yrs, all_yrs, X_source],\\n 'GPT': ['norhem', ncomps_gpt, lags_gpt, trn_yrs, all_yrs, X_source],\\n #'SNC': ['norhem', ncomps_snc, lags_snc, trn_yrs, all_yrs, X_source],\\n }\\n \\n # Optional variables from https://climexp.knmi.nl/, form: 'name_of_index': [lags]\\n X_clxp_definitions = dc['X_clxp_definitions'] = {\\n #'M1i':(1,), 'M2i':(1,), 'M3i':(1,), \\n #'M4i':(1,), 'M5i':(1,), 'M6i':(1,),\\n #'NAO':(1,), 'NINO12':(1,), 'NINO3':(1,), 'NINO34':(1,), 'NINO4',:(1,),\\n #'AMO1':(1,), 'AMO2':(1,), 'PDO1':(1,), 'PDO2':(1,), 'SOI',:(1,),\\n }\\n\\n # Read and preprocess the predictand data using xarray etc.\\n y_eur, Y, cl, tr = dc['y_eur'], dc['Y'], dc['Y_clim'], dc['Y_trend'] = \\\\\\n read_manipulate_Y_data(y_var, in__dir, {}, {}, all_yrs, all_yrs, y_area)\\n\\n # Read and preprocess the raw predictor data using xarray etc.\\n X_vars, cl, tr = dc['X_vars'], dc['X_clim'], dc['X_trnd'] = \\\\\\n read_manipulate_X_data(in__dir, X_var_definitions, {}, {})\\n\\n\\n if(experiment=='INCLPERSIS'): \\n include_persistence=True\\n else:\\n include_persistence=False\\n\\n # Compress raw data with PCA, apply lagging, and create a Pandas dataframe \\n X,p,ei,er = dc['X'], dc['X_PCAs'], dc['X_EIGs'], dc['X_ERRs'] = prepare_X_array(Y, \\n y_var, X_vars, {}, X_var_definitions, X_clxp_definitions, include_persistence=include_persistence)\\n\\n if(experiment=='FOLLAND'):\\n # Folland et al. 2012, Hall et al. 2017\\n for i,vrb in enumerate(X.columns):\\n if((vrb[0:4] == 'SST1')|(vrb[0:4] == 'sst1')):\\n X[vrb] = StandardScaler().fit_transform(X[vrb][:,np.newaxis])\\n X[vrb][ np.abs(X[vrb]) < 1 ] = 0\\n X[vrb][ X[vrb] < -1 ] = -1\\n X[vrb][ X[vrb] > 1.75 ] = 0\\n X[vrb][ X[vrb] > 1 ] = 1\\n print(X[vrb])\\n\\n # Extract variable names\\n vrbl_names = dc['vrbl_names'] = X.columns\\n \\n return dc\",\n \"def get_data(found_file, created_file):\\n\\n try:\\n fh_f = fits.open(found_file)\\n print('Found file has: ', fh_f.info())\\n except Exception:\\n print(' FATAL ERROR: Unable to open found file ', found_file)\\n\\n try:\\n fh_c = fits.open(created_file)\\n print('Created file has: ', fh_c.info())\\n except Exception:\\n print(' FATAL ERROR: Unable to open created file ', created_file)\\n\\n try:\\n data_f = fh_f['SCI'].data\\n except Exception:\\n print(' FATAL ERROR: data for found data was expected in SCI extension')\\n\\n try:\\n data_c = fh_c['SCI'].data\\n except Exception:\\n try:\\n data_c = fh_c[0].data\\n except Exception:\\n print(' FATAL ERROR: created data expected in either SCI or 0 extensions')\\n\\n return fh_f, fh_c, data_f, data_c\",\n \"def scalable(file_name=None, function_name=None, recover=None, omega=None, r=2, tol=1e-8, maxiter=100, init='random',\\n printitn=0):\\n\\n # User Interface\\n if file_name is None:\\n file_name = raw_input(\\\"Please input the file_name of the data: \\\\n\\\")\\n print(\\\"\\\\n\\\")\\n\\n if function_name is None:\\n function_name = raw_input(\\\"Please choose the method you want to use to recover data(Input one number):\\\\n\\\"\\n \\\" 1. Distributed CP(ALS) 2.Distributed CP(ADMM) 3. DisTenC 0.Exit \\\\n\\\")\\n print(\\\"\\\\n\\\")\\n #if recover is None:\\n # recover = raw_input(\\\"If there are missing values in the file? (Input one number)\\\\n\\\"\\n # \\\"1.Yes, recover it 2.No, just decompose (Missing entries in the original tensor will be replaced by 0) 0.Exit\\\\n\\\")\\n\\n # Use pandas package to load data\\n## if file_name[-3:] == 'csv':\\n# dat1 = pd.read_csv(file_name, delimiter=';')\\n\\n # Data preprocessing\\n # First: create Sptensor\\n# dat = dat1.values\\n# sha = dat.shape\\n# subs = dat[:, range(sha[1] - 1)]\\n# subs = subs - 1\\n# vals = dat[:, sha[1] - 1]\\n# vals = vals.reshape(len(vals), 1)\\n# siz = np.max(subs, 0)\\n# siz = np.int32(siz + 1)\\n# X1 = pyten.tenclass.Sptensor(subs, vals, siz)\\n\\n # Second: create Tensor object and find missing data\\n# X = X1.totensor()\\n# Ori = X.data\\n# lstnan = np.isnan(X.data)\\n# X.data = np.nan_to_num(X.data)\\n\\n # Construct omega\\n #output = 1 # An output indicate flag. (Decompose: 1, Recover:2)\\n Ori = None\\n #if type(omega) != np.ndarray:\\n # # if True in lstnan:\\n # omega = X.data * 0 + 1\\n # omega[lstnan] = 0\\n # if recover == '1':\\n # output = 2\\n\\n # Choose method to recover or decompose\\n if type(function_name) == str:\\n if function_name == '1' or function_name == 'D_cp_als':\\n Dals = pyten.method.TensorDecompositionALS()\\n Dals.dir_data = file_name\\n Dals.rank = r\\n Dals.run()\\n Dals.maxIter = maxiter\\n Dals.tol = tol\\n\\n ######\\n Final = Dals.ktensor\\n Rec = None\\n full = Final.totensor()\\n ######\\n\\n elif function_name == '2' or function_name == 'D_ADMM':\\n Dadmm = pyten.method.DistTensorADMM()\\n Dadmm.dir_data = file_name\\n Dadmm.rank = r\\n Dadmm.run()\\n Dadmm.maxIter = maxiter\\n Dadmm.tol = tol\\n\\n ######\\n Final = Dadmm.ktensor\\n Rec = None\\n full = Final.totensor()\\n ######\\n\\n elif function_name == '3' or function_name == 'D_ADMM_C':\\n DadmmC = pyten.method.DistTensorCompletionADMM()\\n DadmmC.dir_data = file_name\\n DadmmC.rank = r\\n DadmmC.run()\\n DadmmC.maxIter = maxiter\\n DadmmC.tol = tol\\n\\n ######\\n Final = DadmmC.ktensor\\n #Rec = Final.totensor().data * omega + X.data * (1 - omega)\\n full = Final.totensor()\\n Rec = full\\n ######\\n\\n elif function_name == '0':\\n print 'Successfully Exit'\\n return None, None, None, None\\n else:\\n raise ValueError('No Such Method')\\n\\n else:\\n raise TypeError('No Such Method')\\n\\n # Output Result\\n # [nv, nd] = subs.shape\\n if function_name == 1 or function_name == 2:\\n newsubs = full.tosptensor().subs\\n tempvals = full.tosptensor().vals\\n newfilename = file_name[:-4] + '_Decomposite' + file_name[-4:]\\n #print \\\"\\\\n\\\" + \\\"The original Tensor is: \\\"\\n #print X1\\n print \\\"\\\\n\\\" + \\\"The Decomposed Result is: \\\"\\n print Final\\n else:\\n newsubs = Rec.tosptensor().subs\\n tempvals = Rec.tosptensor().vals\\n newfilename = file_name[:-4] + '_Recover' + file_name[-4:]\\n #print \\\"\\\\n\\\" + \\\"The original Tensor is: \\\"\\n #print Ori\\n print \\\"\\\\n\\\" + \\\"The Recovered Tensor is: \\\"\\n print Rec.data\\n\\n # Return result\\n return Ori, full, Final, Rec\",\n \"def load_data(data_fn,variables_fn,URL,VariableSet,Drop_extra=True):\\r\\n \\r\\n #If the data file exists locally, load it using pandas\\r\\n breakhere=1\\r\\n try: df = pd.read_csv(data_fn)\\r\\n except: \\r\\n #If the data file does not exist locally, download and save locally, then open\\r\\n print('Downloading data file (~430mb)')\\r\\n urllib.request.urlretrieve(URL,data_fn)\\r\\n print('Download Complete')\\r\\n df = pd.read_csv(data_fn)\\r\\n \\r\\n print('\\\\n************\\\\nNOTE RE: MIXED TYPE WARNING - These variables contain:')\\r\\n print(' 294 - HQ ID of person providing most of the information for this form')\\r\\n print(' 295 - HQ ID of 1st Other providing information for this form')\\r\\n print(' 701 - HF2 Cross wave ID (xwaveid) - 0001')\\r\\n print(' 702 - HF2 Cross wave ID (xwaveid) - 0002')\\r\\n print('These variables are not used in this project so the mixed type warning can be ignored\\\\n************')\\r\\n \\r\\n #Read the variables descriptor file\\r\\n variables = pd.read_csv(variables_fn)\\r\\n \\r\\n #extract the name of the response variable\\r\\n responseVar = variables['Variable'][variables['Response']=='y'].values[0]\\r\\n \\r\\n if Drop_extra:\\r\\n #Store the current number of recores\\r\\n NumRecords = df.shape[0]\\r\\n #remove entries with negative response variables (non-responding person, N/A, not asked, etc)\\r\\n DataSubset = pd.DataFrame(df[df[responseVar]>-1])\\r\\n #Notify the user how of how many records were dropped\\r\\n print('\\\\n{} records dropped due to lack of response variable (non-responding person, N/A, etc)'.format(NumRecords-DataSubset.shape[0]))\\r\\n \\r\\n #Extract the variable names for the variable set being analyzed\\r\\n KeepVars = variables['Variable'][variables[VariableSet]=='y']\\r\\n \\r\\n #Keep only the variables in the variable set\\r\\n DataSubset = DataSubset[KeepVars]\\r\\n \\r\\n else:\\r\\n #Return all variables and records\\r\\n DataSubset = df\\r\\n \\r\\n return DataSubset,variables,responseVar\",\n \"def main():\\n\\n\\t# Parse the file\\n\\tmem_file = advanced_analysis('../data_1/mempages.dat.out')\",\n \"def multiple_files_analysis(lower_wavelength, upper_wavelength, CCD_height, CCD_width, CCD_height_corr, CCD_width_corr, file_paths, file_path_corr_data, progress_update):\\r\\n \\r\\n all_files_data = []\\r\\n FWHM_data = []\\r\\n central_energy_data = []\\r\\n counter = 1\\r\\n\\r\\n for file_path in file_paths:\\r\\n analysis = QDot_Spectroscopy(file_path=r\\\"{}\\\".format(file_path), meas_corr_curve_file_path=r\\\"{}\\\".format(file_path_corr_data), lower_wavelength=lower_wavelength, upper_wavelength=upper_wavelength, CCD_height=CCD_height, CCD_width=CCD_width, CCD_height_corr=CCD_height_corr , CCD_width_corr=CCD_width_corr)\\r\\n\\r\\n twod_map_raw = analysis.matrix_map(bkg_reduction=False, data_correction=False)\\r\\n twod_map_no_bkg = analysis.matrix_map(bkg_reduction=True, data_correction=False)\\r\\n twod_map_raw_corr = analysis.matrix_map(bkg_reduction=False, data_correction=True)\\r\\n twod_map_no_bkg_corr = analysis.matrix_map(bkg_reduction=True, data_correction=True)\\r\\n Q_Dot_plot_data, fit_statistics = analysis.gaussian_fit()\\r\\n\\r\\n file_analysis = [twod_map_raw, twod_map_no_bkg, twod_map_raw_corr, twod_map_no_bkg_corr, Q_Dot_plot_data, fit_statistics]\\r\\n all_files_data.append(file_analysis)\\r\\n\\r\\n # Creates a histogram from the collected FWHM and central energy data from all the analyzed datafales containing quantumdots\\r\\n for FWHM_value in fit_statistics['FWHM'].to_numpy():\\r\\n FWHM_data.append(FWHM_value)\\r\\n for CE_value in fit_statistics['Centre'].to_numpy():\\r\\n central_energy_data.append(CE_value)\\r\\n\\r\\n progress_update.emit(counter * 100/len(file_paths))\\r\\n counter += 1\\r\\n \\r\\n return all_files_data, FWHM_data, central_energy_data\",\n \"def ExecuteInstanceReadingFromFileAux_Functionality(pickled_model,pickled_project_parameters,current_analysis_stage,random_variable,previous_computational_time,mapping_flag,pickled_mapping_reference_model,print_to_file,filename,open_mp_threads):\\n\\n start_time = time.time()\\n # unpickle model and build Kratos Model object\\n serialized_model = pickle.loads(pickled_model)\\n current_model = KratosMultiphysics.Model()\\n serialized_model.Load(\\\"ModelSerialization\\\",current_model)\\n del(serialized_model)\\n # unpickle parameters and build Kratos Parameters object\\n serialized_project_parameters = pickle.loads(pickled_project_parameters)\\n current_project_parameters = KratosMultiphysics.Parameters()\\n serialized_project_parameters.Load(\\\"ParametersSerialization\\\",current_project_parameters)\\n del(serialized_project_parameters)\\n # constructor analysis stage\\n simulation = current_analysis_stage(current_model,current_project_parameters,random_variable)\\n # add filename flag print_to_file is true\\n if (print_to_file):\\n simulation.filename = filename\\n # add flag if current index is maximum index: always True\\n simulation.is_current_index_maximum_index = True\\n # mapping if in current finest level (always true) and mapping flag is true\\n # otherwise standard behavior\\n if (mapping_flag is True):\\n # unpickle mapping reference model and build Kratos Model object\\n serialized_mapping_reference_model = pickle.loads(pickled_mapping_reference_model)\\n mapping_reference_model = KratosMultiphysics.Model()\\n serialized_mapping_reference_model.Load(\\\"ModelSerialization\\\",mapping_reference_model)\\n del(serialized_mapping_reference_model)\\n # send reference model to analysis stage for mapping and set mapping flag to true\\n simulation.mapping_reference_model = mapping_reference_model\\n simulation.mapping = True\\n simulation.Run()\\n # mapping if in current finest level and mapping flag is true\\n # otherwise standard qoi evaluation\\n if (mapping_flag is True):\\n qoi = simulation.MappingAndEvaluateQuantityOfInterest()\\n else:\\n qoi = simulation.EvaluateQuantityOfInterest()\\n del(simulation)\\n end_time = time.time()\\n computational_time = previous_computational_time + open_mp_threads*(end_time-start_time) # multiply by open mp threads to consider real machine cost\\n return qoi,computational_time\",\n \"def testApplyingExternalFile(self):\\n tree_external = CoalescenceTree(os.path.join(\\\"output\\\", \\\"data_3_44_2.db\\\"))\\n tree_external.set_speciation_parameters(\\n 0.0001, metacommunity_option=os.path.join(\\\"sample\\\", \\\"nse_reference.db\\\"), metacommunity_reference=1\\n )\\n tree_external.apply()\",\n \"def test_CFCalculation_txt_files():\\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\\n\\n #Make sure new script produces the same result as old one\\n expected_results = [\\n CFCoefficient(l=2,\\n m=0,\\n spin_up=-419.7891726292168,\\n spin_down=-414.7152560307904,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=4,\\n m=0,\\n spin_up=-35.92607948104669,\\n spin_down=-26.384951772020756,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=6, m=0, spin_up=6.522900740505054, spin_down=5.488104692050172, unit='K', convention='Stevens')\\n ]\\n\\n cf = CFCalculation(reference_radius='cdn')\\n cf.readPot('files/cf_calculation/VKS.2.0.dat',\\n 'files/cf_calculation/VKS.4.0.dat',\\n 'files/cf_calculation/VKS.6.0.dat',\\n lm=[(2, 0), (4, 0), (6, 0)])\\n cf.readCDN('files/cf_calculation/Nd.dat', header=3)\\n cf.cdn['RMT'] = 3.138049652\\n results = cf.performIntegration()\\n\\n assert results == expected_results\",\n \"def init_analysis(session, args):\\r\\n path = os.path.join(session.abs_path,'{}_{}_{}_{}'.format(args[12],args[13],args[14],args[15]))\\r\\n session.case = Case(path, session.method)\\r\\n case = session.case\\r\\n if args[0].split('#')[0]=='R':\\r\\n args[7]= -args[7]\\r\\n\\r\\n case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[6], args[7]))\\r\\n\\r\\n case.file_U.set_field('boundaryField',\\r\\n {'inlet': {'type': 'freestream',\\r\\n 'freestreamValue': 'uniform ({} {} 0)'.format(args[6], args[7])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'fixedValue', 'value':'uniform (0 0 0)'},\\r\\n 'extrados': {'type': 'fixedValue', 'value':'uniform (0 0 0)'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\\r\\n case.file_p.set_field('boundaryField',\\r\\n {'inlet': {'type': 'freestreamPressure'},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\\r\\n session.case.file_T.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[11])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'slip'},\\r\\n 'extrados': {'type': 'slip'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[6], args[7]))\\r\\n session.case.file_U.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue',\\r\\n 'value': 'uniform ({} {} 0)'.format(args[6], args[7])},\\r\\n 'outlet': {'type': 'inletOutlet','inletValue':'uniform ({} {} 0)'.format(args[6], args[7]),\\r\\n 'value':'uniform ({} {} 0)'.format(args[6], args[7])},\\r\\n 'intrados': {'type': 'noSlip'},\\r\\n 'extrados': {'type': 'noSlip'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\\r\\n session.case.file_p.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\\r\\n session.case.file_T.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue','value':'uniform {}'.format(args[11])},\\r\\n 'outlet': {'type': 'inletOutlet','inletValue':'uniform {}'.format(args[11]),'value':'uniform {}'.format(args[11])},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n \\\"\\\"\\\"\\r\\n \\\"\\\"\\\"\\r\\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[7], args[6]))\\r\\n session.case.file_U.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue',\\r\\n 'value': 'uniform ({} {} 0)'.format(args[7], args[6])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'noSlip'},\\r\\n 'extrados': {'type': 'noSlip'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[10]))\\r\\n session.case.file_p.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_T.set_field('internalField', 'uniform {}'.format(args[11]))\\r\\n session.case.file_T.set_field('boundaryField',\\r\\n {'inlet': {'type': 'zeroGradient'},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n \\\"\\\"\\\"\\r\\n \\\"\\\"\\\"\\r\\n session.case.file_U.set_field('internalField', 'uniform ({} {} 0)'.format(args[5], args[6]))\\r\\n session.case.file_U.set_field('boundaryField',\\r\\n {'inlet': {'type': 'fixedValue', 'value': 'uniform ({} {} 0)'.format(args[5], args[6])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'noSlip'},\\r\\n 'extrados': {'type': 'noSlip'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_p.set_field('boundaryField', {'inlet': {'type': 'fixedValue','value':'uniform {}'.format(args[9])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n session.case.file_p.set_field('internalField', 'uniform {}'.format(args[9]))\\r\\n\\r\\n session.case.file_T.set_field('boundaryField', {'inlet': {'type': 'fixedValue', 'value': 'uniform {}'.format(args[10])},\\r\\n 'outlet': {'type': 'zeroGradient'},\\r\\n 'intrados': {'type': 'zeroGradient'},\\r\\n 'extrados': {'type': 'zeroGradient'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n session.case.file_T.set_field('internalField','uniform 300')\\r\\n\\r\\n session.case.file_nut.set_field('boundaryField', {'inlet':{'type':'calculated', 'value':'uniform 0'},\\r\\n 'outlet':{'type':'calculated', 'value':'uniform 0'},\\r\\n 'intrados': {'type': 'nutkWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 0'},\\r\\n 'extrados': {'type': 'nutkWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 0'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_k.set_field('internalField', 'uniform 1')\\r\\n session.case.file_k.set_field('boundaryField', {\\r\\n 'inlet': {'type': 'turbulentIntensityKineticEnergyInlet', 'intensity': '0.05', 'value': 'uniform 1'},\\r\\n 'outlet': {'type': 'inletOutlet', 'inletValue': 'uniform 1', 'value': 'uniform 1'},\\r\\n 'intrados': {'type': 'kqRWallFunction','value':'uniform 1'},\\r\\n 'extrados': {'type': 'kqRWallFunction','value':'uniform 1'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n\\r\\n session.case.file_epsilon.set_field('boundaryField', {'inlet': {'type': 'turbulentMixingLengthDissipationRateInlet', 'mixingLength': '0.005', 'value': 'uniform 200'},\\r\\n 'outlet': {'type': 'inletOutlet', 'inletValue': 'uniform 200', 'value': 'uniform 200'},\\r\\n 'intrados': {'type': 'epsilonWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 200'},\\r\\n 'extrados': {'type': 'epsilonWallFunction', 'Cmu':'0.09', 'kappa':'0.41', 'E':'9.8', 'value':'uniform 200'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n session.case.file_epsilon.set_field('internalField', 'uniform 200')\\r\\n\\r\\n session.case.file_alphat.set_field('boundaryField', {'inlet':{'type':'calculated', 'value':'uniform 0'},\\r\\n 'outlet':{'type':'calculated', 'value':'uniform 0'},\\r\\n 'intrados': {'type': 'compressible::alphatWallFunction', 'Prt':'0.85', 'value':'uniform 0'},\\r\\n 'extrados': {'type': 'compressible::alphatWallFunction', 'Prt':'0.85', 'value':'uniform 0'},\\r\\n 'top_down': {'type': 'empty'},\\r\\n 'cyclic_in_1': {'type': 'cyclic'},\\r\\n 'cyclic_in_2': {'type': 'cyclic'},\\r\\n 'cyclic_out_1': {'type': 'cyclic'},\\r\\n 'cyclic_out_2': {'type': 'cyclic'}})\\r\\n \\\"\\\"\\\"\\r\\n session.case.file_controlDict.set_field('endTime', '10000')\\r\\n session.case.file_controlDict.set_field('startFrom', 'latestTime')\\r\\n session.case.file_controlDict.set_field('functions', {\\\"#includeFunc\\\":\\\"MachNo\\\"})\\r\\n session.case.file_turbulenceProperties.set_field('simulationType', 'laminar')\\r\\n session.case.interacting(100)\\r\\n sim = session.case.simulation(\\\"open40\\\") # Build files\\r\\n sim.limit_write = 50\\r\\n sim.block_mesh(string=write_block_mesh(args[1], args[2], args[3], args[4], args[5], session.mesh))\\r\\n sim.check_mesh()\\r\\n\\r\\n result_dict={\\\"T\\\": 0, \\\"p\\\":0, \\\"Theta\\\":0, \\\"z\\\":0, \\\"profile\\\":args[14]}\\r\\n\\r\\n def _function(container, args):\\r\\n current_time = container['current_time']\\r\\n if float(current_time)>=0.000015:\\r\\n print('Parsing results')\\r\\n sim.foamToVTK()\\r\\n results = sim.get_last_results('outlet')\\r\\n result_U = results.GetCellData('U')\\r\\n result_p = results.GetCellData('p')\\r\\n result_T = results.GetCellData('T')\\r\\n theta = 0.0\\r\\n z = 0.0\\r\\n p=0.0\\r\\n t=0.0\\r\\n U_length = len(result_U)\\r\\n p_length = len(result_p)\\r\\n t_length = len(result_T)\\r\\n for i,j,k in zip(result_p, result_T, result_U):\\r\\n p+= float(i[0])/p_length\\r\\n t+= float(j[0])/t_length\\r\\n theta += float(k[1])/U_length\\r\\n z += float(k[0])/U_length\\r\\n\\r\\n args[\\\"T\\\"] = t\\r\\n args[\\\"p\\\"] = p\\r\\n args[\\\"Theta\\\"] = theta\\r\\n args[\\\"z\\\"] = z\\r\\n return True\\r\\n return False\\r\\n \\r\\n #sim.run(_function, result_dict)\\r\\n #result_dict = {'T': 195.38959999999997, 'z': 429.3120571428572, 'p': 74001.90285714286, 'Theta': -207.19442857142855, 'profile': 0}\\r\\n\\r\\n print('Sending results')\\r\\n if args[0].split('#')[0]=='R':\\r\\n result_dict['Theta']= -result_dict['Theta']\\r\\n\\r\\n session.socket_design.send({'new_data':result_dict})\",\n \"def evaluate_hmdb51_fusion():\\n vlen = 0\\n ob_suffix = '-max.feat.npy.gz'\\n fv_suffix = '_fv.npy.gz'\\n ob_root = '/home/syq/research_final/data/features/ob_hmdb51_pooled_python/'\\n fv_root = '/home/syq/research_final/data/dense-traj/fv_hmdb51_python/'\\n hmdb_splits = 'testTrainMulti_7030_splits/'\\n categories = os.listdir(fv_root)\\n weight = 1.0\\n weights = [i / 20.0 for i in range(21)]\\n acc_to_weights = {}\\n\\n for weight in weights:\\n print \\\"Weight: %.2f\\\" % weight\\n accs = np.zeros(3)\\n for splitnum in range(1,4):\\n ts = time.time()\\n trainfiles, testfiles = hmdb51_splits.loadsplit(categories,\\n hmdb_splits,\\n splitnum)\\n print 'Have %d train files' % len(trainfiles)\\n print 'Have %d test files' % len(testfiles)\\n\\n if not vlen:\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(trainfiles[0][0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n vlen_ob = len(np.load(fp))\\n fp.close()\\n print \\\"OB vector length is %d\\\" % vlen_ob\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(trainfiles[0][0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n vlen_fv = len(np.load(fp))\\n fp.close()\\n print \\\"IDTFV vector length is %d\\\" % vlen_fv\\n\\n Dtrain_ob = np.zeros( (len(trainfiles),vlen_ob), np.float32 )\\n Dtrain_fv = np.zeros( (len(trainfiles),vlen_fv), np.float32 )\\n\\n Ytrain = np.ones ( (len(trainfiles) )) * -1000\\n\\n for fi,f in enumerate(trainfiles):\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n Dtrain_ob[fi][:] = np.load(fp)\\n fp.close()\\n Ytrain[fi] = f[1]\\n\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n Dtrain_fv[fi][:] = np.load(fp)\\n fp.close()\\n\\n Dtest_ob = np.zeros( (len(testfiles),vlen_ob), np.float32 )\\n Dtest_fv = np.zeros( (len(testfiles),vlen_fv), np.float32 )\\n\\n Ytest = np.ones ( (len(testfiles) )) * -1000\\n\\n for fi,f in enumerate(testfiles):\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n Dtest_ob[fi][:] = np.load(fp)\\n fp.close()\\n Ytest[fi] = f[1]\\n\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n Dtest_fv[fi][:] = np.load(fp)\\n fp.close()\\n\\n \\\"\\\"\\\"\\n Early fusion\\n Dtrain = np.hstack((Dtrain_ob, Dtrain_fv))\\n Dtest = np.hstack((Dtest_ob, Dtest_fv))\\n\\n clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\\n acc = clf.fit(Dtrain, Ytrain).score(Dtest, Ytest)\\n \\\"\\\"\\\"\\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\\n\\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\\n cache_size=1000,\\n kernel='linear',\\n probability=True),\\n n_jobs=-1)\\n\\n # Get probabilities for late fusion\\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\\n\\n # Scale decision values b/w 0 and 1\\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\\n Dtest_fv = preprocessing.normalize(Dtest_fv)\\n Dtest_ob = preprocessing.normalize(Dtest_ob)\\n\\n # Late fusion\\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\\n latefusion_clf.fit(scores_train, Ytrain)\\n\\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\\n acc = latefusion_clf.score(scores_test, Ytest)\\n print 'Fold', splitnum, 'late fusion acc', acc\\n print \\\"Train & testing time %.3f\\\" % (time.time() - ts)\\n accs[splitnum-1] = acc\\n acc_to_weights[weight] = accs\\n\\n print \\\"Mean accuracy: %.3f\\\" % accs.mean()\\n with open(\\\"hmdb51_weight_gridsearch.txt\\\", \\\"w\\\") as f:\\n for weight, accs in acc_to_weights.items():\\n f.write(str(weight) + str(accs) + '\\\\n')\\n return acc_to_weights\\n\\n \\\"\\\"\\\"\\n with open('fv_hmdb51_accs.txt', 'w') as f:\\n f.write(\\\"%s\\\\nMean:%.3f\\\" % (str(accs), np.mean(accs)))\\n \\\"\\\"\\\"\",\n \"def FS1Year(inputFolderPath = './Formatted Files Without Missing', outputFolderPath = './Feature Selection'):\\n\\tfileList = []\\n\\tfor root, dirs, files in os.walk(inputFolderPath): \\n\\t for afile in files:\\n\\t \\tfileList.append(afile)\\n\\n\\ttargetList = [2704,2707,2713,2716,2718,808,811,1954]\\n\\t# targetList = [1994,1997,2003,2006,2008,807,810,1953]\\n\\tyearList = [(1998,2015),(2005,2015),(2005,2015),(2005,2015),(2005,2015),(1960,2014),(1961,2014),(2002,2012)]\\n\\n\\n\\tfor i in range(len(targetList)):\\n\\t\\t# i = 0\\n\\t\\trows = []\\n\\t\\tfor year in range(yearList[i][0],yearList[i][1]+1):\\n\\t\\t\\t# print str(year) + '-' + str(targetList[i]) \\n\\t\\t\\tregex = re.compile(\\\"(\\\"+ str(year) +\\\").*\\\")\\n\\t\\t\\tfiles = [m.group(0) for l in fileList for m in [regex.search(l)] if m and len(l) == 28]\\n\\t\\t\\t# print files\\n\\t\\t\\t# call([\\\"java\\\",\\\"-jar\\\",\\\"MINE.jar\\\",\\\"./New Formatted Files/\\\"+files[0],str(targetList[i]+1),\\\"cv=0.5\\\"])\\n\\t\\t\\t\\n\\n\\t\\t\\t# load the CSV file as a numpy matrix\\n\\t\\t\\t# dataset = np.loadtxt('./New Formatted Files/'+files[0], delimiter=\\\",\\\", skiprows=1, usecols=tuple(range(1,3240)))\\n\\t\\t\\t# dataset = np.genfromtxt('./New Formatted Files/'+files[0], delimiter=\\\",\\\", names=True, autostrip=True, max_rows=10, missing_values=np.nan, usecols=tuple(range(1,30)))\\n\\t\\t\\twith open(inputFolderPath+'/'+files[0],'rb') as f:\\n\\t\\t\\t reader = csv.reader(f)\\n\\t\\t\\t header = next(reader)\\n\\t\\t\\t num_cols = len(header)\\n\\t\\t\\t # print header\\n\\t\\t\\t print i\\n\\t\\t\\t target_idx = [idx for idx, item in enumerate(header) if item.startswith(str(targetList[i]).zfill(4))]\\n\\t\\t\\t if len(target_idx) > 0:\\n\\t\\t\\t \\ttarget = target_idx[0]-1\\n\\t\\t\\t \\tprint ('OK',year, targetList[i], inputFolderPath+'/'+files[0])\\n\\t\\t\\t else:\\n\\t\\t\\t \\tprint (year, targetList[i], inputFolderPath+'/'+files[0])\\n\\t\\t\\t \\tbreak\\n\\t\\t\\t f.close()\\n\\t\\t\\tdataset = np.genfromtxt(inputFolderPath+'/'+files[0], delimiter=\\\",\\\", skip_header=1, autostrip=True, missing_values=np.nan, usecols=tuple(range(1,num_cols)))\\n\\t\\t\\t# print (dataset.shape)\\n\\t\\t\\tX = np.concatenate((dataset[:,0:target],dataset[:,target+1:dataset.shape[1]]),axis=1)\\n\\t\\t\\t# X = np.concatenate((dataset[:,0:2],dataset[:,3:dataset.shape[1]),axis=1)\\n\\t\\t\\ty = dataset[:,target]\\n\\t\\t\\t# print tuple(range(1,3240))\\n\\t\\t\\t# print dataset.dtype.names[0]\\n\\t\\t\\t# print dataset.dtype.names[-1]\\n\\t\\t\\t# print dataset[0]\\n\\t\\t\\timp = Imputer(missing_values='NaN', strategy='median', axis=0)\\n\\t\\t\\timputedX = imp.fit_transform(X,y)\\n\\t\\t\\timputedX = np.array([imputedX[j] for j in range(imputedX.shape[0]) if not np.isnan(y[j])])\\n\\t\\t\\tdeleteMissingY = np.array([x1 for x1 in y if not np.isnan(x1)])\\n\\t\\t\\t# print dataset[0]\\n\\t\\t\\t# print (imputedX.shape, y.shape)\\n\\t\\t\\t# print (imputedX.shape, deleteMissingY.shape)\\n\\t\\t\\t# print (np.any(np.isnan(imputedX)), np.all(np.isfinite(imputedX)))\\n\\t\\t\\t# imputedX_new = SelectKBest(chi2, k=10).fit_transform(imputedX, y)\\n\\t\\t\\tk = 30\\n\\t\\t\\tselection = SelectKBest(f_regression, k=k)\\n\\t\\t\\timputedX_new = selection.fit_transform(imputedX, deleteMissingY)\\n\\t\\t\\t# print (len(selection.get_support()), len(header[1:target+1]+header[target+2:]))\\n\\t\\t\\tselectedFeatures = [[item, selection.scores_[idx], selection.pvalues_[idx]] for idx, item in enumerate(header[1:target+1]+header[target+2:]) if selection.get_support()[idx]]\\n\\t\\t\\tselectedFeatures.sort(key=lambda x: x[1], reverse=True)\\n\\t\\t\\t# for sf in selectedFeatures:\\n\\t\\t\\t# \\tprint sf\\n\\t\\t\\t# print selection.scores_\\n\\t\\t\\t# print selection.get_support()\\n\\t\\t\\t# print (imputedX_new.shape, y.shape)\\n\\t\\t\\t# print (imputedX_new.shape, deleteMissingY.shape)\\n\\t\\t\\t# print imputedX[0,1994]\\n\\t\\t\\t# print dataset['3137_Estimates_and_projections_of_the_total_population_by_sex_age_and_rural__urban_areasSexTotal_10year_age_bands__2534_Geographical_coverage__National_Thousands_Persons__ILO']\\n\\t\\t\\t# print dataset\\n\\t\\t\\t# separate the data from the target attributes\\n\\t\\t\\t# X = np.concatenate((imputedDataset[:,0:7],imputedDataset[:,0:7]),axis=1)\\n\\t\\t\\t# y = imputedDataset[:,8]\\n\\t\\t\\trows.append([year, 'score', 'p-value'])\\n\\t\\t\\trows.extend(selectedFeatures)\\n\\t\\t\\trows.append(['', '', ''])\\n\\t\\t\\t# print 'Hey'\\n\\n\\t\\tfilename = outputFolderPath+'/'+('Indicator%d - k%d - %s.csv' % (targetList[i], k, 'f_regression'))\\n\\t\\twith open(filename,'wb') as w:\\n\\t\\t\\ta = csv.writer(w, delimiter = ',')\\n\\t\\t\\ta.writerows(rows)\\n\\t\\tw.close()\",\n \"def analysis():\\n global prediction\\n\\n json_path = os.path.join(basedir, 'static', 'data', 'tmp_json')\\n # csv_path = os.path.join(basedir, 'static', 'data', 'csv')\\n # if not os.path.exists(csv_path):\\n # os.mkdir(csv_path)\\n\\n if os.name == 'nt':\\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf.dir'))\\n video_file = Path(os.path.join(json_path, 'facial_data.shlf.dir'))\\n else:\\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf'))\\n video_file = Path(os.path.join(json_path, 'facial_data.shlf'))\\n\\n # Files exists\\n if audio_file.is_file() and video_file.is_file():\\n with shelve.open(os.path.join(json_path, 'facial_data.shlf')) as shelf:\\n emotion_data = shelf['emotion_data']\\n microexpression_data = shelf['micro_expression_data']\\n blink_data = shelf['blink_data']\\n\\n with shelve.open(os.path.join(json_path, 'audio_data.shlf')) as shelf:\\n mean_energy = shelf['mean_energy']\\n max_pitch_amp = shelf['max_pitch_amp']\\n vowel_duration = shelf['vowel_duration']\\n pitch_contour = shelf['pitch_contour']\\n\\n else:\\n emotion_data = None\\n microexpression_data = None\\n blink_data = None\\n mean_energy = None\\n max_pitch_amp = None\\n vowel_duration = None\\n pitch_contour = None\\n\\n # Training Files (choose one)\\n # soc_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_soc.txt')\\n # niko_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_niko.txt')\\n # vero_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_vero.txt')\\n\\n # txt_file = soc_file\\n\\n # train_data = []\\n\\n # for cases where one parameter has more elements\\n # for i in range(min(len(blink_data), len(microexpression_data), len(mean_energy))):\\n # train_data.append(0)\\n\\n # train_file = open(txt_file)\\n\\n # for line in train_file:\\n # index1 = int((int(line[4]) * 600) + ((int(line[5]) * 60) + (int(line[7]) * 10) + int(line[8])) / 2)\\n # index2 = int((int(line[10]) * 600) + ((int(line[11]) * 60) + (int(line[13]) * 10) + int(line[14])) / 2)\\n # if line[0] == 'F':\\n # train_data[index1] = 1\\n # train_data[index2] = 1\\n\\n # with open(os.path.join(csv_path, 'train.csv'), 'w', newline='') as csv_file:\\n # writer = csv.writer(csv_file)\\n # writer.writerow(['Time Interval', 'Micro-expressions', 'Blinks',\\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency',\\n # 'False/True'])\\n\\n # # for cases where one parameter has more elements than another\\n # for index in range(min(len(mean_energy), len(blink_data), len(microexpression_data))):\\n # writer.writerow([index, microexpression_data[index], blink_data[index],\\n # mean_energy[index], max_pitch_amp[index], vowel_duration[index], pitch_contour[index],\\n # train_data[index]])\\n\\n # finalresults = [['Time Interval', 'Micro-expressions', 'Blinks',\\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency' ]]\\n final_results = []\\n\\n for index in range((min(len(mean_energy), len(blink_data), len(microexpression_data)))):\\n final_results.append([microexpression_data[index], blink_data[index],\\n mean_energy[index], max_pitch_amp[index], vowel_duration[index],\\n pitch_contour[index]])\\n\\n prediction[0] = predict(final_results)\\n\\n return render_template('analysis.html', mean_energy=mean_energy, max_pitch_amp=max_pitch_amp,\\n vowel_duration=vowel_duration, pitch_contour=pitch_contour, blink_data=blink_data,\\n microexpression_data=microexpression_data, emotion_data=emotion_data)\",\n \"def compute_functions(file_name,E_max,E_min,gamma,gamma_k):\\n\\n file = open(file_name,'r')\\n data = file.readlines()\\n file.close()\\n\\n print \\\"Computing functions\\\"\\n all_lor = []\\n for fila in data[2:]:\\n vals = map(eval,fila.split())\\n if(len(vals)>1):\\n if(vals[1]>E_min and vals[1] < E_max):\\n ek = vals[1]\\n weight = 0\\n for j in range(2,len(vals)):\\n weight += vals[j]\\n A = get_func(vals[0],vals[1],weight,gamma,gamma_k)\\n all_lor.append(A)\\n\\n return all_lor\",\n \"def read(source_name, variable_name, url, res_key, headers,\\n out_path='original_data', start_from_user=None, end_from_user=None):\\n data_set = pd.DataFrame()\\n\\n variable_dir = os.path.join(out_path, source_name, variable_name)\\n\\n logger.info('reading %s - %s', source_name, variable_name)\\n\\n files_existing = sum([len(files) for r, d, files in os.walk(variable_dir)])\\n files_success = 0\\n\\n # Check if there are folders for variable_name\\n if not os.path.exists(variable_dir):\\n logger.warning('folder not found for %s, %s',\\n source_name, variable_name)\\n return data_set\\n\\n # For each file downloaded for that variable\\n for container in os.listdir(variable_dir):\\n # Skip this file if period covered excluded by user\\n if start_from_user:\\n # Filecontent is too old\\n if start_from_user > yaml.load(container.split('_')[1]):\\n continue # go to next container\\n\\n if end_from_user:\\n # Filecontent is too recent\\n if end_from_user < yaml.load(container.split('_')[0]):\\n continue # go to next container\\n\\n files = os.listdir(os.path.join(variable_dir, container))\\n\\n # Check if there is only one file per folder\\n if len(files) == 0:\\n logger.warning('found no file in %s %s %s',\\n source_name, variable_name, container)\\n continue\\n\\n elif len(files) > 1:\\n logger.warning('found more than one file in %s %s %s',\\n source_name, variable_name, container)\\n continue\\n\\n filepath = os.path.join(variable_dir, container, files[0])\\n\\n # Check if file is not empty\\n if os.path.getsize(filepath) < 128:\\n logger.warning('%s \\\\n file is smaller than 128 Byte, which means it is probably empty',\\n filepath)\\n else:\\n logger.debug('reading data:\\\\n\\\\t '\\n 'Source: %s\\\\n\\\\t '\\n 'Variable: %s\\\\n\\\\t '\\n 'Filename: %s',\\n source_name, variable_name, files[0])\\n\\n update_progress(files_success, files_existing)\\n\\n if source_name == 'OPSD':\\n data_to_add = read_opsd(filepath, url, headers)\\n elif source_name == 'CEPS':\\n data_to_add = read_ceps(filepath, variable_name, url, headers)\\n elif source_name == 'ENTSO-E Data Portal':\\n #save_stdout = sys.stdout\\n #sys.stdout = open('trash', 'w')\\n data_to_add = read_entso_e_portal(filepath, url, headers)\\n #sys.stdout = save_stdout\\n elif source_name == 'Energinet.dk':\\n data_to_add = read_energinet_dk(filepath, url, headers)\\n elif source_name == 'Elia':\\n data_to_add = read_elia(filepath, variable_name, url, headers)\\n elif source_name == 'PSE':\\n data_to_add = read_pse(filepath, variable_name, url, headers)\\n elif source_name == 'RTE':\\n data_to_add = read_rte(filepath, variable_name, url, headers)\\n elif source_name == 'Svenska Kraftnaet':\\n data_to_add = read_svenska_kraftnaet(\\n filepath, variable_name, url, headers)\\n elif source_name == '50Hertz':\\n data_to_add = read_hertz(filepath, variable_name, url, headers)\\n elif source_name == 'Amprion':\\n data_to_add = read_amprion(\\n filepath, variable_name, url, headers)\\n elif source_name == 'TenneT':\\n data_to_add = read_tennet(\\n filepath, variable_name, url, headers)\\n elif source_name == 'TransnetBW':\\n data_to_add = read_transnetbw(\\n filepath, variable_name, url, headers)\\n\\n if data_set.empty:\\n data_set = data_to_add\\n else:\\n data_set = data_set.combine_first(data_to_add)\\n\\n files_success += 1\\n update_progress(files_success, files_existing)\\n\\n if data_set.empty:\\n logger.warning('returned empty DataFrame for %s, %s',\\n source_name, variable_name)\\n return data_set\\n\\n # Reindex with a new index that is sure to be continous in order to later\\n # expose gaps in the data.\\n no_gaps = pd.DatetimeIndex(start=data_set.index[0],\\n end=data_set.index[-1],\\n freq=res_key)\\n data_set = data_set.reindex(index=no_gaps)\\n\\n # Cut off the data outside of [start_from_user:end_from_user]\\n # First, convert userinout to UTC time\\n if start_from_user:\\n start_from_user = (\\n pytz.timezone('Europe/Brussels')\\n .localize(datetime.combine(start_from_user, time()))\\n .astimezone(pytz.timezone('UTC')))\\n\\n if end_from_user:\\n end_from_user = (\\n pytz.timezone('Europe/Brussels')\\n .localize(datetime.combine(end_from_user, time()))\\n .astimezone(pytz.timezone('UTC'))) - timedelta(minutes=int(res_key[:2]))\\n\\n # Then cut off the data_set\\n data_set = data_set.loc[start_from_user:end_from_user, :]\\n\\n return data_set\",\n \"def process(self):\\n\\n if len(self.files) == self._file_ptr:\\n raise pipeline.PipelineStopIteration\\n\\n # Collect garbage to remove any prior CorrData objects\\n gc.collect()\\n\\n # Fetch and remove the first item in the list\\n file_ = self.files[self._file_ptr]\\n self._file_ptr += 1\\n\\n # Set up product selection\\n # NOTE: this probably doesn't work with stacked data\\n prod_sel = None\\n if self.only_autos:\\n rd = andata.CorrReader(file_)\\n prod_sel = np.array(\\n [ii for (ii, pp) in enumerate(rd.prod) if pp[0] == pp[1]]\\n )\\n\\n # Load file\\n if (\\n isinstance(self.freq_sel, slice)\\n and (prod_sel is None)\\n and (self.datasets is None)\\n ):\\n self.log.info(\\n \\\"Reading file %i of %i. (%s) [fast io]\\\",\\n self._file_ptr,\\n len(self.files),\\n file_,\\n )\\n ts = andata.CorrData.from_acq_h5_fast(\\n file_, freq_sel=self.freq_sel, comm=self.comm\\n )\\n else:\\n self.log.info(\\n \\\"Reading file %i of %i. (%s) [slow io]\\\",\\n self._file_ptr,\\n len(self.files),\\n file_,\\n )\\n ts = andata.CorrData.from_acq_h5(\\n file_,\\n datasets=self.datasets,\\n distributed=True,\\n comm=self.comm,\\n freq_sel=self.freq_sel,\\n prod_sel=prod_sel,\\n )\\n\\n # Store file name\\n ts.attrs[\\\"filename\\\"] = file_\\n\\n # Use a simple incrementing string as the tag\\n if \\\"tag\\\" not in ts.attrs:\\n tag = \\\"file%03i\\\" % self._file_ptr\\n ts.attrs[\\\"tag\\\"] = tag\\n\\n # Add a weight dataset if needed\\n if \\\"vis_weight\\\" not in ts.flags:\\n weight_dset = ts.create_flag(\\n \\\"vis_weight\\\",\\n shape=ts.vis.shape,\\n dtype=np.uint8,\\n distributed=True,\\n distributed_axis=0,\\n )\\n weight_dset.attrs[\\\"axis\\\"] = ts.vis.attrs[\\\"axis\\\"]\\n\\n # Set weight to maximum value (255), unless the vis value is\\n # zero which presumably came from missing data. NOTE: this may have\\n # a small bias\\n weight_dset[:] = np.where(ts.vis[:] == 0.0, 0, 255)\\n\\n # Return timestream\\n if self.use_draco_container:\\n ts = containers.CHIMETimeStream.from_corrdata(ts)\\n\\n return ts\",\n \"def run(self, input_files, input_metadata, output_files):\\n try:\\n # Set and check execution directory. If not exists the directory will be created.\\n execution_path = os.path.abspath(self.configuration.get('execution', '.'))\\n execution_parent_dir = os.path.dirname(execution_path)\\n if not os.path.isdir(execution_parent_dir):\\n os.makedirs(execution_parent_dir)\\n\\n # Update working directory to execution path\\n os.chdir(execution_path)\\n logger.debug(\\\"Execution path: {}\\\".format(execution_path))\\n\\n # Set file names for output files (with random name if not predefined)\\n for key in output_files.keys():\\n if output_files[key] is not None:\\n pop_output_path = os.path.abspath(output_files[key])\\n self.populable_outputs[key] = pop_output_path\\n output_files[key] = pop_output_path\\n else:\\n errstr = \\\"The output_file[{}] can not be located. Please specify its expected path.\\\".format(key)\\n logger.error(errstr)\\n raise Exception(errstr)\\n\\n logger.debug(\\\"Init execution of the Machine Learning Model generation\\\")\\n # Prepare file paths\\n for key in input_files.keys():\\n if key == 'radiomic_features':\\n dataset = input_files[key]\\n elif key == 'ML_technique':\\n ml = input_files[key]\\n else:\\n logger.debug('Unrecognized input file key {}'.format(key))\\n continue\\n\\n\\n\\n output_metadata = {}\\n for key in output_files.keys():\\n \\n logger.info('VRE_ML: Iterating over Key {}'.format(key))\\n\\n \\n if os.path.isfile(output_files[key]):\\n meta = Metadata()\\n meta.file_path = output_files[key] # Set file_path for output files\\n \\n logger.info('VRE_ML: Update metadata with key {} and value {}'.format(key, meta.file_path))\\n\\n meta.data_type = 'tool_statistics'\\n meta.file_type = 'PDF'\\n\\n # Set sources for output files\\n meta.sources = [output_files[key]+'.pdf']\\n # Generate model\\n generate_model.run(dataset=dataset,output_files[key]+'.pdf')\\n\\n # Append new element in output metadata\\n logger.info('VRE_ML: Update metadata with key {} and value {}'.format(key, meta.file_path))\\n output_metadata.update({key: meta})\\n\\n else:\\n logger.warning(\\\"Output {} not found. Path {} not exists\\\".format(key, output_files[key]))\\n\\n logger.debug(\\\"Output metadata created\\\")\\n\\n return output_files, output_metadata\\n\\n except Exception:\\n errstr = \\\"VRE ML RUNNER pipeline failed. See logs\\\"\\n logger.fatal(errstr)\\n raise Exception(errstr)\",\n \"def execute( self, dataToResolve = None ):\\n\\n # Define local configuration options present at every site\\n localSEList = self.configuration['LocalSEList']\\n self.jobID = self.configuration.get( 'JobID' )\\n allReplicas = self.configuration.get( 'AllReplicas', False )\\n if allReplicas:\\n self.log.info( 'All replicas will be used in the resolution' )\\n\\n if dataToResolve:\\n self.log.verbose( 'Data to resolve passed directly to InputDataByProtocol module' )\\n self.inputData = dataToResolve # e.g. list supplied by another module\\n\\n self.inputData = [x.replace( 'LFN:', '' ) for x in self.inputData]\\n self.log.verbose( 'InputData requirement to be resolved by protocol is:\\\\n%s' % '\\\\n'.join( self.inputData ) )\\n\\n # First make a check in case replicas have been removed or are not accessible\\n # from the local site (remove these from consideration for local protocols)\\n replicas = self.fileCatalogResult['Value']['Successful']\\n self.log.debug( 'File Catalogue result is:\\\\n%s' % str( replicas ) )\\n\\n # First get the preferred replica:\\n requestedProtocol = self.configuration.get( 'Protocol', '' )\\n result = self.__resolveReplicas( localSEList, replicas, requestedProtocol = requestedProtocol )\\n if not result['OK']:\\n return result\\n success = result['Value']['Successful']\\n if not allReplicas:\\n bestReplica = {}\\n for lfn in success:\\n bestReplica[lfn] = success[lfn][0]\\n return S_OK( {'Successful': bestReplica, 'Failed':result['Value']['Failed']} )\\n\\n # If all replicas are requested, get results for other SEs\\n seList = set()\\n localSESet = set( localSEList )\\n for lfn in replicas.keys():\\n extraSEs = set( replicas[lfn] ) - localSESet\\n # If any extra SE, add it to the set, othewise don't consider that file\\n if extraSEs:\\n seList.update( extraSEs )\\n else:\\n replicas.pop( lfn )\\n seList -= self.metaKeys\\n\\n if seList:\\n requestedProtocol = self.configuration.get( 'RemoteProtocol', '' )\\n result = self.__resolveReplicas( seList, replicas, ignoreTape = True, requestedProtocol = requestedProtocol )\\n if not result['OK']:\\n return result\\n for lfn in result['Value']['Successful']:\\n success.setdefault( lfn, [] ).extend( result['Value']['Successful'][lfn] )\\n # Only consider failed the files that are not successful as well\\n failed = [lfn for lfn in result['Value']['Failed'] if lfn not in success]\\n return S_OK( {'Successful': success, 'Failed':failed} )\",\n \"def _evaluate_reduced_potential(self, system, trajectory, file_path,\\n compute_resources, subset_energy_corrections=None):\\n from simtk import unit as simtk_unit\\n\\n integrator = openmm.VerletIntegrator(0.1 * simtk_unit.femtoseconds)\\n\\n platform = setup_platform_with_resources(compute_resources, True)\\n openmm_context = openmm.Context(system, integrator, platform)\\n\\n potentials = np.zeros(trajectory.n_frames, dtype=np.float64)\\n reduced_potentials = np.zeros(trajectory.n_frames, dtype=np.float64)\\n\\n temperature = pint_quantity_to_openmm(self.thermodynamic_state.temperature)\\n beta = 1.0 / (simtk_unit.BOLTZMANN_CONSTANT_kB * temperature)\\n\\n pressure = pint_quantity_to_openmm(self.thermodynamic_state.pressure)\\n\\n for frame_index in range(trajectory.n_frames):\\n\\n positions = trajectory.xyz[frame_index]\\n box_vectors = trajectory.openmm_boxes(frame_index)\\n\\n if self.enable_pbc:\\n openmm_context.setPeriodicBoxVectors(*box_vectors)\\n\\n openmm_context.setPositions(positions)\\n\\n state = openmm_context.getState(getEnergy=True)\\n\\n unreduced_potential = state.getPotentialEnergy() / simtk_unit.AVOGADRO_CONSTANT_NA\\n\\n if pressure is not None and self.enable_pbc:\\n unreduced_potential += pressure * state.getPeriodicBoxVolume()\\n\\n potentials[frame_index] = state.getPotentialEnergy().value_in_unit(simtk_unit.kilojoule_per_mole)\\n reduced_potentials[frame_index] = unreduced_potential * beta\\n\\n potentials *= unit.kilojoule / unit.mole\\n reduced_potentials *= unit.dimensionless\\n\\n if subset_energy_corrections is not None:\\n potentials += subset_energy_corrections\\n\\n statistics_array = StatisticsArray()\\n statistics_array[ObservableType.ReducedPotential] = reduced_potentials\\n statistics_array[ObservableType.PotentialEnergy] = potentials\\n statistics_array.to_pandas_csv(file_path)\",\n \"def _m4_file_analysis(self, fin):\\n # imp.reload(m4_macros_analysis)\\n raw_data = fin.read()\\n\\n mylexer = m4_macros_analysis.M4Lexer()\\n mylexer.build()\\n lexer = mylexer.clone()\\n generator = mylexer.get_token_iter(raw_data, lexer=lexer)\\n cache_generator = m4_macros_analysis.CacheGenerator(generator, origin_data=raw_data)\\n\\n self._m4_analyzer.functions_analyze(cache_generator, fin.name)\",\n \"def evaluate(self):\\n for v in _INNVAR_EXPR.findall(self.expr):\\n if v not in self.m_globals and v not in self.m_file_caches:\\n try:\\n self.m_file_caches[v] = model.load_file(self.strip_var(v))\\n except IOError:\\n raise LineProcessError('Undefined variable: \\\"%s\\\"' % self.strip_var(v))\\n return self._eval()\",\n \"def main(opts):\\n if opts.list_vars:\\n list_vars()\\n if not os.path.exists(opts.original):\\n print(\\\"ERROR: Could not find \\\" + opts.original)\\n exit()\\n if not os.path.exists(opts.interp):\\n print(\\\"ERROR: Could not find \\\" + opts.interp)\\n exit()\\n data_functs = { 'a' : read_exp_a,\\n 'c' : read_exp_c,\\n 'f' : read_exp_f}\\n orig_exp = os.path.basename(opts.original)[4]\\n interp_exp = os.path.basename(opts.interp)[4]\\n if not orig_exp == interp_exp and orig_exp in ['a','c','f']:\\n print(\\\"ERROR: Data files not the same experiment!\\\")\\n exit()\\n data_functs[orig_exp](opts.original, opts.interp, opts.var)\",\n \"def analyzeViSDEMData(dict):\\n \\n if 'path_in' in dict:\\n path_in = dict['path_in']\\n else:\\n print(\\\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\\\") \\n return\\n \\n path_out_default = '../colordeficiency-data/' \\n if 'path_out' in dict:\\n path_out = dict['path_out']\\n else:\\n print(\\\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \\\"+str(path_out_default))\\n path_out = path_out_default\\n \\n if 'round' in dict:\\n round = dict['round']\\n else:\\n print(\\\"Error: You have to chose a round first.\\\")\\n \\n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\\n \\n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\\n if round == 1:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids.csv\\\")\\n elif round == 2:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids_2.csv\\\")\\n \\n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\\\";\\\")\\n \\n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\\n observer_ids = os.path.join(path,\\\"observer_ids.csv\\\")\\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\\\";\\\")\\n \\n # 1. Step: Read all the XLSX data in the path\\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\\n dataArray = pandas.DataFrame()\\n i=1\\n for xlsx_file in xlsx_files:\\n sys.stdout.write(xlsx_file)\\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\\n \\n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\\n \\n if \\\"2. Session\\\" in extraDataDict:\\n sessionID = int(extraDataDict['2. Session'])\\n newDataArray['session_id'] = sessionID\\n \\n if 'group' in extraDataDict:\\n obsGroup = str(extraDataDict['group'])\\n newDataArray['obsGroup'] = obsGroup\\n \\n if '0. Participant ID' in extraDataDict:\\n obsID = int(extraDataDict['0. Participant ID'])\\n \\n newDataArray['observer_id'] = obsID\\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\\n \\n dataArray = pandas.concat([dataArray, newDataArray])\\n sys.stdout.write(' . ')\\n if (i%5)==0: sys.stdout.write('\\\\n')\\n i+=1\\n sys.stdout.write('\\\\n')\\n \\n # 2. Step: Adapt values to programstandards\\n for item in settings.colDefLong2ID:\\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\\n \\n for item in settings.dalt2ID:\\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\\n \\n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\\n \\n \\n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\\n 'coldef_type': 'coldef_type',\\n 'resp.corr_raw': 'is_correct',\\n 'resp.rt_raw': 'resp_time',\\n 'stimFile': 'filepath'})\\n dataArray = dataArray.reset_index()\\n \\n # Adding set_id, motive_id and variant_id to each file\\n for index, row in dataArray.iterrows():\\n path_tmp = row['filepath']\\n filename = os.path.basename(path_tmp).split('.')[0]\\n dict_tmp = getStatsFromFilename(filename)\\n imgID_tmp = int(dict_tmp['img_id'])\\n \\n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\\n \\n dataArray.at[index,'image_id'] = imgID_tmp\\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\\n\\n dataArray.image_id = dataArray.image_id.astype(int)\\n dataArray.set_id = dataArray.set_id.astype(int)\\n dataArray.motive_id = dataArray.motive_id.astype(int)\\n dataArray.variant_id = dataArray.variant_id.astype(int)\\n dataArray.is_correct = dataArray.is_correct.astype(bool)\\n \\n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\\n \\n # 3. Saving data to file\\n try:\\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\\\";\\\")\\n sys.stdout.write(\\\"Success: ViSDEM data successfully saved in '\\\"+str(path_out)+\\\"'.\\\\n\\\")\\n except Exception as e:\\n print(e)\",\n \"def main():\\n \\n lookupslocation = 'C:\\\\\\\\Users\\\\\\\\gwilliams\\\\\\\\Desktop\\\\\\\\Python Experiments\\\\\\\\work projects\\\\\\\\FaresIndexSourceData\\\\\\\\regulated_fares_data\\\\\\\\'\\n destination = 'C:\\\\\\\\Users\\\\\\\\gwilliams\\\\\\\\Desktop\\\\\\\\Python Experiments\\\\\\\\work projects\\\\\\\\FaresIndexSourceData\\\\\\\\regulated_fares_data\\\\\\\\comparison output\\\\\\\\'\\n lookupfileslist, count = getdata(lookupslocation)\\n\\n print(f\\\"there are {count} files found.\\\")\\n\\n newlookup = lookupfileslist[0]\\n oldlookup = lookupfileslist[1]\\n\\n #join new to old // old to new\\n new_uniquevalues = pd.merge(left=newlookup,right=oldlookup,how='left',\\n left_on=['orig','dest','route','ticket'],right_on=['orig','dest','route','ticket'])\\n\\n old_uniquevalues = pd.merge(left=newlookup,right=oldlookup,how='right',\\n left_on=['orig','dest','route','ticket'],right_on=['orig','dest','route','ticket'])\\n\\n print(\\\"These are values unique to new lookup\\\") \\n new_uniquevalues = new_uniquevalues[new_uniquevalues.ticketa.isnull()==True]\\n exportfile(new_uniquevalues,destination,'unique_new_values',1)\\n\\n print(\\\"These are values unique to old lookup\\\")\\n old_uniquevalues = old_uniquevalues[old_uniquevalues.new_flag.isnull()==True]\\n exportfile(old_uniquevalues,destination,'unique_old_values',1)\",\n \"def read_files(self):\\n\\n self.selecteddata = []\\n try:\\n for itemnum in self.selected:\\n dfileent = self.indexdata[itemnum]\\n fname = dfileent[0]\\n if not os.path.isabs(fname): fname = os.path.join(self.indexdir, fname)\\n ddata = self.dfparser.parsefile(fname)\\n if self.doppleradj.isChecked(): ddata = doppler.apply_doppler_array(ddata, dfileent[3])\\n self.selecteddata.append(ddata)\\n self.warningmsg.setText(\\\"\\\")\\n except datafile.Datafile_error as e:\\n self.warningmsg.setText(e.args[0] + \\\" file \\\" + e.filename + \\\" line \\\" + e.linenumber + \\\" col \\\" + e.colnumber)\\n self.selected = []\\n self.selecteddata = []\",\n \"def parse(self, **kwargs):\\n if 'qcschema' in self.node.inputs:\\n input_method = 'qcschema'\\n if 'psiapi' in self.node.inputs:\\n input_method = 'psiapi'\\n output_filename = PSI4_FILENAMES[input_method]['output']\\n\\n # Check that folder content is as expected\\n files_retrieved = self.retrieved.list_object_names()\\n files_expected = [output_filename]\\n # Note: set(A) <= set(B) checks whether A is a subset of B\\n if not set(files_expected) <= set(files_retrieved):\\n self.logger.error(\\\"Found files '{}', expected to find '{}'\\\".format(\\n files_retrieved, files_expected))\\n return self.exit_codes.ERROR_MISSING_OUTPUT_FILES\\n\\n # add outputs\\n self.logger.info(\\\"Parsing '{}'\\\".format(output_filename))\\n with self.retrieved.open(output_filename, 'rb') as handle:\\n\\n if input_method == 'psiapi':\\n log_node = SinglefileData(file=handle,\\n filename=output_filename)\\n\\n elif input_method == 'qcschema':\\n output_dict = json.loads(handle.read())\\n if not output_dict['success']:\\n return self.exit_codes.ERROR_CALCULATION_FAILED\\n\\n # remove stdout (don't want to store unparsed files in the database)\\n log_node = SinglefileData(\\n # note: in python3.9 with AiiDA 2.0 this can be simplified to\\n # file=io.StrinIO(''.join(output_dict['stdout'])),\\n file=io.BytesIO(\\n bytes(''.join(output_dict['stdout']),\\n encoding='utf8')),\\n filename=PSI4_FILENAMES['qcschema']['output'])\\n output_dict.pop('stdout')\\n\\n self.out('qcschema', orm.Dict(dict=output_dict))\\n\\n self.out('stdout', log_node)\\n\\n return ExitCode(0)\",\n \"def _clean_datafile_set(self):\\n file_list = self._meta['sets']['data file']['items']\\n for item in file_list[:]:\\n collection = item.split('@')[0]\\n variable = item.split('@')[1]\\n if not variable in self:\\n file_list.remove(item)\\n elif collection == 'masks':\\n for s in self._get_source_ref(variable):\\n while s in file_list:\\n file_list.remove(s)\\n elif self._is_array_item(variable):\\n parent = self.parents(variable)[0]\\n if not parent in file_list:\\n idx = file_list.index(item)\\n file_list[idx] = parent\\n while item in file_list:\\n file_list.remove(item)\\n f_list = []\\n for item in file_list:\\n if not item in f_list: f_list.append(item)\\n self._meta['sets']['data file']['items'] = f_list\\n return None\",\n \"def read_pfile(self, filename:str, filemode:str='vcnmodel.v0', vscale:float=1e-3, iscale:float=1e-9, plot=False):\\n \\n\\n # r = df['Results'][0]\\n #\\n # if plot:\\n # P = PH.Plotter((1, 1), figsize=(6, 4))\\n # cell_ax = list(P.axdict.keys())[0]\\n # for trial in range(len(df['Results'])):\\n # ds = df['Results'][trial]\\n # k0 = list(df['Results'][trial].keys())[0]\\n # dx = ds[k0]['monitor']\\n # P.axdict[cell_ax].plot(dx['time'], dx['postsynapticV'], linewidth=1.0)\\n # P.axdict[cell_ax].set_xlim(0., 150.)\\n # P.axdict[cell_ax].set_ylim(-200., 50.)\\n # PH.calbar(P.axdict[cell_ax], calbar=[120., -95., 25., 20.], axesoff=True, orient='left',\\n # unitNames={'x': 'ms', 'y': 'mV'}, font='Arial', fontsize=8)\\n #\\n # # mpl.savefig(outfile)\\n # mpl.show()\\n # print(list(df.keys()))\\n # print('\\\\nbasename: ', df['basename'])\\n # print('\\\\nruninfo: ', df['runInfo'])\\n \\\"\\\"\\\"\\n The runInfo dictionary holds somethign like this:\\n runinfo: {'folder': PosixPath('VCN_Cells/VCN_c08/Simulations/IV'), 'fileName': 'Normal', 'runName': 'Run', \\n 'manipulation': 'Canonical', 'preMode': 'cc', 'postMode': 'cc', 'TargetCellType': 'Bushy', \\n 'electrodeSection': 'soma', 'dendriticElectrodeSection': 'dendrite', \\n 'dendriticSectionDistance': 100.0, 'celsius': 37, 'nStim': 1, \\n 'stimFreq': 200.0, 'stimInj': {'pulse': [-1.0, 2.01, 0.2]}, \\n 'stimDur': 100.0, 'stimDelay': 5.0, 'stimPost': 3.0, \\n 'vnStim': 1, 'vstimFreq': 200.0, 'vstimInj': 50, \\n 'vstimDur': 50.0, 'vstimDelay': 2.0, 'vstimPost': 3.0, 'vstimHolding': -60, \\n 'gif_i0': 0.0, 'gif_sigma': 0.5, 'gif_fmod': 0.2, 'gif_tau': 3.0, \\n 'gif_dur': 10.0, 'gif_skew': 0.0, \\n 'runTime': 'Wed Oct 9 13:05:54 2019', \\n 'inFile': None, 'inFileRep': 1, 'spikeTimeList': {}, \\n 'v_init': -61.0, 'useSaveState': True, 'tstop': 8.0, 'filename': 'VCN_c08_pulse_'}\\n \\\"\\\"\\\"\\n # print('\\\\nmodelPars: ', df['modelPars'])\\n \\\"\\\"\\\"\\n The modelPars dict holds the following:\\n modelPars: {'species': 'mouse', 'cellClass': 'bushy', 'modelType': 'II', \\n 'modelName': 'mGBC', 'soma': True, 'axon': False, \\n 'dendrites': False, 'pumps': False, 'hillock': False, \\n 'initialsegment': False, 'myelinatedaxon': False, \\n 'unmyelinatedaxon': False, 'na': 'nav11', 'ttx': False, \\n 'name': 'bushy', 'morphology': 'VCN_Cells/VCN_c08/Morphology/VCN_c08.hoc', \\n 'temperature': 34.0}\\n \\n Note 10/28/2019 changed structure so that runInfo and modelPars are both \\n subdictionaries of Params (filemode is 'vcnmodel.v0')\\n ... and undone later, so that all are top-level (filemode is 'vcnmodel.v1')\\n \\\"\\\"\\\"\\n with open(filename, 'rb') as fh:\\n df = FPM.pickle_load(fh)\\n if filemode in ['vcnmodel.v0']:\\n print(f\\\"Reading model file in version v0:, with {len(df['Results']):4d} trials\\\")\\n elif filemode in ['vcnmodel.v1']:\\n print(f\\\"Reading model file in version v1:, with {len(df['Results']):4d} trials\\\")\\n else:\\n raise ValueError(f'Unknown file mode: {filemode:s}')\\n # print('\\\\nrpfile v0: File keys: ', df.keys())\\n #\\n # print('\\\\nrpfile v0: basename: ', df['basename'])\\n mtime = Path(filename).stat().st_mtime\\n timestamp_str = datetime.datetime.fromtimestamp(mtime).strftime('%Y-%m-%d-%H:%M')\\n if filemode == 'vcnmodel.v0':\\n # print(df['Params'].keys())\\n try:\\n dinfo = df['Params']['runInfo']\\n except:\\n try:\\n dinfo = df['runInfo']\\n except:\\n raise ValueError (\\\"Cannot read the file in v0 mode?\\\")\\n run_protocol = df['Params']['runProtocol']\\n if isinstance(dinfo, Params):\\n dinfo = dinfo.todict()\\n dur = dinfo['stimDur']\\n delay = dinfo['stimDelay']\\n mode = dinfo['postMode'].upper()\\n ntr = len(df['Results'])\\n # print(df.keys())\\n # print('runinfo: ', df['runInfo'])\\n # print('Params: ', df['Params'].keys())\\n # print('dinfo: ', dinfo)\\n if 'dt' in df['Params'].keys():\\n self.rate = df['Params']['dt']\\n else:\\n self.rate = df['Params'].dt\\n V = [[]]*ntr\\n I = [[]]*ntr\\n for i in range(len(df['Results'])):\\n fk = list(df['Results'][i].keys())[0]\\n dfx = df['Results'][i][fk]['monitor']\\n timebase = dfx['time']\\n V[i] = dfx['postsynapticV']*vscale\\n I[i] = dfx['i_stim0']*iscale\\n else:\\n dinfo = df['runInfo']\\n x = dir(dinfo)\\n if 'stimVC' not in x: # create fields for missing values from older versions of files.\\n dinfo.stimVC = None\\n # print('rpfile v0: dinfo: ', dinfo)\\n mode = dinfo.postMode.upper()\\n dur = dinfo.stimDur\\n delay = dinfo.stimDelay\\n mode = dinfo.postMode\\n print(\\\"Keys found in file: \\\", df.keys())\\n print('Mode: ', mode)\\n try:\\n self.rate = df['Params'].dt # old version, now separated IC and VC\\n except:\\n if mode == 'VC':\\n self.rate = df['Params'].dtVC\\n elif mode == \\\"CC\\\":\\n self.rate = df['Params'].dtIC\\n else:\\n raise ValueError(\\\"Cannot find rate for data mode: \\\", mode)\\n\\n run_protocol = dinfo.runProtocol\\n if dinfo.runProtocol in ['runIV', 'initIV', 'testIV']:\\n ntr = len(df['Results'])\\n V = [[]]*ntr\\n I = [[]]*ntr\\n for ii, i in enumerate(df['Results'].keys()):\\n dfx = df['Results'][i]['monitor']\\n timebase = dfx['time']\\n V[ii] = np.array(dfx['postsynapticV'])*vscale\\n I[ii] = np.array(dfx['i_stim0'])*iscale\\n elif dinfo.runProtocol in ['runVC', 'initVC', 'testVC']:\\n dur = dinfo.vstimDur # msec\\n delay = dinfo.vstimDelay # msec\\n ntr = len(df['Results'])\\n V = [[]]*ntr\\n I = [[]]*ntr\\n for ii, i in enumerate(df['Results'].keys()):\\n dfx = df['Results'][i]['monitor']\\n timebase = dfx['time']\\n V[ii] = np.array(dfx['postsynapticV'])*vscale\\n I[ii] = np.array(dfx['postsynapticI'])*iscale\\n \\n elif dinfo.runProtocol in ['initAN', 'runANPSTH', 'runANIO', 'runANSingles']:\\n\\n # two ways data can be organized, so try both\\n try: # cnmodel_models simulations\\n ntr = len(df['Results'])\\n V = [[]]*ntr\\n I = [[]]*ntr\\n for j in list(df['Results'].keys()):\\n dfx = df['Results'][j]\\n timebase = dfx['time']\\n V[j] = np.array(dfx['somaVoltage'])*vscale\\n I[j] = np.zeros_like(V[j])\\n except: # vcnmodel simulatipns\\n ntr = len(df[\\\"Results\\\"]['somaVoltage'])\\n V = [[]]*ntr\\n I = [[]]*ntr\\n for j in range(ntr):\\n timebase = df['Results']['time']\\n V[j] = np.array(df['Results']['somaVoltage'][j])*vscale\\n I[j] = np.zeros_like(V[j])\\n\\n V = np.array(V)\\n I = np.array(I)\\n # print('V shape: ', V.shape, 'I shape: ', I.shape, ' timebase: ', timebase.shape, V.shape[1]*self.rate, np.max(timebase))\\n # exit()\\n\\n if run_protocol in ['runVC', 'initVC', 'testVC']:\\n self.MC.set_clamps(dmode=mode, time=timebase, data=I, cmddata=V, tstart_tdur=[delay, dur])\\n else:\\n self.MC.set_clamps(dmode=mode, time=timebase, data=V, cmddata=I, tstart_tdur=[delay, dur])\\n self.MC.getClampData()\",\n \"def objectivefunctions(filelist, observationdatafile, distancefilename, root):\\r\\n global hydrograph, simulation_timestep, sim_time, P_prime\\r\\n P_prime = []\\r\\n for trialfile in filelist:\\r\\n hydrograph = []\\r\\n sim_time = []\\r\\n with Simulation(trialfile) as sim:\\r\\n node_object = Nodes(sim)\\r\\n root_location = node_object[root]\\r\\n simulation_timestep = time_difference.total_seconds()\\r\\n sim.step_advance(simulation_timestep)\\r\\n for step in sim:\\r\\n sim_time.append(sim.current_time)\\r\\n hydrograph.append(root_location.total_inflow)\\r\\n objFunc = [normalizedpeakerror(), normalizedvolumeerror(), nashsutcliffe(), NED(trialfile)]\\r\\n P_prime.append(objFunc)\\r\\n return objFunc\",\n \"def get_311_data():\\n # reading in data and saving to separate DFs\\n source = spark.read.csv(\\\"source.csv\\\", sep=\\\",\\\", header=True, inferSchema=True)\\n case = spark.read.csv(\\\"case.csv\\\", sep=\\\",\\\", header=True, inferSchema=True)\\n dept = spark.read.csv(\\\"dept.csv\\\", sep=\\\",\\\", header=True, inferSchema=True)\\n\\n # returning DFs\\n return source, case, dept\",\n \"def readin (filename, hdu=0, non_std_fits=False,\\n text_comments='#', text_skiprows=0, get_data=False, verbose=False,\\n apply_WCS_rv=False):\\n multi_order_txt = False\\n use_naxis2='all'\\n use_naxis3='all'\\n \\n \\n preferred_wlsoln=None # !! need to fix this\\n # !! should also be able to input wavelength solution?\\n \\n if preferred_wlsoln is not None: preferred_wlsoln = wlsolvefxn.get_func_name(preferred_wlsoln)\\n \\n #### check if file exists ####### #############\\n if not os.path.exists(filename): raise IOError(\\\"File does not exist:'\\\"+filename+\\\"'\\\")\\n\\n\\n #### check if file is text############# \\n np_kwargs = {'comments':text_comments,\\n 'skiprows':text_skiprows}\\n is_text_file, txt_data = check_for_txt_format(filename,**np_kwargs)\\n\\n #### if it is a text file ######################\\n if is_text_file:\\n spec_obj = readin_txt(filename,txt_data,get_data) \\n return spec_obj \\n\\n #### now check how it behaves as a fits file\\n if non_std_fits: hdulist = pyfits.open(filename)\\n else:\\n # give standard pyfits readin a try\\n try: hdulist = pyfits.open(filename)\\n except: raise IOError(\\\"PYFITS DOES NOT LIKE THE FILE YOU GAVE ('\\\"+filename+\\\"'), TO SEE WHAT ERROR IT GIVES TRY: hdulist = pyfits.open('\\\"+filename+\\\"')\\\")\\n\\n\\n #### open up fits file ##############################\\n hdulist = pyfits.open(filename)\\n\\n # select which header unit ot use\\n if len(hdulist) > 1: \\n hdu = int(hdu)\\n hdu = np.clip(hdu,0,len(hdulist)-1)\\n else: hdu = 0\\n\\n # specify the current header unit\\n header_unit = hdulist[hdu]\\n prihdr = header_unit.header\\n\\n # can display some useful information \\n if verbose: \\n print \\\"=\\\"*60\\n print (hdulist.info(),'\\\\n')\\n if len(hdulist) > 1:\\n print \\\"=\\\"*20+\\\" USING HEADER: \\\"+\\\"=\\\"*20\\n print repr(hdulist[hdu])\\n\\n ##### fill in the data class\\n # not get header info of relevance\\n simple = query_fits_header(prihdr,'SIMPLE',noval=False)\\n xtension = query_fits_header(prihdr,'XTENSION')\\n if simple.found:\\n if not simple.val: print \\\"HeadsUp: Header Keyword SIMPLE is False, you may encounter unexpected behavior\\\"\\n else:\\n if not xtension.found: print \\\"HeadsUp: No extension keyword found in headers, you may encounter unexpected behavior\\\"\\n \\n \\n #### read in important information from header, if present\\n ibits = query_fits_header(prihdr,'BITPIX') # how many bits per pixel in the data? Not currently necessary, numpy will adapt\\n \\n naxis = query_fits_header(prihdr,'NAXIS' ,noval=0) # how many dimenstions?\\n naxis1 = query_fits_header(prihdr,'NAXIS1',noval=0) # number of points per order\\n naxis2 = query_fits_header(prihdr,'NAXIS2',noval=0) # number of orders\\n naxis3 = query_fits_header(prihdr,'NAXIS3',noval=0) # number of different spectra\\n\\n apformat = query_fits_header(prihdr,'APFORMAT')\\n if apformat.found: print \\\"WARNING: I'M NOT SURE HOW TO DEAL WITH APFORMAT VALUES\\\" # !! though I think it's just the spec files\\n\\n if not naxis.found: raise IOError(\\\"ERROR: Keyword NAXIS not found\\\")\\n\\n bzero = query_fits_header(prihdr,\\\"BZERO\\\",noval=0)\\n bscale = query_fits_header(prihdr,\\\"BSCALE\\\",noval=1)\\n\\n ###### read in data ##############################################\\n data = header_unit.data\\n\\n if data is None:\\n wl, data, inv_var = np.zeros(3).reshape((3,1))\\n if get_data: return (wl,data,inv_var)\\n else: return eyeSpec_spec(wl,data,inv_var,header_unit.header)\\n else:\\n # check that data matches up with at least one of the dimensions\\n if data.ndim != naxis.val: raise ValueError(\\\"Dimension of data \\\"+str(data.ndim)+\\\" does not match keyword naxis \\\"+str(naxis.val))\\n \\n statement = 'Dimension does not match data.shape = '+str(data.shape)+\\\" fits file (naxis1, naxis2, naxis3) \\\"+str(tuple([naxis1.val,naxis2.val,naxis3.val]))\\n if data.ndim == 1: \\n assert data.shape == (naxis1.val,) , statement\\n data = data.reshape((1,1,)+data.shape)\\n \\n elif data.ndim == 2: \\n assert data.shape == (naxis2.val, naxis1.val), statement\\n data = data.reshape((1,)+data.shape) \\n \\n elif data.ndim == 3: \\n assert data.shape == (naxis3.val, naxis2.val, naxis1.val), statement\\n \\n ##### Determine the which data is useful \\n # which orders to read in \\n nband = np.arange(data.shape[0])+1\\n nord = np.arange(data.shape[1])+1\\n\\n \\n ##### Calculate the wavelengths for the data\\n # set up wavelength and inverse_variance\\n wl = np.ones(data.shape)\\n \\n # get the wavelength coefficients\\n wlcoeff = wlsoln_coeff_from_header(header_unit.header, apply_WCS_rv, preferred_wlsoln)\\n \\n # the same wavelength solution is applied to all bands so just pick the first and broadcast\\n band = 0\\n priv_info = {}\\n \\n # go through all the orders\\n do_progress = True\\n progressive_pt = 1 # this will advance and be used when there is no wavelength solution\\n for i in xrange(len(nord)):\\n order_i = nord[i]\\n\\n # get the coefficients and function type \\n equ_type = wlcoeff.get_equation_type()\\n if equ_type in ['none',None,'no solution'] and do_progress: \\n coeff = [progressive_pt,1]\\n equ_type = 'pts'\\n else: coeff = wlcoeff.get_coeffs(order_i)\\n \\n # pts[0] = 1 :: this was definitely the right thing to do for SPECTRE's 1-D output but may not be for other equations, may need pts[0]=0, this may be for bzero,bscale\\n pts = np.arange(len(wl[0][i]))+1 \\n # apply function\\n wl[0][i] = wlsolvefxn(pts, coeff, equ_type) \\n \\n progressive_pt += len(pts)\\n \\n for j in xrange(len(nband)): \\n band_j = nband[j]\\n if (band_j,order_i) not in priv_info: priv_info[(band_j,order_i)] = {} \\n # record the private information\\n priv_info[(band_j,order_i)]['disp']= [coeff, equ_type]\\n priv_info[(band_j,order_i)]['rv'] = [0] \\n priv_info[(band_j,order_i)]['disp extr'] = deepcopy(wlcoeff.extra)\\n \\n # now propogate the solution to the other bands\\n stdwl = wl[0]\\n for i in xrange(1,len(nband)): wl[i] = stdwl \\n \\n inv_var = np.ones(data.shape)\\n #=================================================================#\\n # return the data .OR. go on and create the spec_obj\\n if get_data: return (wl, data, inv_var)\\n\\n #=================================================================# \\n spec_obj = eyeSpec_spec(wl,data,inv_var,header_unit.header)\\n # set up private information\\n priv_info['filename'] = filename\\n spec_obj.filename = filename\\n \\n bands = np.array(np.arange(1,len(data)+1),dtype=str)\\n band_info = {}\\n i = -1\\n for key in prihdr.keys():\\n if key[:6] != 'BANDID': continue\\n if i < len(bands):\\n i+=1\\n bands[i] = prihdr[key]\\n band_info[key] = prihdr[key]\\n else: raise IOError(\\\"MORE BANDID KEYWORDS IN HEADER THAN FIRST DIMENSION OF DATA\\\") \\n\\n # add band info if available:\\n if len(band_info) != 0: priv_info['bandids'] = band_info\\n else: priv_info['bandids'] = None\\n \\n # match up the private info created during read in to the spec_obj\\n for key in priv_info: spec_obj._private_info[key] = priv_info[key]\\n \\n # map fits value => acutal index\\n # spec_obj._bands = {}\\n # spec_obj._orders = {}\\n # for i in range(len(nspec)): spec_obj._bands[nspec[i]] = i\\n # for i in range(len(nord)): spec_obj._orders[nord[i]] = i\\n # \\n \\n if 7 in nband: spec_obj.set_band(6) # this is where Magellian data stores it's object data, i.e. BANDID7 which is index 6\\n\\n if len(hdulist) > 1: spec_obj.hdrlist = [h.header for h in hdulist]\\n \\n return spec_obj\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n # use the func to insert data from these files to database's fact and dim tables\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def load_function(self):\\n self._fn = from_pickle(\\n read_from_disk(os.path.join(self.location, FNCT_NM))\\n )\\n\\n if self.farmer is not None:\\n if self.farmer.fn is None:\\n self.farmer.fn = self._fn\\n else:\\n # TODO: check equality?\\n raise XYZError(\\n \\\"Trying to load this Crop's function, {}, from \\\"\\n \\\"disk but its farmer already has a function \\\"\\n \\\"set: {}.\\\".format(self._fn, self.farmer.fn)\\n )\",\n \"def calc(main_system,dir_db,dir_def,xlfile,mu_limit,functional=\\\"GGA\\\",soc=False,logfile=None):\\n \\n ## set up logging\\n if logfile:\\n myLogger = logging.setup_logging(logfile)\\n else:\\n myLogger = logging.setup_logging()\\n\\n\\n ## load list of dataframes from sheets from excel file \\n df = pd.read_excel(os.path.join(dir_def,xlfile),sheet_name=None)\\n \\n \\n ## find initdef.json file\\n if osutils.check_file_exists(dir_def,\\\"initdef\\\") == True:\\n for file in os.listdir(dir_def): \\n if file.startswith(\\\"initdef\\\"):\\n file_initdef = file\\n ## get species i and ni from initdefect.json file \\n with open(os.path.join(dir_def,file_initdef), 'r') as file:\\n initdef = json.loads(file.read())\\n species_list, ni_list = [],[]\\n for defect in initdef:\\n species, ni = get_i_ni(initdef[defect])\\n species_list += species\\n ni_list += ni\\n myLogger.info(\\\"Atoms added/removed: \\\" + \\\\\\n \\\", \\\".join([str(n)+\\\"*\\\"+i for n,i in zip(ni_list,species_list)]))\\n\\n \\n for q in [qi for qi in df.keys()]:\\n \\n ## get the relevant chemical potentials\\n found_mu = True\\n for species in species_list:\\n mu = \\\"mu_%s_%s\\\"%(species,mu_limit)\\n \\n ## check if the relevant database entry exists\\n if osutils.check_file_exists(dir_db,\\\"%s.json\\\"%species) == True:\\n dbentry_file = \\\"%s.json\\\"%species\\n with open(os.path.join(dir_db, dbentry_file), 'r') as file:\\n mater = json.loads(file.read())\\n ## search for appropriate mu entry\\n mu_key = \\\"mu\\\"\\n for key in mater[functional].keys():\\n if key.startswith(\\\"mu_%s\\\"%mu_limit):\\n mu_key = key\\n myLogger.info(\\\"Using chemical potential \\\" + mu_key + \\\" from \\\" + dbentry_file) \\n ## input the corresponding mus into the dataframe\\n df[q][mu] = mater[functional][mu_key]\\n \\n else:\\n myLogger.info(\\\"Cannot find the database entry for \\\" + species)\\n found_mu = False\\n \\n \\n ## get the VBMs\\n ## check if the relevant database entry exists\\n if osutils.check_file_exists(dir_db,\\\"%s.json\\\"%main_system) == True:\\n dbentry_file = \\\"%s.json\\\"%(main_system)\\n with open(os.path.join(dir_db, dbentry_file), 'r') as file:\\n mater = json.loads(file.read()) \\n \\n ## input the VBMs corresponding to each vacuum spacing into the dataframe\\n for rowind in df[q].index.values:\\n vac = df[q].loc[rowind].vacuum\\n if vac in mater[functional].keys():\\n df[q].at[rowind,'VBM'] = mater[functional][vac][\\\"VBM\\\"]\\n else:\\n myLogger.info(\\\"Cannot find the VBM entry for \\\" + vac) \\n \\n ## Finally, we can compute the uncorrected defect formation energy:\\n ## Eform = Etot(def) - Etot(pristine) - sum(n_i*mu_i) + q*E_Fermi\\n if found_mu:\\n ## proceed if chemical potentials and VBMs have been correctly entered\\n sum_mu = 0\\n for n,species in zip(ni_list,species_list):\\n mu = \\\"mu_%s_%s\\\"%(species,mu_limit)\\n sum_mu += n * df[q][mu]\\n if q == 'charge_0': \\n colname = \\\"E_form_corr\\\"\\n else:\\n colname = \\\"E_form_uncorr\\\"\\n df[q][colname] = df[q].loc[:,'E_def'] \\\\\\n - df[q].loc[:,'E_bulk'] \\\\\\n - sum_mu \\\\\\n + int(q.split(\\\"_\\\")[-1]) * df[q].loc[:,'VBM'] \\n \\n else:\\n myLogger.info(\\\"Cannot find the database entry for \\\" + main_system)\\n\\n\\n ## write the updated excel file\\n writer = pd.ExcelWriter(os.path.join(dir_def,xlfile))\\n for q in df.keys(): \\n df[q].to_excel(writer, q, index=False)\\n writer.save()\",\n \"def apply(self):\\n\\n sc = SparkContext(appName=\\\"Model Applier\\\")\\n sqlContext = SQLContext(sc)\\n\\n # Add model and supporting files to SparkContext\\n for item in self.model_location_dict.items():\\n ModelApplier.add_files_to_context(item[1], sc)\\n\\n partition_processor = self.get_partition_processor()\\n infile = sc.textFile(self.input_location)\\n header_line = infile.first()\\n infile = infile.filter(lambda x: x != header_line)\\n\\n result = infile.mapPartitions(partition_processor).flatMap(lambda x: x)\\n print('result.class', result.__class__)\\n\\n result = result.map(lambda (x, a, y, segment, model_version):\\n (int(x), float(a), float(y), segment, model_version))\\n sqlContext.createDataFrame(result).saveAsParquetFile(self.output_location)\",\n \"def analyze_data(inputFileList, **kwargs):\\n OBSKEY = 'OBSTYPE'\\n MTKEY = 'MTFLAG'\\n SCNKEY = 'SCAN_TYP'\\n FILKEY = 'FILTER'\\n FILKEY1 = 'FILTER1'\\n FILKEY2 = 'FILTER2'\\n APKEY = 'APERTURE'\\n TARKEY = 'TARGNAME'\\n EXPKEY = 'EXPTIME'\\n FGSKEY = 'FGSLOCK'\\n CHINKEY = 'CHINJECT'\\n\\n acsFiltNameList = [FILKEY1, FILKEY2]\\n\\n catalog = None # Astrometric catalog used for alignment\\n catalogSources = 0 # Number of astrometric catalog sources determined based upon coordinate overlap with image WCS\\n foundSources = 0 # Number of sources detected in images\\n matchSources = 0 # Number of sources cross matched between astrometric catalog and detected in image\\n rms_x = -1.0\\n rms_y = -1.0\\n rms_ra = -1.0\\n rms_dec = -1.0\\n chisq_x = -1.0\\n chisq_y = -1.0\\n completed = False # If true, there was no exception and the processing completed all logic\\n dateObs = None # Human readable date\\n mjdutc = -1.0 # MJD UTC start of exposure\\n fgslock = None\\n processMsg = None\\n status = 9999\\n compromised = 0\\n headerletFile = None\\n\\n fit_rms = -1.0\\n total_rms = -1.0\\n datasetKey = -1.0\\n\\n namesArray = ('imageName', 'instrument', 'detector', 'filter', 'aperture', 'obstype',\\n 'subarray', 'dateObs', 'mjdutc', 'doProcess', 'processMsg', 'catalog', 'foundSources',\\n 'catalogSources','matchSources', 'rms_x', 'rms_y', 'rms_ra', 'rms_dec', 'completed',\\n 'fit_rms', 'total_rms', 'datasetKey', 'status', 'headerletFile')\\n dataType = ('S20', 'S20', 'S20', 'S20', 'S20', 'S20', 'b', 'S20', 'f8', 'b', 'S30',\\n 'S20', 'i4', 'i4', 'i4', 'f8', 'f8', 'f8', 'f8', 'b', 'f8', 'f8', 'i8', 'i4', 'S30')\\n\\n # Create an astropy table\\n outputTable = Table(names=namesArray,dtype=dataType)\\n\\n # Loop over the list of images to determine viability for alignment processing\\n #\\n # Capture the data characteristics before any evaluation so the information is\\n # available for the output table regardless of which keyword is used to \\n # to determine the data is not viable for alignment.\\n\\n for inputFile in inputFileList:\\n\\n header_hdu = 0\\n header_data = getheader(inputFile, header_hdu)\\n\\n # Keywords to use potentially for downstream analysis\\n instrume = (header_data['INSTRUME']).upper()\\n detector = (header_data['DETECTOR']).upper()\\n subarray = header_data['SUBARRAY']\\n dateObs = header_data['DATE-OBS']\\n mjdutc = header_data['EXPSTART']\\n\\n # Obtain keyword values for analysis of viability\\n obstype = (header_data[OBSKEY]).upper()\\n mtflag = (header_data[MTKEY]).upper()\\n \\n scan_typ = ''\\n if instrume == 'WFC3':\\n scan_typ = (header_data[SCNKEY]).upper()\\n\\n sfilter = ''\\n if instrume == 'WFC3':\\n sfilter = (header_data[FILKEY]).upper()\\n # Concatenate the two ACS filter names together with an underscore\\n # If the filter name is blank, skip it\\n if instrume == 'ACS':\\n for filtname in acsFiltNameList:\\n\\n # The filter keyword value could be zero or more blank spaces \\n # Strip off any leading or trailing blanks\\n if len(header_data[filtname].upper().strip()) > 0:\\n\\n # If the current filter variable already has some content,\\n # need to append an underscore before adding more text\\n if len(sfilter) > 0:\\n sfilter += '_'\\n sfilter += header_data[filtname].upper().strip()\\n\\n aperture = (header_data[APKEY]).upper()\\n targname = (header_data[TARKEY]).upper()\\n exptime = header_data[EXPKEY]\\n fgslock = (header_data[FGSKEY]).upper()\\n\\n chinject = 'NONE'\\n if instrume == 'WFC3' and detector == 'UVIS':\\n chinject = (header_data[CHINKEY]).upper()\\n\\n # Determine if the image has one of these conditions. The routine\\n # will exit processing upon the first satisfied condition.\\n\\n noProcKey = None\\n noProcValue = None\\n doProcess = True\\n # Imaging vs spectroscopic or coronagraphic\\n if obstype != 'IMAGING':\\n noProcKey = OBSKEY\\n noProcValue = obstype \\n\\n # Moving target\\n elif mtflag == 'T':\\n noProcKey = MTKEY\\n noProcValue = mtflag \\n\\n # Bostrophidon without or with dwell (WFC3 only)\\n elif any ([scan_typ == 'C', scan_typ == 'D']):\\n noProcKey = SCNKEY\\n noProcValue = scan_typ\\n\\n # Filter which does not begin with: 'F'(F###), 'C'(CLEAR), 'N'(N/A), and is not blank\\n # The sfilter variable may be the concatenation of two filters (F160_CLEAR)\\n elif sfilter[0] != 'F' and sfilter[0] != '' and sfilter[0] != 'C' and sfilter[0] != 'N': \\n noProcKey = FILKEY\\n noProcValue = sfilter\\n\\n elif '_' in sfilter:\\n pos = sfilter.index('_')\\n pos += 1\\n\\n if sfilter[pos] != 'F' and sfilter[pos] != '' and sfilter[pos] != 'C' and sfilter[pos] != 'N': \\n noProcKey = FILKEY\\n noProcValue = sfilter\\n\\n # Ramp, polarizer, grism, or prism \\n elif any (x in aperture for x in ['RAMP', 'POL', 'GRISM', '-REF', 'PRISM']):\\n noProcKey = APKEY\\n noProcValue = aperture \\n\\n # Calibration target\\n elif any (x in targname for x in ['DARK', 'TUNG', 'BIAS', 'FLAT', 'DEUT', 'EARTH-CAL']):\\n noProcKey = TARKEY\\n noProcValue = targname\\n\\n # Exposure time of effectively zero\\n elif math.isclose(exptime, 0.0, abs_tol=1e-5):\\n noProcKey = EXPKEY\\n noProcValue = exptime \\n\\n # Commanded FGS lock\\n elif any (x in fgslock for x in ['GY', 'COARSE']):\\n noProcKey = FGSKEY\\n noProcValue = fgslock\\n\\n # Charge injection mode\\n elif chinject != 'NONE':\\n noProcKey = CHINKEY\\n noProcValue = chinject\\n\\n # If noProcKey is set to a keyword, then this image has been found to not be viable for\\n # alignment purposes.\\n if (noProcKey is not None):\\n if (noProcKey != FGSKEY):\\n doProcess = False\\n msgType = Messages.NOPROC.value\\n else:\\n msgType = Messages.WARN.value\\n\\n processMsg = noProcKey + '=' + str(noProcValue)\\n\\n # Issue message to log file for this data indicating no processing to be done or \\n # processing should be allowed, but there may be some issue with the result (e.g., \\n # GYROS mode so some drift)\\n generate_msg(inputFile, msgType, noProcKey, noProcValue)\\n\\n # Populate a row of the table\\n outputTable.add_row([inputFile, instrume, detector, sfilter, aperture, obstype,\\n subarray, dateObs, mjdutc, doProcess, processMsg, catalog, \\n foundSources, catalogSources, matchSources, rms_x, rms_y, \\n rms_ra, rms_dec, completed, fit_rms, total_rms, datasetKey,\\n status, headerletFile])\\n #outputTable.pprint(max_width=-1)\\n\\n return(outputTable)\",\n \"def run_analysis(self):\\n\\n self._apply_loads_to_framat_model()\\n\\n # ----- Run the FramAT analysis -----\\n results = standard_run(args=StdRunArgs(filename=self.own_files['model_file'], verbose=True))\\n self.last_solution = results\\n\\n # ----- Share loads -----\\n logger.info(\\\"Sharing loads...\\\")\\n frame = results['frame']\\n self.shared.structure.def_fields = frame.deformation.get_displacement_fields(frame, n_sup=1000)\",\n \"def CollectingData(boundaries, target_lon, target_lat, files, basepath, \\\\\\n CAMS_path, apply_land_sea_mask, use_wind_rotations, \\\\\\n incorporate_cams):\\n # Setting the time of starting the script\\n start = datetime.now()\\n \\n # Reading daily csv files for specified area and day as np.arrays\\n daily_data = {}\\n for i, file in enumerate(files): \\n # Reading daily csv's as input array\\n daily_data[i] = inpt.CSVtoArray(file, boundaries, target_lon, target_lat)\\n \\n # Remove background, by CAMS observations\\n if incorporate_cams:\\n dates = [daily_data[i]['day'], daily_data[i]['month'], daily_data[i]['year']]\\n bbox = [daily_data[i]['lat_min'], daily_data[i]['lat_max'], daily_data[i]['lon_min'], daily_data[i]['lon_max']]\\n xres = int((110 * (bbox[3]-bbox[2])) / len(daily_data[i]['CO_ppb'][0]))\\n yres = int((110 * (bbox[1]-bbox[0])) / len(daily_data[i]['CO_ppb']))\\n cams_arr = cams.FetchCams(CAMS_path, dates, bbox, xres, yres)\\n daily_data[i]['CO_excl_background'] = daily_data[i]['CO_ppb'] - cams_arr\\n \\n # Filter measurements taken above the oceans (higher uncertainty)\\n if apply_land_sea_mask:\\n daily_data[i]['CO_ppb'] = mask.land_sea_mask(daily_data[i]['CO_ppb'], boundaries)\\n daily_data[i]['count_t'] = mask.land_sea_mask(daily_data[i]['count_t'], boundaries)\\n \\n # collect meteodata via ECMWF CDS API:\\n if use_wind_rotations:\\n u_wind, v_wind = wind.FetchWindData(daily_data[i], pressure=700, timerange=6, basepath=basepath)\\n daily_data[i]['u_wind'] = u_wind\\n daily_data[i]['v_wind'] = v_wind\\n \\n print('Total time elapsed reading data: {}'.format(datetime.now()-start))\\n\\n return daily_data\",\n \"def try_blackbox_reduce (filename):\\n\\n try:\\n filename_reduced = blackbox_reduce (filename)\\n except:\\n filename_reduced = None\\n raise WrapException()\\n\\n return filename_reduced\",\n \"def retrieve_additional_files(input_qchem, data_fchk, work_dir, scratch_read_level=0):\\n\\n additional_data = {}\\n\\n natom = len(input_qchem.molecule.get_coordinates())\\n file_list = os.listdir(work_dir)\\n\\n # OLD_DIMENSIONS\\n if '819.0' in file_list:\\n with open(work_dir + '819.0', 'r') as f:\\n data = np.fromfile(f, dtype=np.int32)\\n norb_alpha, norb_beta = data[0:2]\\n norb = norb_alpha\\n nbas = norb # assumption\\n else:\\n norb = np.shape(data_fchk['coefficients']['alpha'])[0]\\n nbas = np.shape(data_fchk['coefficients']['alpha'])[1]\\n\\n\\n # MO_COEFS (Already in fchk) in internal order\\n if '53.0' in file_list and 'coefficients' in data_fchk:\\n with open(work_dir + '53.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n mo_alpha = data[:norb*nbas].reshape(-1, norb).tolist()\\n mo_beta = data[norb*nbas: 2*norb_beta*nbas].reshape(-1, norb_beta).tolist()\\n # additional_data['coefficients_internal'] = {'alpha': mo_alpha, 'beta': mo_beta}\\n\\n # obtain the order indices between fchk order and Q-Chem internal order of basis functions\\n diff_square = get_sdm(data_fchk['coefficients']['alpha'], mo_alpha)\\n\\n # get non-repeating indices\\n indices = []\\n for row in diff_square.T:\\n for i in np.argsort(row):\\n if i not in indices:\\n indices.append(int(i))\\n break\\n\\n # indices = np.argmin(diff_square, axis=0).tolist()\\n\\n # store q-chem index order for later use (e.g guess)\\n data_fchk['coefficients']['qchem_order'] = indices\\n else:\\n indices = list(range(nbas))\\n\\n # FOCK_MATRIX\\n if '58.0' in file_list:\\n with open(work_dir + '58.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n fock_alpha = data[:nbas*nbas].reshape(-1, nbas)\\n fock_beta = data[nbas*nbas: 2*nbas*nbas].reshape(-1, nbas)\\n\\n # set basis functions in fchk order\\n fock_alpha = fock_alpha[:, indices]\\n fock_alpha = fock_alpha[indices, :]\\n fock_beta = fock_beta[:, indices]\\n fock_beta = fock_beta[indices, :]\\n\\n additional_data['fock_matrix'] = {'alpha': fock_alpha.tolist(), 'beta': fock_beta.tolist()}\\n\\n if scratch_read_level == -1:\\n # FILE_ENERGY (Not really worth to read it)\\n if '99.0' in file_list:\\n with open(work_dir + '99.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n\\n # FILE_DENSITY_MATRIX (Already in fchk)\\n if '54.0' in file_list:\\n with open(work_dir + '54.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n density_alpha = data[:nbas*nbas].reshape(-1, nbas)\\n density_beta = data[nbas*nbas: 2*nbas*nbas].reshape(-1, nbas)\\n # set basis functions in fchk order\\n density_alpha = density_alpha[:, indices]\\n density_alpha = density_alpha[indices, :]\\n density_beta = density_beta[:, indices]\\n density_beta = density_beta[indices, :]\\n additional_data['scf_density_internal'] = {'alpha': density_alpha.tolist(), 'beta': density_beta.tolist()}\\n\\n # HESSIAN_MATRIX\\n if '132.0' in file_list:\\n with open(work_dir + '132.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n hessian = data.reshape(-1, natom*3)\\n additional_data['hessian'] = hessian.tolist()\\n\\n # AO_INTS_DEBUG\\n if '21.0' in file_list:\\n with open(work_dir + '21.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n ao_integrals = data.reshape(-1, nbas, nbas, nbas)\\n\\n # set basis functions in fchk order\\n ao_integrals = ao_integrals[:, :, :, indices]\\n ao_integrals = ao_integrals[:, :, indices, :]\\n ao_integrals = ao_integrals[:, indices, :, :]\\n ao_integrals = ao_integrals[indices, :, :, :]\\n\\n additional_data['ao_integrals'] = ao_integrals.tolist()\\n\\n if scratch_read_level > 0:\\n # FILE_RAS_AMP\\n if '704.0' in file_list:\\n with open(work_dir + '705.0', 'r') as f:\\n ras_energies = np.fromfile(f, dtype=float)\\n n_ras_roots = len(ras_energies)\\n\\n with open(work_dir + '704.0', 'r') as f:\\n data = np.fromfile(f, dtype=float)\\n ras_amplitudes = data.reshape(n_ras_roots, -1)\\n additional_data['ras_amplitudes'] = ras_amplitudes.tolist()\\n\\n return additional_data\",\n \"def fill_nan(data, fm, filename):\\r\\n print(\\\"fill Nan begining...\\\")\\r\\n\\r\\n # fill categorical variable\\r\\n categorical_variable_fill = pd.read_excel(\\\"./data/VariableFill.xlsx\\\", dtype={'Name': str, 'Value': float})\\r\\n categorical_features = categorical_variable_fill['Variable'].values\\r\\n categorical_variable_fill.set_index('Variable', inplace=True)\\r\\n for cat_col in categorical_features:\\r\\n data[cat_col].fillna(categorical_variable_fill.loc[cat_col, 'Fill'], inplace=True)\\r\\n\\r\\n # fill continue variable\\r\\n columns_name = list(data.columns.values)\\r\\n feature_name = list(fm.keys())\\r\\n\\r\\n for col in columns_name:\\r\\n if col in feature_name:\\r\\n for i in range(len(data)):\\r\\n # 填充空值\\r\\n if np.isnan(data.loc[i, col]):\\r\\n if len(fm[col]) == 4:\\r\\n data.loc[i, col] = uniform(fm[col]['low'], fm[col]['up'], 1)\\r\\n data.loc[i, col+'Grade2'] = fm[col]['grade2']\\r\\n else:\\r\\n if data.loc[i, 'Gender'] == 1:\\r\\n data.loc[i, col] = uniform(fm[col]['F']['low'], fm[col]['F']['up'], 1)\\r\\n data.loc[i, col+'Grade2'] = fm[col]['F']['grade2']\\r\\n elif data.loc[i, 'Gender'] == 0:\\r\\n data.loc[i, col] = uniform(fm[col]['M']['low'], fm[col]['M']['up'], 1)\\r\\n data.loc[i, col + 'Grade2'] = fm[col]['M']['grade2']\\r\\n\\r\\n data.to_csv('./data/'+filename+'processed_data.csv', index=False)\\r\\n print(\\\"fill Nan finished! processed data is saved in ./data/processed_data.csv\\\")\\r\\n return data\",\n \"def execute(self):\\n try:\\n spark_context = self.spark.sparkContext\\n spark_context.addFile(self.location)\\n return self.spark.read.format(self.file_format) \\\\\\n .load(SparkFiles.get(self.location.split('/')[-1]))\\n except AnalysisException as exp:\\n raise\",\n \"def run(self, data_file: Optional[str] = None):\\n\\n \\n\\n # Pandas DF of 'list' files\\n #cpd_list_df = pd.read_csv(self.cpd_list, low_memory=False, sep='\\\\t')\\n #path_list_df = pd.read_csv(self.path_list, low_memory=False, sep='\\\\t')\\n #rn_list_df = pd.read_csv(self.rn_list, low_memory=False, sep='\\\\t')\\n #ko_list_df = pd.read_csv(self.ko_list, low_memory=False, sep='\\\\t')\\n #cpd_to_chebi_df = pd.read_csv(self.cpd2chebi, low_memory=False, sep='\\\\t')\\n\\n # Pandas DF of 'kegg-*.tsv' files\\n \\n path_df = self.prune_columns(pd.read_csv(self.full_path, low_memory=False, sep='\\\\t', usecols=['ENTRY', 'NAME', 'DBLINKS']), 'path')\\n rn_df = self.prune_columns(pd.read_csv(self.full_rn, low_memory=False, sep='\\\\t', usecols=['ENTRY', 'DEFINITION', 'EQUATION', 'DBLINKS']), 'rn')\\n ko_df = self.prune_columns(pd.read_csv(self.full_ko, low_memory=False, sep='\\\\t', usecols=['ENTRY', 'DEFINITION', 'DBLINKS']), 'ko')\\n \\n ## **********************************************************************\\n # Establishing 1-to-1 relation between KO and XRefs (['DBLINKS'] column)\\n ##***********************************************************************\\n\\n # Explode DBLINKS in ko_df to separate rows\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).split('|'))\\n ko_df = ko_df.explode('DBLINKS')\\n\\n #ko_df['ID'] = ko_df['ID'].apply(lambda row : 'ko:'+str(row))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).replace('RN: ', 'KEGG.REACTION:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('COG: ', 'COG:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('GO: ', 'GO:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('TC: ', 'tcdb:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('CAZy: ', 'cazy:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row : str(row).strip().replace('UniProt: ', 'uniprot:'))\\n ko_df['DBLINKS'] = ko_df['DBLINKS'].apply(lambda row: str(row).split(' '))\\n # Add prefixes to all DBLINKS\\n ko_df['DBLINKS'] = ko_df['DBLINKS'] \\\\\\n .apply(lambda row: [str(row[0])]+[str(row[0])\\n .split(':')[0] + ':'+ x \\\\\\n for x in row \\\\\\n if not str(x).startswith(str(row[0]).split(':')[0]+ ':')])\\n\\n ko_df['DBLINKS'] = ['|'.join(map(str, l)) for l in ko_df['DBLINKS']]\\n # Roll up to consolidated rows\\n ko_df = ko_df.groupby(['ID', 'DESCRIPTION'], as_index=False).agg({'DBLINKS': lambda x: '|'.join(x)})\\n ##########################################################################\\n\\n node_dict: dict = defaultdict(int)\\n edge_dict: dict = defaultdict(int)\\n\\n df_dict = {\\n 'pathway': path_df,\\n 'rn': rn_df,\\n 'ko': ko_df\\n }\\n\\n node_dict, edge_dict = self.post_data(self.path_cpd_link, node_dict, edge_dict, df_dict, 'w')\\n node_dict, edge_dict = self.post_data(self.rn_cpd_link, node_dict, edge_dict, df_dict, 'a')\\n node_dict, edge_dict = self.post_data(self.path_rn_link, node_dict, edge_dict, df_dict, 'a')\\n node_dict, edge_dict = self.post_data(self.path_ko_link, node_dict, edge_dict, df_dict, 'a')\\n node_dict, edge_dict = self.post_data(self.rn_ko_link, node_dict, edge_dict, df_dict, 'a')\\n \\n\\n return None\",\n \"def FLargeFile(inputFile = 'New_2006-2013_FilteredColsTargetMissingBlank.csv', outputFolderPath = './Feature Selection 2006-2013'):\\n\\ttargetList = [2704,2707,2713,2716,2718,808,811,835]\\n\\twith open(inputFile,'rb') as f:\\n\\t reader = csv.reader(f)\\n\\t header = next(reader)\\n\\t num_cols = len(header)\\n\\t f.close()\\n\\tdataset = np.genfromtxt(inputFile, delimiter=\\\",\\\", skip_header=1, autostrip=True, missing_values=np.nan, usecols=tuple(range(1,num_cols)))\\n\\n\\tfor target in range(len(targetList)):\\n\\t\\tX = dataset[:,8:dataset.shape[1]]\\n\\t\\ty = dataset[:,target]\\n\\t\\t\\n\\t\\tnewX = np.array([X[j] for j in range(X.shape[0]) if not np.isnan(y[j])])\\n\\t\\tdeleteMissingY = np.array([x1 for x1 in y if not np.isnan(x1)])\\n\\n\\t\\tk = newX.shape[1]\\n\\t\\tselection = SelectKBest(f_regression, k=k)\\n\\t\\timputedX_new = selection.fit_transform(newX, deleteMissingY)\\n\\n\\t\\tselectedFeatures = [[item, selection.scores_[idx], selection.pvalues_[idx]] for idx, item in enumerate(header[9:]) if selection.get_support()[idx]]\\n\\t\\tselectedFeatures.sort(key=lambda x: x[1], reverse=True)\\n\\n\\t\\trows = []\\n\\t\\trows.append([targetList[target], 'score', 'p-value'])\\n\\t\\trows.extend(selectedFeatures)\\n\\n\\t\\tfilename = outputFolderPath+'/'+('AllYear - Indicator%d - k%d - %s.csv' % (targetList[target], k, 'f_regression'))\\n\\t\\twriteCSV(filename,rows)\",\n \"def load_data():\\n\\t\\t# load the data\\n\\t\\tDATPATH = \\\"../data/\\\"\\n\\t\\t#fnino = DATPATH + \\\"nino3.csv\\\" # 1871-2000\\n\\t\\tfnino = DATPATH + \\\"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\\\" # 1871-2016\\n\\t\\t#fnino = DATPATH + \\\"nino34.long.data\\\"\\n\\t\\t#nc_data_nino3 = netCDF4.Dataset(fnino)\\n\\t\\t#nino3_load = nc_data_nino3.variables['tas'][:]\\n\\t\\t#dnino = nino3_load.flatten()\\n\\n\\t\\tdnino = np.genfromtxt(fnino, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fismr = DATPATH + \\\"ismr.csv\\\" # 1871-2000\\n\\t\\t#fismr = DATPATH + \\\"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\\\" # 1871-2016\\n\\t\\tfismr = DATPATH + \\\"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\\\" # 1871-2016\\n\\t\\tdismr = np.genfromtxt(fismr, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fvolc = DATPATH + \\\"robock.txt\\\" # 1871-2000\\n\\t\\tfvolc = DATPATH + \\\"sigl.txt\\\" # 1871-2016\\n\\t\\tdvolc = np.genfromtxt(fvolc, delimiter=\\\",\\\", dtype=float).flatten()\\n\\n\\t\\tfvolc_source = DATPATH + \\\"volc_source_850_1850.csv\\\" # 1871-2016\\n\\t\\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t# simple check for data consistency\\n\\t\\tassert dnino.shape == dismr.shape, \\\"Data sets are unequal!\\\"\\n\\t\\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \\\"Data sets are unequal\\\"\\n\\t\\treturn dnino, dismr, dvolc, dvolc_source\",\n \"def test_filter_maf_file_cols_full(self):\\n input_maf = os.path.join(DATA_SETS['Proj_08390_G']['MAF_DIR'], \\\"Sample1.Sample2.muts.maf\\\")\\n\\n with TemporaryDirectory() as tmpdir:\\n input_json = {\\n \\\"input_file\\\": {\\n \\\"class\\\": \\\"File\\\",\\n \\\"path\\\": input_maf\\n },\\n \\\"output_filename\\\": \\\"output.maf\\\"\\n }\\n\\n output_json, output_dir = run_cwl(\\n testcase = self,\\n tmpdir = tmpdir,\\n input_json = input_json,\\n cwl_file = cwl_file)\\n\\n expected_output = {\\n 'output_file': {\\n 'location': 'file://' + os.path.join(output_dir, 'output.maf'),\\n 'basename': 'output.maf',\\n 'class': 'File',\\n 'checksum': 'sha1$a2f5b9f1533fd443b41561ca718ffca62ab45f36',\\n 'size': 2710681,\\n 'path': os.path.join(output_dir, 'output.maf')\\n }\\n }\\n self.assertDictEqual(output_json, expected_output)\\n\\n # validate number of lines output\\n with open(output_json['output_file']['path']) as fin:\\n output_maf_lines = len(fin.readlines())\\n self.assertEqual(output_maf_lines, 12518)\\n\\n # validate file contents\\n comments, mutations = load_mutations(output_json['output_file']['path'])\\n\\n self.assertEqual(len(mutations), 12514)\\n\\n for key in mutations[0].keys():\\n self.assertTrue(key in cols_to_keep)\\n\\n # make sure there are fewer than or equal to the number of columns in new output as there are entries to keep \\n self.assertTrue( len(mutations[0].keys()) <= len(cols_to_keep) )\",\n \"def read_data(path_to_file, survey):\\n if survey == 'eco':\\n columns = ['name', 'radeg', 'dedeg', 'cz', 'grpcz', 'absrmag', \\n 'logmstar', 'logmgas', 'grp', 'grpn', 'logmh', 'logmh_s', \\n 'fc', 'grpmb', 'grpms']\\n\\n # 13878 galaxies\\n eco_buff = pd.read_csv(path_to_file,delimiter=\\\",\\\", header=0, \\\\\\n usecols=columns)\\n\\n # 6456 galaxies \\n catl = eco_buff.loc[(eco_buff.cz.values >= 3000) & \\\\\\n (eco_buff.cz.values <= 7000) & (eco_buff.absrmag.values <= -17.33) &\\\\\\n (eco_buff.logmstar.values >= 8.9)]\\n\\n volume = 151829.26 # Survey volume without buffer [Mpc/h]^3\\n cvar = 0.125\\n z_median = np.median(catl.grpcz.values) / (3 * 10**5)\\n \\n elif survey == 'resolvea' or survey == 'resolveb':\\n columns = ['name', 'radeg', 'dedeg', 'cz', 'grpcz', 'absrmag', \\n 'logmstar', 'logmgas', 'grp', 'grpn', 'grpnassoc', 'logmh', \\n 'logmh_s', 'fc', 'grpmb', 'grpms', 'f_a', 'f_b']\\n # 2286 galaxies\\n resolve_live18 = pd.read_csv(path_to_file, delimiter=\\\",\\\", header=0, \\\\\\n usecols=columns)\\n\\n if survey == 'resolvea':\\n catl = resolve_live18.loc[(resolve_live18.f_a.values == 1) & \\\\\\n (resolve_live18.grpcz.values > 4500) & \\\\\\n (resolve_live18.grpcz.values < 7000) & \\\\\\n (resolve_live18.absrmag.values < -17.33) & \\\\\\n (resolve_live18.logmstar.values >= 8.9)]\\n\\n\\n volume = 13172.384 # Survey volume without buffer [Mpc/h]^3\\n cvar = 0.30\\n z_median = np.median(resolve_live18.grpcz.values) / (3 * 10**5)\\n \\n elif survey == 'resolveb':\\n # 487 - cz, 369 - grpcz\\n catl = resolve_live18.loc[(resolve_live18.f_b.values == 1) & \\\\\\n (resolve_live18.grpcz.values > 4500) & \\\\\\n (resolve_live18.grpcz.values < 7000) & \\\\\\n (resolve_live18.absrmag.values < -17) & \\\\\\n (resolve_live18.logmstar.values >= 8.7)]\\n\\n volume = 4709.8373 # *2.915 #Survey volume without buffer [Mpc/h]^3\\n cvar = 0.58\\n z_median = np.median(resolve_live18.grpcz.values) / (3 * 10**5)\\n\\n return catl,volume,cvar,z_median\",\n \"def routines(args, infile):\\n\\n # -- Open the tarfile\\n tar = tarfile.open(infile)\\n\\n # -- Set the model year string\\n fyear = str(infile.split(\\\"/\\\")[-1].split(\\\".\\\")[0])\\n print(\\\"Processing \\\" + fyear)\\n\\n # -- Get list of components to process\\n comps = args.component\\n\\n # -- Atmospheric Fields\\n modules = {\\n \\\"atmos_month\\\": \\\"Atmos\\\",\\n \\\"atmos_co2_month\\\": \\\"Atmos\\\",\\n \\\"atmos_month_aer\\\": \\\"AtmosAer\\\",\\n \\\"aerosol_month_cmip\\\": \\\"AeroCMIP\\\",\\n }\\n if any(comp in comps for comp in [\\\"atmos\\\", \\\"all\\\"]):\\n averagers.cubesphere.xr_average(fyear, tar, modules)\\n\\n # -- Land Fields\\n modules = {\\\"land_month\\\": \\\"Land\\\"}\\n if any(comp in comps for comp in [\\\"land\\\", \\\"all\\\"]):\\n averagers.land_lm4.xr_average(fyear, tar, modules)\\n\\n # -- Ice\\n modules = {\\\"ice_month\\\": \\\"Ice\\\"}\\n if any(comp in comps for comp in [\\\"ice\\\", \\\"all\\\"]):\\n averagers.ice.xr_average(fyear, tar, modules)\\n\\n # -- Ocean\\n fname = f\\\"{fyear}.ocean_scalar_annual.nc\\\"\\n if any(comp in comps for comp in [\\\"ocean\\\", \\\"all\\\"]):\\n if tar_member_exists(tar, fname):\\n print(f\\\"{fyear}.ocean_scalar_annual.nc\\\")\\n fdata = nctools.extract_from_tar(tar, fname, ncfile=True)\\n extract_ocean_scalar.mom6(fdata, fyear, \\\"./\\\")\\n fdata.close()\\n\\n # -- OBGC\\n modules = {\\n \\\"ocean_cobalt_sfc\\\": \\\"OBGC\\\",\\n \\\"ocean_cobalt_misc\\\": \\\"OBGC\\\",\\n \\\"ocean_cobalt_tracers_year\\\": \\\"OBGC\\\",\\n \\\"ocean_cobalt_tracers_int\\\": \\\"OBGC\\\",\\n \\\"ocean_bling\\\": \\\"OBGC\\\",\\n \\\"ocean_bling_cmip6_omip_2d\\\": \\\"OBGC\\\",\\n \\\"ocean_bling_cmip6_omip_rates_year_z\\\": \\\"OBGC\\\",\\n \\\"ocean_bling_cmip6_omip_sfc\\\": \\\"OBGC\\\",\\n \\\"ocean_bling_cmip6_omip_tracers_month_z\\\": \\\"OBGC\\\",\\n \\\"ocean_bling_cmip6_omip_tracers_year_z\\\": \\\"OBGC\\\",\\n }\\n if any(comp in comps for comp in [\\\"obgc\\\", \\\"all\\\"]):\\n averagers.tripolar.xr_average(fyear, tar, modules)\\n\\n # -- AMOC\\n if any(comp in comps for comp in [\\\"amoc\\\", \\\"all\\\"]):\\n diags.amoc.mom6_amoc(fyear, tar)\\n\\n # -- Close out the tarfile handle\\n tar.close()\\n\\n # -- Do performance timing\\n #try:\\n # infile = infile.replace(\\\"/history/\\\", \\\"/ascii/\\\")\\n # infile = infile.replace(\\\".nc.tar\\\", \\\".ascii_out.tar\\\")\\n # label = \\\"Timing\\\"\\n # if os.path.exists(infile):\\n # diags.fms.timing(infile, fyear, \\\"./\\\", label)\\n #except RuntimeError:\\n # pass\",\n \"def ffi(ccd=1, camera=1, sector=1, size=150, local_directory='', producing_mask=False):\\n input_files = glob(f'{local_directory}ffi/*{camera}-{ccd}-????-?_ffic.fits')\\n print('camera: ' + str(camera) + ' ccd: ' + str(ccd) + ' num of files: ' + str(len(input_files)))\\n time = []\\n quality = []\\n cadence = []\\n flux = np.empty((len(input_files), 2048, 2048), dtype=np.float32)\\n for i, file in enumerate(tqdm(input_files)):\\n try:\\n with fits.open(file, mode='denywrite', memmap=False) as hdul:\\n quality.append(hdul[1].header['DQUALITY'])\\n cadence.append(hdul[0].header['FFIINDEX'])\\n flux[i] = hdul[1].data[0:2048, 44:2092]\\n time.append((hdul[1].header['TSTOP'] + hdul[1].header['TSTART']) / 2)\\n\\n except:\\n print(f'Corrupted file {file}, download again ...')\\n response = requests.get(\\n f'https://mast.stsci.edu/api/v0.1/Download/file/?uri=mast:TESS/product/{os.path.basename(file)}')\\n open(file, 'wb').write(response.content)\\n with fits.open(file, mode='denywrite', memmap=False) as hdul:\\n quality.append(hdul[1].header['DQUALITY'])\\n cadence.append(hdul[0].header['FFIINDEX'])\\n flux[i] = hdul[1].data[0:2048, 44:2092]\\n time.append((hdul[1].header['TSTOP'] + hdul[1].header['TSTART']) / 2)\\n time_order = np.argsort(np.array(time))\\n time = np.array(time)[time_order]\\n flux = flux[time_order, :, :]\\n quality = np.array(quality)[time_order]\\n cadence = np.array(cadence)[time_order]\\n # mask = np.array([True] * 2048 ** 2).reshape(2048, 2048)\\n # for i in range(len(time)):\\n # mask[np.where(flux[i] > np.percentile(flux[i], 99.95))] = False\\n # mask[np.where(flux[i] < np.median(flux[i]) / 2)] = False\\n\\n if producing_mask:\\n median_flux = np.median(flux, axis=0)\\n mask = background_mask(im=median_flux)\\n mask /= ndimage.median_filter(mask, size=51)\\n np.save(f'{local_directory}mask/mask_sector{sector:04d}_cam{camera}_ccd{ccd}.npy', mask)\\n return\\n # load mask\\n mask = pkg_resources.resource_stream(__name__, f'background_mask/median_mask.fits')\\n mask = fits.open(mask)[0].data[(camera - 1) * 4 + (ccd - 1), :]\\n mask = np.repeat(mask.reshape(1, 2048), repeats=2048, axis=0)\\n bad_pixels = np.zeros(np.shape(flux[0]))\\n med_flux = np.median(flux, axis=0)\\n bad_pixels[med_flux > 0.8 * np.nanmax(med_flux)] = 1\\n bad_pixels[med_flux < 0.2 * np.nanmedian(med_flux)] = 1\\n bad_pixels[np.isnan(med_flux)] = 1\\n\\n x_b, y_b = np.where(bad_pixels)\\n for i in range(len(x_b)):\\n if x_b[i] < 2047:\\n bad_pixels[x_b[i] + 1, y_b[i]] = 1\\n if x_b[i] > 0:\\n bad_pixels[x_b[i] - 1, y_b[i]] = 1\\n if y_b[i] < 2047:\\n bad_pixels[x_b[i], y_b[i] + 1] = 1\\n if y_b[i] > 0:\\n bad_pixels[x_b[i], y_b[i] - 1] = 1\\n\\n mask = np.ma.masked_array(mask, mask=bad_pixels)\\n mask = np.ma.masked_equal(mask, 0)\\n\\n for i in range(10):\\n hdul = fits.open(input_files[np.where(np.array(quality) == 0)[0][i]])\\n wcs = WCS(hdul[1].header)\\n if wcs.axis_type_names == ['RA', 'DEC']:\\n break\\n\\n exposure = int((hdul[0].header['TSTOP'] - hdul[0].header['TSTART']) * 86400)\\n\\n # 95*95 cuts with 2 pixel redundant, (22*22 cuts)\\n # try 77*77 with 4 redundant, (28*28 cuts)\\n os.makedirs(f'{local_directory}source/{camera}-{ccd}/', exist_ok=True)\\n for i in trange(14): # 22\\n for j in range(14): # 22\\n source_path = f'{local_directory}source/{camera}-{ccd}/source_{i:02d}_{j:02d}.pkl'\\n source_exists = exists(source_path)\\n if source_exists and os.path.getsize(source_path) > 0:\\n # print(f'{source_path} exists. ')\\n pass\\n else:\\n with open(source_path, 'wb') as output:\\n source = Source(x=i * (size - 4), y=j * (size - 4), flux=flux, mask=mask, sector=sector,\\n time=time, size=size, quality=quality, wcs=wcs, camera=camera, ccd=ccd,\\n exposure=exposure, cadence=cadence)\\n pickle.dump(source, output, pickle.HIGHEST_PROTOCOL)\",\n \"def evaluate(self):\\n errors_found = 0\\n\\n # Test if destination exists and is a directory\\n if not os.path.isdir(os.path.expandvars(self.path_destination)):\\n message.alert(\\n f\\\"FILE [{self.name}]: '{self.path_destination}' destination path is not a known directory.\\\"\\n )\\n errors_found += 1\\n\\n # Test if sudo is really needed if the file's\\n # destination is in a directory owned by the current user\\n if os.getenv(\\\"HOME\\\") in os.path.expandvars(self.path_destination) and self.sudo:\\n message.alert(\\n f\\\"FILE [{self.name}]: Sudo use may be unnecessary as {self.path_destination} is in your home path.\\\"\\n )\\n errors_found += 1\\n\\n # Test if source is a directory\\n if self.path_source is not None:\\n if not os.path.isdir(os.path.expandvars(self.path_source)):\\n message.alert(\\n f\\\"FILE [{self.name}]: '{self.path_source}' source path is not a known directory.\\\"\\n )\\n errors_found += 1\\n\\n if not os.path.isfile(\\n os.path.join(os.path.expandvars(self.path_source), self.name)\\n ):\\n message.alert(\\n f\\\"FILE [{self.name}] at PATH: [{self.path_source}] does not exist.\\\"\\n )\\n errors_found += 1\\n\\n # Check expected types\\n if not isinstance(self.comments, list):\\n message.alert(\\n f\\\"FILE [{self.name}]: Type mismatch, comments attribute is of type '{type(self.comments)}' instead of 'list'\\\"\\n )\\n errors_found += 1\\n\\n return errors_found\",\n \"def evaluate(self, x, path):\\n\\n # Read the modestats file as CSV\\n mode_stats_paths = glob.glob(\\\"%s/*modestats.txt\\\" % path)\\n df = pd.read_csv(mode_stats_paths[0], sep = \\\"\\\\t\\\")\\n\\n car_share = df[\\\"car\\\"].values[-1] # Share of car trips\\n pt_share = df[\\\"pt\\\"].values[-1] # Share of pt trips\\n\\n # We construct a vector holding the *state* of the simulation. This is not\\n # used by most simulators, but important, for instance, for Opdyts!\\n state = [car_share, pt_share]\\n\\n # Here we construct an objective value. Here, we want to minimize\\n # the quadratic error between the observed and reference mode shares for\\n # car and public transport.\\n objective = np.sqrt((car_share - self.car_reference)**2 + (pt_share - self.pt_reference)**2)\\n\\n # Return state and objective\\n return objective, state\",\n \"def residuals(x, y, filename):\\n empirical_data = y\\n #print(x)\\n # call convert function\\n\\n ans = (empirical_data - run_model(x, filename))/empirical_data * 100\\n #print(ans)\\n return ans\",\n \"def compute_contrast_sphere_offline(path_raw,path_reduced,path_output,debug=True):\\r\\n try:\\r\\n if not type(path_raw) is PosixPath:\\r\\n path_raw = Path(path_raw)\\r\\n if type(path_reduced) is PosixPath:\\r\\n path_reduced = Path(path_reduced)\\r\\n if not type(path_raw) is PosixPath:\\r\\n path_output = Path(path_output) \\r\\n for path in [path_raw,path_reduced]:\\r\\n if not path.exists():\\r\\n print('The input path {0:s} does not exists. Returning'.format(str(path)))\\r\\n return\\r\\n if not path_output.exists():\\r\\n path_output.mkdir()\\r\\n except:\\r\\n print(sys.exc_info()[0])\\r\\n \\r\\n \\r\\n #%% Step 0 : \\r\\n # Load all raw frames and list the original filename, along with the type \\r\\n # and archive names\\r\\n\\r\\n raw_files = []\\r\\n raw_archive_names = []\\r\\n raw_dpr_types = []\\r\\n \\r\\n files_sphere_raw = sorted(path_raw.glob('SPHERE*IRDIS*OBS*fits'))\\r\\n for file in files_sphere_raw:\\r\\n try:\\r\\n h=fits.getheader(file)\\r\\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR'] and 'IRDIS' in h['HIERARCH ESO SEQ ARM']: \\r\\n raw_files.append(files_sphere_raw)\\r\\n raw_archive_names.append(h['ARCFILE'])\\r\\n raw_dpr_types.append(h['HIERACH ESO DPR TYPE'])\\r\\n except:\\r\\n continue\\r\\n \\r\\n\\r\\n #%% Step 1 : \\r\\n \\r\\n # You look for all reduced frames that correspond to \\r\\n # coronagraphic data with PRO.CATG as \\r\\n # - IRD_SCIENCE_DBI_LEFT_CUBE \\r\\n # - IRD_SCIENCE_DBI_RIGHT_CUBE\\r\\n # - IRD_STAR_CENTER\\r\\n \\r\\n files_sphere_reduced = sorted(path_reduced.glob('r.SPHER*.fits'))\\r\\n reduced_files_dbi_left = [] \\r\\n raw_files_dbi_left = [] # careful !! This is not the raw file name as saved in raw/date/\\r\\n \\r\\n reduced_files_dbi_right = []\\r\\n raw_files_dbi_right = []\\r\\n \\r\\n for file in files_sphere_reduced:\\r\\n try:\\r\\n h=fits.getheader(file)\\r\\n # check whether this is a coronagraphic frame\\r\\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR']:\\r\\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_LEFT_CUBE':\\r\\n reduced_files_dbi_left.append(file)\\r\\n raw_files_dbi_left.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\\r\\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_RIGHT_CUBE':\\r\\n reduced_files_dbi_right.append(file)\\r\\n raw_files_dbi_right.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\\r\\n except:\\r\\n continue\\r\\n\\r\\n \\r\\n \\r\\n #%% Step 2: \\r\\n # You isolate for each raw frames one single reduced left and right cube \\r\\n # (currently the pipeline does multiple reductions of the same raw cube for \\r\\n # an unknown reason, we need to get rid of the duplicates here).\\r\\n \\r\\n unique_reduced_files_dbi_left,indices = np.unique(reduced_files_dbi_left,return_index=True)\\r\\n unique_raw_files_dbi_left = [raw_files_dbi_left[i] for i in indices]\\r\\n \\r\\n unique_reduced_files_dbi_right,indices = np.unique(reduced_files_dbi_right,return_index=True)\\r\\n unique_raw_files_dbi_right = [raw_files_dbi_right[i] for i in indices]\\r\\n \\r\\n \\r\\n #%% Step 3\\r\\n # You extract DIT, NDIT, NAXIS3, coronagraph name:\\r\\n # Lyot stop: HIERARCH ESO INS1 OPTI1 NAME\\r\\n # Lyot mask: HIERARCH ESO INS4 OPTI11 NAME\\r\\n # coro combination name: HIERARCH ESO INS COMB ICOR\\r\\n # along with the ND filter and the IRDIS filter from each RAW frame.\\r\\n # Also extract all info that will be useful later for the analysis:\\r\\n # star name and magnitude, airmass, seeing, coherence time, telescope Seeing...)\\r\\n # This is important to do that on each raw frame on not on each reduced frame\\r\\n # as the keywords are changed by the pipeline and unreliable.\\r\\n \\r\\n \\r\\n \\r\\n #%% Step 4\\r\\n # Assoiate each FLUX with a CORONAGRAPHIC image\\r\\n \\r\\n \\r\\n \\r\\n #%% Step 5\\r\\n # Work on the Flux frame first:\\r\\n # - Detect the central star\\r\\n # - measure the FWHM, validate that this is the star by checking the FWHM\\r\\n # (should be the diffraction limit)\\r\\n # - aperture photometry on the star using a diameter of 1 lambda/D \\r\\n # - divide the flux by the DIT and correct by the ND transmission: this\\r\\n # gives you the star reference flux\\r\\n \\r\\n \\r\\n #%% Step 6\\r\\n # Work on the coronographic frame now:\\r\\n # - Detect the coronagraphic center.\\r\\n # - compute the contrast (using the standard deviation of many apertures \\r\\n # place at a given separation, using for instance the python module VIP)\\r\\n\\r\\n\\r\\n #%% Step 7:\\r\\n # Divide the azinuthal standard deviations by the star reference flux to obtain\\r\\n # the contrast as a function of radius. \\r\\n # Plot the result and save in a csv file along with all relevant parameters \\r\\n # for the analysis (coronagraph name, star magnitude, airmass, seeing, coherence time)\\r\",\n \"def potentials(path_to_units, path_to_eez, path_to_shared_coast,\\n path_to_electricity_yield_pv_prio, path_to_electricity_yield_wind_prio,\\n path_to_eligibility_categories, path_to_land_cover, path_to_protected_areas,\\n path_to_result, scenario, config):\\n with rasterio.open(path_to_eligibility_categories, \\\"r\\\") as src:\\n eligibility_categories = src.read(1)\\n with rasterio.open(path_to_electricity_yield_pv_prio, \\\"r\\\") as src:\\n transform = src.transform\\n electricity_yield_pv_prio = src.read(1)\\n with rasterio.open(path_to_electricity_yield_wind_prio, \\\"r\\\") as src:\\n electricity_yield_wind_prio = src.read(1)\\n with rasterio.open(path_to_land_cover, \\\"r\\\") as src:\\n land_cover = src.read(1)\\n with rasterio.open(path_to_protected_areas, \\\"r\\\") as src:\\n protected_areas = src.read(1)\\n with fiona.open(path_to_units, \\\"r\\\") as src:\\n unit_ids = [feature[\\\"properties\\\"][\\\"id\\\"] for feature in src]\\n unit_geometries = [feature[\\\"geometry\\\"] for feature in src]\\n with fiona.open(path_to_eez, \\\"r\\\") as src:\\n eez_ids = [feature[\\\"properties\\\"][\\\"id\\\"] for feature in src]\\n eez_geometries = [feature[\\\"geometry\\\"] for feature in src]\\n shared_coasts = pd.read_csv(path_to_shared_coast, index_col=0)\\n\\n electricity_yield_pv_prio, electricity_yield_wind_prio = apply_scenario_config(\\n potential_pv_prio=electricity_yield_pv_prio,\\n potential_wind_prio=electricity_yield_wind_prio,\\n categories=eligibility_categories,\\n land_cover=land_cover,\\n protected_areas=protected_areas,\\n scenario_config=config[\\\"scenarios\\\"][scenario]\\n )\\n electricity_yield_pv_prio, electricity_yield_wind_prio = decide_between_pv_and_wind(\\n potential_pv_prio=electricity_yield_pv_prio,\\n potential_wind_prio=electricity_yield_wind_prio,\\n electricity_yield_pv_prio=electricity_yield_pv_prio,\\n electricity_yield_wind_prio=electricity_yield_wind_prio,\\n eligibility_categories=eligibility_categories\\n )\\n\\n onshore_potentials = pd.DataFrame(\\n index=unit_ids,\\n data={\\n potential: potentials_per_shape(\\n eligibilities=potential.eligible_on,\\n potential_map=(electricity_yield_pv_prio if \\\"pv\\\" in str(potential).lower()\\n else electricity_yield_wind_prio),\\n eligibility_categories=eligibility_categories,\\n shapes=unit_geometries,\\n transform=transform\\n )\\n for potential in Potential.onshore()\\n }\\n )\\n offshore_eez_potentials = pd.DataFrame(\\n index=eez_ids,\\n data={\\n potential: potentials_per_shape(\\n eligibilities=potential.eligible_on,\\n potential_map=(electricity_yield_pv_prio if \\\"pv\\\" in str(potential).lower()\\n else electricity_yield_wind_prio),\\n eligibility_categories=eligibility_categories,\\n shapes=eez_geometries,\\n transform=transform\\n )\\n for potential in Potential.offshore()\\n }\\n )\\n offshore_potentials = pd.DataFrame(\\n data=shared_coasts.dot(offshore_eez_potentials),\\n columns=Potential.offshore()\\n )\\n potentials = pd.concat([onshore_potentials, offshore_potentials], axis=1)\\n potentials.index.name = \\\"id\\\"\\n potentials.to_csv(\\n path_to_result,\\n header=True,\\n index=True\\n )\",\n \"def test_solution_usage(self, test_data):\\n for finput in test_data[\\\"EKFSLAM.EKFSLAM.Fx\\\"][:1]:\\n params = finput\\n\\n solution.used[\\\"EKFSLAM.EKFSLAM.Fx\\\"] = False\\n\\n EKFSLAM.EKFSLAM.Fx(**params)\\n\\n assert not solution.used[\\\"EKFSLAM.EKFSLAM.Fx\\\"], \\\"The function uses the solution\\\"\",\n \"def find_constants(open_path):\\n\\n if not os.path.exists(MODEL_FILE):\\n easygui.msgbox(\\\"There are no models to use to classify the data. Please train algorithm first.\\\")\\n return\\n\\n clf = joblib.load(MODEL_FILE)\\n\\n if is_empty_model(clf):\\n easygui.msgbox(\\\"The model has not been fitted yet. Please fit data to the model.\\\")\\n return\\n\\n while True:\\n file = easygui.fileopenbox('Please locate csv file', 'Specify File', default=open_path, filetypes='*.csv')\\n\\n if file:\\n open_path = \\\"{0:s}\\\\*.csv\\\".format(os.path.dirname(file))\\n\\n file_data = get_data(file)\\n\\n legacy_log = is_valid_log(file_data, visualize.LEGACY_COLUMNS)\\n current_log = is_valid_log(file_data)\\n\\n if legacy_log or current_log:\\n if legacy_log and not current_log:\\n easygui.msgbox(\\\"Because this log is missing information that makes it optimal \\\"\\n \\\"for manipulating the data efficiently results may be inaccurate\\\")\\n\\n # TODO make it so that when closing the figure using the GUI it reopens normally\\n plot = ConstantViewer(clf)\\n plot.graph(file_data)\\n plot.show()\\n else:\\n\\n easygui.msgbox(\\n \\\"The file {0:s} is not a valid file.\\\".format(os.path.basename(file)))\\n else:\\n break\\n\\n plt.close(\\\"all\\\")\\n return open_path\",\n \"def extract_all_lazy():\\n\\n\\t#Construct filepaths: Data COMP_INFO_1\\n\\tdata_ci1_name = \\\"DATA_2016_COMP_INFO_1.csv\\\"\\n\\tdata_ci1_fullname = os.path.join(files_location, data_ci1_name)\\n\\t#Data COMP_INFO_2\\n\\tdata_ci2_name = \\\"DATA_2016_COMP_INFO_2.csv\\\"\\n\\tdata_ci2_fullname = os.path.join(files_location, data_ci2_name)\\n\\t#Data PROPERTY INFO\\n\\tdata_pi_name = \\\"DATA_2016_PROPERTY_INFO_ST.csv\\\"\\n\\tdata_pi_fullname = os.path.join(files_location, data_pi_name)\\n\\t#Data General Info\\n\\tdata_gi_name = \\\"DATA_2016_GENERAL_INFO.csv\\\"\\n\\tdata_gi_fullname = os.path.join(files_location, data_gi_name)\\n\\n\\t#Read & Process COMP_INFO\\n\\tdata_ci1 = pd.read_csv(data_ci1_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\\n\\tdata_ci2 = pd.read_csv(data_ci2_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\\n\\n\\tdata_ci = data_ci1.append(data_ci2)\\n\\tdata_ci['QUESTION'] = data_ci['QUESTION'].replace(constants.ci_mapping)\\n\\t# Take only the survey questions mapped\\n\\tdata_ci = data_ci[data_ci['QUESTION'].isin(constants.ci_mapping.values())]\\n\\tdata_ci = data_ci.set_index(['PROPERTY_CODE','PROPERTY_NAME','JOB_CODE','POSITION'])\\n\\tdata_ci = data_ci.pivot(columns=\\\"QUESTION\\\")\\n\\tdata_ci.columns = [\\\"_\\\".join(pair) for pair in data_ci.columns]\\n\\tdata_ci = data_ci.reset_index()\\n\\n\\t#Read & Process Property Info data\\n\\tdata_pi = pd.read_csv(data_pi_fullname, usecols = constants.keep_columns_PI, encoding='ISO-8859-1')\\n\\t#survey_type_transformed = transform.surveytype_categorical(data_pi)\\n\\t#data_pi = pd.merge(data_pi, survey_type_transformed, on=['PROPERTY_CODE'])\\n\\n\\t#Read & Process General Info\\n\\tdata_gi = pd.read_csv(data_gi_fullname, skiprows = 2, usecols = constants.keep_columns_GI, encoding='ISO-8859-1')\\n\\tdata_gi['QUESTION'] = data_gi['QUESTION'].replace(constants.gi_mapping)\\n\\t# Take onl the survey questions mapped\\n\\tdata_gi = data_gi[data_gi['QUESTION'].isin(constants.gi_mapping.values())]\\n\\tdata_gi = data_gi.set_index(['PROPERTY_CODE','PROPERTY_NAME'])\\n\\tdata_gi = data_gi.pivot(columns=\\\"QUESTION\\\")\\n\\tdata_gi.columns = [\\\"_\\\".join(pair) for pair in data_gi.columns]\\n\\tdata_gi = data_gi.reset_index()\\n\\n\\t#This frame needs to be reworked\\n\\td_ci = pd.merge(data_gi, data_pi, on = ['PROPERTY_CODE','PROPERTY_NAME'])\\n\\td_ci = pd.merge(d_ci, data_ci, on = ['PROPERTY_CODE','PROPERTY_NAME'],suffixes= ['_ci','_gi'])\\n\\n\\t#Observations by Dimensions to determine top X markets\\n\\t#Can this be in a better position?\\n\\td_ci = d_ci[~(d_ci['PROPERTY_NAME'].isin(constants.del_rows_property_name))]\\n\\td_ci['POSITION'] = d_ci['POSITION'].astype(str)\\n\\n\\tpayload = {}\\n\\tpayload['gi'] = data_gi\\n\\tpayload['pi'] = data_pi\\n\\tpayload['ci'] = data_ci\\n\\tpayload['d_ci'] = d_ci\\n\\n\\treturn payload\",\n \"def on_menu_criteria_file(self, event):\\n if self.data_model == 3:\\n dlg = wx.FileDialog(\\n self, message=\\\"choose a file in MagIC Data Model 3.0 format\\\",\\n defaultDir=self.WD,\\n defaultFile=\\\"criteria.txt\\\",\\n style=wx.FD_OPEN | wx.FD_CHANGE_DIR\\n )\\n else:\\n dlg = wx.FileDialog(\\n self, message=\\\"choose a file in a MagIC Data Model 2.5 pmagpy format\\\",\\n defaultDir=self.WD,\\n defaultFile=\\\"pmag_criteria.txt\\\",\\n # wildcard=wildcard,\\n style=wx.FD_OPEN | wx.FD_CHANGE_DIR\\n )\\n\\n if self.show_dlg(dlg) == wx.ID_OK:\\n criteria_file = dlg.GetPath()\\n self.GUI_log.write(\\n \\\"-I- Read new criteria file: %s\\\\n\\\" % criteria_file)\\n dlg.Destroy()\\n replace_acceptance_criteria = pmag.initialize_acceptance_criteria(\\n data_model=self.data_model)\\n try:\\n if self.data_model == 3:\\n self.read_criteria_file(criteria_file)\\n replace_acceptance_criteria = self.acceptance_criteria\\n # replace_acceptance_criteria=pmag.read_criteria_from_file(criteria_file,replace_acceptance_criteria,data_model=self.data_model)\\n # # just to see if file exists\\n print(replace_acceptance_criteria)\\n else:\\n replace_acceptance_criteria = pmag.read_criteria_from_file(\\n criteria_file, replace_acceptance_criteria, data_model=self.data_model) # just to see if file exists\\n except Exception as ex:\\n print('-W-', ex)\\n dlg1 = wx.MessageDialog(\\n self, caption=\\\"Error:\\\", message=\\\"error in reading file\\\", style=wx.OK)\\n result = self.show_dlg(dlg1)\\n if result == wx.ID_OK:\\n dlg1.Destroy()\\n return\\n self.add_thellier_gui_criteria()\\n self.read_criteria_file(criteria_file)\\n # check if some statistics are in the new criteria but not in old. If\\n # yes, add to self.preferences['show_statistics_on_gui']\\n crit_list_not_in_pref = []\\n for crit in list(self.acceptance_criteria.keys()):\\n if self.acceptance_criteria[crit]['category'] == \\\"IE-SPEC\\\":\\n if self.acceptance_criteria[crit]['value'] != -999:\\n short_crit = crit.split('specimen_')[-1]\\n if short_crit not in self.preferences['show_statistics_on_gui']:\\n print(\\\"-I- statistic %s is not in your preferences\\\" % crit)\\n self.preferences['show_statistics_on_gui'].append(\\n short_crit)\\n crit_list_not_in_pref.append(crit)\\n if len(crit_list_not_in_pref) > 0:\\n stat_list = \\\":\\\".join(crit_list_not_in_pref)\\n dlg1 = wx.MessageDialog(self, caption=\\\"WARNING:\\\",\\n message=\\\"statistics '%s' is in the imported criteria file but not in your appearence preferences.\\\\nThis statistic will not appear on the gui panel.\\\\n The program will exit after saving new acceptance criteria, and it will be added automatically the next time you open it \\\" % stat_list,\\n style=wx.OK | wx.ICON_INFORMATION)\\n self.show_dlg(dlg1)\\n dlg1.Destroy()\\n\\n dia = thellier_gui_dialogs.Criteria_Dialog(\\n None, self.acceptance_criteria, self.preferences, title='Acceptance Criteria')\\n dia.Center()\\n result = self.show_dlg(dia)\\n if result == wx.ID_OK: # Until the user clicks OK, show the message\\n self.On_close_criteria_box(dia)\\n if len(crit_list_not_in_pref) > 0:\\n dlg1 = wx.MessageDialog(self, caption=\\\"WARNING:\\\",\\n message=\\\"Exiting now! When you restart the gui all the new statistics will be added.\\\",\\n style=wx.OK | wx.ICON_INFORMATION)\\n self.show_dlg(dlg1)\\n dlg1.Destroy()\\n self.on_menu_exit(None)\\n # self.Destroy()\\n # sys.exit()\\n\\n if result == wx.ID_CANCEL: # Until the user clicks OK, show the message\\n for crit in crit_list_not_in_pref:\\n short_crit = crit.split('specimen_')[-1]\\n self.preferences['show_statistics_on_gui'].remove(short_crit)\",\n \"def get_clean_data(path = 'ucr_offenses_known_monthly_1960_2016_dta/', \\n identifier_variables = ['fips_state_county_code', 'state', 'date', 'year', 'zip_code', 'month'], \\n crime_category = ['act_aggravated_assault', 'act_simple_assault', 'act_murder', 'act_robbery_total', \\n 'act_manslaughter', 'act_theft_total', 'act_mtr_vhc_theft_total', 'act_burglary_total', 'act_rape_total'], \\n start_year = 1980, end_year = 2009, selected_area = 'all'):\\n all_df = []\\n for i in get_filenames(start_year, end_year):\\n file = path + i\\n print(file)\\n each_df = pd.read_stata(file)\\n each_df = each_df[identifier_variables + crime_category]\\n each_df = each_df[each_df['fips_state_county_code'] == '06001']\\n each_df['zipcode'] = each_df['zip_code'].apply(lambda x: str(x)[0:5])\\n #split Alameda into West and East Alameda according to zip code\\n if selected_area == 'east':\\n each_df = each_df[(each_df['zipcode'] == '94550') | (each_df['zipcode'] == '94566') | \\n (each_df['zipcode'] == '94586') | (each_df['zipcode'] == '94568') | \\n (each_df['zipcode'] == '94588') | (each_df['zipcode'] == '94551')]\\n elif selected_area == 'west':\\n each_df = each_df[(each_df['zipcode'] != '94550') & (each_df['zipcode'] != '94566') & \\n (each_df['zipcode'] != '94586') & (each_df['zipcode'] != '94568') & \\n (each_df['zipcode'] != '94588') & (each_df['zipcode'] != '94551') &\\n (each_df['zipcode'] != '0') & (each_df['zipcode'] != '0.0') & \\n (each_df['zipcode'] != 'not r') & (each_df['zipcode'] != 'missi')]\\n each_df.loc[:, 'YearMonth'] = [int(re.sub('-', '', date)[0:6]) for date in each_df.loc[:, 'date']]\\n #sum up amount of crimes taken place in each category for each month\\n each_df = each_df.groupby(['YearMonth'])[crime_category].sum()\\n each_df['crime_sum'] = each_df.sum(axis = 1)\\n each_df = each_df['crime_sum'].reset_index()\\n all_df.append(each_df)\\n df = pd.concat(all_df).fillna(0)\\n df = df.sort_values('YearMonth').reset_index()\\n #split variable 'YearMonth\\\" into two variables 'year' and \\\"month' for Poission regression\\n del df['index']\\n df['year'] = df['YearMonth'].apply(lambda x: str(x)[:4])\\n df['month'] = df['YearMonth'].apply(lambda x: str(x)[4:])\\n if selected_area == 'east':\\n df.to_csv('east_alameda_crime.csv')\\n elif selected_area == 'west':\\n df.to_csv('west_alameda_crime.csv')\\n else:\\n df.to_csv('all_alameda_crime.csv')\\n return(df)\",\n \"def read_input(self):\\n try:\\n path = tkFileDialog.askdirectory()\\n if not path: # User the cancelled dialog box so bug out\\n return False\\n # Search the user-provided path for all the input files.\\n foundall, missing = self.files.locate_input(path)\\n # If any are missing show the user and error message\\n # with the missing files listed.\\n if not foundall:\\n # Give indentation and numbered bullets to the missing names\\n missing = [' {}) {}'.format(i, name)\\n for i, name in enumerate(sorted(missing), 1)]\\n missing.insert(0, 'The following files were not found:')\\n missing.append('Nothing was modified')\\n tkMessageBox.showerror('Error', '\\\\n'.join(missing))\\n return False\\n # Files were successfully located.\\n # Read contents of gain/voltage files.\\n # This must come first, as it also sets the row and column numbers.\\n with self.files.open_file('GAIN_LARGE') as file:\\n largegains = file.readlines()\\n for x in NORTH_LARGE, SOUTH_LARGE:\\n self.detectors[x].set_voltages(largegains)\\n with self.files.open_file('GAIN_SMALL') as file:\\n smallgains = file.readlines()\\n for x in NORTH_SMALL, SOUTH_SMALL:\\n self.detectors[x].set_voltages(smallgains)\\n # Set QT information\\n qtdirname = os.path.dirname(self.files['QT1'])\\n self.qt = qt.System(qtdirname)\\n for det in self.detectors.itervalues():\\n det.set_qt(self.qt)\\n # Now that the detector information is complete,\\n # let's keep a copy of the initial detector state.\\n # This is required for when we make a ROOT\\n # tree with initial and final information.\\n self.initial = copy.deepcopy(self.detectors)\\n except IOError as err:\\n tkMessageBox.askyesno('I/O error', str(err))\\n self.image_window.canvas.focus_set()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5547697","0.51804596","0.51175356","0.50851357","0.49448034","0.49235836","0.49108392","0.49066615","0.49041834","0.4902881","0.48873246","0.48858833","0.48858833","0.48857036","0.48537314","0.47822648","0.47778893","0.4767607","0.47633898","0.4755537","0.47510976","0.47500542","0.47469684","0.4725044","0.47235817","0.47211826","0.4720177","0.47131965","0.47125056","0.47107178","0.46991256","0.46771374","0.46759552","0.46731335","0.4669779","0.46650594","0.46644914","0.46590522","0.46503302","0.46407652","0.46366358","0.4626278","0.4623703","0.46231648","0.46154952","0.4609283","0.46029028","0.4598195","0.45967734","0.45946622","0.4594253","0.45926502","0.45835775","0.45792267","0.45784947","0.4578369","0.45779434","0.45631492","0.45618302","0.4556907","0.45489767","0.45485315","0.45480376","0.4542908","0.4529325","0.452879","0.4523718","0.45211324","0.45164976","0.45154786","0.449994","0.44986796","0.44980624","0.44955435","0.44874987","0.44829693","0.44776902","0.44725853","0.44723415","0.44669384","0.44658613","0.4465346","0.44644052","0.44631994","0.44600257","0.4448839","0.4448121","0.44476745","0.44471264","0.44452202","0.44443786","0.44438502","0.4437394","0.44301838","0.44257686","0.442202","0.44199303","0.4419876","0.44139612","0.44110712"],"string":"[\n \"0.5547697\",\n \"0.51804596\",\n \"0.51175356\",\n \"0.50851357\",\n \"0.49448034\",\n \"0.49235836\",\n \"0.49108392\",\n \"0.49066615\",\n \"0.49041834\",\n \"0.4902881\",\n \"0.48873246\",\n \"0.48858833\",\n \"0.48858833\",\n \"0.48857036\",\n \"0.48537314\",\n \"0.47822648\",\n \"0.47778893\",\n \"0.4767607\",\n \"0.47633898\",\n \"0.4755537\",\n \"0.47510976\",\n \"0.47500542\",\n \"0.47469684\",\n \"0.4725044\",\n \"0.47235817\",\n \"0.47211826\",\n \"0.4720177\",\n \"0.47131965\",\n \"0.47125056\",\n \"0.47107178\",\n \"0.46991256\",\n \"0.46771374\",\n \"0.46759552\",\n \"0.46731335\",\n \"0.4669779\",\n \"0.46650594\",\n \"0.46644914\",\n \"0.46590522\",\n \"0.46503302\",\n \"0.46407652\",\n \"0.46366358\",\n \"0.4626278\",\n \"0.4623703\",\n \"0.46231648\",\n \"0.46154952\",\n \"0.4609283\",\n \"0.46029028\",\n \"0.4598195\",\n \"0.45967734\",\n \"0.45946622\",\n \"0.4594253\",\n \"0.45926502\",\n \"0.45835775\",\n \"0.45792267\",\n \"0.45784947\",\n \"0.4578369\",\n \"0.45779434\",\n \"0.45631492\",\n \"0.45618302\",\n \"0.4556907\",\n \"0.45489767\",\n \"0.45485315\",\n \"0.45480376\",\n \"0.4542908\",\n \"0.4529325\",\n \"0.452879\",\n \"0.4523718\",\n \"0.45211324\",\n \"0.45164976\",\n \"0.45154786\",\n \"0.449994\",\n \"0.44986796\",\n \"0.44980624\",\n \"0.44955435\",\n \"0.44874987\",\n \"0.44829693\",\n \"0.44776902\",\n \"0.44725853\",\n \"0.44723415\",\n \"0.44669384\",\n \"0.44658613\",\n \"0.4465346\",\n \"0.44644052\",\n \"0.44631994\",\n \"0.44600257\",\n \"0.4448839\",\n \"0.4448121\",\n \"0.44476745\",\n \"0.44471264\",\n \"0.44452202\",\n \"0.44443786\",\n \"0.44438502\",\n \"0.4437394\",\n \"0.44301838\",\n \"0.44257686\",\n \"0.442202\",\n \"0.44199303\",\n \"0.4419876\",\n \"0.44139612\",\n \"0.44110712\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62348145"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19896,"cells":{"query":{"kind":"string","value":"Prepare the file locker. Specify the file to lock and optionally the maximum timeout and the delay between each attempt to lock."},"document":{"kind":"string","value":"def __init__(self, file_name, timeout=10, delay=.05):\r\n self.is_locked = False\r\n #self.lockfile = os.path.join(os.getcwd(), \"%s.lock\" % file_name)\r\n self.lockfile = file_name + '.lock'\r\n self.file_name = file_name\r\n self.timeout = timeout\r\n self.delay = delay"},"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 __init__(self, file_name, timeout=10, delay=.05):\n self.is_locked = False\n self.lockfile = os.path.abspath(file_name)\n self.file_name = file_name\n self.timeout = timeout\n self.delay = delay\n self.fd = None","def __init__(self, protected_file_path, timeout=None, delay=1, lock_file_contents=None):\n self.is_locked = False\n self.lockfile = protected_file_path + \".lock\"\n self.timeout = timeout\n self.delay = delay\n self._lock_file_contents = lock_file_contents\n if self._lock_file_contents is None:\n self._lock_file_contents = \"Owning process args:\\n\"\n for arg in sys.argv:\n self._lock_file_contents += arg + \"\\n\"","def __init__(self, file_name, timeout=10, delay=0.05):\n self.file_name = os.path.abspath(file_name)\n self.lockfile = os.path.abspath(file_name) + \".lock\"\n self.timeout = float(timeout)\n self.delay = float(delay)\n self.is_locked = False\n\n if self.delay > self.timeout or self.delay <= 0 or self.timeout <= 0:\n raise ValueError(\"delay and timeout must be positive with delay \" \"<= timeout\")","def __init__(self, dir, timeout=None):\n self.dir = dir\n if timeout is not None and timeout < 2.0:\n raise ValueError('timeout must be at least 2 seconds')\n self.timeout = timeout\n if self.fileName:\n self.lockDir = os.path.join(dir, self.fileName)\n self._makeDir()\n else:\n self.lockDir = dir \n self._locked = False","def acquire(self):\n start_time = time.time()\n while True:\n try:\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n break\n except (OSError,) as e:\n if e.errno != errno.EEXIST:\n raise\n if (time.time() - start_time) >= self.timeout:\n raise FileLockException(f\"{self.lockfile}: Timeout occurred.\")\n time.sleep(self.delay)\n\n self.is_locked = True","def acquire(self):\r\n start_time = time.time()\r\n import getpass\r\n userName = getpass.getuser()\r\n import platform\r\n computerName = platform.uname()[1]\r\n while True:\r\n try:\r\n self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)\r\n os.write(self.fd, userName + '\\n')\r\n os.write(self.fd, computerName + '\\n')\r\n os.write(self.fd, time.ctime(time.time()))\r\n break;\r\n except OSError as e:\r\n if e.errno != errno.EEXIST and e.errno != errno.EACCES:\r\n raise \r\n if (time.time() - start_time) >= self.timeout:\r\n if e.errno == errno.EEXIST:\r\n raise FileLockException(\"Timeout occured.\")\r\n else:\r\n raise FileLockException(\"Access denied.\")\r\n time.sleep(self.delay)\r\n self.is_locked = True","def lock(self, timeout=0):\n if timeout:\n timeout_time = time.time() + timeout\n # Make sure my temp lockfile exists, and that its contents are\n # up-to-date (e.g. the temp file name, and the lock lifetime).\n self.__write()\n # TBD: This next call can fail with an EPERM. I have no idea why, but\n # I'm nervous about wrapping this in a try/except. It seems to be a\n # very rare occurence, only happens from cron, and (only?) on Solaris\n # 2.6.\n self.__touch()\n\n while True:\n # Create the hard link and test for exactly 2 links to the file\n try:\n os.link(self.__tmpfname, self.__lockfile)\n # If we got here, we know we know we got the lock, and never\n # had it before, so we're done. Just touch it again for the\n # fun of it.\n self.__touch()\n break\n except OSError, e:\n # The link failed for some reason, possibly because someone\n # else already has the lock (i.e. we got an EEXIST), or for\n # some other bizarre reason.\n if e.errno == errno.ENOENT:\n # TBD: in some Linux environments, it is possible to get\n # an ENOENT, which is truly strange, because this means\n # that self.__tmpfname doesn't exist at the time of the\n # os.link(), but self.__write() is supposed to guarantee\n # that this happens! I don't honestly know why this\n # happens, but for now we just say we didn't acquire the\n # lock, and try again next time.\n pass\n elif e.errno <> errno.EEXIST:\n # Something very bizarre happened. Clean up our state and\n # pass the error on up.\n os.unlink(self.__tmpfname)\n raise\n elif self.__linkcount() <> 2:\n # Somebody's messin' with us!\n pass\n elif self.__read() == self.__tmpfname:\n # It was us that already had the link.\n raise AlreadyLockedError\n # otherwise, someone else has the lock\n pass\n # We did not acquire the lock, because someone else already has\n # it. Have we timed out in our quest for the lock?\n if timeout and timeout_time < time.time():\n os.unlink(self.__tmpfname)\n raise TimeOutError\n # Okay, we haven't timed out, but we didn't get the lock. Let's\n # find if the lock lifetime has expired.\n if time.time() > self.__releasetime():\n # Yes, so break the lock.\n self.__break()\n # Okay, someone else has the lock, our claim hasn't timed out yet,\n # and the expected lock lifetime hasn't expired yet. So let's\n # wait a while for the owner of the lock to give it up.\n self.__sleep()","def Lock(self, timeout_secs=_DEFAULT_TIMEOUT_SECS):\n if self._file_desc is not None:\n raise OSError(\"%s has been locked.\" % self._file_path)\n parent_dir = os.path.dirname(self._file_path)\n if not os.path.exists(parent_dir):\n os.makedirs(parent_dir)\n successful = False\n self._file_desc = os.open(self._file_path, os.O_CREAT | os.O_RDWR,\n 0o666)\n try:\n successful = self._Flock(timeout_secs)\n finally:\n if not successful:\n os.close(self._file_desc)\n self._file_desc = None\n return successful","def acquire(lockfile, timeout=None):\n\tif timeout is None:\n\t\ttimeout = max_timeout # 100yrs should suffice\n\tretries = int(float(timeout)/wait_interval)\n\n\t_lock_acquire(lockfile, retries)\n\t\n\treturn lockfile","def lock(tmp_dir, timeout=120, min_wait=5, max_wait=10, verbosity=1):\r\n # Create base of lock directory if required.\r\n base_lock = os.path.dirname(tmp_dir)\r\n if not os.path.isdir(base_lock):\r\n try:\r\n os.makedirs(base_lock)\r\n except OSError:\r\n # Someone else was probably trying to create it at the same time.\r\n # We wait two seconds just to make sure the following assert does\r\n # not fail on some NFS systems.\r\n time.sleep(2)\r\n assert os.path.isdir(base_lock)\r\n\r\n # Variable initialization.\r\n lock_file = os.path.join(tmp_dir, 'lock')\r\n random.seed()\r\n my_pid = os.getpid()\r\n no_display = (verbosity == 0)\r\n\r\n nb_error = 0\r\n # The number of time we sleep when their is no errors.\r\n # Used to don't display it the first time to display it less frequently.\r\n # And so don't get as much email about this!\r\n nb_wait = 0\r\n # Acquire lock.\r\n while True:\r\n try:\r\n last_owner = 'no_owner'\r\n time_start = time.time()\r\n other_dead = False\r\n while os.path.isdir(tmp_dir):\r\n try:\r\n read_owner = open(lock_file).readlines()[0].strip()\r\n # the try is transtion code for old locks\r\n # it may be removed when poeple have upgraded\r\n try:\r\n other_host = read_owner.split('_')[2]\r\n except IndexError:\r\n other_host = () # make sure it isn't equal to any host\r\n if other_host == socket.gethostname():\r\n try:\r\n os.kill(int(read_owner.split('_')[0]), 0)\r\n except OSError:\r\n other_dead = True\r\n except AttributeError:\r\n pass #os.kill does not exist on windows\r\n except Exception:\r\n read_owner = 'failure'\r\n if other_dead:\r\n if not no_display:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.warning(\"Overriding existing lock by dead %s \"\r\n \"(I am process '%s')\", msg, my_pid)\r\n get_lock.unlocker.unlock()\r\n continue\r\n if last_owner == read_owner:\r\n if (timeout is not None and\r\n time.time() - time_start >= timeout):\r\n # Timeout exceeded or locking process dead.\r\n if not no_display:\r\n if read_owner == 'failure':\r\n msg = 'unknown process'\r\n else:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.warning(\"Overriding existing lock by %s \"\r\n \"(I am process '%s')\", msg, my_pid)\r\n get_lock.unlocker.unlock()\r\n continue\r\n else:\r\n last_owner = read_owner\r\n time_start = time.time()\r\n no_display = (verbosity == 0)\r\n if not no_display and nb_wait > 0:\r\n if read_owner == 'failure':\r\n msg = 'unknown process'\r\n else:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.info(\"Waiting for existing lock by %s (I am \"\r\n \"process '%s')\", msg, my_pid)\r\n _logger.info(\"To manually release the lock, delete %s\",\r\n tmp_dir)\r\n if verbosity <= 1:\r\n no_display = True\r\n nb_wait += 1\r\n time.sleep(random.uniform(min_wait, max_wait))\r\n\r\n try:\r\n os.mkdir(tmp_dir)\r\n except OSError:\r\n # Error while creating the directory: someone else\r\n # must have tried at the exact same time.\r\n nb_error += 1\r\n if nb_error < 10:\r\n continue\r\n else:\r\n raise\r\n # Safety check: the directory should be here.\r\n assert os.path.isdir(tmp_dir)\r\n\r\n # Write own id into lock file.\r\n unique_id = refresh_lock(lock_file)\r\n\r\n # Verify we are really the lock owner (this should not be needed,\r\n # but better be safe than sorry).\r\n owner = open(lock_file).readlines()[0].strip()\r\n if owner != unique_id:\r\n # Too bad, try again.\r\n continue\r\n else:\r\n # We got the lock, hoorray!\r\n return\r\n\r\n except Exception, e:\r\n # If something wrong happened, we try again.\r\n _logger.warning(\"Something wrong happened: %s %s\", type(e), e)\r\n nb_error += 1\r\n if nb_error > 10:\r\n raise\r\n time.sleep(random.uniform(min_wait, max_wait))\r\n continue","def __init__(self, dir, timeout=None):\n ExclusiveLock.__init__(self, dir, timeout)\n writeLockDir = os.path.join(self.dir, WriteLock.fileName)\n self.writeLock = ExclusiveLock(writeLockDir, timeout)","def acquire(self, timeout=None):\r\n try:\r\n open(self.unique_name, \"wb\").close()\r\n except IOError:\r\n raise LockFailed\r\n\r\n end_time = time.time()\r\n if timeout is not None and timeout > 0:\r\n end_time += timeout\r\n\r\n while True:\r\n # Try and create a hard link to it.\r\n try:\r\n os.link(self.unique_name, self.lock_file)\r\n except OSError:\r\n # Link creation failed. Maybe we've double-locked?\r\n nlinks = os.stat(self.unique_name).st_nlink\r\n if nlinks == 2:\r\n # The original link plus the one I created == 2. We're\r\n # good to go.\r\n return\r\n else:\r\n # Otherwise the lock creation failed.\r\n if timeout is not None and time.time() > end_time:\r\n os.unlink(self.unique_name)\r\n if timeout > 0:\r\n raise LockTimeout\r\n else:\r\n raise AlreadyLocked\r\n time.sleep(timeout is not None and timeout/10 or 0.1)\r\n else:\r\n # Link creation succeeded. We're good to go.\r\n return","def acquire(self):\n start_time = time.time()\n while True:\n # 当前文件锁对象未有加锁，执行加锁\n if self.fd is None:\n try:\n # 独占式打开文件\n lock_dir = os.path.dirname(self.lockfile)\n if not os.path.isdir(lock_dir):\n os.makedirs(lock_dir, exist_ok=True)\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n break\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n # 超时\n if (time.time() - start_time) >= self.timeout:\n raise FileLockException(\"Timeout occured.\")\n # 本次加锁失败，需要等待\n time.sleep(self.delay)\n self.is_locked = True","def __init__(self, dir, timeout=None, readlocktimeout=None):\n ExclusiveLock.__init__(self, dir, timeout)\n if readlocktimeout is None:\n self.readlocktimeout = timeout\n else:\n self.readlocktimeout = readlocktimeout","def acquire(self, timeout=None):\n if self._locked:\n raise RuntimeError(\"lock already locked\")\n if self.writeLock.acquire(timeout):\n try:\n self.lockDir = tempfile.mkdtemp('', self.fileName, self.dir)\n self._locked = True\n # log('acquired read lock: %s\\n' % self.lockDir)\n return True\n finally:\n self.writeLock.release() \n return False","def testUnlockWait(t, env):\n c = env.c1\n c.init_connection()\n fh, stateid = c.create_confirm(t.code)\n res = c.lock_file(t.code, fh, stateid, 20, 100)\n check(res, msg=\"Locking file %s\" % t.code)\n sleeptime = c.getLeaseTime() * 2\n env.sleep(sleeptime)\n ops = c.use_obj(fh)\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\n _replay(c, ops, [NFS4_OK, NFS4ERR_EXPIRED])","def __init__(self, lockfile, lifetime=DEFAULT_LOCK_LIFETIME):\n self.__lockfile = lockfile\n self.__lifetime = lifetime\n # This works because we know we're single threaded\n self.__counter = LockFile.COUNTER\n LockFile.COUNTER += 1\n self.__tmpfname = '%s.%s.%d.%d' % (lockfile, \n socket.gethostname(),\n os.getpid(),\n self.__counter)","def _file_open_rlock(self, preset_type, timeout=1.0):\n\n if self._fd is None:\n path = self._path(preset_type)\n with open(path, 'r+') as fd:\n # Set up file lock timeout with a raising handler\n # We will need this handler due to PEP 475\n def interrupt(signum, frame):\n raise InterruptedError()\n\n old_handler = signal.signal(signal.SIGALRM, interrupt)\n try:\n signal.setitimer(signal.ITIMER_REAL, timeout)\n fcntl.flock(fd, fcntl.LOCK_EX)\n except InterruptedError:\n # Ignore interrupted and proceed to cleanup\n pass\n finally:\n # Clean up file lock timeout\n signal.setitimer(signal.ITIMER_REAL, 0)\n signal.signal(signal.SIGALRM, old_handler)\n # Error now if we still can't get the lock.\n # Getting lock twice is safe.\n fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)\n logger.debug('acquired lock for %s', path)\n self._fd = fd\n yield fd\n fcntl.flock(fd, fcntl.LOCK_UN)\n logger.debug('released lock for %s', path)\n self._fd = None\n else:\n logger.debug('using already open file descriptor')\n yield self._fd","def __init__(self, fname, lockduration=10, verbosity=0):\n self._verbosity = verbosity\n self._lockduration = lockduration\n fname = op.normpath(fname)\n self._basedir = op.dirname(fname)\n self._lockfilename = \"%s.lock\" % op.basename(fname)\n self._uniquename = \",\".join((\n self._lockfilename, socket.getfqdn(), str(os.getpid()),\n str(uuid.uuid4())[-12:],\n ))\n self._uniquefile_created = False\n self._p(\" File to lock: %s\" % fname)\n self._p(\"Lockfile name: %s\" % self._lockfilename)\n self._p(\" Unique name: %s\" % self._uniquename)","def testLock(t, env):\n c = env.c1\n c.init_connection()\n # Create a file and partially lock it\n fh, stateid = c.create_confirm(t.code)\n res = c.lock_file(t.code, fh, stateid, 20, 100)\n check(res, msg=\"Locking file %s\" % t.code)\n # Create and replay LOCK ops\n ops = c.use_obj(fh)\n lock_owner = exist_lock_owner4(res.lockid, 1)\n locker = locker4(FALSE, lock_owner=lock_owner)\n ops += [c.lock_op(WRITE_LT, FALSE, 0, 10, locker)]\n _replay(c, ops)","def FSLockExclusive(filepath, timeout=None):\n return _lock(filepath, True, timeout=timeout)","def _wait_for_lockfile(self, lockfile_path: Path) -> None:\n if not lockfile_path.exists():\n return\n\n # The first second is free.\n start = time.time()\n time.sleep(1)\n if not lockfile_path.exists():\n return\n\n # After the first second, we print one message, then we stay silent for 10 minutes, at\n # which time we print a message every minute.\n def time_elapsed() -> float:\n return time.time() - start\n self.logger.info(\"Starting to wait for %s\", lockfile_path)\n next_message_time = time.time() + 16 * 60\n while lockfile_path.exists():\n if next_message_time - time.time() < 0:\n self.logger.warning(\n \"Lockfile %s has been blocked for %.0f seconds\",\n lockfile_path,\n time_elapsed())\n next_message_time = time.time() + 60\n time.sleep(1)","def _Flock(self, timeout_secs):\n try:\n if timeout_secs > 0:\n wrapper = utils.TimeoutException(timeout_secs)\n wrapper(fcntl.flock)(self._file_desc, fcntl.LOCK_EX)\n else:\n fcntl.flock(self._file_desc, fcntl.LOCK_EX | fcntl.LOCK_NB)\n except errors.FunctionTimeoutError as e:\n logger.debug(\"Cannot lock %s within %s seconds\",\n self._file_path, timeout_secs)\n return False\n except (OSError, IOError) as e:\n # flock raises IOError in python2; OSError in python3.\n if e.errno in (errno.EACCES, errno.EAGAIN):\n logger.debug(\"Cannot lock %s\", self._file_path)\n return False\n raise\n return True","def test_waits_on_existing_lockfile(self):\n self.lock.__enter__()\n self.assertTrue(os.path.exists(self.lock.lockfile_path))\n\n def exit_first_lock():\n time.sleep(0.1)\n self.lock.__exit__(None, None, None)\n thread = threading.Thread(target=exit_first_lock)\n thread.start()\n\n new_lock = disk.DiskDatasetLock(self.dataset, timeout_sec=1)\n new_lock.__enter__()\n\n thread.join()","def acquire(path, onwait=None):\r\n\r\n touch(path)\r\n lock_fd = lock_file(path, blocking=False)\r\n if not lock_fd:\r\n blocking = True\r\n with open(path, 'r') as fd:\r\n pid = int(fd.read().strip())\r\n if onwait:\r\n blocking = onwait(pid)\r\n if not blocking:\r\n return None\r\n lock_fd = lock_file(path, blocking=blocking)\r\n\r\n lock_fd.truncate(0)\r\n lock_fd.write('%d\\n' % os.getpid())\r\n lock_fd.flush()\r\n return Lock(lock_fd)","def _lock_process(pipe, filepath, exclusive, timeout=None):\n try:\n # Reset signal handlers\n signal.signal(signal.SIGINT, signal.SIG_DFL)\n signal.signal(signal.SIGHUP, signal.SIG_DFL)\n signal.signal(signal.SIGTERM, signal.SIG_DFL)\n\n # Open the file\n mode = os.O_RDONLY | os.O_CREAT if exclusive else os.O_RDONLY\n try:\n fd = os.open(filepath, mode)\n except FileNotFoundError:\n pipe.send('NOTFOUND')\n return\n\n # Lock it\n op = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH\n if timeout is None:\n fcntl.flock(fd, op)\n elif timeout == 0:\n try:\n fcntl.flock(fd, op | fcntl.LOCK_NB)\n except BlockingIOError:\n pipe.send('TIMEOUT')\n return\n else:\n with timeout_syscall(timeout):\n try:\n fcntl.flock(fd, op)\n except InterruptedError:\n pipe.send('TIMEOUT')\n return\n pipe.send('LOCKED')\n except Exception:\n pipe.send('ERROR')\n raise\n\n # Wait for unlock message then exit\n assert pipe.recv() == 'UNLOCK'\n\n # Exiting releases the lock","def acquire(self, timeout=None):\n timer = self.timerClass(timeout)\n timer.start()\n while timer.haveTime():\n try:\n os.mkdir(self.lockDir)\n self._locked = True\n # log('acquired exclusive lock: %s\\n' % (self.lockDir, ))\n return True\n except OSError, err:\n if err.errno != errno.EEXIST:\n raise\n if self.expire():\n continue # Try immediately to acquire\n timer.sleep()\n return False","def AcquireFileLock(target_file, flags):\n assert flags in (\n LOCK_EX, LOCK_SH, LOCK_NB, LOCK_EX | LOCK_NB, LOCK_SH | LOCK_NB)\n if os.name == 'nt':\n _LockImplWin(target_file, flags)\n elif os.name == 'posix':\n _LockImplPosix(target_file, flags)\n else:\n raise NotImplementedError('%s is not supported' % os.name)","def make_pidlockfile(path, acquire_timeout):\n if not isinstance(path, basestring):\n error = ValueError(\"Not a filesystem path: %(path)r\" % vars())\n raise error\n if not os.path.isabs(path):\n error = ValueError(\"Not an absolute path: %(path)r\" % vars())\n raise error\n lockfile = pidlockfile.TimeoutPIDLockFile(path, acquire_timeout)\n\n return lockfile","def test_locked_file_03(self):\n \n f = open(\"tests/locked.db3\", \"a+\")\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \n \n x = subprocess.Popen([\"sqlbak\", \"tests\", \"--ms-towait=4000\"],\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT)\n\n time.sleep(3)\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\n f.close()\n\n result = x.communicate()[0]\n\n self.assertTrue(\"cannot obtain lock\" not in result)","def _lock(self):\n self._create_unique_file()\n while True:\n try:\n self._extend_expiration_time() # in case we had to wait...\n os.link(self.uniquefile, self.lockfile)\n self._p(\"Lock successfully acquired.\")\n return\n except OSError as e:\n if e.errno in self.NOT_EXIST_ERRORS:\n # Didn't work for some reason. Try again in a bit.\n pass\n elif e.errno == errno.EEXIST:\n links = self._count_links()\n if links == 2 and self._read_lockfile() == self._uniquename:\n raise AlreadyLockedError(\"Lock already exists.\")\n else:\n # An unexpected error occurred.\n self._remove_unique_file()\n raise\n # Release expired lock of the others.\n if self._has_expired():\n self._break_foreign_lock()\n time.sleep(2)\n continue\n # No luck getting the lock.\n self._p(\"Locked by someone else. Waiting to retry...\", level=1)\n time.sleep(5)","def test_file_lock_busy(get_config, monkeypatch, config_dict):\n cfg = get_config(DeviceConfig, config_dict.get('str'))\n # just ignore time sleep\n monkeypatch.setattr(time, 'sleep', lambda x: None)\n file_lock = FileLock(cfg.config_path, timeout=.1)\n with file_lock:\n file_lock.acquire()\n with pytest.raises(Exception):\n assert cfg.write()\n assert cfg.read()\n\n # assert res == None, 'lock acquired but should not'","def lock (self):\n self._createLockFileIfNeeded()\n self._lockHandle=open(self._lockFileName, \"r\")\n fcntl.flock(self._lockHandle, fcntl.LOCK_EX)","def create_lock_file():\n\n print(\"Creating lock file\")","def __init__(self, file_name, exclusive=None):\n self.file_name = file_name\n self.exclusive = exclusive\n self.filelock = Event()","def FSLockShared(filepath, timeout=None):\n return _lock(filepath, False, timeout=timeout)","def lock(path, timeout, create=True):\n # ``FileLock`` requires that the to-be-locked file exists; if it\n # does not, we create an empty one (and avoid overwriting any\n # content, in case another process is also writing to it). There\n # is thus no race condition here, as we attempt to lock the file\n # anyway, and this will stop concurrent processes.\n if not os.path.exists(path) and create:\n open(path, \"a\").close()\n created = True\n else:\n created = False\n try:\n lck = lockfile.FileLock(path, threaded=False)\n lck.acquire(timeout=timeout)\n except Exception:\n if created:\n try:\n os.remove(path)\n except:\n pass\n raise\n return lck","def acquire(self, timeout=None):\r\n pass","def acquire(self, exclusive=None):\n self.filelock.clear()\n self.locked = True\n self.exclusive = exclusive","def acquire(self, exclusive=None):\n self.filelock.clear()\n self.locked = True\n self.exclusive = exclusive","def _openLockFile(self):\n lock_file = self._getLockFile()\n self.stream_lock = open(lock_file, \"w\")","def lock(self):\n\n\t\t# Acquire the threading lock first\n\t\tself.s.acquire()\n\t\t# Acquire the file lock\n\t\tfcntl.lockf(self.lockfile, fcntl.LOCK_EX)","def wait(lock_path, duration_s):\n with filelock.FileLock(lock_path, 3 * 60):\n # We can't use time.monotonic() as we're comparing time between processes and\n # time.monotonic() explicitly does not support that\n # This means the test can fail during leap seconds, but this is only a test, we\n # don't need total reliability\n print(time.time())\n time.sleep(duration_s)\n print(time.time())","def acquire(self, blocking=True):\n\n start_time = time.time()\n while True:\n try:\n # Attempt to create the lockfile.\n # These flags cause os.open to raise an OSError if the file already exists.\n fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n with os.fdopen(fd, \"a\") as f:\n # Print some info about the current process as debug info for anyone who bothers to look.\n f.write(self._lock_file_contents)\n break\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n if self.timeout is not None and (time.time() - start_time) >= self.timeout:\n raise FileLock.FileLockException(\"Timeout occurred for lock '{!s}'.\".format(self.lockfile))\n if not blocking:\n return False\n time.sleep(self.delay)\n self.is_locked = True\n return True","def update_lock_timeout(self, timeout):\n\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\n raise FatalError(\"Timeout is out of range!\")\n elif not self._in_use:\n raise CoreError(\"This SystemUnderTest is not currently checked-out!\")\n\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)","def _lock(self):\n self._thread_lock.acquire()\n try:\n self._file.open_and_lock()\n except IOError as e:\n if e.errno == errno.ENOSYS:\n logger.warn('File system does not support locking the '\n 'credentials file.')\n elif e.errno == errno.ENOLCK:\n logger.warn('File system is out of resources for writing the '\n 'credentials file (is your disk full?).')\n elif e.errno == errno.EDEADLK:\n logger.warn('Lock contention on multistore file, opening '\n 'in read-only mode.')\n else:\n raise\n if not self._file.is_locked():\n self._read_only = True\n if self._warn_on_readonly:\n logger.warn('The credentials file (%s) is not writable. '\n 'Opening in read-only mode. Any refreshed '\n 'credentials will only be '\n 'valid for this run.', self._file.filename())\n if os.path.getsize(self._file.filename()) == 0:\n logger.debug('Initializing empty multistore file')\n # The multistore is empty so write out an empty file.\n self._data = {}\n self._write()\n elif not self._read_only or self._data is None:\n # Only refresh the data if we are read/write or we haven't\n # cached the data yet. If we are readonly, we assume is isn't\n # changing out from under us and that we only have to read it\n # once. This prevents us from whacking any new access keys that\n # we have cached in memory but were unable to write out.\n self._refresh_data_cache()","def force_unlock():\r\n global timeout_before_override\r\n timeout_backup = timeout_before_override\r\n timeout_before_override = 0\r\n try:\r\n get_lock(min_wait=0, max_wait=0.001)\r\n release_lock()\r\n finally:\r\n timeout_before_override = timeout_backup","def test_temp_file_lock(tmp_path, monkeypatch):\n monkeypatch.setenv(\"RAY_TMPDIR\", str(tmp_path))\n assert str(tmp_path) in ray._private.utils.get_user_temp_dir()\n with TempFileLock(path=\"abc.txt\"):\n assert RAY_LOCKFILE_DIR in os.listdir(tmp_path)\n assert os.listdir(tmp_path / RAY_LOCKFILE_DIR)","def withFileLock(reason=\"unknown\"):\n\n if _lock_tracing:\n my_print(getThreadIdent(), \"Want file lock for %s\" % reason)\n file_lock.acquire()\n if _lock_tracing:\n my_print(getThreadIdent(), \"Acquired file lock for %s\" % reason)\n yield\n if _lock_tracing:\n my_print(getThreadIdent(), \"Released file lock for %s\" % reason)\n file_lock.release()","def heartbeat(self):\n timeout_at = time.time() + self.timeout\n\n try:\n os.utime(self.filename, (timeout_at, timeout_at))\n\n except OSError as err:\n if err.errno == errno.ENOENT:\n _LOGGER.warning('Lost lease file: %r', self.filename)\n self._write(timeout_at)\n else:\n raise","def test_locked_file_01(self):\n \n f = open(\"tests/locked.db3\", \"a+\")\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \n \n x = subprocess.Popen([\"sqlbak\", \"tests\"],\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT)\n\n time.sleep(1)\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\n f.close()\n\n result = x.communicate()[0]\n\n self.assertTrue(\"cannot obtain lock\" not in result)","def acquire_lock_1(force, lock_file=None):\n if lock_file is None:\n lock_file = config.LOCK_FILE\n lock = Lock(lock_file, LOCK_LIFETIME)\n try:\n lock.lock(timedelta(seconds=0.1))\n return lock\n except TimeOutError:\n if not force:\n raise\n # Force removal of lock first.\n lock.disown()\n hostname, pid, tempfile = lock.details\n os.unlink(lock_file)\n return acquire_lock_1(force=False)","def __init__(self, exclusive=None):\n self.filelock = Event()\n self.locked = False\n self.exclusive = False","def __init__(self,filename,**kwargs):\n modlogger.debug( \"LF:%s %s\"%(filename,kwargs))\n self.fname = filename\n reserve = kwargs.get(\"reserve\",DEFAULT_LOGSZ)\n reserve = max(reserve,MINIMUM_LOGSZ)\n self.ro = kwargs.get(\"readonly\",False)\n\n mode = \"wb+\" if not self.ro else \"rb\"\n self.fd = open(filename,mode)\n #FIXME: In the case that this is a new file\n #we should sync the directory fd (which means opening one).\n \n #We detect sparse logfile, and dont really support\n # them properly.\n self.sparse = False\n self.not_complete_lock = threading.Lock()\n self.not_complete = []\n self.closing = False \n self.outstanding = threading.Condition(self.not_complete_lock)\n \n if not self.ro: self._reserve(reserve)","def __init__(self, directory ,**kwargs ): \n self.home = directory\n self.track_state = kwargs.get('track_state',True)\n\n self.last_opid = -1 #cleanup\n try:\n os.remove(tstfile) \n except Exception:\n pass \n\n\n #id_lock prevents new transactions being created \n # and protect last_opid.\n self.id_lock = threading.Lock() \n #not_complete_lock protects the not_complete list, prevents\n #transaction being submitted and is used for the \n #outstanding condition variable. Always acquire not_complete_lock\n #before id_lock\n self.oldlogtx = -1\n self.tx = None\n\n if kwargs.pop('recover',True): self._recover()\n self.frozen = False #FIXME: In the case that this is a new file\n #we also should sync the directory fd (which means opening one).\n \n self.logf = None\n self.in_use_logs = []\n self.logsync = threading.Semaphore(0)\n self.loglocker = RWLock()\n self.rotatelog(**kwargs)","def set_lock(self, process):\n if not os.path.isdir(self.args.dir[process]):\n os.system('mkdir -p ' + self.args.dir[process])\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\n lockFN = os.path.join(self.args.dir[process], \\\n '.lock_pose%03d'%self.args.params['CD']['pose'])\n else:\n lockFN = os.path.join(self.args.dir[process], '.lock')\n if os.path.isfile(lockFN):\n raise Exception(process + ' is locked')\n else:\n lockF = open(lockFN, 'w')\n lockF.close()\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\n logFN = os.path.join(self.args.dir[process],'%s_pose%03d_log.txt'%(\\\n process, self.args.params['CD']['pose']))\n else:\n logFN = os.path.join(self.args.dir[process], process + '_log.txt')\n self.log = open(logFN, 'a')","def lock_init(self, file_path=None, file_hash=None):\n\n with locks_db.atomic() as transaction: # Opens new transaction.\n try:\n self.lock_obj.lock_init(file_path=file_path, file_hash=file_hash)\n except Exception as ex:\n locks_db.rollback()\n raise ex","def set_lock_time():\n\n pass","def test_multiple_file_locks(tmp_path, monkeypatch):\n monkeypatch.setenv(\"RAY_TMPDIR\", str(tmp_path))\n with TempFileLock(path=\"abc.txt\"):\n with TempFileLock(path=\"subdir/abc.txt\"):\n assert RAY_LOCKFILE_DIR in os.listdir(tmp_path)\n # We should have 2 locks, one for abc.txt and one for subdir/abc.txt\n assert len(os.listdir(tmp_path / RAY_LOCKFILE_DIR)) == 2","def acquire(self):\n BaseRotatingHandler.acquire(self)\n if self.stream_lock:\n if self.stream_lock.closed:\n try:\n self._openLockFile()\n except Exception:\n self.stream_lock = None\n return\n lock(self.stream_lock, LOCK_EX)","def test_creates_lockfile_on_enter(self):\n self.lock.__enter__()\n self.assertTrue(os.path.exists(self.lock.lockfile_path))","def acquire(self, blocking=True):\n ops = fcntl.LOCK_EX\n if not blocking:\n ops |= fcntl.LOCK_NB\n fcntl.flock(self.lock_file, ops)","def test_lock_timeout():\n lock_unlock_timeout(0)","def test_locked_file_02(self):\n \n f = open(\"tests/locked.db3\", \"a+\")\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \n \n x = subprocess.Popen([\"sqlbak\", \"tests\"],\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT)\n\n time.sleep(3)\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\n f.close()\n\n result = x.communicate()[0]\n\n self.assertTrue(\"cannot obtain lock\" in result)\n self.assertTrue(\"lock held by pid %d\" % os.getpid() in result)","def __enter__(self):\n\t\tmode = 'r+' if os.path.exists(self.filename) else 'w'\n\t\tself.file = open(self.filename, mode)\n\t\ttry:\n\t\t\tfcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)\n\t\texcept IOError, e:\n\t\t\tsys.exit('Unable to obtain lock on %s, probably due to other ' \n\t\t\t\t'running instances of pydbpintegrator.' % self.filename)\n\t\treturn self","def test_syncer_wait_or_retry_timeout(temp_data_dirs, tmp_path):\n tmp_source, tmp_target = temp_data_dirs\n\n def slow_upload(*args, **kwargs):\n time.sleep(5)\n\n class HangingSyncer(_FilesystemSyncer):\n def _sync_up_command(\n self, local_path: str, uri: str, exclude: Optional[List] = None\n ):\n return (\n slow_upload,\n dict(local_path=local_path, uri=uri, exclude=exclude),\n )\n\n syncer = HangingSyncer(\n storage_filesystem=_create_mock_custom_fs(tmp_path),\n sync_period=60,\n sync_timeout=0.1,\n )\n\n syncer.sync_up(local_dir=tmp_source, remote_dir=\"/test/timeout\")\n with pytest.raises(RuntimeError) as e:\n syncer.wait_or_retry(max_retries=3, backoff_s=0)\n assert \"Failed sync even after 3 retries.\" in str(e.value)\n assert isinstance(e.value.__cause__, TimeoutError)","def testLockWithTimeout(self, mock_timeout_exception):\n mock_wrapped_flock = mock.Mock(side_effect=errors.FunctionTimeoutError)\n mock_wrapper = mock.Mock(return_value=mock_wrapped_flock)\n mock_timeout_exception.return_value = mock_wrapper\n\n self.assertFalse(self._lock.Lock(timeout_secs=1))\n\n mock_wrapper.assert_called_once_with(fcntl.flock)\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\n mock_wrapper.reset_mock()\n mock_wrapped_flock.reset_mock()\n\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=1))\n\n mock_wrapper.assert_called_once_with(fcntl.flock)\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)","def acquire_exclusive_nb_flock(lockfd, max_retry=5, wait_interval=5):\n return _acquire_file_lock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB,\n max_retry, wait_interval)","def acquire(self):\n if pidfile_exists(self.path):\n error = AlreadyLocked()\n raise error\n try:\n write_pid_to_pidfile(self.path)\n except OSError:\n error = LockFailed()\n raise error","def testLock(self):\n self.assertTrue(self._lock.LockIfNotInUse())\n self.assertTrue(os.path.isfile(self._lock_path))\n self._lock.Unlock()\n\n self.assertTrue(self._lock.LockIfNotInUse(timeout_secs=0))\n self._lock.SetInUse(True)\n self._lock.Unlock()\n\n self.assertFalse(self._lock.LockIfNotInUse())\n\n self.assertTrue(self._lock.Lock())\n self._lock.SetInUse(False)\n self._lock.Unlock()\n\n self.assertTrue(self._lock.Lock(timeout_secs=0))\n self._lock.Unlock()","def __init__(self, filename, mode='a', maxBytes=512*1024*1024,\r\n backupCount=10):\r\n# FileHandler.__init__(self, filename, mode)\r\n if maxBytes > 0:\r\n mode = 'a' # doesn't make sense otherwise!\r\n FileHandler.__init__(self, filename, mode)\r\n self.maxBytes = maxBytes\r\n self.backupCount = backupCount\r\n self.counter = 0\r\n self.every = 10","def test_prep_file(self, mock_open):\n path = \"/tmp/foo\"\n request = DownloadRequest(None, None, None, path)\n download_threads._MultithreadedDownloader._prep_file(request)\n mock_open.assert_called_once_with(path, \"wb\")\n\n mock_open.return_value.close.assert_called_once_with()","def __init__(self, path, threaded=True):\r\n LockBase.__init__(self, path)\r\n if threaded:\r\n tname = \"%x-\" % thread.get_ident()\r\n else:\r\n tname = \"\"\r\n # Lock file itself is a directory. Place the unique file name into\r\n # it.\r\n self.unique_name = os.path.join(self.lock_file,\r\n \"%s.%s%s\" % (self.hostname,\r\n tname,\r\n self.pid))","def locked_call(callable: Callable[[], Any], lock_file: str, lock_timeout: int) -> Any:\n lock = SoftFileLock(lock_file, timeout=lock_timeout)\n with lock.acquire(timeout=lock_timeout):\n return callable()","def lock(self, name, timeout=None, sleep=0.1):\n return Lock(self, name, timeout=timeout, sleep=sleep)","def __call__(self, resource: LockResource, timeout: timedelta) -> Lock:","def acquire_shared_nb_flock(lockfd, max_retry=5, wait_interval=5):\n return _acquire_file_lock(lockfd, fcntl.LOCK_SH | fcntl.LOCK_NB,\n max_retry, wait_interval)","def acquire(self):\r\n self.log('acquire enter')\r\n\r\n start = datetime.now()\r\n\r\n # try and fetch the lock, looping until it's available\r\n while not self.try_acquire():\r\n if (datetime.now() - start).seconds > self.timeout:\r\n raise TimeoutExpired\r\n sleep(0.1)\r\n\r\n self.log('acquire exit')","def set_open_file_limit(soft_limit: int) -> None:\n if os.name != 'nt': # resource module not available on Windows OS\n curr_soft_limit, curr_hard_limit = resource.getrlimit(\n resource.RLIMIT_NOFILE)\n if curr_soft_limit < soft_limit < curr_hard_limit:\n resource.setrlimit(\n resource.RLIMIT_NOFILE, (soft_limit, curr_hard_limit))\n logger.debug(\n 'Open file descriptor soft limit set to %d' %\n soft_limit)","def __init__(self, lock_name, try_count=0, sleep_seconds=__SLEEP_SECONDS,\n expire_milliseconds=None):\n self._lock_key = db.Key.from_path(LockModel.kind(), lock_name)\n self._acquired_lock = None\n self._try_count = try_count\n self._sleep_seconds = sleep_seconds\n\n if expire_milliseconds is None:\n expire_milliseconds = self.__MAX_LOCK_MILLISECONDS\n self._expire_timedelta = datetime.timedelta(\n milliseconds=expire_milliseconds\n )","def _file_lock(file_handle):\n lock = False\n try:\n _platform_lock(file_handle)\n lock = True\n yield\n finally:\n if lock:\n _platform_unlock(file_handle)","def _lock(self):\n self._lockFile = open(self._lockFilename, \"w\")\n self._lockFile.write(\"%d\" % (os.getpid()))\n self._lockFile.flush()","def file(self, file_h):\n if os.path.exists(file_h):\n self._file = file_h\n self._lockedFile = self._file + consts.LOCKED_NOTIFIER\n self.locked = self.is_locked\n else:\n self._file = None\n self._lockedFile = None","def _setup_lock(self):\n\n try:\n ml2_config.cfg.CONF.set_override('lock_path', \"lock\")\n except ml2_config.cfg.NoSuchOptError:\n ml2_config.cfg.CONF.set_override(\n 'lock_path', \"lock\", \"oslo_concurrency\")","def close_file(self):\n SpooledTemporaryFile.flush(self)\n response = requests.post(LOCK_SERVER_ADDR, json={'file_path': self.filename, 'lock_file': False, 'user_id': self.user_id})\n print response","def min_file_install_timeout(self):\n raise DeviceException(DeviceException.FEATURE_NOT_IMPLEMENTED)","def set_wait_timeout(self, timeout):\n self.__wait_timeout = timeout","def set_import_timeout(self, value):\n\t\tself.spinImportTimeout.set_value(value)","def testLockDenied(t, env):\n c = env.c1\n c.init_connection()\n # Create a file and lock it\n fh, stateid = c.create_confirm(t.code)\n res1 = c.lock_file(t.code, fh, stateid, 20, 100)\n check(res1, msg=\"Locking file %s for first owner\" % t.code)\n res2 = c.lock_file(t.code, fh, stateid, 0, 10)\n check(res2, msg=\"Locking file %s for second owner\" % t.code)\n # Create and replay LOCK ops\n ops = c.use_obj(fh)\n lock_owner = exist_lock_owner4(res1.lockid, 1)\n locker = locker4(FALSE, lock_owner=lock_owner)\n ops += [c.lock_op(WRITE_LT, FALSE, 0, 10, locker)]\n _replay(c, ops, NFS4ERR_DENIED)","def testUnlock(t, env):\n c = env.c1\n c.init_connection()\n fh, stateid = c.create_confirm(t.code)\n res = c.lock_file(t.code, fh, stateid, 20, 100)\n check(res, msg=\"Locking file %s\" % t.code)\n ops = c.use_obj(fh)\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\n _replay(c, ops)","def lock_file(path):\n #TODO if open fails and the lockfile is present, check its creation date\n # and, if it's more than ??? remove it and retry\n # pylint: disable=global-statement\n try:\n lock_fd = os.open(path, os.O_CREAT | os.O_WRONLY | os.O_EXCL)\n except OSError:\n return False\n else:\n global LOCK_FILENAME\n LOCK_FILENAME = path\n os.close(lock_fd)\n return True","def test_lock_timeout_loop():\n lock_unlock_timeout(0.2)","def test_syncer_hanging_sync_with_timeout(temp_data_dirs, tmp_path):\n tmp_source, tmp_target = temp_data_dirs\n\n def _hanging_sync_up_command(*args, **kwargs):\n time.sleep(200)\n\n class _HangingSyncer(_FilesystemSyncer):\n def _sync_up_command(\n self, local_path: str, uri: str, exclude: Optional[List] = None\n ):\n return _hanging_sync_up_command, {}\n\n syncer = _HangingSyncer(\n storage_filesystem=_create_mock_custom_fs(tmp_path),\n sync_period=60,\n sync_timeout=10,\n )\n\n def sync_up():\n return syncer.sync_up(\n local_dir=tmp_source, remote_dir=\"/test/test_syncer_timeout\"\n )\n\n with freeze_time() as frozen:\n assert sync_up()\n frozen.tick(5)\n # 5 seconds - initial sync hasn't reached the timeout yet\n # It should continue running without launching a new sync\n assert not sync_up()\n frozen.tick(5)\n # Reached the timeout - start running a new sync command\n assert sync_up()\n frozen.tick(20)\n # We're 10 seconds past the timeout, waiting should result in a timeout error\n with pytest.raises(TimeoutError):\n syncer.wait()","def __init__(self, default_timeout = 300.0):\n dict.__init__(self)\n self._timeouts = {}\n self._default_timeout = default_timeout\n self._lock = threading.RLock()","def lock(lockfile, flags):\n fd = os.open(lockfile, flags)\n fcntl.lockf(fd, fcntl.LOCK_EX)\n return fd","def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=0, utc=0, maxBytes=0):\n # super(self). #It's old style class, so super doesn't work.\n logging.handlers.TimedRotatingFileHandler.__init__(self, filename, when, interval, backupCount, encoding, delay, utc)\n self.maxBytes=maxBytes","def locked_build(args):\n ### NOTE: we do not delete/clean up this file, as that may interfere\n ### with other processes. Just leave 'em around. Zero length files.\n with open(f'{SCRATCH_DIR}/{args.project}.lock', 'w') as fp:\n start_time = time.time()\n\n while (time.time() - start_time) < 120:\n try:\n fcntl.flock(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)\n except BlockingIOError:\n print(f'WARNING: Building for \"{args.project}\" is locked, trying again in 10 seconds.')\n # Pause a bit, then loop.\n time.sleep(10)\n continue\n # Got the lock!\n\n try:\n start_build(args)\n finally:\n # Done, or errored. Release the lock.\n fcntl.flock(fp, fcntl.LOCK_UN)\n\n # All done.\n return\n\n print(\"ERROR: Could not acquire lock for project directory - is another build taking ages to complete?!\")\n sys.exit(-1)","def _lock(self):\n import os\n from time import sleep\n # Waits until another process completes it's process\n while os.path.isfile(self.db_path+\".lock\"):\n print(\"Another process is using\",\n self.db_path, \". Waiting for release.\")\n sleep(1)\n with open(self.db_path+\".lock\", 'w') as fp:\n pass","def flock_exclusive(fileobj):\n msvcrt.locking(fileobj.fileno(), msvcrt.LK_LOCK, 2147483647)","def __init__(self, filename, mode='ab', maxBytes=512*1024*1024,\n backupCount=10):\n if maxBytes > 0:\n mode = 'ab' # doesn't make sense otherwise!\n FileHandler.__init__(self, filename, mode)\n self.maxBytes = maxBytes\n self.backupCount = backupCount\n self.counter = 0\n self.every = 10"],"string":"[\n \"def __init__(self, file_name, timeout=10, delay=.05):\\n self.is_locked = False\\n self.lockfile = os.path.abspath(file_name)\\n self.file_name = file_name\\n self.timeout = timeout\\n self.delay = delay\\n self.fd = None\",\n \"def __init__(self, protected_file_path, timeout=None, delay=1, lock_file_contents=None):\\n self.is_locked = False\\n self.lockfile = protected_file_path + \\\".lock\\\"\\n self.timeout = timeout\\n self.delay = delay\\n self._lock_file_contents = lock_file_contents\\n if self._lock_file_contents is None:\\n self._lock_file_contents = \\\"Owning process args:\\\\n\\\"\\n for arg in sys.argv:\\n self._lock_file_contents += arg + \\\"\\\\n\\\"\",\n \"def __init__(self, file_name, timeout=10, delay=0.05):\\n self.file_name = os.path.abspath(file_name)\\n self.lockfile = os.path.abspath(file_name) + \\\".lock\\\"\\n self.timeout = float(timeout)\\n self.delay = float(delay)\\n self.is_locked = False\\n\\n if self.delay > self.timeout or self.delay <= 0 or self.timeout <= 0:\\n raise ValueError(\\\"delay and timeout must be positive with delay \\\" \\\"<= timeout\\\")\",\n \"def __init__(self, dir, timeout=None):\\n self.dir = dir\\n if timeout is not None and timeout < 2.0:\\n raise ValueError('timeout must be at least 2 seconds')\\n self.timeout = timeout\\n if self.fileName:\\n self.lockDir = os.path.join(dir, self.fileName)\\n self._makeDir()\\n else:\\n self.lockDir = dir \\n self._locked = False\",\n \"def acquire(self):\\n start_time = time.time()\\n while True:\\n try:\\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n break\\n except (OSError,) as e:\\n if e.errno != errno.EEXIST:\\n raise\\n if (time.time() - start_time) >= self.timeout:\\n raise FileLockException(f\\\"{self.lockfile}: Timeout occurred.\\\")\\n time.sleep(self.delay)\\n\\n self.is_locked = True\",\n \"def acquire(self):\\r\\n start_time = time.time()\\r\\n import getpass\\r\\n userName = getpass.getuser()\\r\\n import platform\\r\\n computerName = platform.uname()[1]\\r\\n while True:\\r\\n try:\\r\\n self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)\\r\\n os.write(self.fd, userName + '\\\\n')\\r\\n os.write(self.fd, computerName + '\\\\n')\\r\\n os.write(self.fd, time.ctime(time.time()))\\r\\n break;\\r\\n except OSError as e:\\r\\n if e.errno != errno.EEXIST and e.errno != errno.EACCES:\\r\\n raise \\r\\n if (time.time() - start_time) >= self.timeout:\\r\\n if e.errno == errno.EEXIST:\\r\\n raise FileLockException(\\\"Timeout occured.\\\")\\r\\n else:\\r\\n raise FileLockException(\\\"Access denied.\\\")\\r\\n time.sleep(self.delay)\\r\\n self.is_locked = True\",\n \"def lock(self, timeout=0):\\n if timeout:\\n timeout_time = time.time() + timeout\\n # Make sure my temp lockfile exists, and that its contents are\\n # up-to-date (e.g. the temp file name, and the lock lifetime).\\n self.__write()\\n # TBD: This next call can fail with an EPERM. I have no idea why, but\\n # I'm nervous about wrapping this in a try/except. It seems to be a\\n # very rare occurence, only happens from cron, and (only?) on Solaris\\n # 2.6.\\n self.__touch()\\n\\n while True:\\n # Create the hard link and test for exactly 2 links to the file\\n try:\\n os.link(self.__tmpfname, self.__lockfile)\\n # If we got here, we know we know we got the lock, and never\\n # had it before, so we're done. Just touch it again for the\\n # fun of it.\\n self.__touch()\\n break\\n except OSError, e:\\n # The link failed for some reason, possibly because someone\\n # else already has the lock (i.e. we got an EEXIST), or for\\n # some other bizarre reason.\\n if e.errno == errno.ENOENT:\\n # TBD: in some Linux environments, it is possible to get\\n # an ENOENT, which is truly strange, because this means\\n # that self.__tmpfname doesn't exist at the time of the\\n # os.link(), but self.__write() is supposed to guarantee\\n # that this happens! I don't honestly know why this\\n # happens, but for now we just say we didn't acquire the\\n # lock, and try again next time.\\n pass\\n elif e.errno <> errno.EEXIST:\\n # Something very bizarre happened. Clean up our state and\\n # pass the error on up.\\n os.unlink(self.__tmpfname)\\n raise\\n elif self.__linkcount() <> 2:\\n # Somebody's messin' with us!\\n pass\\n elif self.__read() == self.__tmpfname:\\n # It was us that already had the link.\\n raise AlreadyLockedError\\n # otherwise, someone else has the lock\\n pass\\n # We did not acquire the lock, because someone else already has\\n # it. Have we timed out in our quest for the lock?\\n if timeout and timeout_time < time.time():\\n os.unlink(self.__tmpfname)\\n raise TimeOutError\\n # Okay, we haven't timed out, but we didn't get the lock. Let's\\n # find if the lock lifetime has expired.\\n if time.time() > self.__releasetime():\\n # Yes, so break the lock.\\n self.__break()\\n # Okay, someone else has the lock, our claim hasn't timed out yet,\\n # and the expected lock lifetime hasn't expired yet. So let's\\n # wait a while for the owner of the lock to give it up.\\n self.__sleep()\",\n \"def Lock(self, timeout_secs=_DEFAULT_TIMEOUT_SECS):\\n if self._file_desc is not None:\\n raise OSError(\\\"%s has been locked.\\\" % self._file_path)\\n parent_dir = os.path.dirname(self._file_path)\\n if not os.path.exists(parent_dir):\\n os.makedirs(parent_dir)\\n successful = False\\n self._file_desc = os.open(self._file_path, os.O_CREAT | os.O_RDWR,\\n 0o666)\\n try:\\n successful = self._Flock(timeout_secs)\\n finally:\\n if not successful:\\n os.close(self._file_desc)\\n self._file_desc = None\\n return successful\",\n \"def acquire(lockfile, timeout=None):\\n\\tif timeout is None:\\n\\t\\ttimeout = max_timeout # 100yrs should suffice\\n\\tretries = int(float(timeout)/wait_interval)\\n\\n\\t_lock_acquire(lockfile, retries)\\n\\t\\n\\treturn lockfile\",\n \"def lock(tmp_dir, timeout=120, min_wait=5, max_wait=10, verbosity=1):\\r\\n # Create base of lock directory if required.\\r\\n base_lock = os.path.dirname(tmp_dir)\\r\\n if not os.path.isdir(base_lock):\\r\\n try:\\r\\n os.makedirs(base_lock)\\r\\n except OSError:\\r\\n # Someone else was probably trying to create it at the same time.\\r\\n # We wait two seconds just to make sure the following assert does\\r\\n # not fail on some NFS systems.\\r\\n time.sleep(2)\\r\\n assert os.path.isdir(base_lock)\\r\\n\\r\\n # Variable initialization.\\r\\n lock_file = os.path.join(tmp_dir, 'lock')\\r\\n random.seed()\\r\\n my_pid = os.getpid()\\r\\n no_display = (verbosity == 0)\\r\\n\\r\\n nb_error = 0\\r\\n # The number of time we sleep when their is no errors.\\r\\n # Used to don't display it the first time to display it less frequently.\\r\\n # And so don't get as much email about this!\\r\\n nb_wait = 0\\r\\n # Acquire lock.\\r\\n while True:\\r\\n try:\\r\\n last_owner = 'no_owner'\\r\\n time_start = time.time()\\r\\n other_dead = False\\r\\n while os.path.isdir(tmp_dir):\\r\\n try:\\r\\n read_owner = open(lock_file).readlines()[0].strip()\\r\\n # the try is transtion code for old locks\\r\\n # it may be removed when poeple have upgraded\\r\\n try:\\r\\n other_host = read_owner.split('_')[2]\\r\\n except IndexError:\\r\\n other_host = () # make sure it isn't equal to any host\\r\\n if other_host == socket.gethostname():\\r\\n try:\\r\\n os.kill(int(read_owner.split('_')[0]), 0)\\r\\n except OSError:\\r\\n other_dead = True\\r\\n except AttributeError:\\r\\n pass #os.kill does not exist on windows\\r\\n except Exception:\\r\\n read_owner = 'failure'\\r\\n if other_dead:\\r\\n if not no_display:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.warning(\\\"Overriding existing lock by dead %s \\\"\\r\\n \\\"(I am process '%s')\\\", msg, my_pid)\\r\\n get_lock.unlocker.unlock()\\r\\n continue\\r\\n if last_owner == read_owner:\\r\\n if (timeout is not None and\\r\\n time.time() - time_start >= timeout):\\r\\n # Timeout exceeded or locking process dead.\\r\\n if not no_display:\\r\\n if read_owner == 'failure':\\r\\n msg = 'unknown process'\\r\\n else:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.warning(\\\"Overriding existing lock by %s \\\"\\r\\n \\\"(I am process '%s')\\\", msg, my_pid)\\r\\n get_lock.unlocker.unlock()\\r\\n continue\\r\\n else:\\r\\n last_owner = read_owner\\r\\n time_start = time.time()\\r\\n no_display = (verbosity == 0)\\r\\n if not no_display and nb_wait > 0:\\r\\n if read_owner == 'failure':\\r\\n msg = 'unknown process'\\r\\n else:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.info(\\\"Waiting for existing lock by %s (I am \\\"\\r\\n \\\"process '%s')\\\", msg, my_pid)\\r\\n _logger.info(\\\"To manually release the lock, delete %s\\\",\\r\\n tmp_dir)\\r\\n if verbosity <= 1:\\r\\n no_display = True\\r\\n nb_wait += 1\\r\\n time.sleep(random.uniform(min_wait, max_wait))\\r\\n\\r\\n try:\\r\\n os.mkdir(tmp_dir)\\r\\n except OSError:\\r\\n # Error while creating the directory: someone else\\r\\n # must have tried at the exact same time.\\r\\n nb_error += 1\\r\\n if nb_error < 10:\\r\\n continue\\r\\n else:\\r\\n raise\\r\\n # Safety check: the directory should be here.\\r\\n assert os.path.isdir(tmp_dir)\\r\\n\\r\\n # Write own id into lock file.\\r\\n unique_id = refresh_lock(lock_file)\\r\\n\\r\\n # Verify we are really the lock owner (this should not be needed,\\r\\n # but better be safe than sorry).\\r\\n owner = open(lock_file).readlines()[0].strip()\\r\\n if owner != unique_id:\\r\\n # Too bad, try again.\\r\\n continue\\r\\n else:\\r\\n # We got the lock, hoorray!\\r\\n return\\r\\n\\r\\n except Exception, e:\\r\\n # If something wrong happened, we try again.\\r\\n _logger.warning(\\\"Something wrong happened: %s %s\\\", type(e), e)\\r\\n nb_error += 1\\r\\n if nb_error > 10:\\r\\n raise\\r\\n time.sleep(random.uniform(min_wait, max_wait))\\r\\n continue\",\n \"def __init__(self, dir, timeout=None):\\n ExclusiveLock.__init__(self, dir, timeout)\\n writeLockDir = os.path.join(self.dir, WriteLock.fileName)\\n self.writeLock = ExclusiveLock(writeLockDir, timeout)\",\n \"def acquire(self, timeout=None):\\r\\n try:\\r\\n open(self.unique_name, \\\"wb\\\").close()\\r\\n except IOError:\\r\\n raise LockFailed\\r\\n\\r\\n end_time = time.time()\\r\\n if timeout is not None and timeout > 0:\\r\\n end_time += timeout\\r\\n\\r\\n while True:\\r\\n # Try and create a hard link to it.\\r\\n try:\\r\\n os.link(self.unique_name, self.lock_file)\\r\\n except OSError:\\r\\n # Link creation failed. Maybe we've double-locked?\\r\\n nlinks = os.stat(self.unique_name).st_nlink\\r\\n if nlinks == 2:\\r\\n # The original link plus the one I created == 2. We're\\r\\n # good to go.\\r\\n return\\r\\n else:\\r\\n # Otherwise the lock creation failed.\\r\\n if timeout is not None and time.time() > end_time:\\r\\n os.unlink(self.unique_name)\\r\\n if timeout > 0:\\r\\n raise LockTimeout\\r\\n else:\\r\\n raise AlreadyLocked\\r\\n time.sleep(timeout is not None and timeout/10 or 0.1)\\r\\n else:\\r\\n # Link creation succeeded. We're good to go.\\r\\n return\",\n \"def acquire(self):\\n start_time = time.time()\\n while True:\\n # 当前文件锁对象未有加锁，执行加锁\\n if self.fd is None:\\n try:\\n # 独占式打开文件\\n lock_dir = os.path.dirname(self.lockfile)\\n if not os.path.isdir(lock_dir):\\n os.makedirs(lock_dir, exist_ok=True)\\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n break\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n # 超时\\n if (time.time() - start_time) >= self.timeout:\\n raise FileLockException(\\\"Timeout occured.\\\")\\n # 本次加锁失败，需要等待\\n time.sleep(self.delay)\\n self.is_locked = True\",\n \"def __init__(self, dir, timeout=None, readlocktimeout=None):\\n ExclusiveLock.__init__(self, dir, timeout)\\n if readlocktimeout is None:\\n self.readlocktimeout = timeout\\n else:\\n self.readlocktimeout = readlocktimeout\",\n \"def acquire(self, timeout=None):\\n if self._locked:\\n raise RuntimeError(\\\"lock already locked\\\")\\n if self.writeLock.acquire(timeout):\\n try:\\n self.lockDir = tempfile.mkdtemp('', self.fileName, self.dir)\\n self._locked = True\\n # log('acquired read lock: %s\\\\n' % self.lockDir)\\n return True\\n finally:\\n self.writeLock.release() \\n return False\",\n \"def testUnlockWait(t, env):\\n c = env.c1\\n c.init_connection()\\n fh, stateid = c.create_confirm(t.code)\\n res = c.lock_file(t.code, fh, stateid, 20, 100)\\n check(res, msg=\\\"Locking file %s\\\" % t.code)\\n sleeptime = c.getLeaseTime() * 2\\n env.sleep(sleeptime)\\n ops = c.use_obj(fh)\\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\\n _replay(c, ops, [NFS4_OK, NFS4ERR_EXPIRED])\",\n \"def __init__(self, lockfile, lifetime=DEFAULT_LOCK_LIFETIME):\\n self.__lockfile = lockfile\\n self.__lifetime = lifetime\\n # This works because we know we're single threaded\\n self.__counter = LockFile.COUNTER\\n LockFile.COUNTER += 1\\n self.__tmpfname = '%s.%s.%d.%d' % (lockfile, \\n socket.gethostname(),\\n os.getpid(),\\n self.__counter)\",\n \"def _file_open_rlock(self, preset_type, timeout=1.0):\\n\\n if self._fd is None:\\n path = self._path(preset_type)\\n with open(path, 'r+') as fd:\\n # Set up file lock timeout with a raising handler\\n # We will need this handler due to PEP 475\\n def interrupt(signum, frame):\\n raise InterruptedError()\\n\\n old_handler = signal.signal(signal.SIGALRM, interrupt)\\n try:\\n signal.setitimer(signal.ITIMER_REAL, timeout)\\n fcntl.flock(fd, fcntl.LOCK_EX)\\n except InterruptedError:\\n # Ignore interrupted and proceed to cleanup\\n pass\\n finally:\\n # Clean up file lock timeout\\n signal.setitimer(signal.ITIMER_REAL, 0)\\n signal.signal(signal.SIGALRM, old_handler)\\n # Error now if we still can't get the lock.\\n # Getting lock twice is safe.\\n fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n logger.debug('acquired lock for %s', path)\\n self._fd = fd\\n yield fd\\n fcntl.flock(fd, fcntl.LOCK_UN)\\n logger.debug('released lock for %s', path)\\n self._fd = None\\n else:\\n logger.debug('using already open file descriptor')\\n yield self._fd\",\n \"def __init__(self, fname, lockduration=10, verbosity=0):\\n self._verbosity = verbosity\\n self._lockduration = lockduration\\n fname = op.normpath(fname)\\n self._basedir = op.dirname(fname)\\n self._lockfilename = \\\"%s.lock\\\" % op.basename(fname)\\n self._uniquename = \\\",\\\".join((\\n self._lockfilename, socket.getfqdn(), str(os.getpid()),\\n str(uuid.uuid4())[-12:],\\n ))\\n self._uniquefile_created = False\\n self._p(\\\" File to lock: %s\\\" % fname)\\n self._p(\\\"Lockfile name: %s\\\" % self._lockfilename)\\n self._p(\\\" Unique name: %s\\\" % self._uniquename)\",\n \"def testLock(t, env):\\n c = env.c1\\n c.init_connection()\\n # Create a file and partially lock it\\n fh, stateid = c.create_confirm(t.code)\\n res = c.lock_file(t.code, fh, stateid, 20, 100)\\n check(res, msg=\\\"Locking file %s\\\" % t.code)\\n # Create and replay LOCK ops\\n ops = c.use_obj(fh)\\n lock_owner = exist_lock_owner4(res.lockid, 1)\\n locker = locker4(FALSE, lock_owner=lock_owner)\\n ops += [c.lock_op(WRITE_LT, FALSE, 0, 10, locker)]\\n _replay(c, ops)\",\n \"def FSLockExclusive(filepath, timeout=None):\\n return _lock(filepath, True, timeout=timeout)\",\n \"def _wait_for_lockfile(self, lockfile_path: Path) -> None:\\n if not lockfile_path.exists():\\n return\\n\\n # The first second is free.\\n start = time.time()\\n time.sleep(1)\\n if not lockfile_path.exists():\\n return\\n\\n # After the first second, we print one message, then we stay silent for 10 minutes, at\\n # which time we print a message every minute.\\n def time_elapsed() -> float:\\n return time.time() - start\\n self.logger.info(\\\"Starting to wait for %s\\\", lockfile_path)\\n next_message_time = time.time() + 16 * 60\\n while lockfile_path.exists():\\n if next_message_time - time.time() < 0:\\n self.logger.warning(\\n \\\"Lockfile %s has been blocked for %.0f seconds\\\",\\n lockfile_path,\\n time_elapsed())\\n next_message_time = time.time() + 60\\n time.sleep(1)\",\n \"def _Flock(self, timeout_secs):\\n try:\\n if timeout_secs > 0:\\n wrapper = utils.TimeoutException(timeout_secs)\\n wrapper(fcntl.flock)(self._file_desc, fcntl.LOCK_EX)\\n else:\\n fcntl.flock(self._file_desc, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n except errors.FunctionTimeoutError as e:\\n logger.debug(\\\"Cannot lock %s within %s seconds\\\",\\n self._file_path, timeout_secs)\\n return False\\n except (OSError, IOError) as e:\\n # flock raises IOError in python2; OSError in python3.\\n if e.errno in (errno.EACCES, errno.EAGAIN):\\n logger.debug(\\\"Cannot lock %s\\\", self._file_path)\\n return False\\n raise\\n return True\",\n \"def test_waits_on_existing_lockfile(self):\\n self.lock.__enter__()\\n self.assertTrue(os.path.exists(self.lock.lockfile_path))\\n\\n def exit_first_lock():\\n time.sleep(0.1)\\n self.lock.__exit__(None, None, None)\\n thread = threading.Thread(target=exit_first_lock)\\n thread.start()\\n\\n new_lock = disk.DiskDatasetLock(self.dataset, timeout_sec=1)\\n new_lock.__enter__()\\n\\n thread.join()\",\n \"def acquire(path, onwait=None):\\r\\n\\r\\n touch(path)\\r\\n lock_fd = lock_file(path, blocking=False)\\r\\n if not lock_fd:\\r\\n blocking = True\\r\\n with open(path, 'r') as fd:\\r\\n pid = int(fd.read().strip())\\r\\n if onwait:\\r\\n blocking = onwait(pid)\\r\\n if not blocking:\\r\\n return None\\r\\n lock_fd = lock_file(path, blocking=blocking)\\r\\n\\r\\n lock_fd.truncate(0)\\r\\n lock_fd.write('%d\\\\n' % os.getpid())\\r\\n lock_fd.flush()\\r\\n return Lock(lock_fd)\",\n \"def _lock_process(pipe, filepath, exclusive, timeout=None):\\n try:\\n # Reset signal handlers\\n signal.signal(signal.SIGINT, signal.SIG_DFL)\\n signal.signal(signal.SIGHUP, signal.SIG_DFL)\\n signal.signal(signal.SIGTERM, signal.SIG_DFL)\\n\\n # Open the file\\n mode = os.O_RDONLY | os.O_CREAT if exclusive else os.O_RDONLY\\n try:\\n fd = os.open(filepath, mode)\\n except FileNotFoundError:\\n pipe.send('NOTFOUND')\\n return\\n\\n # Lock it\\n op = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH\\n if timeout is None:\\n fcntl.flock(fd, op)\\n elif timeout == 0:\\n try:\\n fcntl.flock(fd, op | fcntl.LOCK_NB)\\n except BlockingIOError:\\n pipe.send('TIMEOUT')\\n return\\n else:\\n with timeout_syscall(timeout):\\n try:\\n fcntl.flock(fd, op)\\n except InterruptedError:\\n pipe.send('TIMEOUT')\\n return\\n pipe.send('LOCKED')\\n except Exception:\\n pipe.send('ERROR')\\n raise\\n\\n # Wait for unlock message then exit\\n assert pipe.recv() == 'UNLOCK'\\n\\n # Exiting releases the lock\",\n \"def acquire(self, timeout=None):\\n timer = self.timerClass(timeout)\\n timer.start()\\n while timer.haveTime():\\n try:\\n os.mkdir(self.lockDir)\\n self._locked = True\\n # log('acquired exclusive lock: %s\\\\n' % (self.lockDir, ))\\n return True\\n except OSError, err:\\n if err.errno != errno.EEXIST:\\n raise\\n if self.expire():\\n continue # Try immediately to acquire\\n timer.sleep()\\n return False\",\n \"def AcquireFileLock(target_file, flags):\\n assert flags in (\\n LOCK_EX, LOCK_SH, LOCK_NB, LOCK_EX | LOCK_NB, LOCK_SH | LOCK_NB)\\n if os.name == 'nt':\\n _LockImplWin(target_file, flags)\\n elif os.name == 'posix':\\n _LockImplPosix(target_file, flags)\\n else:\\n raise NotImplementedError('%s is not supported' % os.name)\",\n \"def make_pidlockfile(path, acquire_timeout):\\n if not isinstance(path, basestring):\\n error = ValueError(\\\"Not a filesystem path: %(path)r\\\" % vars())\\n raise error\\n if not os.path.isabs(path):\\n error = ValueError(\\\"Not an absolute path: %(path)r\\\" % vars())\\n raise error\\n lockfile = pidlockfile.TimeoutPIDLockFile(path, acquire_timeout)\\n\\n return lockfile\",\n \"def test_locked_file_03(self):\\n \\n f = open(\\\"tests/locked.db3\\\", \\\"a+\\\")\\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \\n \\n x = subprocess.Popen([\\\"sqlbak\\\", \\\"tests\\\", \\\"--ms-towait=4000\\\"],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT)\\n\\n time.sleep(3)\\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\\n f.close()\\n\\n result = x.communicate()[0]\\n\\n self.assertTrue(\\\"cannot obtain lock\\\" not in result)\",\n \"def _lock(self):\\n self._create_unique_file()\\n while True:\\n try:\\n self._extend_expiration_time() # in case we had to wait...\\n os.link(self.uniquefile, self.lockfile)\\n self._p(\\\"Lock successfully acquired.\\\")\\n return\\n except OSError as e:\\n if e.errno in self.NOT_EXIST_ERRORS:\\n # Didn't work for some reason. Try again in a bit.\\n pass\\n elif e.errno == errno.EEXIST:\\n links = self._count_links()\\n if links == 2 and self._read_lockfile() == self._uniquename:\\n raise AlreadyLockedError(\\\"Lock already exists.\\\")\\n else:\\n # An unexpected error occurred.\\n self._remove_unique_file()\\n raise\\n # Release expired lock of the others.\\n if self._has_expired():\\n self._break_foreign_lock()\\n time.sleep(2)\\n continue\\n # No luck getting the lock.\\n self._p(\\\"Locked by someone else. Waiting to retry...\\\", level=1)\\n time.sleep(5)\",\n \"def test_file_lock_busy(get_config, monkeypatch, config_dict):\\n cfg = get_config(DeviceConfig, config_dict.get('str'))\\n # just ignore time sleep\\n monkeypatch.setattr(time, 'sleep', lambda x: None)\\n file_lock = FileLock(cfg.config_path, timeout=.1)\\n with file_lock:\\n file_lock.acquire()\\n with pytest.raises(Exception):\\n assert cfg.write()\\n assert cfg.read()\\n\\n # assert res == None, 'lock acquired but should not'\",\n \"def lock (self):\\n self._createLockFileIfNeeded()\\n self._lockHandle=open(self._lockFileName, \\\"r\\\")\\n fcntl.flock(self._lockHandle, fcntl.LOCK_EX)\",\n \"def create_lock_file():\\n\\n print(\\\"Creating lock file\\\")\",\n \"def __init__(self, file_name, exclusive=None):\\n self.file_name = file_name\\n self.exclusive = exclusive\\n self.filelock = Event()\",\n \"def FSLockShared(filepath, timeout=None):\\n return _lock(filepath, False, timeout=timeout)\",\n \"def lock(path, timeout, create=True):\\n # ``FileLock`` requires that the to-be-locked file exists; if it\\n # does not, we create an empty one (and avoid overwriting any\\n # content, in case another process is also writing to it). There\\n # is thus no race condition here, as we attempt to lock the file\\n # anyway, and this will stop concurrent processes.\\n if not os.path.exists(path) and create:\\n open(path, \\\"a\\\").close()\\n created = True\\n else:\\n created = False\\n try:\\n lck = lockfile.FileLock(path, threaded=False)\\n lck.acquire(timeout=timeout)\\n except Exception:\\n if created:\\n try:\\n os.remove(path)\\n except:\\n pass\\n raise\\n return lck\",\n \"def acquire(self, timeout=None):\\r\\n pass\",\n \"def acquire(self, exclusive=None):\\n self.filelock.clear()\\n self.locked = True\\n self.exclusive = exclusive\",\n \"def acquire(self, exclusive=None):\\n self.filelock.clear()\\n self.locked = True\\n self.exclusive = exclusive\",\n \"def _openLockFile(self):\\n lock_file = self._getLockFile()\\n self.stream_lock = open(lock_file, \\\"w\\\")\",\n \"def lock(self):\\n\\n\\t\\t# Acquire the threading lock first\\n\\t\\tself.s.acquire()\\n\\t\\t# Acquire the file lock\\n\\t\\tfcntl.lockf(self.lockfile, fcntl.LOCK_EX)\",\n \"def wait(lock_path, duration_s):\\n with filelock.FileLock(lock_path, 3 * 60):\\n # We can't use time.monotonic() as we're comparing time between processes and\\n # time.monotonic() explicitly does not support that\\n # This means the test can fail during leap seconds, but this is only a test, we\\n # don't need total reliability\\n print(time.time())\\n time.sleep(duration_s)\\n print(time.time())\",\n \"def acquire(self, blocking=True):\\n\\n start_time = time.time()\\n while True:\\n try:\\n # Attempt to create the lockfile.\\n # These flags cause os.open to raise an OSError if the file already exists.\\n fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n with os.fdopen(fd, \\\"a\\\") as f:\\n # Print some info about the current process as debug info for anyone who bothers to look.\\n f.write(self._lock_file_contents)\\n break\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n if self.timeout is not None and (time.time() - start_time) >= self.timeout:\\n raise FileLock.FileLockException(\\\"Timeout occurred for lock '{!s}'.\\\".format(self.lockfile))\\n if not blocking:\\n return False\\n time.sleep(self.delay)\\n self.is_locked = True\\n return True\",\n \"def update_lock_timeout(self, timeout):\\n\\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\\n raise FatalError(\\\"Timeout is out of range!\\\")\\n elif not self._in_use:\\n raise CoreError(\\\"This SystemUnderTest is not currently checked-out!\\\")\\n\\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)\",\n \"def _lock(self):\\n self._thread_lock.acquire()\\n try:\\n self._file.open_and_lock()\\n except IOError as e:\\n if e.errno == errno.ENOSYS:\\n logger.warn('File system does not support locking the '\\n 'credentials file.')\\n elif e.errno == errno.ENOLCK:\\n logger.warn('File system is out of resources for writing the '\\n 'credentials file (is your disk full?).')\\n elif e.errno == errno.EDEADLK:\\n logger.warn('Lock contention on multistore file, opening '\\n 'in read-only mode.')\\n else:\\n raise\\n if not self._file.is_locked():\\n self._read_only = True\\n if self._warn_on_readonly:\\n logger.warn('The credentials file (%s) is not writable. '\\n 'Opening in read-only mode. Any refreshed '\\n 'credentials will only be '\\n 'valid for this run.', self._file.filename())\\n if os.path.getsize(self._file.filename()) == 0:\\n logger.debug('Initializing empty multistore file')\\n # The multistore is empty so write out an empty file.\\n self._data = {}\\n self._write()\\n elif not self._read_only or self._data is None:\\n # Only refresh the data if we are read/write or we haven't\\n # cached the data yet. If we are readonly, we assume is isn't\\n # changing out from under us and that we only have to read it\\n # once. This prevents us from whacking any new access keys that\\n # we have cached in memory but were unable to write out.\\n self._refresh_data_cache()\",\n \"def force_unlock():\\r\\n global timeout_before_override\\r\\n timeout_backup = timeout_before_override\\r\\n timeout_before_override = 0\\r\\n try:\\r\\n get_lock(min_wait=0, max_wait=0.001)\\r\\n release_lock()\\r\\n finally:\\r\\n timeout_before_override = timeout_backup\",\n \"def test_temp_file_lock(tmp_path, monkeypatch):\\n monkeypatch.setenv(\\\"RAY_TMPDIR\\\", str(tmp_path))\\n assert str(tmp_path) in ray._private.utils.get_user_temp_dir()\\n with TempFileLock(path=\\\"abc.txt\\\"):\\n assert RAY_LOCKFILE_DIR in os.listdir(tmp_path)\\n assert os.listdir(tmp_path / RAY_LOCKFILE_DIR)\",\n \"def withFileLock(reason=\\\"unknown\\\"):\\n\\n if _lock_tracing:\\n my_print(getThreadIdent(), \\\"Want file lock for %s\\\" % reason)\\n file_lock.acquire()\\n if _lock_tracing:\\n my_print(getThreadIdent(), \\\"Acquired file lock for %s\\\" % reason)\\n yield\\n if _lock_tracing:\\n my_print(getThreadIdent(), \\\"Released file lock for %s\\\" % reason)\\n file_lock.release()\",\n \"def heartbeat(self):\\n timeout_at = time.time() + self.timeout\\n\\n try:\\n os.utime(self.filename, (timeout_at, timeout_at))\\n\\n except OSError as err:\\n if err.errno == errno.ENOENT:\\n _LOGGER.warning('Lost lease file: %r', self.filename)\\n self._write(timeout_at)\\n else:\\n raise\",\n \"def test_locked_file_01(self):\\n \\n f = open(\\\"tests/locked.db3\\\", \\\"a+\\\")\\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \\n \\n x = subprocess.Popen([\\\"sqlbak\\\", \\\"tests\\\"],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT)\\n\\n time.sleep(1)\\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\\n f.close()\\n\\n result = x.communicate()[0]\\n\\n self.assertTrue(\\\"cannot obtain lock\\\" not in result)\",\n \"def acquire_lock_1(force, lock_file=None):\\n if lock_file is None:\\n lock_file = config.LOCK_FILE\\n lock = Lock(lock_file, LOCK_LIFETIME)\\n try:\\n lock.lock(timedelta(seconds=0.1))\\n return lock\\n except TimeOutError:\\n if not force:\\n raise\\n # Force removal of lock first.\\n lock.disown()\\n hostname, pid, tempfile = lock.details\\n os.unlink(lock_file)\\n return acquire_lock_1(force=False)\",\n \"def __init__(self, exclusive=None):\\n self.filelock = Event()\\n self.locked = False\\n self.exclusive = False\",\n \"def __init__(self,filename,**kwargs):\\n modlogger.debug( \\\"LF:%s %s\\\"%(filename,kwargs))\\n self.fname = filename\\n reserve = kwargs.get(\\\"reserve\\\",DEFAULT_LOGSZ)\\n reserve = max(reserve,MINIMUM_LOGSZ)\\n self.ro = kwargs.get(\\\"readonly\\\",False)\\n\\n mode = \\\"wb+\\\" if not self.ro else \\\"rb\\\"\\n self.fd = open(filename,mode)\\n #FIXME: In the case that this is a new file\\n #we should sync the directory fd (which means opening one).\\n \\n #We detect sparse logfile, and dont really support\\n # them properly.\\n self.sparse = False\\n self.not_complete_lock = threading.Lock()\\n self.not_complete = []\\n self.closing = False \\n self.outstanding = threading.Condition(self.not_complete_lock)\\n \\n if not self.ro: self._reserve(reserve)\",\n \"def __init__(self, directory ,**kwargs ): \\n self.home = directory\\n self.track_state = kwargs.get('track_state',True)\\n\\n self.last_opid = -1 #cleanup\\n try:\\n os.remove(tstfile) \\n except Exception:\\n pass \\n\\n\\n #id_lock prevents new transactions being created \\n # and protect last_opid.\\n self.id_lock = threading.Lock() \\n #not_complete_lock protects the not_complete list, prevents\\n #transaction being submitted and is used for the \\n #outstanding condition variable. Always acquire not_complete_lock\\n #before id_lock\\n self.oldlogtx = -1\\n self.tx = None\\n\\n if kwargs.pop('recover',True): self._recover()\\n self.frozen = False #FIXME: In the case that this is a new file\\n #we also should sync the directory fd (which means opening one).\\n \\n self.logf = None\\n self.in_use_logs = []\\n self.logsync = threading.Semaphore(0)\\n self.loglocker = RWLock()\\n self.rotatelog(**kwargs)\",\n \"def set_lock(self, process):\\n if not os.path.isdir(self.args.dir[process]):\\n os.system('mkdir -p ' + self.args.dir[process])\\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\\n lockFN = os.path.join(self.args.dir[process], \\\\\\n '.lock_pose%03d'%self.args.params['CD']['pose'])\\n else:\\n lockFN = os.path.join(self.args.dir[process], '.lock')\\n if os.path.isfile(lockFN):\\n raise Exception(process + ' is locked')\\n else:\\n lockF = open(lockFN, 'w')\\n lockF.close()\\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\\n logFN = os.path.join(self.args.dir[process],'%s_pose%03d_log.txt'%(\\\\\\n process, self.args.params['CD']['pose']))\\n else:\\n logFN = os.path.join(self.args.dir[process], process + '_log.txt')\\n self.log = open(logFN, 'a')\",\n \"def lock_init(self, file_path=None, file_hash=None):\\n\\n with locks_db.atomic() as transaction: # Opens new transaction.\\n try:\\n self.lock_obj.lock_init(file_path=file_path, file_hash=file_hash)\\n except Exception as ex:\\n locks_db.rollback()\\n raise ex\",\n \"def set_lock_time():\\n\\n pass\",\n \"def test_multiple_file_locks(tmp_path, monkeypatch):\\n monkeypatch.setenv(\\\"RAY_TMPDIR\\\", str(tmp_path))\\n with TempFileLock(path=\\\"abc.txt\\\"):\\n with TempFileLock(path=\\\"subdir/abc.txt\\\"):\\n assert RAY_LOCKFILE_DIR in os.listdir(tmp_path)\\n # We should have 2 locks, one for abc.txt and one for subdir/abc.txt\\n assert len(os.listdir(tmp_path / RAY_LOCKFILE_DIR)) == 2\",\n \"def acquire(self):\\n BaseRotatingHandler.acquire(self)\\n if self.stream_lock:\\n if self.stream_lock.closed:\\n try:\\n self._openLockFile()\\n except Exception:\\n self.stream_lock = None\\n return\\n lock(self.stream_lock, LOCK_EX)\",\n \"def test_creates_lockfile_on_enter(self):\\n self.lock.__enter__()\\n self.assertTrue(os.path.exists(self.lock.lockfile_path))\",\n \"def acquire(self, blocking=True):\\n ops = fcntl.LOCK_EX\\n if not blocking:\\n ops |= fcntl.LOCK_NB\\n fcntl.flock(self.lock_file, ops)\",\n \"def test_lock_timeout():\\n lock_unlock_timeout(0)\",\n \"def test_locked_file_02(self):\\n \\n f = open(\\\"tests/locked.db3\\\", \\\"a+\\\")\\n fcntl.lockf(f.fileno(), fcntl.LOCK_EX) \\n \\n x = subprocess.Popen([\\\"sqlbak\\\", \\\"tests\\\"],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT)\\n\\n time.sleep(3)\\n fcntl.lockf(f.fileno(), fcntl.LOCK_UN)\\n f.close()\\n\\n result = x.communicate()[0]\\n\\n self.assertTrue(\\\"cannot obtain lock\\\" in result)\\n self.assertTrue(\\\"lock held by pid %d\\\" % os.getpid() in result)\",\n \"def __enter__(self):\\n\\t\\tmode = 'r+' if os.path.exists(self.filename) else 'w'\\n\\t\\tself.file = open(self.filename, mode)\\n\\t\\ttry:\\n\\t\\t\\tfcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n\\t\\texcept IOError, e:\\n\\t\\t\\tsys.exit('Unable to obtain lock on %s, probably due to other ' \\n\\t\\t\\t\\t'running instances of pydbpintegrator.' % self.filename)\\n\\t\\treturn self\",\n \"def test_syncer_wait_or_retry_timeout(temp_data_dirs, tmp_path):\\n tmp_source, tmp_target = temp_data_dirs\\n\\n def slow_upload(*args, **kwargs):\\n time.sleep(5)\\n\\n class HangingSyncer(_FilesystemSyncer):\\n def _sync_up_command(\\n self, local_path: str, uri: str, exclude: Optional[List] = None\\n ):\\n return (\\n slow_upload,\\n dict(local_path=local_path, uri=uri, exclude=exclude),\\n )\\n\\n syncer = HangingSyncer(\\n storage_filesystem=_create_mock_custom_fs(tmp_path),\\n sync_period=60,\\n sync_timeout=0.1,\\n )\\n\\n syncer.sync_up(local_dir=tmp_source, remote_dir=\\\"/test/timeout\\\")\\n with pytest.raises(RuntimeError) as e:\\n syncer.wait_or_retry(max_retries=3, backoff_s=0)\\n assert \\\"Failed sync even after 3 retries.\\\" in str(e.value)\\n assert isinstance(e.value.__cause__, TimeoutError)\",\n \"def testLockWithTimeout(self, mock_timeout_exception):\\n mock_wrapped_flock = mock.Mock(side_effect=errors.FunctionTimeoutError)\\n mock_wrapper = mock.Mock(return_value=mock_wrapped_flock)\\n mock_timeout_exception.return_value = mock_wrapper\\n\\n self.assertFalse(self._lock.Lock(timeout_secs=1))\\n\\n mock_wrapper.assert_called_once_with(fcntl.flock)\\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\\n mock_wrapper.reset_mock()\\n mock_wrapped_flock.reset_mock()\\n\\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=1))\\n\\n mock_wrapper.assert_called_once_with(fcntl.flock)\\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\",\n \"def acquire_exclusive_nb_flock(lockfd, max_retry=5, wait_interval=5):\\n return _acquire_file_lock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB,\\n max_retry, wait_interval)\",\n \"def acquire(self):\\n if pidfile_exists(self.path):\\n error = AlreadyLocked()\\n raise error\\n try:\\n write_pid_to_pidfile(self.path)\\n except OSError:\\n error = LockFailed()\\n raise error\",\n \"def testLock(self):\\n self.assertTrue(self._lock.LockIfNotInUse())\\n self.assertTrue(os.path.isfile(self._lock_path))\\n self._lock.Unlock()\\n\\n self.assertTrue(self._lock.LockIfNotInUse(timeout_secs=0))\\n self._lock.SetInUse(True)\\n self._lock.Unlock()\\n\\n self.assertFalse(self._lock.LockIfNotInUse())\\n\\n self.assertTrue(self._lock.Lock())\\n self._lock.SetInUse(False)\\n self._lock.Unlock()\\n\\n self.assertTrue(self._lock.Lock(timeout_secs=0))\\n self._lock.Unlock()\",\n \"def __init__(self, filename, mode='a', maxBytes=512*1024*1024,\\r\\n backupCount=10):\\r\\n# FileHandler.__init__(self, filename, mode)\\r\\n if maxBytes > 0:\\r\\n mode = 'a' # doesn't make sense otherwise!\\r\\n FileHandler.__init__(self, filename, mode)\\r\\n self.maxBytes = maxBytes\\r\\n self.backupCount = backupCount\\r\\n self.counter = 0\\r\\n self.every = 10\",\n \"def test_prep_file(self, mock_open):\\n path = \\\"/tmp/foo\\\"\\n request = DownloadRequest(None, None, None, path)\\n download_threads._MultithreadedDownloader._prep_file(request)\\n mock_open.assert_called_once_with(path, \\\"wb\\\")\\n\\n mock_open.return_value.close.assert_called_once_with()\",\n \"def __init__(self, path, threaded=True):\\r\\n LockBase.__init__(self, path)\\r\\n if threaded:\\r\\n tname = \\\"%x-\\\" % thread.get_ident()\\r\\n else:\\r\\n tname = \\\"\\\"\\r\\n # Lock file itself is a directory. Place the unique file name into\\r\\n # it.\\r\\n self.unique_name = os.path.join(self.lock_file,\\r\\n \\\"%s.%s%s\\\" % (self.hostname,\\r\\n tname,\\r\\n self.pid))\",\n \"def locked_call(callable: Callable[[], Any], lock_file: str, lock_timeout: int) -> Any:\\n lock = SoftFileLock(lock_file, timeout=lock_timeout)\\n with lock.acquire(timeout=lock_timeout):\\n return callable()\",\n \"def lock(self, name, timeout=None, sleep=0.1):\\n return Lock(self, name, timeout=timeout, sleep=sleep)\",\n \"def __call__(self, resource: LockResource, timeout: timedelta) -> Lock:\",\n \"def acquire_shared_nb_flock(lockfd, max_retry=5, wait_interval=5):\\n return _acquire_file_lock(lockfd, fcntl.LOCK_SH | fcntl.LOCK_NB,\\n max_retry, wait_interval)\",\n \"def acquire(self):\\r\\n self.log('acquire enter')\\r\\n\\r\\n start = datetime.now()\\r\\n\\r\\n # try and fetch the lock, looping until it's available\\r\\n while not self.try_acquire():\\r\\n if (datetime.now() - start).seconds > self.timeout:\\r\\n raise TimeoutExpired\\r\\n sleep(0.1)\\r\\n\\r\\n self.log('acquire exit')\",\n \"def set_open_file_limit(soft_limit: int) -> None:\\n if os.name != 'nt': # resource module not available on Windows OS\\n curr_soft_limit, curr_hard_limit = resource.getrlimit(\\n resource.RLIMIT_NOFILE)\\n if curr_soft_limit < soft_limit < curr_hard_limit:\\n resource.setrlimit(\\n resource.RLIMIT_NOFILE, (soft_limit, curr_hard_limit))\\n logger.debug(\\n 'Open file descriptor soft limit set to %d' %\\n soft_limit)\",\n \"def __init__(self, lock_name, try_count=0, sleep_seconds=__SLEEP_SECONDS,\\n expire_milliseconds=None):\\n self._lock_key = db.Key.from_path(LockModel.kind(), lock_name)\\n self._acquired_lock = None\\n self._try_count = try_count\\n self._sleep_seconds = sleep_seconds\\n\\n if expire_milliseconds is None:\\n expire_milliseconds = self.__MAX_LOCK_MILLISECONDS\\n self._expire_timedelta = datetime.timedelta(\\n milliseconds=expire_milliseconds\\n )\",\n \"def _file_lock(file_handle):\\n lock = False\\n try:\\n _platform_lock(file_handle)\\n lock = True\\n yield\\n finally:\\n if lock:\\n _platform_unlock(file_handle)\",\n \"def _lock(self):\\n self._lockFile = open(self._lockFilename, \\\"w\\\")\\n self._lockFile.write(\\\"%d\\\" % (os.getpid()))\\n self._lockFile.flush()\",\n \"def file(self, file_h):\\n if os.path.exists(file_h):\\n self._file = file_h\\n self._lockedFile = self._file + consts.LOCKED_NOTIFIER\\n self.locked = self.is_locked\\n else:\\n self._file = None\\n self._lockedFile = None\",\n \"def _setup_lock(self):\\n\\n try:\\n ml2_config.cfg.CONF.set_override('lock_path', \\\"lock\\\")\\n except ml2_config.cfg.NoSuchOptError:\\n ml2_config.cfg.CONF.set_override(\\n 'lock_path', \\\"lock\\\", \\\"oslo_concurrency\\\")\",\n \"def close_file(self):\\n SpooledTemporaryFile.flush(self)\\n response = requests.post(LOCK_SERVER_ADDR, json={'file_path': self.filename, 'lock_file': False, 'user_id': self.user_id})\\n print response\",\n \"def min_file_install_timeout(self):\\n raise DeviceException(DeviceException.FEATURE_NOT_IMPLEMENTED)\",\n \"def set_wait_timeout(self, timeout):\\n self.__wait_timeout = timeout\",\n \"def set_import_timeout(self, value):\\n\\t\\tself.spinImportTimeout.set_value(value)\",\n \"def testLockDenied(t, env):\\n c = env.c1\\n c.init_connection()\\n # Create a file and lock it\\n fh, stateid = c.create_confirm(t.code)\\n res1 = c.lock_file(t.code, fh, stateid, 20, 100)\\n check(res1, msg=\\\"Locking file %s for first owner\\\" % t.code)\\n res2 = c.lock_file(t.code, fh, stateid, 0, 10)\\n check(res2, msg=\\\"Locking file %s for second owner\\\" % t.code)\\n # Create and replay LOCK ops\\n ops = c.use_obj(fh)\\n lock_owner = exist_lock_owner4(res1.lockid, 1)\\n locker = locker4(FALSE, lock_owner=lock_owner)\\n ops += [c.lock_op(WRITE_LT, FALSE, 0, 10, locker)]\\n _replay(c, ops, NFS4ERR_DENIED)\",\n \"def testUnlock(t, env):\\n c = env.c1\\n c.init_connection()\\n fh, stateid = c.create_confirm(t.code)\\n res = c.lock_file(t.code, fh, stateid, 20, 100)\\n check(res, msg=\\\"Locking file %s\\\" % t.code)\\n ops = c.use_obj(fh)\\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\\n _replay(c, ops)\",\n \"def lock_file(path):\\n #TODO if open fails and the lockfile is present, check its creation date\\n # and, if it's more than ??? remove it and retry\\n # pylint: disable=global-statement\\n try:\\n lock_fd = os.open(path, os.O_CREAT | os.O_WRONLY | os.O_EXCL)\\n except OSError:\\n return False\\n else:\\n global LOCK_FILENAME\\n LOCK_FILENAME = path\\n os.close(lock_fd)\\n return True\",\n \"def test_lock_timeout_loop():\\n lock_unlock_timeout(0.2)\",\n \"def test_syncer_hanging_sync_with_timeout(temp_data_dirs, tmp_path):\\n tmp_source, tmp_target = temp_data_dirs\\n\\n def _hanging_sync_up_command(*args, **kwargs):\\n time.sleep(200)\\n\\n class _HangingSyncer(_FilesystemSyncer):\\n def _sync_up_command(\\n self, local_path: str, uri: str, exclude: Optional[List] = None\\n ):\\n return _hanging_sync_up_command, {}\\n\\n syncer = _HangingSyncer(\\n storage_filesystem=_create_mock_custom_fs(tmp_path),\\n sync_period=60,\\n sync_timeout=10,\\n )\\n\\n def sync_up():\\n return syncer.sync_up(\\n local_dir=tmp_source, remote_dir=\\\"/test/test_syncer_timeout\\\"\\n )\\n\\n with freeze_time() as frozen:\\n assert sync_up()\\n frozen.tick(5)\\n # 5 seconds - initial sync hasn't reached the timeout yet\\n # It should continue running without launching a new sync\\n assert not sync_up()\\n frozen.tick(5)\\n # Reached the timeout - start running a new sync command\\n assert sync_up()\\n frozen.tick(20)\\n # We're 10 seconds past the timeout, waiting should result in a timeout error\\n with pytest.raises(TimeoutError):\\n syncer.wait()\",\n \"def __init__(self, default_timeout = 300.0):\\n dict.__init__(self)\\n self._timeouts = {}\\n self._default_timeout = default_timeout\\n self._lock = threading.RLock()\",\n \"def lock(lockfile, flags):\\n fd = os.open(lockfile, flags)\\n fcntl.lockf(fd, fcntl.LOCK_EX)\\n return fd\",\n \"def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=0, utc=0, maxBytes=0):\\n # super(self). #It's old style class, so super doesn't work.\\n logging.handlers.TimedRotatingFileHandler.__init__(self, filename, when, interval, backupCount, encoding, delay, utc)\\n self.maxBytes=maxBytes\",\n \"def locked_build(args):\\n ### NOTE: we do not delete/clean up this file, as that may interfere\\n ### with other processes. Just leave 'em around. Zero length files.\\n with open(f'{SCRATCH_DIR}/{args.project}.lock', 'w') as fp:\\n start_time = time.time()\\n\\n while (time.time() - start_time) < 120:\\n try:\\n fcntl.flock(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n except BlockingIOError:\\n print(f'WARNING: Building for \\\"{args.project}\\\" is locked, trying again in 10 seconds.')\\n # Pause a bit, then loop.\\n time.sleep(10)\\n continue\\n # Got the lock!\\n\\n try:\\n start_build(args)\\n finally:\\n # Done, or errored. Release the lock.\\n fcntl.flock(fp, fcntl.LOCK_UN)\\n\\n # All done.\\n return\\n\\n print(\\\"ERROR: Could not acquire lock for project directory - is another build taking ages to complete?!\\\")\\n sys.exit(-1)\",\n \"def _lock(self):\\n import os\\n from time import sleep\\n # Waits until another process completes it's process\\n while os.path.isfile(self.db_path+\\\".lock\\\"):\\n print(\\\"Another process is using\\\",\\n self.db_path, \\\". Waiting for release.\\\")\\n sleep(1)\\n with open(self.db_path+\\\".lock\\\", 'w') as fp:\\n pass\",\n \"def flock_exclusive(fileobj):\\n msvcrt.locking(fileobj.fileno(), msvcrt.LK_LOCK, 2147483647)\",\n \"def __init__(self, filename, mode='ab', maxBytes=512*1024*1024,\\n backupCount=10):\\n if maxBytes > 0:\\n mode = 'ab' # doesn't make sense otherwise!\\n FileHandler.__init__(self, filename, mode)\\n self.maxBytes = maxBytes\\n self.backupCount = backupCount\\n self.counter = 0\\n self.every = 10\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7269624","0.6982146","0.69293517","0.67427164","0.6594269","0.6411413","0.6381823","0.63453645","0.63121194","0.63120097","0.62144","0.6043685","0.59835607","0.5917388","0.5861188","0.577998","0.5779113","0.57543266","0.5674176","0.56467295","0.5624611","0.5607124","0.55963784","0.55711716","0.5542878","0.5485642","0.54830825","0.54784495","0.5458545","0.5419394","0.5408647","0.5388893","0.53664196","0.53634566","0.536174","0.533907","0.52782845","0.5267642","0.5262497","0.5262497","0.52584577","0.52505124","0.5232028","0.517707","0.5168745","0.51660323","0.51527846","0.51453584","0.5124801","0.5121825","0.5076446","0.5072323","0.5070037","0.5069979","0.50613284","0.5060728","0.5046035","0.5027347","0.5017842","0.5006265","0.49993005","0.49931133","0.49743146","0.4945205","0.4943066","0.4920633","0.49082792","0.4907853","0.48932007","0.48925126","0.4888762","0.486539","0.4858534","0.48541036","0.485269","0.4852077","0.48447967","0.4839747","0.4818203","0.4814024","0.47927463","0.47896612","0.4782602","0.47807264","0.477294","0.47643605","0.4760204","0.47201845","0.4698746","0.46859545","0.46822542","0.46792284","0.46748012","0.46734765","0.46717653","0.4666155","0.46656743","0.46589458","0.46380642","0.4635086"],"string":"[\n \"0.7269624\",\n \"0.6982146\",\n \"0.69293517\",\n \"0.67427164\",\n \"0.6594269\",\n \"0.6411413\",\n \"0.6381823\",\n \"0.63453645\",\n \"0.63121194\",\n \"0.63120097\",\n \"0.62144\",\n \"0.6043685\",\n \"0.59835607\",\n \"0.5917388\",\n \"0.5861188\",\n \"0.577998\",\n \"0.5779113\",\n \"0.57543266\",\n \"0.5674176\",\n \"0.56467295\",\n \"0.5624611\",\n \"0.5607124\",\n \"0.55963784\",\n \"0.55711716\",\n \"0.5542878\",\n \"0.5485642\",\n \"0.54830825\",\n \"0.54784495\",\n \"0.5458545\",\n \"0.5419394\",\n \"0.5408647\",\n \"0.5388893\",\n \"0.53664196\",\n \"0.53634566\",\n \"0.536174\",\n \"0.533907\",\n \"0.52782845\",\n \"0.5267642\",\n \"0.5262497\",\n \"0.5262497\",\n \"0.52584577\",\n \"0.52505124\",\n \"0.5232028\",\n \"0.517707\",\n \"0.5168745\",\n \"0.51660323\",\n \"0.51527846\",\n \"0.51453584\",\n \"0.5124801\",\n \"0.5121825\",\n \"0.5076446\",\n \"0.5072323\",\n \"0.5070037\",\n \"0.5069979\",\n \"0.50613284\",\n \"0.5060728\",\n \"0.5046035\",\n \"0.5027347\",\n \"0.5017842\",\n \"0.5006265\",\n \"0.49993005\",\n \"0.49931133\",\n \"0.49743146\",\n \"0.4945205\",\n \"0.4943066\",\n \"0.4920633\",\n \"0.49082792\",\n \"0.4907853\",\n \"0.48932007\",\n \"0.48925126\",\n \"0.4888762\",\n \"0.486539\",\n \"0.4858534\",\n \"0.48541036\",\n \"0.485269\",\n \"0.4852077\",\n \"0.48447967\",\n \"0.4839747\",\n \"0.4818203\",\n \"0.4814024\",\n \"0.47927463\",\n \"0.47896612\",\n \"0.4782602\",\n \"0.47807264\",\n \"0.477294\",\n \"0.47643605\",\n \"0.4760204\",\n \"0.47201845\",\n \"0.4698746\",\n \"0.46859545\",\n \"0.46822542\",\n \"0.46792284\",\n \"0.46748012\",\n \"0.46734765\",\n \"0.46717653\",\n \"0.4666155\",\n \"0.46656743\",\n \"0.46589458\",\n \"0.46380642\",\n \"0.4635086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72758126"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19897,"cells":{"query":{"kind":"string","value":"Acquire the lock, if possible. If the lock is in use, it check again every `wait` seconds. It does this until it either gets the lock or exceeds `timeout` number of seconds, in which case it throws an exception."},"document":{"kind":"string","value":"def acquire(self):\r\n start_time = time.time()\r\n import getpass\r\n userName = getpass.getuser()\r\n import platform\r\n computerName = platform.uname()[1]\r\n while True:\r\n try:\r\n self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)\r\n os.write(self.fd, userName + '\\n')\r\n os.write(self.fd, computerName + '\\n')\r\n os.write(self.fd, time.ctime(time.time()))\r\n break;\r\n except OSError as e:\r\n if e.errno != errno.EEXIST and e.errno != errno.EACCES:\r\n raise \r\n if (time.time() - start_time) >= self.timeout:\r\n if e.errno == errno.EEXIST:\r\n raise FileLockException(\"Timeout occured.\")\r\n else:\r\n raise FileLockException(\"Access denied.\")\r\n time.sleep(self.delay)\r\n self.is_locked = True"},"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 acquire(self, timeout=None): \n if self._locked:\n raise RuntimeError(\"lock already locked\")\n result = False\n timer = self.timerClass(timeout)\n timer.start()\n if ExclusiveLock.acquire(self, timeout):\n try:\n while timer.haveTime():\n self._expireReadLocks()\n if not self._haveReadLocks():\n result = timer.haveTime()\n break\n timer.sleep()\n finally:\n if result:\n # log('acquired write lock: %s\\n' % (self.lockDir))\n return True\n else:\n self.release()\n return False","def acquire(self, timeout=None):\n timer = self.timerClass(timeout)\n timer.start()\n while timer.haveTime():\n try:\n os.mkdir(self.lockDir)\n self._locked = True\n # log('acquired exclusive lock: %s\\n' % (self.lockDir, ))\n return True\n except OSError, err:\n if err.errno != errno.EEXIST:\n raise\n if self.expire():\n continue # Try immediately to acquire\n timer.sleep()\n return False","def acquire(self):\r\n self.log('acquire enter')\r\n\r\n start = datetime.now()\r\n\r\n # try and fetch the lock, looping until it's available\r\n while not self.try_acquire():\r\n if (datetime.now() - start).seconds > self.timeout:\r\n raise TimeoutExpired\r\n sleep(0.1)\r\n\r\n self.log('acquire exit')","def acquire(self,blocking=True,timeout=None):\n if timeout is None:\n return self.__lock.acquire(blocking)\n else:\n # Simulated timeout using progressively longer sleeps.\n # This is the same timeout scheme used in the stdlib Condition\n # class. If there's lots of contention on the lock then there's\n # a good chance you won't get it; but then again, Python doesn't\n # guarantee fairness anyway. We hope that platform-specific\n # extensions can provide a better mechanism.\n endtime = _time() + timeout\n delay = 0.0005\n while not self.__lock.acquire(False):\n remaining = endtime - _time()\n if remaining <= 0:\n return False\n delay = min(delay*2,remaining,0.05)\n _sleep(delay)\n return True","def acquire(lockfile, timeout=None):\n\tif timeout is None:\n\t\ttimeout = max_timeout # 100yrs should suffice\n\tretries = int(float(timeout)/wait_interval)\n\n\t_lock_acquire(lockfile, retries)\n\t\n\treturn lockfile","def wait_for_acquire(self, timeout=30):\n self._acquire_event.wait(timeout)","def acquire(self, timeout=None):\r\n try:\r\n open(self.unique_name, \"wb\").close()\r\n except IOError:\r\n raise LockFailed\r\n\r\n end_time = time.time()\r\n if timeout is not None and timeout > 0:\r\n end_time += timeout\r\n\r\n while True:\r\n # Try and create a hard link to it.\r\n try:\r\n os.link(self.unique_name, self.lock_file)\r\n except OSError:\r\n # Link creation failed. Maybe we've double-locked?\r\n nlinks = os.stat(self.unique_name).st_nlink\r\n if nlinks == 2:\r\n # The original link plus the one I created == 2. We're\r\n # good to go.\r\n return\r\n else:\r\n # Otherwise the lock creation failed.\r\n if timeout is not None and time.time() > end_time:\r\n os.unlink(self.unique_name)\r\n if timeout > 0:\r\n raise LockTimeout\r\n else:\r\n raise AlreadyLocked\r\n time.sleep(timeout is not None and timeout/10 or 0.1)\r\n else:\r\n # Link creation succeeded. We're good to go.\r\n return","def test_lock_wait_timeout(self):\n get_lock('test_wait', expires=15)\n start_lock = timezone.now()\n # LockMgr should raise `Locked` because `test_wait` should still be valid for another 10 seconds.\n with self.assertRaises(Locked):\n with LockMgr('test_wait', wait=5):\n pass\n end_lock = timezone.now()\n self.assertGreaterEqual(end_lock, start_lock + timedelta(seconds=5),\n msg=\"Lock wait timed out after at least 5 secs\")\n self.assertLess(end_lock, start_lock + timedelta(seconds=15), msg=\"Lock wait timed out in <15 seconds\")","def try_lock_acquire(lock):\n\tlogging.debug('Starting')\n\tfor i in range(2):\n\t\ttime.sleep(0.5)\n\t\tlogging.debug('Trying to acquire')\n\n\t\t\"\"\".acqire() returns false if the timeout passed in has elapsed.\"\"\"\n\t\thave_it = lock.acquire(0)\n\t\ttry:\n\t\t\tif have_it:\n\t\t\t\t\"\"\" only one thread will acquire the lock each iteration \"\"\"\n\t\t\t\tlogging.debug('Iteration %d: Acquired', i+1)\n\t\t\telse:\n\t\t\t\t\"\"\" the thread that calles .acquire() but does not have the lock blocks\"\"\"\n\t\t\t\tlogging.debug('Iteration %d: Not acquired', i+1)\n\t\tfinally:\n\t\t\tif have_it:\n\t\t\t\t\"\"\" .release() resets the state of the lock to unlocked \"\"\"\n\t\t\t\t\"\"\" one of the threads proceeds to acquire the lock \"\"\"\n\t\t\t\tlock.release()\n\t\t\t\tlogging.debug('Iteration %d: Lock released', i+1)\n\t\t\t\tlogging.debug('Thread %s done after %d iterations', threading.currentThread().getName(), i+1)","def test_lock_wait(self):\n get_lock('test_wait', expires=4)\n start_lock = timezone.now()\n with LockMgr('test_wait', wait=5):\n end_lock = timezone.now()\n self.assertGreaterEqual(end_lock, start_lock + timedelta(seconds=4),\n msg=\"Assert lock released after at least 4 seconds\")\n self.assertLess(end_lock, start_lock + timedelta(seconds=15), msg=\"Assert lock released in <15 seconds\")","def lock(self, wait: bool = True, timeout: int = None) -> 'Eva':\n self.__logger.debug('Eva.lock called')\n if wait:\n self.__http_client.lock_wait_for(timeout=timeout)\n else:\n self.__http_client.lock_lock()\n return self","def acquire(self):\n retries = [0]\n self._acquire_start_seconds = self._reactor.seconds()\n\n def log_lock_acquired(result):\n self._lock_acquired_seconds = self._reactor.seconds()\n seconds = self._lock_acquired_seconds - self._acquire_start_seconds\n self._log.msg('Acquired lock in {0} seconds'.format(seconds),\n lock_acquire_time=seconds, **self._log_kwargs)\n return result\n\n def acquire_lock():\n d = self._write_lock()\n d.addCallback(self._read_lock)\n d.addCallback(self._verify_lock)\n if self._log:\n d.addCallback(log_lock_acquired)\n d.addErrback(lock_not_acquired)\n return d\n\n def lock_not_acquired(failure):\n failure.trap(BusyLockError, NoLockClaimsError)\n retries[0] += 1\n if retries[0] <= self._max_retry:\n return task.deferLater(self._reactor, self._retry_wait, acquire_lock)\n else:\n return failure\n\n def log_lock_acquire_failure(failure):\n if self._log:\n seconds = self._reactor.seconds() - self._acquire_start_seconds\n self._log.msg(\n 'Could not acquire lock in {0} seconds due to {1}'.format(seconds, failure),\n lock_acquire_fail_time=seconds, reason=failure, **self._log_kwargs)\n return failure\n\n return acquire_lock().addErrback(log_lock_acquire_failure)","def acquire(self, timeout=None):\n if self._locked:\n raise RuntimeError(\"lock already locked\")\n if self.writeLock.acquire(timeout):\n try:\n self.lockDir = tempfile.mkdtemp('', self.fileName, self.dir)\n self._locked = True\n # log('acquired read lock: %s\\n' % self.lockDir)\n return True\n finally:\n self.writeLock.release() \n return False","def acquire(self, timeout=None):\r\n pass","def wait(self) -> None:\n now = time.time()\n if now < self.lockTime:\n diff = self.lockTime - now\n logger.debug(\"Waiting %ss to avoid ratelimit\", diff)\n time.sleep(diff)","def acquire(self, wait=True):\n return self.__lock.acquire(wait)","def force_unlock():\r\n global timeout_before_override\r\n timeout_backup = timeout_before_override\r\n timeout_before_override = 0\r\n try:\r\n get_lock(min_wait=0, max_wait=0.001)\r\n release_lock()\r\n finally:\r\n timeout_before_override = timeout_backup","def acquire(self):\n start_time = time.time()\n while True:\n try:\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n break\n except (OSError,) as e:\n if e.errno != errno.EEXIST:\n raise\n if (time.time() - start_time) >= self.timeout:\n raise FileLockException(f\"{self.lockfile}: Timeout occurred.\")\n time.sleep(self.delay)\n\n self.is_locked = True","def lock(self, timeout=0):\n if timeout:\n timeout_time = time.time() + timeout\n # Make sure my temp lockfile exists, and that its contents are\n # up-to-date (e.g. the temp file name, and the lock lifetime).\n self.__write()\n # TBD: This next call can fail with an EPERM. I have no idea why, but\n # I'm nervous about wrapping this in a try/except. It seems to be a\n # very rare occurence, only happens from cron, and (only?) on Solaris\n # 2.6.\n self.__touch()\n\n while True:\n # Create the hard link and test for exactly 2 links to the file\n try:\n os.link(self.__tmpfname, self.__lockfile)\n # If we got here, we know we know we got the lock, and never\n # had it before, so we're done. Just touch it again for the\n # fun of it.\n self.__touch()\n break\n except OSError, e:\n # The link failed for some reason, possibly because someone\n # else already has the lock (i.e. we got an EEXIST), or for\n # some other bizarre reason.\n if e.errno == errno.ENOENT:\n # TBD: in some Linux environments, it is possible to get\n # an ENOENT, which is truly strange, because this means\n # that self.__tmpfname doesn't exist at the time of the\n # os.link(), but self.__write() is supposed to guarantee\n # that this happens! I don't honestly know why this\n # happens, but for now we just say we didn't acquire the\n # lock, and try again next time.\n pass\n elif e.errno <> errno.EEXIST:\n # Something very bizarre happened. Clean up our state and\n # pass the error on up.\n os.unlink(self.__tmpfname)\n raise\n elif self.__linkcount() <> 2:\n # Somebody's messin' with us!\n pass\n elif self.__read() == self.__tmpfname:\n # It was us that already had the link.\n raise AlreadyLockedError\n # otherwise, someone else has the lock\n pass\n # We did not acquire the lock, because someone else already has\n # it. Have we timed out in our quest for the lock?\n if timeout and timeout_time < time.time():\n os.unlink(self.__tmpfname)\n raise TimeOutError\n # Okay, we haven't timed out, but we didn't get the lock. Let's\n # find if the lock lifetime has expired.\n if time.time() > self.__releasetime():\n # Yes, so break the lock.\n self.__break()\n # Okay, someone else has the lock, our claim hasn't timed out yet,\n # and the expected lock lifetime hasn't expired yet. So let's\n # wait a while for the owner of the lock to give it up.\n self.__sleep()","def lock(tmp_dir, timeout=120, min_wait=5, max_wait=10, verbosity=1):\r\n # Create base of lock directory if required.\r\n base_lock = os.path.dirname(tmp_dir)\r\n if not os.path.isdir(base_lock):\r\n try:\r\n os.makedirs(base_lock)\r\n except OSError:\r\n # Someone else was probably trying to create it at the same time.\r\n # We wait two seconds just to make sure the following assert does\r\n # not fail on some NFS systems.\r\n time.sleep(2)\r\n assert os.path.isdir(base_lock)\r\n\r\n # Variable initialization.\r\n lock_file = os.path.join(tmp_dir, 'lock')\r\n random.seed()\r\n my_pid = os.getpid()\r\n no_display = (verbosity == 0)\r\n\r\n nb_error = 0\r\n # The number of time we sleep when their is no errors.\r\n # Used to don't display it the first time to display it less frequently.\r\n # And so don't get as much email about this!\r\n nb_wait = 0\r\n # Acquire lock.\r\n while True:\r\n try:\r\n last_owner = 'no_owner'\r\n time_start = time.time()\r\n other_dead = False\r\n while os.path.isdir(tmp_dir):\r\n try:\r\n read_owner = open(lock_file).readlines()[0].strip()\r\n # the try is transtion code for old locks\r\n # it may be removed when poeple have upgraded\r\n try:\r\n other_host = read_owner.split('_')[2]\r\n except IndexError:\r\n other_host = () # make sure it isn't equal to any host\r\n if other_host == socket.gethostname():\r\n try:\r\n os.kill(int(read_owner.split('_')[0]), 0)\r\n except OSError:\r\n other_dead = True\r\n except AttributeError:\r\n pass #os.kill does not exist on windows\r\n except Exception:\r\n read_owner = 'failure'\r\n if other_dead:\r\n if not no_display:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.warning(\"Overriding existing lock by dead %s \"\r\n \"(I am process '%s')\", msg, my_pid)\r\n get_lock.unlocker.unlock()\r\n continue\r\n if last_owner == read_owner:\r\n if (timeout is not None and\r\n time.time() - time_start >= timeout):\r\n # Timeout exceeded or locking process dead.\r\n if not no_display:\r\n if read_owner == 'failure':\r\n msg = 'unknown process'\r\n else:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.warning(\"Overriding existing lock by %s \"\r\n \"(I am process '%s')\", msg, my_pid)\r\n get_lock.unlocker.unlock()\r\n continue\r\n else:\r\n last_owner = read_owner\r\n time_start = time.time()\r\n no_display = (verbosity == 0)\r\n if not no_display and nb_wait > 0:\r\n if read_owner == 'failure':\r\n msg = 'unknown process'\r\n else:\r\n msg = \"process '%s'\" % read_owner.split('_')[0]\r\n _logger.info(\"Waiting for existing lock by %s (I am \"\r\n \"process '%s')\", msg, my_pid)\r\n _logger.info(\"To manually release the lock, delete %s\",\r\n tmp_dir)\r\n if verbosity <= 1:\r\n no_display = True\r\n nb_wait += 1\r\n time.sleep(random.uniform(min_wait, max_wait))\r\n\r\n try:\r\n os.mkdir(tmp_dir)\r\n except OSError:\r\n # Error while creating the directory: someone else\r\n # must have tried at the exact same time.\r\n nb_error += 1\r\n if nb_error < 10:\r\n continue\r\n else:\r\n raise\r\n # Safety check: the directory should be here.\r\n assert os.path.isdir(tmp_dir)\r\n\r\n # Write own id into lock file.\r\n unique_id = refresh_lock(lock_file)\r\n\r\n # Verify we are really the lock owner (this should not be needed,\r\n # but better be safe than sorry).\r\n owner = open(lock_file).readlines()[0].strip()\r\n if owner != unique_id:\r\n # Too bad, try again.\r\n continue\r\n else:\r\n # We got the lock, hoorray!\r\n return\r\n\r\n except Exception, e:\r\n # If something wrong happened, we try again.\r\n _logger.warning(\"Something wrong happened: %s %s\", type(e), e)\r\n nb_error += 1\r\n if nb_error > 10:\r\n raise\r\n time.sleep(random.uniform(min_wait, max_wait))\r\n continue","def lock(self, name, timeout=None, sleep=0.1):\n return Lock(self, name, timeout=timeout, sleep=sleep)","def _wait_on_condition(self, timeout):\n self.__condition.wait(timeout)","def update_lock_timeout(self, timeout):\n\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\n raise FatalError(\"Timeout is out of range!\")\n elif not self._in_use:\n raise CoreError(\"This SystemUnderTest is not currently checked-out!\")\n\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)","def acquire(self):\n start_time = time.time()\n while True:\n # 当前文件锁对象未有加锁，执行加锁\n if self.fd is None:\n try:\n # 独占式打开文件\n lock_dir = os.path.dirname(self.lockfile)\n if not os.path.isdir(lock_dir):\n os.makedirs(lock_dir, exist_ok=True)\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n break\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n # 超时\n if (time.time() - start_time) >= self.timeout:\n raise FileLockException(\"Timeout occured.\")\n # 本次加锁失败，需要等待\n time.sleep(self.delay)\n self.is_locked = True","def _lock(self):\n self._create_unique_file()\n while True:\n try:\n self._extend_expiration_time() # in case we had to wait...\n os.link(self.uniquefile, self.lockfile)\n self._p(\"Lock successfully acquired.\")\n return\n except OSError as e:\n if e.errno in self.NOT_EXIST_ERRORS:\n # Didn't work for some reason. Try again in a bit.\n pass\n elif e.errno == errno.EEXIST:\n links = self._count_links()\n if links == 2 and self._read_lockfile() == self._uniquename:\n raise AlreadyLockedError(\"Lock already exists.\")\n else:\n # An unexpected error occurred.\n self._remove_unique_file()\n raise\n # Release expired lock of the others.\n if self._has_expired():\n self._break_foreign_lock()\n time.sleep(2)\n continue\n # No luck getting the lock.\n self._p(\"Locked by someone else. Waiting to retry...\", level=1)\n time.sleep(5)","def wait(self):\n assert self._pa_threaded_mainloop is not None\n # Although lock and unlock can be called reentrantly, the wait call only releases one lock.\n assert self._lock_count > 0\n original_lock_count = self._lock_count\n while self._lock_count > 1:\n self.unlock()\n pa.pa_threaded_mainloop_wait(self._pa_threaded_mainloop)\n while self._lock_count < original_lock_count:\n self.lock()","def wait(self, timeout=None):\n with self.condition:\n if not self.ready:\n self.condition.wait(timeout)","def test_lock_timeout():\n lock_unlock_timeout(0)","def lock_unlock_timeout(timeout=0):\n connection = FakeBaseConnection(session_timeout=timeout)\n assert not connection._session_locker.locked()\n connection._lock_netmiko_session()\n assert connection._session_locker.locked()\n\n try:\n connection._lock_netmiko_session()\n except NetmikoTimeoutException:\n return\n finally:\n assert connection._session_locker.locked()\n connection._unlock_netmiko_session()\n assert not connection._session_locker.locked()\n\n assert False","def wait(self, timeout):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)","def acquire(self, blocking=True):\n ops = fcntl.LOCK_EX\n if not blocking:\n ops |= fcntl.LOCK_NB\n fcntl.flock(self.lock_file, ops)","def testLockWithTimeout(self, mock_timeout_exception):\n mock_wrapped_flock = mock.Mock(side_effect=errors.FunctionTimeoutError)\n mock_wrapper = mock.Mock(return_value=mock_wrapped_flock)\n mock_timeout_exception.return_value = mock_wrapper\n\n self.assertFalse(self._lock.Lock(timeout_secs=1))\n\n mock_wrapper.assert_called_once_with(fcntl.flock)\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\n mock_wrapper.reset_mock()\n mock_wrapped_flock.reset_mock()\n\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=1))\n\n mock_wrapper.assert_called_once_with(fcntl.flock)\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)","def wait_for_locks(self):\n retries = 0\n while len(self.mongos.get_locks()) and retries < 360:\n logging.info(\"Waiting for locks to be released: %s\" %\n self.mongos.get_locks())\n time.sleep(5)\n retries += 1\n\n if len(self.mongos.get_locks()):\n raise Exception(\"Something is still locking the cluster,\"\n \" aborting backup\")","def acquire_lock_1(force, lock_file=None):\n if lock_file is None:\n lock_file = config.LOCK_FILE\n lock = Lock(lock_file, LOCK_LIFETIME)\n try:\n lock.lock(timedelta(seconds=0.1))\n return lock\n except TimeOutError:\n if not force:\n raise\n # Force removal of lock first.\n lock.disown()\n hostname, pid, tempfile = lock.details\n os.unlink(lock_file)\n return acquire_lock_1(force=False)","def lock(self, timeout=10):\n if self._is_locked:\n yield\n return\n\n pid = os.getpid()\n self._insert_lock_row(pid, timeout)\n try:\n self._is_locked = True\n yield\n self._is_locked = False\n finally:\n self._delete_lock_row(pid)","async def acquire(self) -> None:\n try:\n self.acquire_nowait()\n except WouldBlock:\n event = create_event()\n self._waiters.append(event)\n try:\n await event.wait()\n except BaseException:\n if not event.is_set():\n self._waiters.remove(event)\n\n raise\n\n self.acquire_nowait()","def wait(lock_path, duration_s):\n with filelock.FileLock(lock_path, 3 * 60):\n # We can't use time.monotonic() as we're comparing time between processes and\n # time.monotonic() explicitly does not support that\n # This means the test can fail during leap seconds, but this is only a test, we\n # don't need total reliability\n print(time.time())\n time.sleep(duration_s)\n print(time.time())","def acquire(path, onwait=None):\r\n\r\n touch(path)\r\n lock_fd = lock_file(path, blocking=False)\r\n if not lock_fd:\r\n blocking = True\r\n with open(path, 'r') as fd:\r\n pid = int(fd.read().strip())\r\n if onwait:\r\n blocking = onwait(pid)\r\n if not blocking:\r\n return None\r\n lock_fd = lock_file(path, blocking=blocking)\r\n\r\n lock_fd.truncate(0)\r\n lock_fd.write('%d\\n' % os.getpid())\r\n lock_fd.flush()\r\n return Lock(lock_fd)","def acquire(self, wait=True):\n ok = self._acquire_once(False)\n if ok or not wait:\n return ok\n if self.callback:\n self.callback()\n while True:\n if self._acquire_once(True):\n break\n return True","def test_lock_timeout_loop():\n lock_unlock_timeout(0.2)","def acquire_lock (self):\n\n self._exec (self.select)\n self.locked = True","def acquire(self, retry=True):\n lock_conductor_id = objects.BayLock.create(self.bay.uuid,\n self.conductor_id)\n if lock_conductor_id is None:\n LOG.debug(\"Conductor %(conductor)s acquired lock on bay \"\n \"%(bay)s\" % {'conductor': self.conductor_id,\n 'bay': self.bay.uuid})\n return\n\n if (lock_conductor_id == self.conductor_id or\n self.conductor_alive(self.context, lock_conductor_id)):\n LOG.debug(\"Lock on bay %(bay)s is owned by conductor \"\n \"%(conductor)s\" % {'bay': self.bay.uuid,\n 'conductor': lock_conductor_id})\n raise exception.OperationInProgress(bay_name=self.bay.name)\n else:\n LOG.info(_LI(\"Stale lock detected on bay %(bay)s. Conductor \"\n \"%(conductor)s will attempt to steal the lock\"),\n {'bay': self.bay.uuid, 'conductor': self.conductor_id})\n\n result = objects.BayLock.steal(self.bay.uuid,\n lock_conductor_id,\n self.conductor_id)\n\n if result is None:\n LOG.info(_LI(\"Conductor %(conductor)s successfully stole the \"\n \"lock on bay %(bay)s\"),\n {'conductor': self.conductor_id,\n 'bay': self.bay.uuid})\n return\n elif result is True:\n if retry:\n LOG.info(_LI(\"The lock on bay %(bay)s was released while \"\n \"conductor %(conductor)s was stealing it. \"\n \"Trying again\"),\n {'bay': self.bay.uuid,\n 'conductor': self.conductor_id})\n return self.acquire(retry=False)\n else:\n new_lock_conductor_id = result\n LOG.info(_LI(\"Failed to steal lock on bay %(bay)s. \"\n \"Conductor %(conductor)s stole the lock first\"),\n {'bay': self.bay.uuid,\n 'conductor': new_lock_conductor_id})\n\n raise exception.OperationInProgress(bay_name=self.bay.name)","def test_acquire_can_prolong_lifetime_of_peer():\r\n with throttle_client(b\"[semaphores]\\nA=1\") as client:\r\n blocker = client.new_peer(expires_in=timedelta(minutes=1))\r\n # Acquire \"A\", so subsequent locks are pending\r\n client.acquire(blocker, \"A\")\r\n\r\n peer = client.new_peer(expires_in=timedelta(seconds=1))\r\n # This lock can not be acquired due to `blocker` holding the lock. This request\r\n # is going to block for one second. After which the peer should have been\r\n # expired. Yet acquire can prolong the lifetime of the peer.\r\n client.acquire(\r\n peer,\r\n semaphore=\"A\",\r\n block_for=timedelta(seconds=1),\r\n expires_in=timedelta(seconds=5),\r\n )\r\n # The initial timeout of one second should have been expired by now, yet nothing\r\n # is removed.\r\n assert client.remove_expired() == 0","def acquire_lock(force):\n try:\n lock = acquire_lock_1(force)\n return lock\n except TimeOutError:\n status, lock = master_state()\n if status is WatcherState.conflict:\n # Hostname matches and process exists.\n message = _(\"\"\"\\\nThe master lock could not be acquired because it appears as though another\nmaster is already running.\"\"\")\n elif status is WatcherState.stale_lock:\n # Hostname matches but the process does not exist.\n program = sys.argv[0] # noqa: F841\n message = _(\"\"\"\\\nThe master lock could not be acquired. It appears as though there is a stale\nmaster lock. Try re-running $program with the --force flag.\"\"\")\n elif status is WatcherState.host_mismatch:\n # Hostname doesn't even match.\n hostname, pid, tempfile = lock.details\n message = _(\"\"\"\\\nThe master lock could not be acquired, because it appears as if some process\non some other host may have acquired it. We can't test for stale locks across\nhost boundaries, so you'll have to clean this up manually.\n\nLock file: $config.LOCK_FILE\nLock host: $hostname\n\nExiting.\"\"\")\n else:\n assert status is WatcherState.none, (\n 'Invalid enum value: ${0}'.format(status))\n hostname, pid, tempfile = lock.details\n message = _(\"\"\"\\\nFor unknown reasons, the master lock could not be acquired.\n\n\nLock file: $config.LOCK_FILE\nLock host: $hostname\n\nExiting.\"\"\")\n config.options.parser.error(message)","def acquire(self, blocking=True, timeout=None):\n # pylint:disable=too-many-return-statements,too-many-branches\n # Sadly, the body of this method is rather complicated.\n if self._multithreaded is _UNSET:\n self._multithreaded = self._get_thread_ident()\n elif self._multithreaded != self._get_thread_ident():\n self._multithreaded = _MULTI\n\n # We conceptually now belong to the hub of the thread that\n # called this, whether or not we have to block. Note that we\n # cannot force it to be created yet, because Semaphore is used\n # by importlib.ModuleLock which is used when importing the hub\n # itself! This also checks for cross-thread issues.\n invalid_thread_use = None\n try:\n self._capture_hub(False)\n except InvalidThreadUseError as e:\n # My hub belongs to some other thread. We didn't release the GIL/object lock\n # by raising the exception, so we know this is still true.\n invalid_thread_use = e.args\n e = None\n if not self.counter and blocking:\n # We would need to block. So coordinate with the main hub.\n return self.__acquire_from_other_thread(invalid_thread_use, blocking, timeout)\n\n if self.counter > 0:\n self.counter -= 1\n return True\n\n if not blocking:\n return False\n\n if self._multithreaded is not _MULTI and self.hub is None: # pylint:disable=access-member-before-definition\n self.hub = get_hub() # pylint:disable=attribute-defined-outside-init\n\n if self.hub is None and not invalid_thread_use:\n # Someone else is holding us. There's not a hub here,\n # nor is there a hub in that thread. We'll need to use regular locks.\n # This will be unfair to yet a third thread that tries to use us with greenlets.\n return self.__acquire_from_other_thread(\n (None, None, self._getcurrent(), \"NoHubs\"),\n blocking,\n timeout\n )\n\n # self._wait may drop both the GIL and the _lock_lock.\n # By the time we regain control, both have been reacquired.\n try:\n success = self._wait(timeout)\n except LoopExit as ex:\n args = ex.args\n ex = None\n if self.counter:\n success = True\n else:\n # Avoid using ex.hub property to keep holding the GIL\n if len(args) == 3 and args[1].main_hub:\n # The main hub, meaning the main thread. We probably can do nothing with this.\n raise\n return self.__acquire_from_other_thread(\n (self.hub, get_hub_if_exists(), self._getcurrent(), \"LoopExit\"),\n blocking,\n timeout)\n\n if not success:\n assert timeout is not None\n # Our timer expired.\n return False\n\n # Neither our timer or another one expired, so we blocked until\n # awoke. Therefore, the counter is ours\n assert self.counter > 0, (self.counter, blocking, timeout, success,)\n self.counter -= 1\n return True","def wait(self, timeout=None):\r\n with self._lock:\r\n if self._finished:\r\n raise RuntimeError(\"wait() does not support re-entry!\")\r\n if not self._started:\r\n for thread in self._wait_events:\r\n thread.timeout = timeout\r\n thread.start()\r\n self._started = True\r\n try:\r\n if self._queue.get(timeout=timeout):\r\n return True\r\n return False\r\n except Empty:\r\n return False\r\n finally:\r\n with self._lock:\r\n self._finished = True","def api_acquire(self):\n\n self._api_acquire_lock_with_timer()","def wait_lease(self, timeout = None, raise_exceptions = True):\n return self.wait_ipv4_lease(timeout = timeout, raise_exceptions = raise_exceptions)","def acquire_lock(self):\n if self.lock:\n self.lock.acquire()","def lock(self):\n\n self.wait = True","def acquire_read(self) -> None:\n if not self.__monitor.acquire(timeout=self.__timeout):\n raise PetroniaLockTimeoutError()\n while self.__rwlock < 0 or self.__writers_waiting:\n self.__readers_ok.wait()\n self.__rwlock += 1\n self.__monitor.release()","def wait(self, wait_timeout=10):\n if self._TransferInitiated == 0:\n return\n Error = \"DMA wait timed out.\"\n with timeout(seconds = wait_timeout, error_message = Error):\n while True:\n if libdma.XAxiDma_Busy(self.DMAengine,self.direction) == 0:\n break","def wait(wait_time=WAIT_TIME):\n # time.sleep(wait_time)\n pass","def set_wait_timeout(self, timeout):\n self.__wait_timeout = timeout","def wait(self, timeout=None):\n assert False, \"Deriving class must implement\"","def wait(wait_time):\n\n time.sleep(wait_time)","def acquire_exclusive_nb_flock(lockfd, max_retry=5, wait_interval=5):\n return _acquire_file_lock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB,\n max_retry, wait_interval)","def acquireRead(self, timeout=None, _id=None):\n me = _id or (current_process().ident, current_thread().ident)\n # print \"[DEBUG] acquireRead ID:\", me\n if timeout is not None:\n expire_time = time.time() + timeout\n with self.__cond:\n # If we're the writer, we should also be able to read since reading\n # from other sources is currently locked while we're the writer.\n # Increment our reader reentrant level. Required a matching\n # releaseRead within acquireWrite block.\n if self.__writer == me:\n self.__readers[me] = self.__readers.get(me, 0) + 1\n return\n while True:\n # Only consider granting a read lock if there is currently no\n # writer.\n if not self.__writer:\n # Increment the reentrant level if we already have a read\n # lock (including if we're an upgraded reader), else\n # grant a read lock if there are no pending writers or an\n # upgraded reader.\n if self.__readers.get(me):\n self.__readers[me] += 1\n return\n elif not self.__pending_writers:\n self.__readers[me] = 1\n return\n\n if timeout is not None:\n # noinspection PyUnboundLocalVariable\n remaining = expire_time - time.time()\n if remaining <= 0:\n raise RuntimeError(\"Timeout expired while waiting for \"\n \"read lock acquire.\")\n self.__cond.wait(remaining)\n else:\n self.__cond.wait()","def wait(self, timeout=None):\n assert type(timeout) in (\n int, type(None)), 'Wrong type for [timeout], should be an int or None [was {0}]'.format(type(timeout))\n\n self._process.join(timeout)","async def test_wait_synchronized(self):\n client.wait_synchronized = AsyncMock(side_effect=[TimeoutException('timeout'), TimeoutException('timeout'),\n MagicMock()])\n await api.wait_synchronized()","async def wait(self) -> None:\n await checkpoint()\n event = create_event()\n self._waiters.append(event)\n self.release()\n try:\n await event.wait()\n except BaseException:\n if not event.is_set():\n self._waiters.remove(event)\n\n raise\n finally:\n with open_cancel_scope(shield=True):\n await self.acquire()","def distributed_lock(timeout=60):\n\n def call(func):\n def doLock(*args, **kwargs):\n result = None\n with lockPool.reserve(func.__name__) as lock:\n try:\n if lock.acquire(timeout):\n result = func(*args, **kwargs)\n finally:\n lock.release()\n\n return result\n\n return doLock\n\n return call","def acquire(self, blocking=True):\n\n start_time = time.time()\n while True:\n try:\n # Attempt to create the lockfile.\n # These flags cause os.open to raise an OSError if the file already exists.\n fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\n with os.fdopen(fd, \"a\") as f:\n # Print some info about the current process as debug info for anyone who bothers to look.\n f.write(self._lock_file_contents)\n break\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n if self.timeout is not None and (time.time() - start_time) >= self.timeout:\n raise FileLock.FileLockException(\"Timeout occurred for lock '{!s}'.\".format(self.lockfile))\n if not blocking:\n return False\n time.sleep(self.delay)\n self.is_locked = True\n return True","def test_acquire_locks_immediatly_after_expiration():\r\n with throttle_client(\r\n b'litter_collection_interval = \"10ms\"\\n' b\"[semaphores]\\nA=1\"\r\n ) as client:\r\n one = client.new_peer(expires_in=timedelta(minutes=1))\r\n two = client.new_peer(expires_in=timedelta(minutes=1))\r\n\r\n # Acquire first lease\r\n client.acquire(one, \"A\")\r\n\r\n # Wait for it in a seperate thread so we can use this thread to release `one`\r\n def wait_for_two():\r\n client.acquire(two, \"A\", block_for=timedelta(seconds=20))\r\n\r\n t = Thread(target=wait_for_two)\r\n t.start()\r\n\r\n # Unblock `t`. With expiration\r\n client.heartbeat(one, expires_in=timedelta(seconds=0))\r\n\r\n # Three seconds should be ample time for `t` to return\r\n t.join(4)\r\n # If `t` is alive, the join timed out, which should not be the case\r\n assert not t.is_alive()","def wait(self, timeout=0):\n if timeout:\n self._finished.wait(timeout=timeout)\n else:\n self._finished.wait()","def __call__(self, resource: LockResource, timeout: timedelta) -> Lock:","def simulate_waiting(self, exit_when=None):\n self._time_condition.acquire()\n\n # Helper function to reduce code copy\n def wait_block():\n self._increment_waiting_count(1)\n self._time_condition.wait()\n self._increment_waiting_count(-1)\n\n try:\n if exit_when is None:\n wait_block()\n else:\n while not exit_when(self._time):\n wait_block()\n finally:\n self._time_condition.release()","def testNonBlockingLock(self):\n lock = local_instance_lock.LocalInstanceLock(self._lock_path)\n self.assertTrue(lock.Lock(timeout_secs=0))\n try:\n self.assertFalse(self._lock.Lock(timeout_secs=0))\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=0))\n finally:\n lock.Unlock()","def _blocking(self, timeout, func):\n ret = func(True)\n if ret is not None or self._in_transaction:\n return ret\n if timeout:\n deadline = time.time() + timeout\n else:\n deadline = None\n while True:\n timeout = deadline - time.time() if deadline is not None else None\n if timeout is not None and timeout <= 0:\n return None\n # Python <3.2 doesn't return a status from wait. On Python 3.2+\n # we bail out early on False.\n if self._db.condition.wait(timeout=timeout) is False:\n return None # Timeout expired\n ret = func(False)\n if ret is not None:\n return ret","def lock(path, timeout, create=True):\n # ``FileLock`` requires that the to-be-locked file exists; if it\n # does not, we create an empty one (and avoid overwriting any\n # content, in case another process is also writing to it). There\n # is thus no race condition here, as we attempt to lock the file\n # anyway, and this will stop concurrent processes.\n if not os.path.exists(path) and create:\n open(path, \"a\").close()\n created = True\n else:\n created = False\n try:\n lck = lockfile.FileLock(path, threaded=False)\n lck.acquire(timeout=timeout)\n except Exception:\n if created:\n try:\n os.remove(path)\n except:\n pass\n raise\n return lck","def _api_acquire_lock_with_timer(self):\n\n self._api_lock.acquire()\n\n self._apt_timer = threading.Timer(self._api_timer_expiration, self._api_timer_expiration_handler)\n self._apt_timer.start()","def check_for_lock_request(self):\n while True:\n sleep(0.1)\n if self.get_state():\n sleep(5)\n self.lock()\n break","def wait(self, mutex):\n semap = thread.allocate_lock()\n semap.acquire() # initialize to 0\n self.waiters.append(semap)\n mutex.release()\n semap.acquire() # wait on semaphore\n mutex.acquire()","def acquire_nowait(self) -> None:\n task = get_current_task()\n if self._owner_task == task:\n raise RuntimeError('Attempted to acquire an already held Lock')\n\n if self._owner_task is not None:\n raise WouldBlock\n\n self._owner_task = task","def wait(self, msecs = sys.maxint):\n\t\tcall_sdk_function('PrlJob_Wait', self.handle, msecs)\n\t\terr_obj = None\n\t\ttry:\n\t\t\terr_obj = self.get_error()\n\t\texcept:\n\t\t\tpass\n\t\tsdk_check_result(self.get_ret_code(), err_obj)\n\t\treturn self.get_result()","def wait(self, timeout: float):\n timeout = timeout or float(\"inf\")\n started = datetime.utcnow()\n n_tasks = self.n_tasks()\n while self.n_tasks() > 0:\n self.log.tick(\n \"%s tasks remaining, sleeping for %s s\", n_tasks, POLL_INTERVAL\n )\n time.sleep(POLL_INTERVAL)\n elapsed = datetime.utcnow() - started\n if elapsed.total_seconds() > timeout:\n raise QueueTimeoutError(\"Joining queue timed out\")\n n_tasks = self.n_tasks()\n self.log.debug(\"Waited successfully\")","def acquire(self):\n waiter = Future()\n if self.redis_client.set(self.key, self.value, ex=self.ttl, nx=True):\n waiter.set_result(locks._ReleasingContextManager(self))\n else:\n waiter.set_exception(DDosError(\"被暴击了\"))\n # def on_timeout():\n # waiter.set_exception(gen.TimeoutError())\n # io_loop = ioloop.IOLoop.current()\n # timeout_handle = io_loop.add_timeout(timeout, on_timeout)\n # waiter.add_done_callback(\n # lambda _: io_loop.remove_timeout(timeout_handle))\n return waiter","def acquireWrite(self, timeout=None, _id=None):\n me = _id or (current_process().ident, current_thread().ident)\n # print \"[DEBUG] acquireWrite ID:\", me\n if timeout is not None:\n expire_time = time.time() + timeout\n with self.__cond:\n # if we're either the writer or an upgraded reader already,\n # increment reentrant level and grant lock.\n if self.__writer == me:\n self.__writer_count += 1\n return\n\n # Notifying of no read lock upgrade ability at this time.\n elif self.__readers.get(me, False):\n raise ReaderUpdateException(\"Read lock upgrades not supported \"\n \"at this time.\")\n\n # we're now a normal \"pending\" writer, no readers will acquire while\n # we are pending.\n else:\n self.__pending_writers.append(me)\n\n while True:\n # If no readers and no writer, we have clear passage. An\n # upgraded reader would have an entry in __readers if it\n # existed.\n if self.__writer is None and not self.__readers:\n if self.__pending_writers[0] == me:\n assert (self.__writer is None and\n self.__writer_count == 0)\n self.__writer = self.__pending_writers.popleft()\n self.__writer_count = 1\n return\n\n if timeout is not None:\n # noinspection PyUnboundLocalVariable\n remaining = expire_time - time.time()\n if remaining <= 0:\n # Timeout expired. Pull ourself from pending deque.\n # (must be in the queue since in order to get here we\n # had to have added ourself above).\n self.__pending_writers.remove(me)\n raise RuntimeError(\"Timeout expired while waiting for \"\n \"write lock acquire.\")\n self.__cond.wait(remaining)\n else:\n self.__cond.wait()","def wait(self):\n for _ in range(15):\n time.sleep(10)\n if self.ready:\n break\n else:\n raise RuntimeError('timeout, lease failed to start')","def checkout(self, timeout):\n\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\n raise FatalError(\"Timeout is out of range!\")\n elif self._in_use and (datetime.now() < self._lock_expiration):\n raise CoreError(\"This SystemUnderTest is in use currently!\")\n elif self._in_use and (datetime.now() > self._lock_expiration):\n # A lock time out occurred and we need to force a checkin first.\n self.checkin()\n\n self._in_use = True\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)\n\n self._machine.setup()","def Lock(self, timeout_secs=_DEFAULT_TIMEOUT_SECS):\n if self._file_desc is not None:\n raise OSError(\"%s has been locked.\" % self._file_path)\n parent_dir = os.path.dirname(self._file_path)\n if not os.path.exists(parent_dir):\n os.makedirs(parent_dir)\n successful = False\n self._file_desc = os.open(self._file_path, os.O_CREAT | os.O_RDWR,\n 0o666)\n try:\n successful = self._Flock(timeout_secs)\n finally:\n if not successful:\n os.close(self._file_desc)\n self._file_desc = None\n return successful","async def _acquire_lock(self, key: Hashable) -> _LinearizerEntry:\n entry = self.key_to_defer.setdefault(\n key, _LinearizerEntry(0, collections.OrderedDict())\n )\n\n if entry.count < self.max_count:\n # The number of things executing is less than the maximum.\n logger.debug(\n \"Acquired uncontended linearizer lock %r for key %r\", self.name, key\n )\n entry.count += 1\n return entry\n\n # Otherwise, the number of things executing is at the maximum and we have to\n # add a deferred to the list of blocked items.\n # When one of the things currently executing finishes it will callback\n # this item so that it can continue executing.\n logger.debug(\"Waiting to acquire linearizer lock %r for key %r\", self.name, key)\n\n new_defer: \"defer.Deferred[None]\" = make_deferred_yieldable(defer.Deferred())\n entry.deferreds[new_defer] = 1\n\n try:\n await new_defer\n except Exception as e:\n logger.info(\"defer %r got err %r\", new_defer, e)\n if isinstance(e, CancelledError):\n logger.debug(\n \"Cancelling wait for linearizer lock %r for key %r\",\n self.name,\n key,\n )\n else:\n logger.warning(\n \"Unexpected exception waiting for linearizer lock %r for key %r\",\n self.name,\n key,\n )\n\n # we just have to take ourselves back out of the queue.\n del entry.deferreds[new_defer]\n raise\n\n logger.debug(\"Acquired linearizer lock %r for key %r\", self.name, key)\n entry.count += 1\n\n # if the code holding the lock completes synchronously, then it\n # will recursively run the next claimant on the list. That can\n # relatively rapidly lead to stack exhaustion. This is essentially\n # the same problem as http://twistedmatrix.com/trac/ticket/9304.\n #\n # In order to break the cycle, we add a cheeky sleep(0) here to\n # ensure that we fall back to the reactor between each iteration.\n #\n # This needs to happen while we hold the lock. We could put it on the\n # exit path, but that would slow down the uncontended case.\n try:\n await self._clock.sleep(0)\n except CancelledError:\n self._release_lock(key, entry)\n raise\n\n return entry","def test_lock_blocks():\r\n with throttle_client(b\"[semaphores]\\nA=1\") as client:\r\n first = client.new_peer(expires_in=timedelta(minutes=1))\r\n second = client.new_peer(expires_in=timedelta(minutes=1))\r\n # Acquire first lock\r\n client.acquire(first, \"A\")\r\n\r\n acquired = False\r\n\r\n def wait_for_second_lock():\r\n nonlocal acquired\r\n acquired = client.acquire(\r\n second, semaphore=\"A\", block_for=timedelta(seconds=2)\r\n )\r\n\r\n t = Thread(target=wait_for_second_lock)\r\n t.start()\r\n client.release(first)\r\n t.join()\r\n # Second lock is no longer pending, because we released first and t is finished\r\n assert acquired","def test_wait_race(self):\n mock_handler = mock.Mock()\n async_result = self._makeOne(mock_handler)\n\n async_result.set(\"immediate\")\n\n cv = threading.Event()\n\n def wait_for_val():\n # NB: should not sleep\n async_result.wait(20)\n cv.set()\n th = threading.Thread(target=wait_for_val)\n th.daemon = True\n th.start()\n\n # if the wait() didn't sleep (correctly), cv will be set quickly\n # if it did sleep, the cv will not be set yet and this will timeout\n cv.wait(10)\n eq_(cv.is_set(), True)\n th.join()","def testUnlockWait(t, env):\n c = env.c1\n c.init_connection()\n fh, stateid = c.create_confirm(t.code)\n res = c.lock_file(t.code, fh, stateid, 20, 100)\n check(res, msg=\"Locking file %s\" % t.code)\n sleeptime = c.getLeaseTime() * 2\n env.sleep(sleeptime)\n ops = c.use_obj(fh)\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\n _replay(c, ops, [NFS4_OK, NFS4ERR_EXPIRED])","def testLock(self):\n self.assertTrue(self._lock.LockIfNotInUse())\n self.assertTrue(os.path.isfile(self._lock_path))\n self._lock.Unlock()\n\n self.assertTrue(self._lock.LockIfNotInUse(timeout_secs=0))\n self._lock.SetInUse(True)\n self._lock.Unlock()\n\n self.assertFalse(self._lock.LockIfNotInUse())\n\n self.assertTrue(self._lock.Lock())\n self._lock.SetInUse(False)\n self._lock.Unlock()\n\n self.assertTrue(self._lock.Lock(timeout_secs=0))\n self._lock.Unlock()","def acquire_write(self) -> None:\n if not self.__monitor.acquire(timeout=self.__timeout):\n raise PetroniaLockTimeoutError()\n while self.__rwlock != 0:\n self.__writers_waiting += 1\n self.__writers_ok.wait()\n self.__writers_waiting -= 1\n self.__rwlock = -1\n self.__monitor.release()","def make_waitable(self):\n if not self.is_waitable():\n self._condition = threading.Condition()","def get_lock(self, name, try_=False):\n lock = Lock(self, name, try_)\n with lock as got_lock:\n yield got_lock","def wait(self, time):\n self._wait = Event()\n return not self._wait.wait(time)","def wait(self, timeout):\n if not self._is_active:\n raise StopIteration\n try:\n self._pid.wait(timeout=timeout)\n self._is_active = False\n except subprocess.TimeoutExpired:\n pass","def implicitlyWait(self, timeout=10.0):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n cmdId = self.executeCommand(Command.IMPLICIT_WAIT, {'ms': float(timeout) * 1000})\n return cmdId","def wait_for_interrupts(self, wait_time = 1):\n raise AssertionError(\"wait_for_interrupts function i not implemented\")","def _wait_for_lockfile(self, lockfile_path: Path) -> None:\n if not lockfile_path.exists():\n return\n\n # The first second is free.\n start = time.time()\n time.sleep(1)\n if not lockfile_path.exists():\n return\n\n # After the first second, we print one message, then we stay silent for 10 minutes, at\n # which time we print a message every minute.\n def time_elapsed() -> float:\n return time.time() - start\n self.logger.info(\"Starting to wait for %s\", lockfile_path)\n next_message_time = time.time() + 16 * 60\n while lockfile_path.exists():\n if next_message_time - time.time() < 0:\n self.logger.warning(\n \"Lockfile %s has been blocked for %.0f seconds\",\n lockfile_path,\n time_elapsed())\n next_message_time = time.time() + 60\n time.sleep(1)","def _wait_expiration(self, raiden, transfer, sleep=DEFAULT_EVENTS_POLL_TIMEOUT):\n # pylint: disable=no-self-use\n\n expiration = transfer.lock.expiration + 1\n\n while True:\n current_block = raiden.get_block_number()\n\n if current_block > expiration:\n return\n\n gevent.sleep(sleep)","def acquire(self, rw_flag: str, timeout=-1):\n\n obtained = False\n rw_flag = self._check_rw_flag(rw_flag)\n if rw_flag == \"r\":\n obtained = self._readers_queue.acquire(timeout=timeout)\n if not obtained:\n return False\n\n obtained = self._no_readers.acquire(timeout=timeout)\n if not obtained:\n self._readers_queue.release()\n return False\n\n obtained = self.read_counter.acquire(timeout=timeout)\n\n self._no_readers.release()\n self._readers_queue.release()\n elif rw_flag == \"w\":\n obtained = self._write_counter.acquire(timeout=timeout)\n if not obtained:\n return False\n\n obtained = self._no_writers.acquire(timeout=timeout)\n if not obtained:\n self._write_counter.release()\n return obtained","def try_get_lock_or_break_open():\r\n #pylint: disable=W0212\r\n time_end = time.time() + 2\r\n while time.time() < time_end:\r\n if goxapi.Signal._lock.acquire(False):\r\n return\r\n time.sleep(0.001)\r\n\r\n # something keeps holding the lock, apparently some slot is stuck\r\n # in an infinite loop. In order to be able to shut down anyways\r\n # we just throw away that lock and replace it with a new one\r\n lock = threading.RLock()\r\n lock.acquire()\r\n goxapi.Signal._lock = lock\r\n print \"### could not acquire signal lock, frozen slot somewhere?\"\r\n print \"### please see the stacktrace log to determine the cause.\"","def acquire_lock(self):\n self._multistore._lock()","def _wait(self, remain):\n print \"%s waiting %s\" % (self.uid, remain)\n sleep(remain) # dummy implementation just for testing","def wait_if_needed(self):\n now = datetime.datetime.now()\n # Note that this quantity is always positive because now is always bigger than the timestamp.\n seconds_since_last_attempt = (now - self._timestamp).total_seconds()\n # Note again that because seconds_since_last_attempt is positive, the wait seconds will\n # never exceed self.effective_lockout_seconds, so\n # 0 <= wait_seconds <= self.effective_lockout_seconds\n wait_seconds = max(0.0, self.effective_lockout_seconds - seconds_since_last_attempt)\n if wait_seconds > 0.0:\n shared_message = (\"Last %s attempt was at %s (%s seconds ago).\"\n % (self.action, self._timestamp, seconds_since_last_attempt))\n if self.lockout_enabled:\n action_message = \"Waiting %s seconds before attempting another.\" % wait_seconds\n self.log.warning(\"%s %s\" % (shared_message, action_message))\n time.sleep(wait_seconds)\n else:\n action_message = \"Continuing anyway because lockout is disabled.\"\n self.log.warning(\"%s %s\" % (shared_message, action_message))\n self.update_timestamp()"],"string":"[\n \"def acquire(self, timeout=None): \\n if self._locked:\\n raise RuntimeError(\\\"lock already locked\\\")\\n result = False\\n timer = self.timerClass(timeout)\\n timer.start()\\n if ExclusiveLock.acquire(self, timeout):\\n try:\\n while timer.haveTime():\\n self._expireReadLocks()\\n if not self._haveReadLocks():\\n result = timer.haveTime()\\n break\\n timer.sleep()\\n finally:\\n if result:\\n # log('acquired write lock: %s\\\\n' % (self.lockDir))\\n return True\\n else:\\n self.release()\\n return False\",\n \"def acquire(self, timeout=None):\\n timer = self.timerClass(timeout)\\n timer.start()\\n while timer.haveTime():\\n try:\\n os.mkdir(self.lockDir)\\n self._locked = True\\n # log('acquired exclusive lock: %s\\\\n' % (self.lockDir, ))\\n return True\\n except OSError, err:\\n if err.errno != errno.EEXIST:\\n raise\\n if self.expire():\\n continue # Try immediately to acquire\\n timer.sleep()\\n return False\",\n \"def acquire(self):\\r\\n self.log('acquire enter')\\r\\n\\r\\n start = datetime.now()\\r\\n\\r\\n # try and fetch the lock, looping until it's available\\r\\n while not self.try_acquire():\\r\\n if (datetime.now() - start).seconds > self.timeout:\\r\\n raise TimeoutExpired\\r\\n sleep(0.1)\\r\\n\\r\\n self.log('acquire exit')\",\n \"def acquire(self,blocking=True,timeout=None):\\n if timeout is None:\\n return self.__lock.acquire(blocking)\\n else:\\n # Simulated timeout using progressively longer sleeps.\\n # This is the same timeout scheme used in the stdlib Condition\\n # class. If there's lots of contention on the lock then there's\\n # a good chance you won't get it; but then again, Python doesn't\\n # guarantee fairness anyway. We hope that platform-specific\\n # extensions can provide a better mechanism.\\n endtime = _time() + timeout\\n delay = 0.0005\\n while not self.__lock.acquire(False):\\n remaining = endtime - _time()\\n if remaining <= 0:\\n return False\\n delay = min(delay*2,remaining,0.05)\\n _sleep(delay)\\n return True\",\n \"def acquire(lockfile, timeout=None):\\n\\tif timeout is None:\\n\\t\\ttimeout = max_timeout # 100yrs should suffice\\n\\tretries = int(float(timeout)/wait_interval)\\n\\n\\t_lock_acquire(lockfile, retries)\\n\\t\\n\\treturn lockfile\",\n \"def wait_for_acquire(self, timeout=30):\\n self._acquire_event.wait(timeout)\",\n \"def acquire(self, timeout=None):\\r\\n try:\\r\\n open(self.unique_name, \\\"wb\\\").close()\\r\\n except IOError:\\r\\n raise LockFailed\\r\\n\\r\\n end_time = time.time()\\r\\n if timeout is not None and timeout > 0:\\r\\n end_time += timeout\\r\\n\\r\\n while True:\\r\\n # Try and create a hard link to it.\\r\\n try:\\r\\n os.link(self.unique_name, self.lock_file)\\r\\n except OSError:\\r\\n # Link creation failed. Maybe we've double-locked?\\r\\n nlinks = os.stat(self.unique_name).st_nlink\\r\\n if nlinks == 2:\\r\\n # The original link plus the one I created == 2. We're\\r\\n # good to go.\\r\\n return\\r\\n else:\\r\\n # Otherwise the lock creation failed.\\r\\n if timeout is not None and time.time() > end_time:\\r\\n os.unlink(self.unique_name)\\r\\n if timeout > 0:\\r\\n raise LockTimeout\\r\\n else:\\r\\n raise AlreadyLocked\\r\\n time.sleep(timeout is not None and timeout/10 or 0.1)\\r\\n else:\\r\\n # Link creation succeeded. We're good to go.\\r\\n return\",\n \"def test_lock_wait_timeout(self):\\n get_lock('test_wait', expires=15)\\n start_lock = timezone.now()\\n # LockMgr should raise `Locked` because `test_wait` should still be valid for another 10 seconds.\\n with self.assertRaises(Locked):\\n with LockMgr('test_wait', wait=5):\\n pass\\n end_lock = timezone.now()\\n self.assertGreaterEqual(end_lock, start_lock + timedelta(seconds=5),\\n msg=\\\"Lock wait timed out after at least 5 secs\\\")\\n self.assertLess(end_lock, start_lock + timedelta(seconds=15), msg=\\\"Lock wait timed out in <15 seconds\\\")\",\n \"def try_lock_acquire(lock):\\n\\tlogging.debug('Starting')\\n\\tfor i in range(2):\\n\\t\\ttime.sleep(0.5)\\n\\t\\tlogging.debug('Trying to acquire')\\n\\n\\t\\t\\\"\\\"\\\".acqire() returns false if the timeout passed in has elapsed.\\\"\\\"\\\"\\n\\t\\thave_it = lock.acquire(0)\\n\\t\\ttry:\\n\\t\\t\\tif have_it:\\n\\t\\t\\t\\t\\\"\\\"\\\" only one thread will acquire the lock each iteration \\\"\\\"\\\"\\n\\t\\t\\t\\tlogging.debug('Iteration %d: Acquired', i+1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\t\\\"\\\"\\\" the thread that calles .acquire() but does not have the lock blocks\\\"\\\"\\\"\\n\\t\\t\\t\\tlogging.debug('Iteration %d: Not acquired', i+1)\\n\\t\\tfinally:\\n\\t\\t\\tif have_it:\\n\\t\\t\\t\\t\\\"\\\"\\\" .release() resets the state of the lock to unlocked \\\"\\\"\\\"\\n\\t\\t\\t\\t\\\"\\\"\\\" one of the threads proceeds to acquire the lock \\\"\\\"\\\"\\n\\t\\t\\t\\tlock.release()\\n\\t\\t\\t\\tlogging.debug('Iteration %d: Lock released', i+1)\\n\\t\\t\\t\\tlogging.debug('Thread %s done after %d iterations', threading.currentThread().getName(), i+1)\",\n \"def test_lock_wait(self):\\n get_lock('test_wait', expires=4)\\n start_lock = timezone.now()\\n with LockMgr('test_wait', wait=5):\\n end_lock = timezone.now()\\n self.assertGreaterEqual(end_lock, start_lock + timedelta(seconds=4),\\n msg=\\\"Assert lock released after at least 4 seconds\\\")\\n self.assertLess(end_lock, start_lock + timedelta(seconds=15), msg=\\\"Assert lock released in <15 seconds\\\")\",\n \"def lock(self, wait: bool = True, timeout: int = None) -> 'Eva':\\n self.__logger.debug('Eva.lock called')\\n if wait:\\n self.__http_client.lock_wait_for(timeout=timeout)\\n else:\\n self.__http_client.lock_lock()\\n return self\",\n \"def acquire(self):\\n retries = [0]\\n self._acquire_start_seconds = self._reactor.seconds()\\n\\n def log_lock_acquired(result):\\n self._lock_acquired_seconds = self._reactor.seconds()\\n seconds = self._lock_acquired_seconds - self._acquire_start_seconds\\n self._log.msg('Acquired lock in {0} seconds'.format(seconds),\\n lock_acquire_time=seconds, **self._log_kwargs)\\n return result\\n\\n def acquire_lock():\\n d = self._write_lock()\\n d.addCallback(self._read_lock)\\n d.addCallback(self._verify_lock)\\n if self._log:\\n d.addCallback(log_lock_acquired)\\n d.addErrback(lock_not_acquired)\\n return d\\n\\n def lock_not_acquired(failure):\\n failure.trap(BusyLockError, NoLockClaimsError)\\n retries[0] += 1\\n if retries[0] <= self._max_retry:\\n return task.deferLater(self._reactor, self._retry_wait, acquire_lock)\\n else:\\n return failure\\n\\n def log_lock_acquire_failure(failure):\\n if self._log:\\n seconds = self._reactor.seconds() - self._acquire_start_seconds\\n self._log.msg(\\n 'Could not acquire lock in {0} seconds due to {1}'.format(seconds, failure),\\n lock_acquire_fail_time=seconds, reason=failure, **self._log_kwargs)\\n return failure\\n\\n return acquire_lock().addErrback(log_lock_acquire_failure)\",\n \"def acquire(self, timeout=None):\\n if self._locked:\\n raise RuntimeError(\\\"lock already locked\\\")\\n if self.writeLock.acquire(timeout):\\n try:\\n self.lockDir = tempfile.mkdtemp('', self.fileName, self.dir)\\n self._locked = True\\n # log('acquired read lock: %s\\\\n' % self.lockDir)\\n return True\\n finally:\\n self.writeLock.release() \\n return False\",\n \"def acquire(self, timeout=None):\\r\\n pass\",\n \"def wait(self) -> None:\\n now = time.time()\\n if now < self.lockTime:\\n diff = self.lockTime - now\\n logger.debug(\\\"Waiting %ss to avoid ratelimit\\\", diff)\\n time.sleep(diff)\",\n \"def acquire(self, wait=True):\\n return self.__lock.acquire(wait)\",\n \"def force_unlock():\\r\\n global timeout_before_override\\r\\n timeout_backup = timeout_before_override\\r\\n timeout_before_override = 0\\r\\n try:\\r\\n get_lock(min_wait=0, max_wait=0.001)\\r\\n release_lock()\\r\\n finally:\\r\\n timeout_before_override = timeout_backup\",\n \"def acquire(self):\\n start_time = time.time()\\n while True:\\n try:\\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n break\\n except (OSError,) as e:\\n if e.errno != errno.EEXIST:\\n raise\\n if (time.time() - start_time) >= self.timeout:\\n raise FileLockException(f\\\"{self.lockfile}: Timeout occurred.\\\")\\n time.sleep(self.delay)\\n\\n self.is_locked = True\",\n \"def lock(self, timeout=0):\\n if timeout:\\n timeout_time = time.time() + timeout\\n # Make sure my temp lockfile exists, and that its contents are\\n # up-to-date (e.g. the temp file name, and the lock lifetime).\\n self.__write()\\n # TBD: This next call can fail with an EPERM. I have no idea why, but\\n # I'm nervous about wrapping this in a try/except. It seems to be a\\n # very rare occurence, only happens from cron, and (only?) on Solaris\\n # 2.6.\\n self.__touch()\\n\\n while True:\\n # Create the hard link and test for exactly 2 links to the file\\n try:\\n os.link(self.__tmpfname, self.__lockfile)\\n # If we got here, we know we know we got the lock, and never\\n # had it before, so we're done. Just touch it again for the\\n # fun of it.\\n self.__touch()\\n break\\n except OSError, e:\\n # The link failed for some reason, possibly because someone\\n # else already has the lock (i.e. we got an EEXIST), or for\\n # some other bizarre reason.\\n if e.errno == errno.ENOENT:\\n # TBD: in some Linux environments, it is possible to get\\n # an ENOENT, which is truly strange, because this means\\n # that self.__tmpfname doesn't exist at the time of the\\n # os.link(), but self.__write() is supposed to guarantee\\n # that this happens! I don't honestly know why this\\n # happens, but for now we just say we didn't acquire the\\n # lock, and try again next time.\\n pass\\n elif e.errno <> errno.EEXIST:\\n # Something very bizarre happened. Clean up our state and\\n # pass the error on up.\\n os.unlink(self.__tmpfname)\\n raise\\n elif self.__linkcount() <> 2:\\n # Somebody's messin' with us!\\n pass\\n elif self.__read() == self.__tmpfname:\\n # It was us that already had the link.\\n raise AlreadyLockedError\\n # otherwise, someone else has the lock\\n pass\\n # We did not acquire the lock, because someone else already has\\n # it. Have we timed out in our quest for the lock?\\n if timeout and timeout_time < time.time():\\n os.unlink(self.__tmpfname)\\n raise TimeOutError\\n # Okay, we haven't timed out, but we didn't get the lock. Let's\\n # find if the lock lifetime has expired.\\n if time.time() > self.__releasetime():\\n # Yes, so break the lock.\\n self.__break()\\n # Okay, someone else has the lock, our claim hasn't timed out yet,\\n # and the expected lock lifetime hasn't expired yet. So let's\\n # wait a while for the owner of the lock to give it up.\\n self.__sleep()\",\n \"def lock(tmp_dir, timeout=120, min_wait=5, max_wait=10, verbosity=1):\\r\\n # Create base of lock directory if required.\\r\\n base_lock = os.path.dirname(tmp_dir)\\r\\n if not os.path.isdir(base_lock):\\r\\n try:\\r\\n os.makedirs(base_lock)\\r\\n except OSError:\\r\\n # Someone else was probably trying to create it at the same time.\\r\\n # We wait two seconds just to make sure the following assert does\\r\\n # not fail on some NFS systems.\\r\\n time.sleep(2)\\r\\n assert os.path.isdir(base_lock)\\r\\n\\r\\n # Variable initialization.\\r\\n lock_file = os.path.join(tmp_dir, 'lock')\\r\\n random.seed()\\r\\n my_pid = os.getpid()\\r\\n no_display = (verbosity == 0)\\r\\n\\r\\n nb_error = 0\\r\\n # The number of time we sleep when their is no errors.\\r\\n # Used to don't display it the first time to display it less frequently.\\r\\n # And so don't get as much email about this!\\r\\n nb_wait = 0\\r\\n # Acquire lock.\\r\\n while True:\\r\\n try:\\r\\n last_owner = 'no_owner'\\r\\n time_start = time.time()\\r\\n other_dead = False\\r\\n while os.path.isdir(tmp_dir):\\r\\n try:\\r\\n read_owner = open(lock_file).readlines()[0].strip()\\r\\n # the try is transtion code for old locks\\r\\n # it may be removed when poeple have upgraded\\r\\n try:\\r\\n other_host = read_owner.split('_')[2]\\r\\n except IndexError:\\r\\n other_host = () # make sure it isn't equal to any host\\r\\n if other_host == socket.gethostname():\\r\\n try:\\r\\n os.kill(int(read_owner.split('_')[0]), 0)\\r\\n except OSError:\\r\\n other_dead = True\\r\\n except AttributeError:\\r\\n pass #os.kill does not exist on windows\\r\\n except Exception:\\r\\n read_owner = 'failure'\\r\\n if other_dead:\\r\\n if not no_display:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.warning(\\\"Overriding existing lock by dead %s \\\"\\r\\n \\\"(I am process '%s')\\\", msg, my_pid)\\r\\n get_lock.unlocker.unlock()\\r\\n continue\\r\\n if last_owner == read_owner:\\r\\n if (timeout is not None and\\r\\n time.time() - time_start >= timeout):\\r\\n # Timeout exceeded or locking process dead.\\r\\n if not no_display:\\r\\n if read_owner == 'failure':\\r\\n msg = 'unknown process'\\r\\n else:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.warning(\\\"Overriding existing lock by %s \\\"\\r\\n \\\"(I am process '%s')\\\", msg, my_pid)\\r\\n get_lock.unlocker.unlock()\\r\\n continue\\r\\n else:\\r\\n last_owner = read_owner\\r\\n time_start = time.time()\\r\\n no_display = (verbosity == 0)\\r\\n if not no_display and nb_wait > 0:\\r\\n if read_owner == 'failure':\\r\\n msg = 'unknown process'\\r\\n else:\\r\\n msg = \\\"process '%s'\\\" % read_owner.split('_')[0]\\r\\n _logger.info(\\\"Waiting for existing lock by %s (I am \\\"\\r\\n \\\"process '%s')\\\", msg, my_pid)\\r\\n _logger.info(\\\"To manually release the lock, delete %s\\\",\\r\\n tmp_dir)\\r\\n if verbosity <= 1:\\r\\n no_display = True\\r\\n nb_wait += 1\\r\\n time.sleep(random.uniform(min_wait, max_wait))\\r\\n\\r\\n try:\\r\\n os.mkdir(tmp_dir)\\r\\n except OSError:\\r\\n # Error while creating the directory: someone else\\r\\n # must have tried at the exact same time.\\r\\n nb_error += 1\\r\\n if nb_error < 10:\\r\\n continue\\r\\n else:\\r\\n raise\\r\\n # Safety check: the directory should be here.\\r\\n assert os.path.isdir(tmp_dir)\\r\\n\\r\\n # Write own id into lock file.\\r\\n unique_id = refresh_lock(lock_file)\\r\\n\\r\\n # Verify we are really the lock owner (this should not be needed,\\r\\n # but better be safe than sorry).\\r\\n owner = open(lock_file).readlines()[0].strip()\\r\\n if owner != unique_id:\\r\\n # Too bad, try again.\\r\\n continue\\r\\n else:\\r\\n # We got the lock, hoorray!\\r\\n return\\r\\n\\r\\n except Exception, e:\\r\\n # If something wrong happened, we try again.\\r\\n _logger.warning(\\\"Something wrong happened: %s %s\\\", type(e), e)\\r\\n nb_error += 1\\r\\n if nb_error > 10:\\r\\n raise\\r\\n time.sleep(random.uniform(min_wait, max_wait))\\r\\n continue\",\n \"def lock(self, name, timeout=None, sleep=0.1):\\n return Lock(self, name, timeout=timeout, sleep=sleep)\",\n \"def _wait_on_condition(self, timeout):\\n self.__condition.wait(timeout)\",\n \"def update_lock_timeout(self, timeout):\\n\\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\\n raise FatalError(\\\"Timeout is out of range!\\\")\\n elif not self._in_use:\\n raise CoreError(\\\"This SystemUnderTest is not currently checked-out!\\\")\\n\\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)\",\n \"def acquire(self):\\n start_time = time.time()\\n while True:\\n # 当前文件锁对象未有加锁，执行加锁\\n if self.fd is None:\\n try:\\n # 独占式打开文件\\n lock_dir = os.path.dirname(self.lockfile)\\n if not os.path.isdir(lock_dir):\\n os.makedirs(lock_dir, exist_ok=True)\\n self.fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n break\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n # 超时\\n if (time.time() - start_time) >= self.timeout:\\n raise FileLockException(\\\"Timeout occured.\\\")\\n # 本次加锁失败，需要等待\\n time.sleep(self.delay)\\n self.is_locked = True\",\n \"def _lock(self):\\n self._create_unique_file()\\n while True:\\n try:\\n self._extend_expiration_time() # in case we had to wait...\\n os.link(self.uniquefile, self.lockfile)\\n self._p(\\\"Lock successfully acquired.\\\")\\n return\\n except OSError as e:\\n if e.errno in self.NOT_EXIST_ERRORS:\\n # Didn't work for some reason. Try again in a bit.\\n pass\\n elif e.errno == errno.EEXIST:\\n links = self._count_links()\\n if links == 2 and self._read_lockfile() == self._uniquename:\\n raise AlreadyLockedError(\\\"Lock already exists.\\\")\\n else:\\n # An unexpected error occurred.\\n self._remove_unique_file()\\n raise\\n # Release expired lock of the others.\\n if self._has_expired():\\n self._break_foreign_lock()\\n time.sleep(2)\\n continue\\n # No luck getting the lock.\\n self._p(\\\"Locked by someone else. Waiting to retry...\\\", level=1)\\n time.sleep(5)\",\n \"def wait(self):\\n assert self._pa_threaded_mainloop is not None\\n # Although lock and unlock can be called reentrantly, the wait call only releases one lock.\\n assert self._lock_count > 0\\n original_lock_count = self._lock_count\\n while self._lock_count > 1:\\n self.unlock()\\n pa.pa_threaded_mainloop_wait(self._pa_threaded_mainloop)\\n while self._lock_count < original_lock_count:\\n self.lock()\",\n \"def wait(self, timeout=None):\\n with self.condition:\\n if not self.ready:\\n self.condition.wait(timeout)\",\n \"def test_lock_timeout():\\n lock_unlock_timeout(0)\",\n \"def lock_unlock_timeout(timeout=0):\\n connection = FakeBaseConnection(session_timeout=timeout)\\n assert not connection._session_locker.locked()\\n connection._lock_netmiko_session()\\n assert connection._session_locker.locked()\\n\\n try:\\n connection._lock_netmiko_session()\\n except NetmikoTimeoutException:\\n return\\n finally:\\n assert connection._session_locker.locked()\\n connection._unlock_netmiko_session()\\n assert not connection._session_locker.locked()\\n\\n assert False\",\n \"def wait(self, timeout):\\n raise NotImplementedError(\\n u\\\"%s: Method not implemented\\\", self.__class__.__name__)\",\n \"def acquire(self, blocking=True):\\n ops = fcntl.LOCK_EX\\n if not blocking:\\n ops |= fcntl.LOCK_NB\\n fcntl.flock(self.lock_file, ops)\",\n \"def testLockWithTimeout(self, mock_timeout_exception):\\n mock_wrapped_flock = mock.Mock(side_effect=errors.FunctionTimeoutError)\\n mock_wrapper = mock.Mock(return_value=mock_wrapped_flock)\\n mock_timeout_exception.return_value = mock_wrapper\\n\\n self.assertFalse(self._lock.Lock(timeout_secs=1))\\n\\n mock_wrapper.assert_called_once_with(fcntl.flock)\\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\\n mock_wrapper.reset_mock()\\n mock_wrapped_flock.reset_mock()\\n\\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=1))\\n\\n mock_wrapper.assert_called_once_with(fcntl.flock)\\n mock_wrapped_flock.assert_called_once_with(mock.ANY, fcntl.LOCK_EX)\",\n \"def wait_for_locks(self):\\n retries = 0\\n while len(self.mongos.get_locks()) and retries < 360:\\n logging.info(\\\"Waiting for locks to be released: %s\\\" %\\n self.mongos.get_locks())\\n time.sleep(5)\\n retries += 1\\n\\n if len(self.mongos.get_locks()):\\n raise Exception(\\\"Something is still locking the cluster,\\\"\\n \\\" aborting backup\\\")\",\n \"def acquire_lock_1(force, lock_file=None):\\n if lock_file is None:\\n lock_file = config.LOCK_FILE\\n lock = Lock(lock_file, LOCK_LIFETIME)\\n try:\\n lock.lock(timedelta(seconds=0.1))\\n return lock\\n except TimeOutError:\\n if not force:\\n raise\\n # Force removal of lock first.\\n lock.disown()\\n hostname, pid, tempfile = lock.details\\n os.unlink(lock_file)\\n return acquire_lock_1(force=False)\",\n \"def lock(self, timeout=10):\\n if self._is_locked:\\n yield\\n return\\n\\n pid = os.getpid()\\n self._insert_lock_row(pid, timeout)\\n try:\\n self._is_locked = True\\n yield\\n self._is_locked = False\\n finally:\\n self._delete_lock_row(pid)\",\n \"async def acquire(self) -> None:\\n try:\\n self.acquire_nowait()\\n except WouldBlock:\\n event = create_event()\\n self._waiters.append(event)\\n try:\\n await event.wait()\\n except BaseException:\\n if not event.is_set():\\n self._waiters.remove(event)\\n\\n raise\\n\\n self.acquire_nowait()\",\n \"def wait(lock_path, duration_s):\\n with filelock.FileLock(lock_path, 3 * 60):\\n # We can't use time.monotonic() as we're comparing time between processes and\\n # time.monotonic() explicitly does not support that\\n # This means the test can fail during leap seconds, but this is only a test, we\\n # don't need total reliability\\n print(time.time())\\n time.sleep(duration_s)\\n print(time.time())\",\n \"def acquire(path, onwait=None):\\r\\n\\r\\n touch(path)\\r\\n lock_fd = lock_file(path, blocking=False)\\r\\n if not lock_fd:\\r\\n blocking = True\\r\\n with open(path, 'r') as fd:\\r\\n pid = int(fd.read().strip())\\r\\n if onwait:\\r\\n blocking = onwait(pid)\\r\\n if not blocking:\\r\\n return None\\r\\n lock_fd = lock_file(path, blocking=blocking)\\r\\n\\r\\n lock_fd.truncate(0)\\r\\n lock_fd.write('%d\\\\n' % os.getpid())\\r\\n lock_fd.flush()\\r\\n return Lock(lock_fd)\",\n \"def acquire(self, wait=True):\\n ok = self._acquire_once(False)\\n if ok or not wait:\\n return ok\\n if self.callback:\\n self.callback()\\n while True:\\n if self._acquire_once(True):\\n break\\n return True\",\n \"def test_lock_timeout_loop():\\n lock_unlock_timeout(0.2)\",\n \"def acquire_lock (self):\\n\\n self._exec (self.select)\\n self.locked = True\",\n \"def acquire(self, retry=True):\\n lock_conductor_id = objects.BayLock.create(self.bay.uuid,\\n self.conductor_id)\\n if lock_conductor_id is None:\\n LOG.debug(\\\"Conductor %(conductor)s acquired lock on bay \\\"\\n \\\"%(bay)s\\\" % {'conductor': self.conductor_id,\\n 'bay': self.bay.uuid})\\n return\\n\\n if (lock_conductor_id == self.conductor_id or\\n self.conductor_alive(self.context, lock_conductor_id)):\\n LOG.debug(\\\"Lock on bay %(bay)s is owned by conductor \\\"\\n \\\"%(conductor)s\\\" % {'bay': self.bay.uuid,\\n 'conductor': lock_conductor_id})\\n raise exception.OperationInProgress(bay_name=self.bay.name)\\n else:\\n LOG.info(_LI(\\\"Stale lock detected on bay %(bay)s. Conductor \\\"\\n \\\"%(conductor)s will attempt to steal the lock\\\"),\\n {'bay': self.bay.uuid, 'conductor': self.conductor_id})\\n\\n result = objects.BayLock.steal(self.bay.uuid,\\n lock_conductor_id,\\n self.conductor_id)\\n\\n if result is None:\\n LOG.info(_LI(\\\"Conductor %(conductor)s successfully stole the \\\"\\n \\\"lock on bay %(bay)s\\\"),\\n {'conductor': self.conductor_id,\\n 'bay': self.bay.uuid})\\n return\\n elif result is True:\\n if retry:\\n LOG.info(_LI(\\\"The lock on bay %(bay)s was released while \\\"\\n \\\"conductor %(conductor)s was stealing it. \\\"\\n \\\"Trying again\\\"),\\n {'bay': self.bay.uuid,\\n 'conductor': self.conductor_id})\\n return self.acquire(retry=False)\\n else:\\n new_lock_conductor_id = result\\n LOG.info(_LI(\\\"Failed to steal lock on bay %(bay)s. \\\"\\n \\\"Conductor %(conductor)s stole the lock first\\\"),\\n {'bay': self.bay.uuid,\\n 'conductor': new_lock_conductor_id})\\n\\n raise exception.OperationInProgress(bay_name=self.bay.name)\",\n \"def test_acquire_can_prolong_lifetime_of_peer():\\r\\n with throttle_client(b\\\"[semaphores]\\\\nA=1\\\") as client:\\r\\n blocker = client.new_peer(expires_in=timedelta(minutes=1))\\r\\n # Acquire \\\"A\\\", so subsequent locks are pending\\r\\n client.acquire(blocker, \\\"A\\\")\\r\\n\\r\\n peer = client.new_peer(expires_in=timedelta(seconds=1))\\r\\n # This lock can not be acquired due to `blocker` holding the lock. This request\\r\\n # is going to block for one second. After which the peer should have been\\r\\n # expired. Yet acquire can prolong the lifetime of the peer.\\r\\n client.acquire(\\r\\n peer,\\r\\n semaphore=\\\"A\\\",\\r\\n block_for=timedelta(seconds=1),\\r\\n expires_in=timedelta(seconds=5),\\r\\n )\\r\\n # The initial timeout of one second should have been expired by now, yet nothing\\r\\n # is removed.\\r\\n assert client.remove_expired() == 0\",\n \"def acquire_lock(force):\\n try:\\n lock = acquire_lock_1(force)\\n return lock\\n except TimeOutError:\\n status, lock = master_state()\\n if status is WatcherState.conflict:\\n # Hostname matches and process exists.\\n message = _(\\\"\\\"\\\"\\\\\\nThe master lock could not be acquired because it appears as though another\\nmaster is already running.\\\"\\\"\\\")\\n elif status is WatcherState.stale_lock:\\n # Hostname matches but the process does not exist.\\n program = sys.argv[0] # noqa: F841\\n message = _(\\\"\\\"\\\"\\\\\\nThe master lock could not be acquired. It appears as though there is a stale\\nmaster lock. Try re-running $program with the --force flag.\\\"\\\"\\\")\\n elif status is WatcherState.host_mismatch:\\n # Hostname doesn't even match.\\n hostname, pid, tempfile = lock.details\\n message = _(\\\"\\\"\\\"\\\\\\nThe master lock could not be acquired, because it appears as if some process\\non some other host may have acquired it. We can't test for stale locks across\\nhost boundaries, so you'll have to clean this up manually.\\n\\nLock file: $config.LOCK_FILE\\nLock host: $hostname\\n\\nExiting.\\\"\\\"\\\")\\n else:\\n assert status is WatcherState.none, (\\n 'Invalid enum value: ${0}'.format(status))\\n hostname, pid, tempfile = lock.details\\n message = _(\\\"\\\"\\\"\\\\\\nFor unknown reasons, the master lock could not be acquired.\\n\\n\\nLock file: $config.LOCK_FILE\\nLock host: $hostname\\n\\nExiting.\\\"\\\"\\\")\\n config.options.parser.error(message)\",\n \"def acquire(self, blocking=True, timeout=None):\\n # pylint:disable=too-many-return-statements,too-many-branches\\n # Sadly, the body of this method is rather complicated.\\n if self._multithreaded is _UNSET:\\n self._multithreaded = self._get_thread_ident()\\n elif self._multithreaded != self._get_thread_ident():\\n self._multithreaded = _MULTI\\n\\n # We conceptually now belong to the hub of the thread that\\n # called this, whether or not we have to block. Note that we\\n # cannot force it to be created yet, because Semaphore is used\\n # by importlib.ModuleLock which is used when importing the hub\\n # itself! This also checks for cross-thread issues.\\n invalid_thread_use = None\\n try:\\n self._capture_hub(False)\\n except InvalidThreadUseError as e:\\n # My hub belongs to some other thread. We didn't release the GIL/object lock\\n # by raising the exception, so we know this is still true.\\n invalid_thread_use = e.args\\n e = None\\n if not self.counter and blocking:\\n # We would need to block. So coordinate with the main hub.\\n return self.__acquire_from_other_thread(invalid_thread_use, blocking, timeout)\\n\\n if self.counter > 0:\\n self.counter -= 1\\n return True\\n\\n if not blocking:\\n return False\\n\\n if self._multithreaded is not _MULTI and self.hub is None: # pylint:disable=access-member-before-definition\\n self.hub = get_hub() # pylint:disable=attribute-defined-outside-init\\n\\n if self.hub is None and not invalid_thread_use:\\n # Someone else is holding us. There's not a hub here,\\n # nor is there a hub in that thread. We'll need to use regular locks.\\n # This will be unfair to yet a third thread that tries to use us with greenlets.\\n return self.__acquire_from_other_thread(\\n (None, None, self._getcurrent(), \\\"NoHubs\\\"),\\n blocking,\\n timeout\\n )\\n\\n # self._wait may drop both the GIL and the _lock_lock.\\n # By the time we regain control, both have been reacquired.\\n try:\\n success = self._wait(timeout)\\n except LoopExit as ex:\\n args = ex.args\\n ex = None\\n if self.counter:\\n success = True\\n else:\\n # Avoid using ex.hub property to keep holding the GIL\\n if len(args) == 3 and args[1].main_hub:\\n # The main hub, meaning the main thread. We probably can do nothing with this.\\n raise\\n return self.__acquire_from_other_thread(\\n (self.hub, get_hub_if_exists(), self._getcurrent(), \\\"LoopExit\\\"),\\n blocking,\\n timeout)\\n\\n if not success:\\n assert timeout is not None\\n # Our timer expired.\\n return False\\n\\n # Neither our timer or another one expired, so we blocked until\\n # awoke. Therefore, the counter is ours\\n assert self.counter > 0, (self.counter, blocking, timeout, success,)\\n self.counter -= 1\\n return True\",\n \"def wait(self, timeout=None):\\r\\n with self._lock:\\r\\n if self._finished:\\r\\n raise RuntimeError(\\\"wait() does not support re-entry!\\\")\\r\\n if not self._started:\\r\\n for thread in self._wait_events:\\r\\n thread.timeout = timeout\\r\\n thread.start()\\r\\n self._started = True\\r\\n try:\\r\\n if self._queue.get(timeout=timeout):\\r\\n return True\\r\\n return False\\r\\n except Empty:\\r\\n return False\\r\\n finally:\\r\\n with self._lock:\\r\\n self._finished = True\",\n \"def api_acquire(self):\\n\\n self._api_acquire_lock_with_timer()\",\n \"def wait_lease(self, timeout = None, raise_exceptions = True):\\n return self.wait_ipv4_lease(timeout = timeout, raise_exceptions = raise_exceptions)\",\n \"def acquire_lock(self):\\n if self.lock:\\n self.lock.acquire()\",\n \"def lock(self):\\n\\n self.wait = True\",\n \"def acquire_read(self) -> None:\\n if not self.__monitor.acquire(timeout=self.__timeout):\\n raise PetroniaLockTimeoutError()\\n while self.__rwlock < 0 or self.__writers_waiting:\\n self.__readers_ok.wait()\\n self.__rwlock += 1\\n self.__monitor.release()\",\n \"def wait(self, wait_timeout=10):\\n if self._TransferInitiated == 0:\\n return\\n Error = \\\"DMA wait timed out.\\\"\\n with timeout(seconds = wait_timeout, error_message = Error):\\n while True:\\n if libdma.XAxiDma_Busy(self.DMAengine,self.direction) == 0:\\n break\",\n \"def wait(wait_time=WAIT_TIME):\\n # time.sleep(wait_time)\\n pass\",\n \"def set_wait_timeout(self, timeout):\\n self.__wait_timeout = timeout\",\n \"def wait(self, timeout=None):\\n assert False, \\\"Deriving class must implement\\\"\",\n \"def wait(wait_time):\\n\\n time.sleep(wait_time)\",\n \"def acquire_exclusive_nb_flock(lockfd, max_retry=5, wait_interval=5):\\n return _acquire_file_lock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB,\\n max_retry, wait_interval)\",\n \"def acquireRead(self, timeout=None, _id=None):\\n me = _id or (current_process().ident, current_thread().ident)\\n # print \\\"[DEBUG] acquireRead ID:\\\", me\\n if timeout is not None:\\n expire_time = time.time() + timeout\\n with self.__cond:\\n # If we're the writer, we should also be able to read since reading\\n # from other sources is currently locked while we're the writer.\\n # Increment our reader reentrant level. Required a matching\\n # releaseRead within acquireWrite block.\\n if self.__writer == me:\\n self.__readers[me] = self.__readers.get(me, 0) + 1\\n return\\n while True:\\n # Only consider granting a read lock if there is currently no\\n # writer.\\n if not self.__writer:\\n # Increment the reentrant level if we already have a read\\n # lock (including if we're an upgraded reader), else\\n # grant a read lock if there are no pending writers or an\\n # upgraded reader.\\n if self.__readers.get(me):\\n self.__readers[me] += 1\\n return\\n elif not self.__pending_writers:\\n self.__readers[me] = 1\\n return\\n\\n if timeout is not None:\\n # noinspection PyUnboundLocalVariable\\n remaining = expire_time - time.time()\\n if remaining <= 0:\\n raise RuntimeError(\\\"Timeout expired while waiting for \\\"\\n \\\"read lock acquire.\\\")\\n self.__cond.wait(remaining)\\n else:\\n self.__cond.wait()\",\n \"def wait(self, timeout=None):\\n assert type(timeout) in (\\n int, type(None)), 'Wrong type for [timeout], should be an int or None [was {0}]'.format(type(timeout))\\n\\n self._process.join(timeout)\",\n \"async def test_wait_synchronized(self):\\n client.wait_synchronized = AsyncMock(side_effect=[TimeoutException('timeout'), TimeoutException('timeout'),\\n MagicMock()])\\n await api.wait_synchronized()\",\n \"async def wait(self) -> None:\\n await checkpoint()\\n event = create_event()\\n self._waiters.append(event)\\n self.release()\\n try:\\n await event.wait()\\n except BaseException:\\n if not event.is_set():\\n self._waiters.remove(event)\\n\\n raise\\n finally:\\n with open_cancel_scope(shield=True):\\n await self.acquire()\",\n \"def distributed_lock(timeout=60):\\n\\n def call(func):\\n def doLock(*args, **kwargs):\\n result = None\\n with lockPool.reserve(func.__name__) as lock:\\n try:\\n if lock.acquire(timeout):\\n result = func(*args, **kwargs)\\n finally:\\n lock.release()\\n\\n return result\\n\\n return doLock\\n\\n return call\",\n \"def acquire(self, blocking=True):\\n\\n start_time = time.time()\\n while True:\\n try:\\n # Attempt to create the lockfile.\\n # These flags cause os.open to raise an OSError if the file already exists.\\n fd = os.open(self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)\\n with os.fdopen(fd, \\\"a\\\") as f:\\n # Print some info about the current process as debug info for anyone who bothers to look.\\n f.write(self._lock_file_contents)\\n break\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n if self.timeout is not None and (time.time() - start_time) >= self.timeout:\\n raise FileLock.FileLockException(\\\"Timeout occurred for lock '{!s}'.\\\".format(self.lockfile))\\n if not blocking:\\n return False\\n time.sleep(self.delay)\\n self.is_locked = True\\n return True\",\n \"def test_acquire_locks_immediatly_after_expiration():\\r\\n with throttle_client(\\r\\n b'litter_collection_interval = \\\"10ms\\\"\\\\n' b\\\"[semaphores]\\\\nA=1\\\"\\r\\n ) as client:\\r\\n one = client.new_peer(expires_in=timedelta(minutes=1))\\r\\n two = client.new_peer(expires_in=timedelta(minutes=1))\\r\\n\\r\\n # Acquire first lease\\r\\n client.acquire(one, \\\"A\\\")\\r\\n\\r\\n # Wait for it in a seperate thread so we can use this thread to release `one`\\r\\n def wait_for_two():\\r\\n client.acquire(two, \\\"A\\\", block_for=timedelta(seconds=20))\\r\\n\\r\\n t = Thread(target=wait_for_two)\\r\\n t.start()\\r\\n\\r\\n # Unblock `t`. With expiration\\r\\n client.heartbeat(one, expires_in=timedelta(seconds=0))\\r\\n\\r\\n # Three seconds should be ample time for `t` to return\\r\\n t.join(4)\\r\\n # If `t` is alive, the join timed out, which should not be the case\\r\\n assert not t.is_alive()\",\n \"def wait(self, timeout=0):\\n if timeout:\\n self._finished.wait(timeout=timeout)\\n else:\\n self._finished.wait()\",\n \"def __call__(self, resource: LockResource, timeout: timedelta) -> Lock:\",\n \"def simulate_waiting(self, exit_when=None):\\n self._time_condition.acquire()\\n\\n # Helper function to reduce code copy\\n def wait_block():\\n self._increment_waiting_count(1)\\n self._time_condition.wait()\\n self._increment_waiting_count(-1)\\n\\n try:\\n if exit_when is None:\\n wait_block()\\n else:\\n while not exit_when(self._time):\\n wait_block()\\n finally:\\n self._time_condition.release()\",\n \"def testNonBlockingLock(self):\\n lock = local_instance_lock.LocalInstanceLock(self._lock_path)\\n self.assertTrue(lock.Lock(timeout_secs=0))\\n try:\\n self.assertFalse(self._lock.Lock(timeout_secs=0))\\n self.assertFalse(self._lock.LockIfNotInUse(timeout_secs=0))\\n finally:\\n lock.Unlock()\",\n \"def _blocking(self, timeout, func):\\n ret = func(True)\\n if ret is not None or self._in_transaction:\\n return ret\\n if timeout:\\n deadline = time.time() + timeout\\n else:\\n deadline = None\\n while True:\\n timeout = deadline - time.time() if deadline is not None else None\\n if timeout is not None and timeout <= 0:\\n return None\\n # Python <3.2 doesn't return a status from wait. On Python 3.2+\\n # we bail out early on False.\\n if self._db.condition.wait(timeout=timeout) is False:\\n return None # Timeout expired\\n ret = func(False)\\n if ret is not None:\\n return ret\",\n \"def lock(path, timeout, create=True):\\n # ``FileLock`` requires that the to-be-locked file exists; if it\\n # does not, we create an empty one (and avoid overwriting any\\n # content, in case another process is also writing to it). There\\n # is thus no race condition here, as we attempt to lock the file\\n # anyway, and this will stop concurrent processes.\\n if not os.path.exists(path) and create:\\n open(path, \\\"a\\\").close()\\n created = True\\n else:\\n created = False\\n try:\\n lck = lockfile.FileLock(path, threaded=False)\\n lck.acquire(timeout=timeout)\\n except Exception:\\n if created:\\n try:\\n os.remove(path)\\n except:\\n pass\\n raise\\n return lck\",\n \"def _api_acquire_lock_with_timer(self):\\n\\n self._api_lock.acquire()\\n\\n self._apt_timer = threading.Timer(self._api_timer_expiration, self._api_timer_expiration_handler)\\n self._apt_timer.start()\",\n \"def check_for_lock_request(self):\\n while True:\\n sleep(0.1)\\n if self.get_state():\\n sleep(5)\\n self.lock()\\n break\",\n \"def wait(self, mutex):\\n semap = thread.allocate_lock()\\n semap.acquire() # initialize to 0\\n self.waiters.append(semap)\\n mutex.release()\\n semap.acquire() # wait on semaphore\\n mutex.acquire()\",\n \"def acquire_nowait(self) -> None:\\n task = get_current_task()\\n if self._owner_task == task:\\n raise RuntimeError('Attempted to acquire an already held Lock')\\n\\n if self._owner_task is not None:\\n raise WouldBlock\\n\\n self._owner_task = task\",\n \"def wait(self, msecs = sys.maxint):\\n\\t\\tcall_sdk_function('PrlJob_Wait', self.handle, msecs)\\n\\t\\terr_obj = None\\n\\t\\ttry:\\n\\t\\t\\terr_obj = self.get_error()\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\t\\tsdk_check_result(self.get_ret_code(), err_obj)\\n\\t\\treturn self.get_result()\",\n \"def wait(self, timeout: float):\\n timeout = timeout or float(\\\"inf\\\")\\n started = datetime.utcnow()\\n n_tasks = self.n_tasks()\\n while self.n_tasks() > 0:\\n self.log.tick(\\n \\\"%s tasks remaining, sleeping for %s s\\\", n_tasks, POLL_INTERVAL\\n )\\n time.sleep(POLL_INTERVAL)\\n elapsed = datetime.utcnow() - started\\n if elapsed.total_seconds() > timeout:\\n raise QueueTimeoutError(\\\"Joining queue timed out\\\")\\n n_tasks = self.n_tasks()\\n self.log.debug(\\\"Waited successfully\\\")\",\n \"def acquire(self):\\n waiter = Future()\\n if self.redis_client.set(self.key, self.value, ex=self.ttl, nx=True):\\n waiter.set_result(locks._ReleasingContextManager(self))\\n else:\\n waiter.set_exception(DDosError(\\\"被暴击了\\\"))\\n # def on_timeout():\\n # waiter.set_exception(gen.TimeoutError())\\n # io_loop = ioloop.IOLoop.current()\\n # timeout_handle = io_loop.add_timeout(timeout, on_timeout)\\n # waiter.add_done_callback(\\n # lambda _: io_loop.remove_timeout(timeout_handle))\\n return waiter\",\n \"def acquireWrite(self, timeout=None, _id=None):\\n me = _id or (current_process().ident, current_thread().ident)\\n # print \\\"[DEBUG] acquireWrite ID:\\\", me\\n if timeout is not None:\\n expire_time = time.time() + timeout\\n with self.__cond:\\n # if we're either the writer or an upgraded reader already,\\n # increment reentrant level and grant lock.\\n if self.__writer == me:\\n self.__writer_count += 1\\n return\\n\\n # Notifying of no read lock upgrade ability at this time.\\n elif self.__readers.get(me, False):\\n raise ReaderUpdateException(\\\"Read lock upgrades not supported \\\"\\n \\\"at this time.\\\")\\n\\n # we're now a normal \\\"pending\\\" writer, no readers will acquire while\\n # we are pending.\\n else:\\n self.__pending_writers.append(me)\\n\\n while True:\\n # If no readers and no writer, we have clear passage. An\\n # upgraded reader would have an entry in __readers if it\\n # existed.\\n if self.__writer is None and not self.__readers:\\n if self.__pending_writers[0] == me:\\n assert (self.__writer is None and\\n self.__writer_count == 0)\\n self.__writer = self.__pending_writers.popleft()\\n self.__writer_count = 1\\n return\\n\\n if timeout is not None:\\n # noinspection PyUnboundLocalVariable\\n remaining = expire_time - time.time()\\n if remaining <= 0:\\n # Timeout expired. Pull ourself from pending deque.\\n # (must be in the queue since in order to get here we\\n # had to have added ourself above).\\n self.__pending_writers.remove(me)\\n raise RuntimeError(\\\"Timeout expired while waiting for \\\"\\n \\\"write lock acquire.\\\")\\n self.__cond.wait(remaining)\\n else:\\n self.__cond.wait()\",\n \"def wait(self):\\n for _ in range(15):\\n time.sleep(10)\\n if self.ready:\\n break\\n else:\\n raise RuntimeError('timeout, lease failed to start')\",\n \"def checkout(self, timeout):\\n\\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\\n raise FatalError(\\\"Timeout is out of range!\\\")\\n elif self._in_use and (datetime.now() < self._lock_expiration):\\n raise CoreError(\\\"This SystemUnderTest is in use currently!\\\")\\n elif self._in_use and (datetime.now() > self._lock_expiration):\\n # A lock time out occurred and we need to force a checkin first.\\n self.checkin()\\n\\n self._in_use = True\\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)\\n\\n self._machine.setup()\",\n \"def Lock(self, timeout_secs=_DEFAULT_TIMEOUT_SECS):\\n if self._file_desc is not None:\\n raise OSError(\\\"%s has been locked.\\\" % self._file_path)\\n parent_dir = os.path.dirname(self._file_path)\\n if not os.path.exists(parent_dir):\\n os.makedirs(parent_dir)\\n successful = False\\n self._file_desc = os.open(self._file_path, os.O_CREAT | os.O_RDWR,\\n 0o666)\\n try:\\n successful = self._Flock(timeout_secs)\\n finally:\\n if not successful:\\n os.close(self._file_desc)\\n self._file_desc = None\\n return successful\",\n \"async def _acquire_lock(self, key: Hashable) -> _LinearizerEntry:\\n entry = self.key_to_defer.setdefault(\\n key, _LinearizerEntry(0, collections.OrderedDict())\\n )\\n\\n if entry.count < self.max_count:\\n # The number of things executing is less than the maximum.\\n logger.debug(\\n \\\"Acquired uncontended linearizer lock %r for key %r\\\", self.name, key\\n )\\n entry.count += 1\\n return entry\\n\\n # Otherwise, the number of things executing is at the maximum and we have to\\n # add a deferred to the list of blocked items.\\n # When one of the things currently executing finishes it will callback\\n # this item so that it can continue executing.\\n logger.debug(\\\"Waiting to acquire linearizer lock %r for key %r\\\", self.name, key)\\n\\n new_defer: \\\"defer.Deferred[None]\\\" = make_deferred_yieldable(defer.Deferred())\\n entry.deferreds[new_defer] = 1\\n\\n try:\\n await new_defer\\n except Exception as e:\\n logger.info(\\\"defer %r got err %r\\\", new_defer, e)\\n if isinstance(e, CancelledError):\\n logger.debug(\\n \\\"Cancelling wait for linearizer lock %r for key %r\\\",\\n self.name,\\n key,\\n )\\n else:\\n logger.warning(\\n \\\"Unexpected exception waiting for linearizer lock %r for key %r\\\",\\n self.name,\\n key,\\n )\\n\\n # we just have to take ourselves back out of the queue.\\n del entry.deferreds[new_defer]\\n raise\\n\\n logger.debug(\\\"Acquired linearizer lock %r for key %r\\\", self.name, key)\\n entry.count += 1\\n\\n # if the code holding the lock completes synchronously, then it\\n # will recursively run the next claimant on the list. That can\\n # relatively rapidly lead to stack exhaustion. This is essentially\\n # the same problem as http://twistedmatrix.com/trac/ticket/9304.\\n #\\n # In order to break the cycle, we add a cheeky sleep(0) here to\\n # ensure that we fall back to the reactor between each iteration.\\n #\\n # This needs to happen while we hold the lock. We could put it on the\\n # exit path, but that would slow down the uncontended case.\\n try:\\n await self._clock.sleep(0)\\n except CancelledError:\\n self._release_lock(key, entry)\\n raise\\n\\n return entry\",\n \"def test_lock_blocks():\\r\\n with throttle_client(b\\\"[semaphores]\\\\nA=1\\\") as client:\\r\\n first = client.new_peer(expires_in=timedelta(minutes=1))\\r\\n second = client.new_peer(expires_in=timedelta(minutes=1))\\r\\n # Acquire first lock\\r\\n client.acquire(first, \\\"A\\\")\\r\\n\\r\\n acquired = False\\r\\n\\r\\n def wait_for_second_lock():\\r\\n nonlocal acquired\\r\\n acquired = client.acquire(\\r\\n second, semaphore=\\\"A\\\", block_for=timedelta(seconds=2)\\r\\n )\\r\\n\\r\\n t = Thread(target=wait_for_second_lock)\\r\\n t.start()\\r\\n client.release(first)\\r\\n t.join()\\r\\n # Second lock is no longer pending, because we released first and t is finished\\r\\n assert acquired\",\n \"def test_wait_race(self):\\n mock_handler = mock.Mock()\\n async_result = self._makeOne(mock_handler)\\n\\n async_result.set(\\\"immediate\\\")\\n\\n cv = threading.Event()\\n\\n def wait_for_val():\\n # NB: should not sleep\\n async_result.wait(20)\\n cv.set()\\n th = threading.Thread(target=wait_for_val)\\n th.daemon = True\\n th.start()\\n\\n # if the wait() didn't sleep (correctly), cv will be set quickly\\n # if it did sleep, the cv will not be set yet and this will timeout\\n cv.wait(10)\\n eq_(cv.is_set(), True)\\n th.join()\",\n \"def testUnlockWait(t, env):\\n c = env.c1\\n c.init_connection()\\n fh, stateid = c.create_confirm(t.code)\\n res = c.lock_file(t.code, fh, stateid, 20, 100)\\n check(res, msg=\\\"Locking file %s\\\" % t.code)\\n sleeptime = c.getLeaseTime() * 2\\n env.sleep(sleeptime)\\n ops = c.use_obj(fh)\\n ops += [c.locku_op(READ_LT, 1, res.lockid, 0, 0xffffffffffffffff)]\\n _replay(c, ops, [NFS4_OK, NFS4ERR_EXPIRED])\",\n \"def testLock(self):\\n self.assertTrue(self._lock.LockIfNotInUse())\\n self.assertTrue(os.path.isfile(self._lock_path))\\n self._lock.Unlock()\\n\\n self.assertTrue(self._lock.LockIfNotInUse(timeout_secs=0))\\n self._lock.SetInUse(True)\\n self._lock.Unlock()\\n\\n self.assertFalse(self._lock.LockIfNotInUse())\\n\\n self.assertTrue(self._lock.Lock())\\n self._lock.SetInUse(False)\\n self._lock.Unlock()\\n\\n self.assertTrue(self._lock.Lock(timeout_secs=0))\\n self._lock.Unlock()\",\n \"def acquire_write(self) -> None:\\n if not self.__monitor.acquire(timeout=self.__timeout):\\n raise PetroniaLockTimeoutError()\\n while self.__rwlock != 0:\\n self.__writers_waiting += 1\\n self.__writers_ok.wait()\\n self.__writers_waiting -= 1\\n self.__rwlock = -1\\n self.__monitor.release()\",\n \"def make_waitable(self):\\n if not self.is_waitable():\\n self._condition = threading.Condition()\",\n \"def get_lock(self, name, try_=False):\\n lock = Lock(self, name, try_)\\n with lock as got_lock:\\n yield got_lock\",\n \"def wait(self, time):\\n self._wait = Event()\\n return not self._wait.wait(time)\",\n \"def wait(self, timeout):\\n if not self._is_active:\\n raise StopIteration\\n try:\\n self._pid.wait(timeout=timeout)\\n self._is_active = False\\n except subprocess.TimeoutExpired:\\n pass\",\n \"def implicitlyWait(self, timeout=10.0):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n cmdId = self.executeCommand(Command.IMPLICIT_WAIT, {'ms': float(timeout) * 1000})\\n return cmdId\",\n \"def wait_for_interrupts(self, wait_time = 1):\\n raise AssertionError(\\\"wait_for_interrupts function i not implemented\\\")\",\n \"def _wait_for_lockfile(self, lockfile_path: Path) -> None:\\n if not lockfile_path.exists():\\n return\\n\\n # The first second is free.\\n start = time.time()\\n time.sleep(1)\\n if not lockfile_path.exists():\\n return\\n\\n # After the first second, we print one message, then we stay silent for 10 minutes, at\\n # which time we print a message every minute.\\n def time_elapsed() -> float:\\n return time.time() - start\\n self.logger.info(\\\"Starting to wait for %s\\\", lockfile_path)\\n next_message_time = time.time() + 16 * 60\\n while lockfile_path.exists():\\n if next_message_time - time.time() < 0:\\n self.logger.warning(\\n \\\"Lockfile %s has been blocked for %.0f seconds\\\",\\n lockfile_path,\\n time_elapsed())\\n next_message_time = time.time() + 60\\n time.sleep(1)\",\n \"def _wait_expiration(self, raiden, transfer, sleep=DEFAULT_EVENTS_POLL_TIMEOUT):\\n # pylint: disable=no-self-use\\n\\n expiration = transfer.lock.expiration + 1\\n\\n while True:\\n current_block = raiden.get_block_number()\\n\\n if current_block > expiration:\\n return\\n\\n gevent.sleep(sleep)\",\n \"def acquire(self, rw_flag: str, timeout=-1):\\n\\n obtained = False\\n rw_flag = self._check_rw_flag(rw_flag)\\n if rw_flag == \\\"r\\\":\\n obtained = self._readers_queue.acquire(timeout=timeout)\\n if not obtained:\\n return False\\n\\n obtained = self._no_readers.acquire(timeout=timeout)\\n if not obtained:\\n self._readers_queue.release()\\n return False\\n\\n obtained = self.read_counter.acquire(timeout=timeout)\\n\\n self._no_readers.release()\\n self._readers_queue.release()\\n elif rw_flag == \\\"w\\\":\\n obtained = self._write_counter.acquire(timeout=timeout)\\n if not obtained:\\n return False\\n\\n obtained = self._no_writers.acquire(timeout=timeout)\\n if not obtained:\\n self._write_counter.release()\\n return obtained\",\n \"def try_get_lock_or_break_open():\\r\\n #pylint: disable=W0212\\r\\n time_end = time.time() + 2\\r\\n while time.time() < time_end:\\r\\n if goxapi.Signal._lock.acquire(False):\\r\\n return\\r\\n time.sleep(0.001)\\r\\n\\r\\n # something keeps holding the lock, apparently some slot is stuck\\r\\n # in an infinite loop. In order to be able to shut down anyways\\r\\n # we just throw away that lock and replace it with a new one\\r\\n lock = threading.RLock()\\r\\n lock.acquire()\\r\\n goxapi.Signal._lock = lock\\r\\n print \\\"### could not acquire signal lock, frozen slot somewhere?\\\"\\r\\n print \\\"### please see the stacktrace log to determine the cause.\\\"\",\n \"def acquire_lock(self):\\n self._multistore._lock()\",\n \"def _wait(self, remain):\\n print \\\"%s waiting %s\\\" % (self.uid, remain)\\n sleep(remain) # dummy implementation just for testing\",\n \"def wait_if_needed(self):\\n now = datetime.datetime.now()\\n # Note that this quantity is always positive because now is always bigger than the timestamp.\\n seconds_since_last_attempt = (now - self._timestamp).total_seconds()\\n # Note again that because seconds_since_last_attempt is positive, the wait seconds will\\n # never exceed self.effective_lockout_seconds, so\\n # 0 <= wait_seconds <= self.effective_lockout_seconds\\n wait_seconds = max(0.0, self.effective_lockout_seconds - seconds_since_last_attempt)\\n if wait_seconds > 0.0:\\n shared_message = (\\\"Last %s attempt was at %s (%s seconds ago).\\\"\\n % (self.action, self._timestamp, seconds_since_last_attempt))\\n if self.lockout_enabled:\\n action_message = \\\"Waiting %s seconds before attempting another.\\\" % wait_seconds\\n self.log.warning(\\\"%s %s\\\" % (shared_message, action_message))\\n time.sleep(wait_seconds)\\n else:\\n action_message = \\\"Continuing anyway because lockout is disabled.\\\"\\n self.log.warning(\\\"%s %s\\\" % (shared_message, action_message))\\n self.update_timestamp()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71883535","0.7154213","0.7148563","0.7108066","0.70570654","0.70437825","0.6900739","0.68663","0.67674184","0.6726042","0.6638591","0.6588066","0.6562686","0.63730717","0.63200384","0.6303491","0.6290304","0.6253313","0.619019","0.6133735","0.612871","0.6040424","0.6036152","0.6027077","0.6014016","0.5951841","0.59481883","0.5924959","0.5889055","0.5878101","0.58714753","0.5861483","0.5845657","0.58287394","0.5810868","0.5807277","0.579345","0.57906336","0.5774559","0.5768636","0.5763904","0.57531387","0.5745276","0.5740261","0.565539","0.56425273","0.56216246","0.56127787","0.5598426","0.5581737","0.55761427","0.55760056","0.55642366","0.5524463","0.5498469","0.549776","0.54965556","0.54819965","0.5462716","0.5403095","0.53993577","0.539711","0.53959876","0.53856695","0.5376543","0.537447","0.5368998","0.5364492","0.5357892","0.534978","0.53370994","0.5332693","0.5327563","0.5320317","0.529591","0.5277301","0.52769125","0.52563506","0.52560186","0.525078","0.5237155","0.5232369","0.52150327","0.5213019","0.52028286","0.5202419","0.5200055","0.51992136","0.51952255","0.51879114","0.5161406","0.5159572","0.5156402","0.51337695","0.51273143","0.51198417","0.5119315","0.51174444","0.511646","0.51099324"],"string":"[\n \"0.71883535\",\n \"0.7154213\",\n \"0.7148563\",\n \"0.7108066\",\n \"0.70570654\",\n \"0.70437825\",\n \"0.6900739\",\n \"0.68663\",\n \"0.67674184\",\n \"0.6726042\",\n \"0.6638591\",\n \"0.6588066\",\n \"0.6562686\",\n \"0.63730717\",\n \"0.63200384\",\n \"0.6303491\",\n \"0.6290304\",\n \"0.6253313\",\n \"0.619019\",\n \"0.6133735\",\n \"0.612871\",\n \"0.6040424\",\n \"0.6036152\",\n \"0.6027077\",\n \"0.6014016\",\n \"0.5951841\",\n \"0.59481883\",\n \"0.5924959\",\n \"0.5889055\",\n \"0.5878101\",\n \"0.58714753\",\n \"0.5861483\",\n \"0.5845657\",\n \"0.58287394\",\n \"0.5810868\",\n \"0.5807277\",\n \"0.579345\",\n \"0.57906336\",\n \"0.5774559\",\n \"0.5768636\",\n \"0.5763904\",\n \"0.57531387\",\n \"0.5745276\",\n \"0.5740261\",\n \"0.565539\",\n \"0.56425273\",\n \"0.56216246\",\n \"0.56127787\",\n \"0.5598426\",\n \"0.5581737\",\n \"0.55761427\",\n \"0.55760056\",\n \"0.55642366\",\n \"0.5524463\",\n \"0.5498469\",\n \"0.549776\",\n \"0.54965556\",\n \"0.54819965\",\n \"0.5462716\",\n \"0.5403095\",\n \"0.53993577\",\n \"0.539711\",\n \"0.53959876\",\n \"0.53856695\",\n \"0.5376543\",\n \"0.537447\",\n \"0.5368998\",\n \"0.5364492\",\n \"0.5357892\",\n \"0.534978\",\n \"0.53370994\",\n \"0.5332693\",\n \"0.5327563\",\n \"0.5320317\",\n \"0.529591\",\n \"0.5277301\",\n \"0.52769125\",\n \"0.52563506\",\n \"0.52560186\",\n \"0.525078\",\n \"0.5237155\",\n \"0.5232369\",\n \"0.52150327\",\n \"0.5213019\",\n \"0.52028286\",\n \"0.5202419\",\n \"0.5200055\",\n \"0.51992136\",\n \"0.51952255\",\n \"0.51879114\",\n \"0.5161406\",\n \"0.5159572\",\n \"0.5156402\",\n \"0.51337695\",\n \"0.51273143\",\n \"0.51198417\",\n \"0.5119315\",\n \"0.51174444\",\n \"0.511646\",\n \"0.51099324\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57434064"},"document_rank":{"kind":"string","value":"43"}}},{"rowIdx":19898,"cells":{"query":{"kind":"string","value":"Get rid of the lock by deleting the lockfile. When working in a `with` statement, this gets automatically called at the end."},"document":{"kind":"string","value":"def release(self):\r\n if self.is_locked:\r\n os.close(self.fd)\r\n os.unlink(self.lockfile)\r\n self.is_locked = False"},"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 release_lock():\n lock_file = get_lock_file()\n if exists(lock_file):\n LOG.info('Removing lock file %r' % lock_file)\n os.unlink(lock_file)\n else:\n LOG.warning('Lock file %r did not exist.' % lock_file)","def release(self):\n fcntl.flock(self.lock_file, fcntl.LOCK_UN)","def _unlock(self):\n self._lockFile.close()\n os.unlink(self._lockFilename)","def _unlock(self):\n if self.is_locked():\n self._unlink(self.lockfile)\n self._remove_unique_file()\n self._p(\"Lock removed.\")\n else:\n self._remove_unique_file()","def release(self):\n self.is_locked = False\n os.unlink(self.lockfile)","def un_lock(self):\n self._un_lock()","def _unlock(self):\n from os import remove\n remove(self.db_path + \".lock\")","def unlock (self):\n fcntl.flock(self._lockHandle, fcntl.LOCK_UN)\n self._lockHandle.close()","def release(lockfile):\n\t# Must be called _only_ if the lockfile was successfully obtained\n\tos.unlink(lockfile)","def unlock(self):\n\n\t\t# Release the file lock first\n\t\tfcntl.lockf(self.lockfile, fcntl.LOCK_UN)\n\t\t# Release the thread lock\n\t\tself.s.release()","def remove_lock_file():\n # pylint: disable=global-statement\n global LOCK_FILENAME\n\n if LOCK_FILENAME is not None and os.path.isfile(LOCK_FILENAME):\n os.unlink(LOCK_FILENAME)","def release(self):\n if self.is_locked:\n os.close(self.fd)\n os.unlink(self.lockfile)\n self.is_locked = False","def remove_lock(lockfilename):\n if os.path.isfile(lockfilename):\n os.remove(lockfilename)","def unlock(self):\n self.remove_pid_file()","def clear_lock(self, process):\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\n lockFN = os.path.join(self.args.dir[process], \\\n '.lock_pose%03d'%self.args.params['CD']['pose'])\n else:\n lockFN = os.path.join(self.args.dir[process], '.lock')\n if os.path.isfile(lockFN):\n os.remove(lockFN)\n if hasattr(self, 'log'):\n self.log.close()\n del self.log","def release(self):\n #关闭文件，删除文件\n if self.fd is not None:\n os.close(self.fd)\n os.unlink(self.lockfile)\n self.is_locked = False\n self.fd = None","def release_lock(fl):\n try:\n fcntl.lockf(fl, fcntl.LOCK_UN)\n except IOError as e:\n sys.exit(3)","def release_flock(lockfd):\n if lockfd:\n fcntl.flock(lockfd, fcntl.LOCK_UN)","def atexit_remove_lockfile(lockfile):\n mypid = os.getpid()\n\n def try_remove_lockfile():\n # in a fork() situation, only the last process should\n # remove the .lock, otherwise the other processes run the\n # risk of seeing their temporary dir disappear. For now\n # we remove the .lock in the parent only (i.e. we assume\n # that the children finish before the parent).\n if os.getpid() != mypid:\n return\n try:\n lockfile.remove()\n except error.Error:\n pass\n\n atexit.register(try_remove_lockfile)","def _release(self):\n try:\n os.unlink(self.lockfile)\n\n # Log success.\n logging.info(\"Released lock at \" + self.lockfile + \"...\")\n except:\n # Ignore all errors.\n pass","def test_deletes_lockfile_on_exit(self):\n self.lock.__enter__()\n self.assertTrue(os.path.exists(self.lock.lockfile_path))\n self.lock.__exit__(None, None, None)\n self.assertFalse(os.path.exists(self.lock.lockfile_path))","def unlock(self, unconditionally=False):\n islocked = self.locked()\n if not islocked and not unconditionally:\n raise NotLockedError\n # If we owned the lock, remove the global file, relinquishing it.\n if islocked:\n try:\n os.unlink(self.__lockfile)\n except OSError, e:\n if e.errno <> errno.ENOENT: raise\n # Remove our tempfile\n try:\n os.unlink(self.__tmpfname)\n except OSError, e:\n if e.errno <> errno.ENOENT: raise","def _release_lock(self, job_info):\n os.remove(self.lock_file)\n self.logger.debug(\"lock release for '%s'\" % job_info)","def cleanup(self):\r\n # XXX should be fixed properly!!!\r\n try:\r\n self.unlock()\r\n except:\r\n pass","def lock_delete(self):\n self.lock_stop()\n # print(self.lock_obj.file_path)\n self.lock_obj.delete_instance()\n # print(self.lock_obj.file_path)\n # print(\"self.lock_obj.lock_delete()\")","def unlock(self):\r\n # If any error occurs, we assume this is because someone else tried to\r\n # unlock this directory at the same time.\r\n # Note that it is important not to have both remove statements within\r\n # the same try/except block. The reason is that while the attempt to\r\n # remove the file may fail (e.g. because for some reason this file does\r\n # not exist), we still want to try and remove the directory.\r\n try:\r\n self.os.remove(self.os.path.join(self.tmp_dir, 'lock'))\r\n except Exception:\r\n pass\r\n try:\r\n self.os.rmdir(self.tmp_dir)\r\n except Exception:\r\n pass","def _unlock(self):\n self._file.unlock_and_close()\n self._thread_lock.release()","def release(self):\n self.filelock.set()\n self.locked = False\n self.exclusive = False","def release(self):\n self.filelock.set()\n self.locked = False\n self.exclusive = False","def unlock(lock):\n lock.release()","def break_lock(self):\n remove_existing_pidfile(self.path)","def removeLocks():\n global lockFnames\n for lockFname in lockFnames:\n if isfile(lockFname):\n logging.debug('Removing lockfile %s' % lockFname)\n os.remove(lockFname)\n\n lockFnames = []","def __del__(self):\n if self.is_locked:\n self.release()","def release_lock(self):\n if self.lock:\n self.lock.release()","def purge(self):\n if os.path.exists(self.lockfile):\n self.release()\n return True\n return False","def unlock(fd):\n fcntl.lockf(fd, fcntl.LOCK_UN)\n os.close(fd)","def _remove_lock(self, lock):\n try:\n # Ignore exceptions and do not raise for status.\n # If necessary the curator will clean up the orphaned lock.\n super(self.__class__, self).delete(_locks_collection,\n Job._get_lock_collection_key(lock.collection, lock.key),\n lock.lock_ref)\n except:\n pass","def remove(self, hashlock):\n self._cached_lock_hashes.remove(sha3(self.get(hashlock).lock.as_bytes))\n self._cached_root = None\n del self.locked[hashlock]","def __del__(self):\n if hasattr(self, \"_uniquefile_created\"):\n self._unlock()\n else:\n # When instance attributes don't exist, we probably had an error\n # in the construction process (like an invalid argument to\n # __init__()). In that case, there's no chance we have a unique\n # file or a lock to clean up.\n pass","def release(self):\n if not self.is_locked():\n error = NotLocked()\n raise error\n if not self.i_am_locking():\n error = NotMyLock()\n raise error\n remove_existing_pidfile(self.path)","def locked_delete(self):\n self._multistore._delete_credential(self._key)","def unfreeze(self,):\n if self.frozen and self.id_lock.locked():\n self.id_lock.release()\n self.loglocker.release()\n self.frozen = False","def release_lock(self):\n self._multistore._unlock()","def _unlock(self, fd):\n fcntl.lockf(fd, fcntl.LOCK_UN)","def release(self):\n if self._ctx is None:\n return\n self.atomicfile.delete()\n try:\n self._ctx.__exit__(None, None, None)\n finally:\n self._ctx = None","def delete(self):\n with self.locked():\n self.path.delete()","def delete(self):\n with self.locked():\n self.path.delete()","def release():\n lockfile = path.user('.%s.lock' % application.NAME)\n if isfile(lockfile):\n unlink(lockfile)\n return True\n return False","def release_lock():\r\n get_lock.n_lock -= 1\r\n assert get_lock.n_lock >= 0\r\n # Only really release lock once all lock requests have ended.\r\n if get_lock.lock_is_enabled and get_lock.n_lock == 0:\r\n get_lock.start_time = None\r\n get_lock.unlocker.unlock()","def remove(self, name):\n path = '%s/%s' % (self.path, name)\n lock = '%s%s' % (path, LOCKED_SUFFIX)\n os.unlink(path)\n os.unlink(lock)","def _delpid(self):\n pidfile = self._pidfile\n if pidfile is not None:\n self._log.debug('Removing pidfile: %s (%d)',\n pidfile.name, os.getpid())\n flock(pidfile, LOCK_UN)\n pidfile.close()\n os.remove(pidfile.name)\n self._pidfile = None","def unlock(self):\n self.mtx.release()","def __exit__(self, *args, **kwargs):\n\t\tfcntl.flock(self.file, fcntl.LOCK_UN)\n\t\tself.file.close()\n\t\tfor function in self.exit_functions:\n\t\t\tfunction()","def release(self):\r\n\r\n if self._lock_fd:\r\n unlock_file(self._lock_fd, close=True)\r\n self._lock_fd = None\r\n return True\r\n else:\r\n return False","def unlocked():\r\n return Lock(None)","def _removeLockDir(self):\n try:\n os.rmdir(self.lockDir)\n except OSError, err:\n if err.errno != errno.ENOENT: \n raise","def release_lock (self):\n\n self.connection.commit ()\n self.locked = False","def __del__(self):\n if self.file is None:\n return\n try:\n self.file.close()\n del self.file\n self.file = None\n except:\n getLogger(__name__).warning('Error on file close', exc_info=True)","def f_unlock(self):\n self._locked = False","def wipeFile(file_name):\r\n WipeFileThread(file_name)","def drop_cache(self, filename=None):\n os.remove(self._cache_filename(filename))","def _cleanup(self):\n if self.pidfile:\n os.unlink(self.pidfile)","def unlock(self):\n assert self._pa_threaded_mainloop is not None\n # TODO: This is not completely safe. Unlock might be called without lock.\n assert self._lock_count > 0\n self._lock_count -= 1\n pa.pa_threaded_mainloop_unlock(self._pa_threaded_mainloop)","def close_file(self):\n SpooledTemporaryFile.flush(self)\n response = requests.post(LOCK_SERVER_ADDR, json={'file_path': self.filename, 'lock_file': False, 'user_id': self.user_id})\n print response","def _destroy(self):\n # FIXME: Arrange for a more controlled shutdown through the credentials\n\n self.replay_window_persisted = True\n self.sequence_number_persisted = self.sender_sequence_number\n self._store()\n\n del self.sender_key\n del self.recipient_key\n\n os.unlink(self.lockfile.lock_file)\n self.lockfile.release()\n\n self.lockfile = None","def _forget_file(self, snapshot: Bug, filepath: str) -> None:\n try:\n cache_key = (snapshot.name, filepath)\n del self.__cache_offsets[cache_key]\n del self.__cache_file_contents[cache_key]\n except KeyError:\n pass","def destroy(self):\n\t\tos.remove(self.account_file)","def __del__(self):\n\n if self._is_open:\n self.close()","def unlink(self,):\n self._wait()\n self.fd.close()\n self.fd = None\n os.unlink(self.fname)","def delete_lock(self, lock_name):\n path = '/locks/delete/%s' % lock_name\n response = self.rest.request(content_type='text/plain',\n method='delete', path=path)\n return response.ok","def __del__(self):\n self.file.close()","def ReleaseLock(self, lock_data=None):\n if self._acquired_lock is not None:\n if lock_data is not None:\n lock_data = LockData(lock_data)\n\n self._acquired_lock.expire_time = datetime.datetime.min # Force expire.\n self._acquired_lock.lock_data = lock_data\n self._acquired_lock.put()\n else:\n self._acquired_lock.delete()","def unlock(self):\n\n self.wait = False","def force_unlock():\r\n global timeout_before_override\r\n timeout_backup = timeout_before_override\r\n timeout_before_override = 0\r\n try:\r\n get_lock(min_wait=0, max_wait=0.001)\r\n release_lock()\r\n finally:\r\n timeout_before_override = timeout_backup","def __del__(self):\n self.f.close()","def delete(self):\n\n try:\n remove(self.file)\n except OSError:\n pass","def close(self) -> None:\n os.remove(self.FILE_NAME)","def clean(self):\n with self._lock:\n self.__cache.expire()","def __del__(self):\n try:\n self.close()\n except:\n pass","def __del__(self):\n self.close_files()","def __del__(self) -> None:\n try:\n shutil.rmtree(self.temp_path)\n except FileNotFoundError:\n pass","def __del__(self):\n self._cleanup()","def reset() -> None:\n RwLocks.by_name = {}\n RwLocks.lockers = {}","def unlock(self):\n raise NotImplementedError","def _close_stream_lock(self):\n if self.stream_lock:\n try:\n if not self.stream_lock.closed:\n self.stream_lock.flush()\n self.stream_lock.close()\n finally:\n self.stream_lock = None","def _remove_stale_pidfile():\n pidfile = PIDLockFile(PID_LOCK_FILE)\n if (pid := pidfile.read_pid()) and not psutil.pid_exists(pid):\n Path(pidfile.path).unlink()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n self.close()","def __del__(self):\n if (\n self._fpointer is not None and not self._fpointer.closed\n ): # pragma: no mutate\n self._fpointer.close()","def dispose(self):\n rmtree(self._temp_path)","def __del__(self):\n self.exit()","def ReleaseFileLock(target_file):\n if os.name == 'nt':\n _UnlockImplWin(target_file)\n elif os.name == 'posix':\n _UnlockImplPosix(target_file)\n else:\n raise NotImplementedError('%s is not supported' % os.name)","def __del__(self):\n if not self.sigfile.closed:\n self.sigfile.close()","def __del__(self):\n\t\tif self.temp_dir:\n\t\t\tself.temp_dir.cleanup()"],"string":"[\n \"def release_lock():\\n lock_file = get_lock_file()\\n if exists(lock_file):\\n LOG.info('Removing lock file %r' % lock_file)\\n os.unlink(lock_file)\\n else:\\n LOG.warning('Lock file %r did not exist.' % lock_file)\",\n \"def release(self):\\n fcntl.flock(self.lock_file, fcntl.LOCK_UN)\",\n \"def _unlock(self):\\n self._lockFile.close()\\n os.unlink(self._lockFilename)\",\n \"def _unlock(self):\\n if self.is_locked():\\n self._unlink(self.lockfile)\\n self._remove_unique_file()\\n self._p(\\\"Lock removed.\\\")\\n else:\\n self._remove_unique_file()\",\n \"def release(self):\\n self.is_locked = False\\n os.unlink(self.lockfile)\",\n \"def un_lock(self):\\n self._un_lock()\",\n \"def _unlock(self):\\n from os import remove\\n remove(self.db_path + \\\".lock\\\")\",\n \"def unlock (self):\\n fcntl.flock(self._lockHandle, fcntl.LOCK_UN)\\n self._lockHandle.close()\",\n \"def release(lockfile):\\n\\t# Must be called _only_ if the lockfile was successfully obtained\\n\\tos.unlink(lockfile)\",\n \"def unlock(self):\\n\\n\\t\\t# Release the file lock first\\n\\t\\tfcntl.lockf(self.lockfile, fcntl.LOCK_UN)\\n\\t\\t# Release the thread lock\\n\\t\\tself.s.release()\",\n \"def remove_lock_file():\\n # pylint: disable=global-statement\\n global LOCK_FILENAME\\n\\n if LOCK_FILENAME is not None and os.path.isfile(LOCK_FILENAME):\\n os.unlink(LOCK_FILENAME)\",\n \"def release(self):\\n if self.is_locked:\\n os.close(self.fd)\\n os.unlink(self.lockfile)\\n self.is_locked = False\",\n \"def remove_lock(lockfilename):\\n if os.path.isfile(lockfilename):\\n os.remove(lockfilename)\",\n \"def unlock(self):\\n self.remove_pid_file()\",\n \"def clear_lock(self, process):\\n if process == 'CD' and self.args.params['CD']['pose'] > -1:\\n lockFN = os.path.join(self.args.dir[process], \\\\\\n '.lock_pose%03d'%self.args.params['CD']['pose'])\\n else:\\n lockFN = os.path.join(self.args.dir[process], '.lock')\\n if os.path.isfile(lockFN):\\n os.remove(lockFN)\\n if hasattr(self, 'log'):\\n self.log.close()\\n del self.log\",\n \"def release(self):\\n #关闭文件，删除文件\\n if self.fd is not None:\\n os.close(self.fd)\\n os.unlink(self.lockfile)\\n self.is_locked = False\\n self.fd = None\",\n \"def release_lock(fl):\\n try:\\n fcntl.lockf(fl, fcntl.LOCK_UN)\\n except IOError as e:\\n sys.exit(3)\",\n \"def release_flock(lockfd):\\n if lockfd:\\n fcntl.flock(lockfd, fcntl.LOCK_UN)\",\n \"def atexit_remove_lockfile(lockfile):\\n mypid = os.getpid()\\n\\n def try_remove_lockfile():\\n # in a fork() situation, only the last process should\\n # remove the .lock, otherwise the other processes run the\\n # risk of seeing their temporary dir disappear. For now\\n # we remove the .lock in the parent only (i.e. we assume\\n # that the children finish before the parent).\\n if os.getpid() != mypid:\\n return\\n try:\\n lockfile.remove()\\n except error.Error:\\n pass\\n\\n atexit.register(try_remove_lockfile)\",\n \"def _release(self):\\n try:\\n os.unlink(self.lockfile)\\n\\n # Log success.\\n logging.info(\\\"Released lock at \\\" + self.lockfile + \\\"...\\\")\\n except:\\n # Ignore all errors.\\n pass\",\n \"def test_deletes_lockfile_on_exit(self):\\n self.lock.__enter__()\\n self.assertTrue(os.path.exists(self.lock.lockfile_path))\\n self.lock.__exit__(None, None, None)\\n self.assertFalse(os.path.exists(self.lock.lockfile_path))\",\n \"def unlock(self, unconditionally=False):\\n islocked = self.locked()\\n if not islocked and not unconditionally:\\n raise NotLockedError\\n # If we owned the lock, remove the global file, relinquishing it.\\n if islocked:\\n try:\\n os.unlink(self.__lockfile)\\n except OSError, e:\\n if e.errno <> errno.ENOENT: raise\\n # Remove our tempfile\\n try:\\n os.unlink(self.__tmpfname)\\n except OSError, e:\\n if e.errno <> errno.ENOENT: raise\",\n \"def _release_lock(self, job_info):\\n os.remove(self.lock_file)\\n self.logger.debug(\\\"lock release for '%s'\\\" % job_info)\",\n \"def cleanup(self):\\r\\n # XXX should be fixed properly!!!\\r\\n try:\\r\\n self.unlock()\\r\\n except:\\r\\n pass\",\n \"def lock_delete(self):\\n self.lock_stop()\\n # print(self.lock_obj.file_path)\\n self.lock_obj.delete_instance()\\n # print(self.lock_obj.file_path)\\n # print(\\\"self.lock_obj.lock_delete()\\\")\",\n \"def unlock(self):\\r\\n # If any error occurs, we assume this is because someone else tried to\\r\\n # unlock this directory at the same time.\\r\\n # Note that it is important not to have both remove statements within\\r\\n # the same try/except block. The reason is that while the attempt to\\r\\n # remove the file may fail (e.g. because for some reason this file does\\r\\n # not exist), we still want to try and remove the directory.\\r\\n try:\\r\\n self.os.remove(self.os.path.join(self.tmp_dir, 'lock'))\\r\\n except Exception:\\r\\n pass\\r\\n try:\\r\\n self.os.rmdir(self.tmp_dir)\\r\\n except Exception:\\r\\n pass\",\n \"def _unlock(self):\\n self._file.unlock_and_close()\\n self._thread_lock.release()\",\n \"def release(self):\\n self.filelock.set()\\n self.locked = False\\n self.exclusive = False\",\n \"def release(self):\\n self.filelock.set()\\n self.locked = False\\n self.exclusive = False\",\n \"def unlock(lock):\\n lock.release()\",\n \"def break_lock(self):\\n remove_existing_pidfile(self.path)\",\n \"def removeLocks():\\n global lockFnames\\n for lockFname in lockFnames:\\n if isfile(lockFname):\\n logging.debug('Removing lockfile %s' % lockFname)\\n os.remove(lockFname)\\n\\n lockFnames = []\",\n \"def __del__(self):\\n if self.is_locked:\\n self.release()\",\n \"def release_lock(self):\\n if self.lock:\\n self.lock.release()\",\n \"def purge(self):\\n if os.path.exists(self.lockfile):\\n self.release()\\n return True\\n return False\",\n \"def unlock(fd):\\n fcntl.lockf(fd, fcntl.LOCK_UN)\\n os.close(fd)\",\n \"def _remove_lock(self, lock):\\n try:\\n # Ignore exceptions and do not raise for status.\\n # If necessary the curator will clean up the orphaned lock.\\n super(self.__class__, self).delete(_locks_collection,\\n Job._get_lock_collection_key(lock.collection, lock.key),\\n lock.lock_ref)\\n except:\\n pass\",\n \"def remove(self, hashlock):\\n self._cached_lock_hashes.remove(sha3(self.get(hashlock).lock.as_bytes))\\n self._cached_root = None\\n del self.locked[hashlock]\",\n \"def __del__(self):\\n if hasattr(self, \\\"_uniquefile_created\\\"):\\n self._unlock()\\n else:\\n # When instance attributes don't exist, we probably had an error\\n # in the construction process (like an invalid argument to\\n # __init__()). In that case, there's no chance we have a unique\\n # file or a lock to clean up.\\n pass\",\n \"def release(self):\\n if not self.is_locked():\\n error = NotLocked()\\n raise error\\n if not self.i_am_locking():\\n error = NotMyLock()\\n raise error\\n remove_existing_pidfile(self.path)\",\n \"def locked_delete(self):\\n self._multistore._delete_credential(self._key)\",\n \"def unfreeze(self,):\\n if self.frozen and self.id_lock.locked():\\n self.id_lock.release()\\n self.loglocker.release()\\n self.frozen = False\",\n \"def release_lock(self):\\n self._multistore._unlock()\",\n \"def _unlock(self, fd):\\n fcntl.lockf(fd, fcntl.LOCK_UN)\",\n \"def release(self):\\n if self._ctx is None:\\n return\\n self.atomicfile.delete()\\n try:\\n self._ctx.__exit__(None, None, None)\\n finally:\\n self._ctx = None\",\n \"def delete(self):\\n with self.locked():\\n self.path.delete()\",\n \"def delete(self):\\n with self.locked():\\n self.path.delete()\",\n \"def release():\\n lockfile = path.user('.%s.lock' % application.NAME)\\n if isfile(lockfile):\\n unlink(lockfile)\\n return True\\n return False\",\n \"def release_lock():\\r\\n get_lock.n_lock -= 1\\r\\n assert get_lock.n_lock >= 0\\r\\n # Only really release lock once all lock requests have ended.\\r\\n if get_lock.lock_is_enabled and get_lock.n_lock == 0:\\r\\n get_lock.start_time = None\\r\\n get_lock.unlocker.unlock()\",\n \"def remove(self, name):\\n path = '%s/%s' % (self.path, name)\\n lock = '%s%s' % (path, LOCKED_SUFFIX)\\n os.unlink(path)\\n os.unlink(lock)\",\n \"def _delpid(self):\\n pidfile = self._pidfile\\n if pidfile is not None:\\n self._log.debug('Removing pidfile: %s (%d)',\\n pidfile.name, os.getpid())\\n flock(pidfile, LOCK_UN)\\n pidfile.close()\\n os.remove(pidfile.name)\\n self._pidfile = None\",\n \"def unlock(self):\\n self.mtx.release()\",\n \"def __exit__(self, *args, **kwargs):\\n\\t\\tfcntl.flock(self.file, fcntl.LOCK_UN)\\n\\t\\tself.file.close()\\n\\t\\tfor function in self.exit_functions:\\n\\t\\t\\tfunction()\",\n \"def release(self):\\r\\n\\r\\n if self._lock_fd:\\r\\n unlock_file(self._lock_fd, close=True)\\r\\n self._lock_fd = None\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def unlocked():\\r\\n return Lock(None)\",\n \"def _removeLockDir(self):\\n try:\\n os.rmdir(self.lockDir)\\n except OSError, err:\\n if err.errno != errno.ENOENT: \\n raise\",\n \"def release_lock (self):\\n\\n self.connection.commit ()\\n self.locked = False\",\n \"def __del__(self):\\n if self.file is None:\\n return\\n try:\\n self.file.close()\\n del self.file\\n self.file = None\\n except:\\n getLogger(__name__).warning('Error on file close', exc_info=True)\",\n \"def f_unlock(self):\\n self._locked = False\",\n \"def wipeFile(file_name):\\r\\n WipeFileThread(file_name)\",\n \"def drop_cache(self, filename=None):\\n os.remove(self._cache_filename(filename))\",\n \"def _cleanup(self):\\n if self.pidfile:\\n os.unlink(self.pidfile)\",\n \"def unlock(self):\\n assert self._pa_threaded_mainloop is not None\\n # TODO: This is not completely safe. Unlock might be called without lock.\\n assert self._lock_count > 0\\n self._lock_count -= 1\\n pa.pa_threaded_mainloop_unlock(self._pa_threaded_mainloop)\",\n \"def close_file(self):\\n SpooledTemporaryFile.flush(self)\\n response = requests.post(LOCK_SERVER_ADDR, json={'file_path': self.filename, 'lock_file': False, 'user_id': self.user_id})\\n print response\",\n \"def _destroy(self):\\n # FIXME: Arrange for a more controlled shutdown through the credentials\\n\\n self.replay_window_persisted = True\\n self.sequence_number_persisted = self.sender_sequence_number\\n self._store()\\n\\n del self.sender_key\\n del self.recipient_key\\n\\n os.unlink(self.lockfile.lock_file)\\n self.lockfile.release()\\n\\n self.lockfile = None\",\n \"def _forget_file(self, snapshot: Bug, filepath: str) -> None:\\n try:\\n cache_key = (snapshot.name, filepath)\\n del self.__cache_offsets[cache_key]\\n del self.__cache_file_contents[cache_key]\\n except KeyError:\\n pass\",\n \"def destroy(self):\\n\\t\\tos.remove(self.account_file)\",\n \"def __del__(self):\\n\\n if self._is_open:\\n self.close()\",\n \"def unlink(self,):\\n self._wait()\\n self.fd.close()\\n self.fd = None\\n os.unlink(self.fname)\",\n \"def delete_lock(self, lock_name):\\n path = '/locks/delete/%s' % lock_name\\n response = self.rest.request(content_type='text/plain',\\n method='delete', path=path)\\n return response.ok\",\n \"def __del__(self):\\n self.file.close()\",\n \"def ReleaseLock(self, lock_data=None):\\n if self._acquired_lock is not None:\\n if lock_data is not None:\\n lock_data = LockData(lock_data)\\n\\n self._acquired_lock.expire_time = datetime.datetime.min # Force expire.\\n self._acquired_lock.lock_data = lock_data\\n self._acquired_lock.put()\\n else:\\n self._acquired_lock.delete()\",\n \"def unlock(self):\\n\\n self.wait = False\",\n \"def force_unlock():\\r\\n global timeout_before_override\\r\\n timeout_backup = timeout_before_override\\r\\n timeout_before_override = 0\\r\\n try:\\r\\n get_lock(min_wait=0, max_wait=0.001)\\r\\n release_lock()\\r\\n finally:\\r\\n timeout_before_override = timeout_backup\",\n \"def __del__(self):\\n self.f.close()\",\n \"def delete(self):\\n\\n try:\\n remove(self.file)\\n except OSError:\\n pass\",\n \"def close(self) -> None:\\n os.remove(self.FILE_NAME)\",\n \"def clean(self):\\n with self._lock:\\n self.__cache.expire()\",\n \"def __del__(self):\\n try:\\n self.close()\\n except:\\n pass\",\n \"def __del__(self):\\n self.close_files()\",\n \"def __del__(self) -> None:\\n try:\\n shutil.rmtree(self.temp_path)\\n except FileNotFoundError:\\n pass\",\n \"def __del__(self):\\n self._cleanup()\",\n \"def reset() -> None:\\n RwLocks.by_name = {}\\n RwLocks.lockers = {}\",\n \"def unlock(self):\\n raise NotImplementedError\",\n \"def _close_stream_lock(self):\\n if self.stream_lock:\\n try:\\n if not self.stream_lock.closed:\\n self.stream_lock.flush()\\n self.stream_lock.close()\\n finally:\\n self.stream_lock = None\",\n \"def _remove_stale_pidfile():\\n pidfile = PIDLockFile(PID_LOCK_FILE)\\n if (pid := pidfile.read_pid()) and not psutil.pid_exists(pid):\\n Path(pidfile.path).unlink()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n self.close()\",\n \"def __del__(self):\\n if (\\n self._fpointer is not None and not self._fpointer.closed\\n ): # pragma: no mutate\\n self._fpointer.close()\",\n \"def dispose(self):\\n rmtree(self._temp_path)\",\n \"def __del__(self):\\n self.exit()\",\n \"def ReleaseFileLock(target_file):\\n if os.name == 'nt':\\n _UnlockImplWin(target_file)\\n elif os.name == 'posix':\\n _UnlockImplPosix(target_file)\\n else:\\n raise NotImplementedError('%s is not supported' % os.name)\",\n \"def __del__(self):\\n if not self.sigfile.closed:\\n self.sigfile.close()\",\n \"def __del__(self):\\n\\t\\tif self.temp_dir:\\n\\t\\t\\tself.temp_dir.cleanup()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84547544","0.8364578","0.8101169","0.80762964","0.8035398","0.80157477","0.7947669","0.793357","0.788736","0.78680533","0.78488946","0.78055084","0.77679634","0.7763988","0.7752474","0.7686199","0.7607583","0.75954175","0.7480247","0.7437406","0.7421161","0.7357311","0.734224","0.7317355","0.72845834","0.7237429","0.7221725","0.7217681","0.7217681","0.71960855","0.71943027","0.71929085","0.7128136","0.7091538","0.7039303","0.7007682","0.6958621","0.6924767","0.69189715","0.69015527","0.68719554","0.6863054","0.6828924","0.68267655","0.68251264","0.68156254","0.68156254","0.6814333","0.6809408","0.67169017","0.667221","0.66469264","0.66029793","0.660058","0.6520368","0.64999765","0.64254427","0.6366065","0.6326026","0.6303144","0.62947035","0.6294648","0.62923163","0.62896925","0.6276973","0.62765455","0.6261801","0.6245073","0.62426275","0.6234517","0.62339854","0.6230357","0.62240833","0.6205718","0.62054986","0.61982256","0.6175533","0.61745197","0.6160617","0.61516255","0.61504716","0.61399","0.6138926","0.6132147","0.61239666","0.61187035","0.6114579","0.6114579","0.6114579","0.6114579","0.6114579","0.6114579","0.6114579","0.6114579","0.61128485","0.6108976","0.61024296","0.61009926","0.60979563","0.6092745"],"string":"[\n \"0.84547544\",\n \"0.8364578\",\n \"0.8101169\",\n \"0.80762964\",\n \"0.8035398\",\n \"0.80157477\",\n \"0.7947669\",\n \"0.793357\",\n \"0.788736\",\n \"0.78680533\",\n \"0.78488946\",\n \"0.78055084\",\n \"0.77679634\",\n \"0.7763988\",\n \"0.7752474\",\n \"0.7686199\",\n \"0.7607583\",\n \"0.75954175\",\n \"0.7480247\",\n \"0.7437406\",\n \"0.7421161\",\n \"0.7357311\",\n \"0.734224\",\n \"0.7317355\",\n \"0.72845834\",\n \"0.7237429\",\n \"0.7221725\",\n \"0.7217681\",\n \"0.7217681\",\n \"0.71960855\",\n \"0.71943027\",\n \"0.71929085\",\n \"0.7128136\",\n \"0.7091538\",\n \"0.7039303\",\n \"0.7007682\",\n \"0.6958621\",\n \"0.6924767\",\n \"0.69189715\",\n \"0.69015527\",\n \"0.68719554\",\n \"0.6863054\",\n \"0.6828924\",\n \"0.68267655\",\n \"0.68251264\",\n \"0.68156254\",\n \"0.68156254\",\n \"0.6814333\",\n \"0.6809408\",\n \"0.67169017\",\n \"0.667221\",\n \"0.66469264\",\n \"0.66029793\",\n \"0.660058\",\n \"0.6520368\",\n \"0.64999765\",\n \"0.64254427\",\n \"0.6366065\",\n \"0.6326026\",\n \"0.6303144\",\n \"0.62947035\",\n \"0.6294648\",\n \"0.62923163\",\n \"0.62896925\",\n \"0.6276973\",\n \"0.62765455\",\n \"0.6261801\",\n \"0.6245073\",\n \"0.62426275\",\n \"0.6234517\",\n \"0.62339854\",\n \"0.6230357\",\n \"0.62240833\",\n \"0.6205718\",\n \"0.62054986\",\n \"0.61982256\",\n \"0.6175533\",\n \"0.61745197\",\n \"0.6160617\",\n \"0.61516255\",\n \"0.61504716\",\n \"0.61399\",\n \"0.6138926\",\n \"0.6132147\",\n \"0.61239666\",\n \"0.61187035\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.6114579\",\n \"0.61128485\",\n \"0.6108976\",\n \"0.61024296\",\n \"0.61009926\",\n \"0.60979563\",\n \"0.6092745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7873586"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":19899,"cells":{"query":{"kind":"string","value":"Activated when used in the with statement. Should automatically acquire a lock to be used in the with block."},"document":{"kind":"string","value":"def __enter__(self):\r\n if not self.is_locked:\r\n self.acquire()\r\n return self"},"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 __enter__(self):\n return self._lock.__enter__()","async def __aenter__(self):\n self.acquired = True\n return self","def __enter__(self):\r\n self.acquire()\r\n return self","def __enter__(self):\n self.acquire()\n return self","def __enter__(self):\n self.acquire()\n return self","def __enter__(self):\n if not self.is_locked:\n self.acquire()\n return self","def __enter__(self):\n try:\n self._lock()\n except:\n self._unlock()\n raise\n return self","def i_am_locking(self):\r\n pass","def lock(self):\n raise NotImplementedError","def locking_context(self):\n self.fasta_indexing_lock.acquire(True)\n try:\n yield\n finally: # here is exit\n self.fasta_indexing_lock.release()\n pass","def __enter__(self):\n\t\tmode = 'r+' if os.path.exists(self.filename) else 'w'\n\t\tself.file = open(self.filename, mode)\n\t\ttry:\n\t\t\tfcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)\n\t\texcept IOError, e:\n\t\t\tsys.exit('Unable to obtain lock on %s, probably due to other ' \n\t\t\t\t'running instances of pydbpintegrator.' % self.filename)\n\t\treturn self","def __enter__(self):\r\n pass","def __enter__(self):\n pass","def __enter__(self):\n pass","def f_lock(self):\n self._locked = True","def __enter__(self):\n self.manual_enter()\n return self","def __enter__(self):\n return self.connection.__enter__","def lock(self):\n self.lock.acquire()\n yield\n self.lock.release()","def __enter__(self):\n raise NotImplementedError","def lock(self):\n self.mtx.acquire()","def __enter__(self):\n\t\treturn self","def __enter__(self) -> None:\n raise NotImplementedError()","def _lock(req): # static method\n tran = req.db.transaction(req.log_info)\n c = tran.cursor()\n c.execute('BEGIN EXCLUSIVE TRANSACTION')\n return c","def __enter__(self):\r\n return self","def __enter__(self):\n self.__within_context = True\n if not self.__initialized:\n self.__initialization__()\n return self","def acquire_lock (self):\n\n self._exec (self.select)\n self.locked = True","def lock(self):\r\n return self._lock","def secondary_locking_context(self):\n self.secondary_fasta_indexing_lock.acquire(True)\n try:\n yield\n finally: # here is exit\n self.secondary_fasta_indexing_lock.release()\n pass","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n self._in_context_block = True\n # TODO: create local backup of file in case we can't upload and have to roll back\n return self","def __enter__(self):\n # mark the beginning of a transaction\n self.execute(*self.sql.transaction())\n # and hand me back to the caller\n return self","def acquire_lock(self):\n if self.lock:\n self.lock.acquire()","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","async def __aenter__(self):\n return self","async def __aenter__(self):\n return self","def acquire_lock(self):\n self._multistore._lock()","def __enter__(self):\n self._source.__enter__()\n return self","def __enter__(self):\n self.open()\n return self","def __enter__(self):\n self.open()\n return self","def __enter__(self):\n self.open()\n return self","def __enter__(self):\n self.open()\n return self","def __enter__(self):\n self.open()\n return self","def __enter__(self):\n return self","def __enter__(self):\n return self","def __enter__(self):\n self.initialize()\n return self","def __enter__(self):\n\n return self","def __enter__(self):\n\n return self","def __enter__(self):\n\n return self","def __enter__(self):\n\n return self","def __enter__(self):\n\n return self","def __enter__(self):\n\n return self","def break_lock(self):\r\n pass","def __enter__(self):\n if self._transaction_count == 0:\n self._db_copy = self.db._read()\n self._transaction_count += 1\n return self","def __enter__(self):\n self._logger.debug(\"__enter__()\")\n self.install(\"PRE\")","def _warn_and_lock_if_needed(self, transaction: Transaction) -> None:\n pass","def __enter__(self):\n # The user count must be incremented before locking. In python, simple\n # I Python, simple assignment is thead-safe, but compound assignment, \n # e.g. += is not. \n u = self.users\n self.users = u + 1\n self.lock()\n return self","def __enter__(self):\n self.__init__()\n return self","def lock(self):\n\n self.wait = True","def acquire_nowait(self) -> None:\n task = get_current_task()\n if self._owner_task == task:\n raise RuntimeError('Attempted to acquire an already held Lock')\n\n if self._owner_task is not None:\n raise WouldBlock\n\n self._owner_task = task","def acquire(self, blocking=True, shared=False):","def processLock(self):\r\n self.controller.executionLock()"],"string":"[\n \"def __enter__(self):\\n return self._lock.__enter__()\",\n \"async def __aenter__(self):\\n self.acquired = True\\n return self\",\n \"def __enter__(self):\\r\\n self.acquire()\\r\\n return self\",\n \"def __enter__(self):\\n self.acquire()\\n return self\",\n \"def __enter__(self):\\n self.acquire()\\n return self\",\n \"def __enter__(self):\\n if not self.is_locked:\\n self.acquire()\\n return self\",\n \"def __enter__(self):\\n try:\\n self._lock()\\n except:\\n self._unlock()\\n raise\\n return self\",\n \"def i_am_locking(self):\\r\\n pass\",\n \"def lock(self):\\n raise NotImplementedError\",\n \"def locking_context(self):\\n self.fasta_indexing_lock.acquire(True)\\n try:\\n yield\\n finally: # here is exit\\n self.fasta_indexing_lock.release()\\n pass\",\n \"def __enter__(self):\\n\\t\\tmode = 'r+' if os.path.exists(self.filename) else 'w'\\n\\t\\tself.file = open(self.filename, mode)\\n\\t\\ttry:\\n\\t\\t\\tfcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n\\t\\texcept IOError, e:\\n\\t\\t\\tsys.exit('Unable to obtain lock on %s, probably due to other ' \\n\\t\\t\\t\\t'running instances of pydbpintegrator.' % self.filename)\\n\\t\\treturn self\",\n \"def __enter__(self):\\r\\n pass\",\n \"def __enter__(self):\\n pass\",\n \"def __enter__(self):\\n pass\",\n \"def f_lock(self):\\n self._locked = True\",\n \"def __enter__(self):\\n self.manual_enter()\\n return self\",\n \"def __enter__(self):\\n return self.connection.__enter__\",\n \"def lock(self):\\n self.lock.acquire()\\n yield\\n self.lock.release()\",\n \"def __enter__(self):\\n raise NotImplementedError\",\n \"def lock(self):\\n self.mtx.acquire()\",\n \"def __enter__(self):\\n\\t\\treturn self\",\n \"def __enter__(self) -> None:\\n raise NotImplementedError()\",\n \"def _lock(req): # static method\\n tran = req.db.transaction(req.log_info)\\n c = tran.cursor()\\n c.execute('BEGIN EXCLUSIVE TRANSACTION')\\n return c\",\n \"def __enter__(self):\\r\\n return self\",\n \"def __enter__(self):\\n self.__within_context = True\\n if not self.__initialized:\\n self.__initialization__()\\n return self\",\n \"def acquire_lock (self):\\n\\n self._exec (self.select)\\n self.locked = True\",\n \"def lock(self):\\r\\n return self._lock\",\n \"def secondary_locking_context(self):\\n self.secondary_fasta_indexing_lock.acquire(True)\\n try:\\n yield\\n finally: # here is exit\\n self.secondary_fasta_indexing_lock.release()\\n pass\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n self._in_context_block = True\\n # TODO: create local backup of file in case we can't upload and have to roll back\\n return self\",\n \"def __enter__(self):\\n # mark the beginning of a transaction\\n self.execute(*self.sql.transaction())\\n # and hand me back to the caller\\n return self\",\n \"def acquire_lock(self):\\n if self.lock:\\n self.lock.acquire()\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"async def __aenter__(self):\\n return self\",\n \"async def __aenter__(self):\\n return self\",\n \"def acquire_lock(self):\\n self._multistore._lock()\",\n \"def __enter__(self):\\n self._source.__enter__()\\n return self\",\n \"def __enter__(self):\\n self.open()\\n return self\",\n \"def __enter__(self):\\n self.open()\\n return self\",\n \"def __enter__(self):\\n self.open()\\n return self\",\n \"def __enter__(self):\\n self.open()\\n return self\",\n \"def __enter__(self):\\n self.open()\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n return self\",\n \"def __enter__(self):\\n self.initialize()\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def __enter__(self):\\n\\n return self\",\n \"def break_lock(self):\\r\\n pass\",\n \"def __enter__(self):\\n if self._transaction_count == 0:\\n self._db_copy = self.db._read()\\n self._transaction_count += 1\\n return self\",\n \"def __enter__(self):\\n self._logger.debug(\\\"__enter__()\\\")\\n self.install(\\\"PRE\\\")\",\n \"def _warn_and_lock_if_needed(self, transaction: Transaction) -> None:\\n pass\",\n \"def __enter__(self):\\n # The user count must be incremented before locking. In python, simple\\n # I Python, simple assignment is thead-safe, but compound assignment, \\n # e.g. += is not. \\n u = self.users\\n self.users = u + 1\\n self.lock()\\n return self\",\n \"def __enter__(self):\\n self.__init__()\\n return self\",\n \"def lock(self):\\n\\n self.wait = True\",\n \"def acquire_nowait(self) -> None:\\n task = get_current_task()\\n if self._owner_task == task:\\n raise RuntimeError('Attempted to acquire an already held Lock')\\n\\n if self._owner_task is not None:\\n raise WouldBlock\\n\\n self._owner_task = task\",\n \"def acquire(self, blocking=True, shared=False):\",\n \"def processLock(self):\\r\\n self.controller.executionLock()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76681423","0.75623655","0.7512478","0.74385935","0.74385935","0.7426379","0.7235537","0.7198601","0.7103257","0.7099194","0.70519584","0.6976629","0.6971899","0.6971899","0.6871852","0.6831314","0.6821339","0.6815241","0.67311513","0.67223877","0.66881794","0.6655449","0.66538864","0.66419286","0.664054","0.6615767","0.66050893","0.6573725","0.6554647","0.6554647","0.65265024","0.6517909","0.65030795","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.65001565","0.64985216","0.64985216","0.64843464","0.64823806","0.6456787","0.6456787","0.6456787","0.6456787","0.6456787","0.64432657","0.64432657","0.6426457","0.64158833","0.64158833","0.64158833","0.64158833","0.64158833","0.64158833","0.6412788","0.64023286","0.6396658","0.6387797","0.6360459","0.6356114","0.6351166","0.63248837","0.6314404","0.63056904"],"string":"[\n \"0.76681423\",\n \"0.75623655\",\n \"0.7512478\",\n \"0.74385935\",\n \"0.74385935\",\n \"0.7426379\",\n \"0.7235537\",\n \"0.7198601\",\n \"0.7103257\",\n \"0.7099194\",\n \"0.70519584\",\n \"0.6976629\",\n \"0.6971899\",\n \"0.6971899\",\n \"0.6871852\",\n \"0.6831314\",\n \"0.6821339\",\n \"0.6815241\",\n \"0.67311513\",\n \"0.67223877\",\n \"0.66881794\",\n \"0.6655449\",\n \"0.66538864\",\n \"0.66419286\",\n \"0.664054\",\n \"0.6615767\",\n \"0.66050893\",\n \"0.6573725\",\n \"0.6554647\",\n \"0.6554647\",\n \"0.65265024\",\n \"0.6517909\",\n \"0.65030795\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.65001565\",\n \"0.64985216\",\n \"0.64985216\",\n \"0.64843464\",\n \"0.64823806\",\n \"0.6456787\",\n \"0.6456787\",\n \"0.6456787\",\n \"0.6456787\",\n \"0.6456787\",\n \"0.64432657\",\n \"0.64432657\",\n \"0.6426457\",\n \"0.64158833\",\n \"0.64158833\",\n \"0.64158833\",\n \"0.64158833\",\n \"0.64158833\",\n \"0.64158833\",\n \"0.6412788\",\n \"0.64023286\",\n \"0.6396658\",\n \"0.6387797\",\n \"0.6360459\",\n \"0.6356114\",\n \"0.6351166\",\n \"0.63248837\",\n \"0.6314404\",\n \"0.63056904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7459506"},"document_rank":{"kind":"string","value":"3"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":198,"numItemsPerPage":100,"numTotalItems":95772,"offset":19800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMzMzI4MSwianRpIjoiODYyOTQ4YzEtMjE5ZC00MDU0LThhMzItNjAwZmY3OTZlMzc1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMzY4ODEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xf4kBbbLjW_HQ4IPYyfFPF1I6He3r-j1jMlpksZsJpvZGmgrJmuiQDYzSXkf3oOrjkUsfCW8Z-HCPxpCQI9eDg","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 |
|---|---|---|---|---|---|---|
For each cluster calculate the distance from each point to the centroid/medoid | def calculate_all_distances_to_center(self):
all_distances = pd.DataFrame()
for label in np.unique(self.embedding_df['cluster']):
distance_df = self.calculate_distances_for_cluster(label)
all_distances = pd.concat([all_distances, distance_df])
self.emb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calc_distance(self, X):\n distances = np.zeros((X.shape[0], self.n_clusters))\n print(distances.shape)\n for i, centroid in enumerate(self.centroids):\n distances[:, i] = np.linalg.norm(X - centroid, axis=1)\n return distances",
"def clusterAndDistance(self, data):\n\t... | [
"0.7406177",
"0.7224814",
"0.7208233",
"0.7151215",
"0.708985",
"0.7055581",
"0.7028743",
"0.70208573",
"0.6990872",
"0.6973009",
"0.696932",
"0.6856841",
"0.6850477",
"0.6842931",
"0.68366003",
"0.680196",
"0.6769376",
"0.67255235",
"0.67136353",
"0.6698315",
"0.66856843",
... | 0.70009273 | 8 |
For a given cluster_id calculate the distance from each point to the centroid/medoid. | def calculate_distances_for_cluster(self, cluster_id):
cluster_of_interest = self.embedding_df[self.embedding_df['cluster'] == cluster_id].copy()
if cluster_of_interest.empty:
raise ValueError(f'Cluster id {cluster_id} not found')
# Don't calculate distances for the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calcDistortion(medoids, clusters, class_header=\"Class\"):\n distortion = 0\n for medoid_row_index, medoid_tuple in enumerate(medoids.iterrows()): # For every Medoid\n for _, datum in clusters[medoid_row_index].iterrows(): # For each point in the medoid cluster\n # Add... | [
"0.67842567",
"0.67745066",
"0.6764742",
"0.67052865",
"0.6705151",
"0.6693539",
"0.6685048",
"0.65840197",
"0.6572326",
"0.65583515",
"0.64906234",
"0.6264555",
"0.6253788",
"0.6250515",
"0.62433743",
"0.62167305",
"0.6175956",
"0.61737406",
"0.6170333",
"0.61438906",
"0.614... | 0.7704725 | 0 |
For a given cluster return a pandas dataframe of points ranked by distance to the cluster centroid/medoid | def rank_cluster_points_by_distance(self, cluster_id):
cluster_of_interest = self.embedding_df[self.embedding_df['cluster'] == cluster_id].copy()
if cluster_of_interest.empty:
raise ValueError(f'Cluster id {cluster_id} not found')
if 'dist_to_rep_point' not in s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_cluster_rankings(self):\n if 'dist_to_rep_point' not in self.embedding_df.columns:\n self.calculate_all_distances_to_center()\n\n self.embedding_df['rank_in_cluster'] = self.embedding_df.groupby('cluster')['dist_to_rep_point'].rank(method='min')",
"def cluster_spatial_positio... | [
"0.74079317",
"0.67105204",
"0.64238435",
"0.63077164",
"0.6306624",
"0.6294445",
"0.62434506",
"0.6157537",
"0.6113591",
"0.61009115",
"0.6098193",
"0.607835",
"0.60371375",
"0.6021003",
"0.60085094",
"0.60084623",
"0.5979887",
"0.59464717",
"0.59397215",
"0.5935677",
"0.592... | 0.74946755 | 0 |
Calculate the rank of each point within a cluster | def get_all_cluster_rankings(self):
if 'dist_to_rep_point' not in self.embedding_df.columns:
self.calculate_all_distances_to_center()
self.embedding_df['rank_in_cluster'] = self.embedding_df.groupby('cluster')['dist_to_rep_point'].rank(method='min') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rank():\n return 0",
"def rankNeighbors(Data):\r\n strokeDist = []\r\n for i in range(len(Data)):\r\n strokeDist.append([])\r\n index = 0\r\n for point1 in Data:\r\n dist = []\r\n index1=0\r\n for point2 in Data:\r\n #dist.append(math.sqrt((center1[0]-cen... | [
"0.70503414",
"0.7008832",
"0.6786571",
"0.6764138",
"0.67443216",
"0.66818386",
"0.6654572",
"0.6623286",
"0.6598719",
"0.65756667",
"0.65539867",
"0.6456434",
"0.6411865",
"0.6378525",
"0.63583297",
"0.63149124",
"0.6295258",
"0.62677336",
"0.6262239",
"0.6217441",
"0.61610... | 0.7514025 | 0 |
Get the N closest points to the cluster centroid/medoid | def get_closest_samples_for_cluster(self, cluster_id, n_samples=5):
return self.rank_cluster_points_by_distance(cluster_id).head(n_samples) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_centroid(x,centroids):\n\tK =len(centroids)\n\tN = len(x)\n\tDistance = np.zeros((N,K))\n\tfor j in range(K):\n\t\tmu = centroids[j]\n\t\tDistance[:,j] = np.linalg.norm(x-mu,axis=1)\n\tout = np.argmin(Distance,axis=1) \n\treturn out",
"def closestCentroids(self, points , centroids ):\n dists =... | [
"0.7343606",
"0.72781867",
"0.71205705",
"0.6924735",
"0.6859449",
"0.6853737",
"0.6829529",
"0.6827063",
"0.6808693",
"0.6704461",
"0.66894203",
"0.6678887",
"0.66732544",
"0.66403407",
"0.6632764",
"0.66146874",
"0.6592352",
"0.656101",
"0.65443325",
"0.65115714",
"0.650200... | 0.67615163 | 9 |
Get the N points furthest away from the cluster centroid/medoid | def get_furthest_samples_for_cluster(self, cluster_id, n_samples=5):
return self.rank_cluster_points_by_distance(cluster_id).tail(n_samples) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_centroid(x,centroids):\n\tK =len(centroids)\n\tN = len(x)\n\tDistance = np.zeros((N,K))\n\tfor j in range(K):\n\t\tmu = centroids[j]\n\t\tDistance[:,j] = np.linalg.norm(x-mu,axis=1)\n\tout = np.argmin(Distance,axis=1) \n\treturn out",
"def find_centroid_for_each(self):",
"def find_closest_centroid(... | [
"0.66241753",
"0.6465052",
"0.641947",
"0.64152354",
"0.6400747",
"0.633942",
"0.6306366",
"0.6299195",
"0.62724966",
"0.6231763",
"0.6229463",
"0.6175052",
"0.6131195",
"0.61069965",
"0.6090556",
"0.6089263",
"0.60883355",
"0.6073964",
"0.60512024",
"0.60488605",
"0.60463613... | 0.625018 | 9 |
It should train the BM25 model on the given corpus docs Return nothing | def fit(self, X):
X = self.tf_vectorizer.fit_transform(X).toarray()
if not sp.issparse(X):
X = sp.csc_matrix(X)
n_samples, n_features = X.shape
if sp.isspmatrix_csr(X):
df = bincount(X.indices, minlength=X.shape[1])
else:
df = np.diff(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_with_corpus(corpus):\n\n chatbot.set_trainer(\"chatterbot.trainers.ChatterBotCorpusTrainer\")\n chatbot.train(corpus)",
"def train(self, corpus):\n self.tokens = []\n self.tags = []\n sentences = corpus.split(NEW_LINE)\n for sentence in sentences:\n start = ... | [
"0.6795744",
"0.6774191",
"0.6740312",
"0.6709312",
"0.6631094",
"0.6580085",
"0.6452751",
"0.64361066",
"0.6405335",
"0.63766575",
"0.6367579",
"0.6351783",
"0.63233477",
"0.63163066",
"0.6267682",
"0.62623096",
"0.625112",
"0.6227979",
"0.62257004",
"0.62190145",
"0.6202841... | 0.0 | -1 |
Train the BM25 model and return a vectorspace representation of the corpus Return a matrix where each row is one document, each column is feature | def fit_transform(self, X):
self.fit(X)
return self.transform(X) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainingModel4wmd(corpus):\n model = Word2Vec(corpus, workers = nCores, size = 100, window = 300,\n min_count = 2, iter = 250)\n # model = Word2Vec(corpus)\n\n # use the following if we want to normalize the vectors\n model.init_sims(replace=True)\n\n return model",
"def build_model(self, ... | [
"0.68189424",
"0.65753895",
"0.6421289",
"0.6344367",
"0.6242432",
"0.62343466",
"0.6107891",
"0.6102696",
"0.6091877",
"0.6071134",
"0.60613745",
"0.60417163",
"0.60304743",
"0.5970605",
"0.5967089",
"0.59405553",
"0.59382325",
"0.5937518",
"0.59349877",
"0.59299314",
"0.592... | 0.0 | -1 |
Find text in collections | def fuzzyfinder(user_input, collection):
suggestions = []
pattern = '.*?'.join(user_input) # Converts 'djm' to 'd.*?j.*?m'
regex = re.compile(pattern, re.IGNORECASE)
for item in collection:
match = regex.search(item)
if match:
suggestions.append(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def text_search():\n existing_fields = self.attr_name_map[object_class]\n text = \"%{}%\".format(exp[\"text\"])\n p = lambda f: f.ilike(text)\n return or_(*(\n with_key(field, p)\n for field in fields\n if field in existing_fields\n ))",
"def find_matches(self,... | [
"0.6595098",
"0.6506341",
"0.6453324",
"0.64229476",
"0.63823557",
"0.628753",
"0.6222342",
"0.6208727",
"0.6166719",
"0.61623925",
"0.61597556",
"0.6141293",
"0.6113045",
"0.609483",
"0.609124",
"0.6073653",
"0.60039556",
"0.59964216",
"0.5945154",
"0.5939557",
"0.59151816",... | 0.5410252 | 75 |
Adds the object to this world. | def add_object(self, object_to_be_added):
new_mapping = Map.add_object(self.id, object_to_be_added)
if new_mapping:
object_to_be_added.save()
new_mapping.ref_id = object_to_be_added.id
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_world(self, thing):\n\t\tthing.set_world_info(self.current_id, self)\n\t\tself.gameObjects.append(thing)\n\t\tself.current_id += 1",
"def add_object(self, obj):\n\t\tself.objects.append(obj)",
"def add(self, obj):\n raise NotImplementedError",
"def add(self, obj):\n self.objects.appe... | [
"0.7806233",
"0.7238987",
"0.7172745",
"0.71658224",
"0.71255547",
"0.7012599",
"0.6983041",
"0.6965109",
"0.6878019",
"0.68778664",
"0.67840016",
"0.6766624",
"0.66833013",
"0.6667035",
"0.66547865",
"0.6638408",
"0.66247624",
"0.6623228",
"0.66065276",
"0.65824896",
"0.6509... | 0.62936544 | 31 |
Removes the object from this world. | def remove_object(self, object_to_be_removed):
Map.remove_object(object_to_be_removed)
object_to_be_removed.query.delete() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_obj(self, obj_name):\n self.scene.remove_world_object(obj_name)",
"def remove(self):\n self._world.remove_mob(self)",
"def remove_object(self, name):\n if name in self._objects:\n del self._objects[name]\n else:\n raise ValueError('Object {} not in s... | [
"0.8095782",
"0.7762199",
"0.7431813",
"0.7195679",
"0.7184229",
"0.7052576",
"0.69814664",
"0.6966261",
"0.6925698",
"0.69233143",
"0.6888144",
"0.6798792",
"0.673691",
"0.6721849",
"0.6594416",
"0.65179706",
"0.65097326",
"0.6495488",
"0.6477363",
"0.6472084",
"0.6472084",
... | 0.6862572 | 11 |
Returns the object located at given coordinates. | def get_object_at_location(self, x, y):
object_map_at_target_location = self.maps.get((x, y))
if not object_map_at_target_location:
return None
return object_map_at_target_location.get_real_object() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_object_at_location(cls, x, y):\n object_map_at_target_location = cls.query\\\n .filter_by(x=x, y=y).one_or_none()\n if not object_map_at_target_location:\n return None\n return object_map_at_target_location.get_real_object()",
"def get_object_at(self, position, ... | [
"0.7401787",
"0.65084153",
"0.64662015",
"0.6462374",
"0.6404084",
"0.62852186",
"0.61791605",
"0.6087064",
"0.5851252",
"0.5840479",
"0.58224994",
"0.58224994",
"0.5814853",
"0.5790992",
"0.57650596",
"0.5756242",
"0.5745209",
"0.5740608",
"0.5726151",
"0.5704214",
"0.566702... | 0.71457946 | 1 |
Creates a food object randomly somewhere in this world. | def generate_food(self):
x = random.randint(0, self.width)
y = random.randint(0, self.height)
new_food = Food(self.id, x, y)
food_created = self.add_object(new_food)
if not food_created:
existing_object = self.get_object_at_location(x, y)
if isinstance(exi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_food(self):\n self.penup()\n self.shape(\"circle\")\n self.color(\"green\")\n self.x_cordinates = random.randint(-210, 210)\n self.y_cordinates = random.randint(-210, 210)\n self.goto(self.x_cordinates, self.y_cordinates)\n print(f\"This Is Food {self.x_c... | [
"0.7924229",
"0.7388662",
"0.68496233",
"0.67906237",
"0.6670745",
"0.66257876",
"0.6595156",
"0.64915293",
"0.63676316",
"0.63369346",
"0.63189137",
"0.6317571",
"0.61416024",
"0.6115891",
"0.6053006",
"0.6016661",
"0.60126746",
"0.6003472",
"0.58886176",
"0.58674264",
"0.58... | 0.79373443 | 0 |
Return True if the choice's value is empty string or None. | def _choice_has_empty_value(choice):
value, _, crige = choice
return value is None or value == '' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def non_empty(val):\n return val is not None and val != \"\"",
"def is_str_none_or_empty(val):\n if val is None:\n return True\n if isinstance(val, string_types):\n val = val.strip()\n if not val:\n return True\n return False",
"def empty(self, value):\r\n return ... | [
"0.7685549",
"0.76462",
"0.74445015",
"0.74445015",
"0.74445015",
"0.74445015",
"0.74445015",
"0.73680663",
"0.7361419",
"0.73225313",
"0.7155328",
"0.7097266",
"0.7065049",
"0.7033588",
"0.70299554",
"0.6994321",
"0.69693965",
"0.691823",
"0.6896403",
"0.687022",
"0.6839705"... | 0.8938283 | 0 |
Return a list of optgroups for this widget. | def optgroups(self, name, value, attrs=None):
groups = []
has_selected = False
for index, (option_value, option_label, option_crige) in enumerate(self.choices):
if option_value is None:
option_value = ''
subgroup = []
if isinstance(option_lab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_options(self):\n return [o for g in self.parser.option_groups for o in g.option_list]",
"def optgroups(self, name, value, attrs=None):\n options = []\n\n for index, (name, product_data) in enumerate(self.product_fields.items()):\n quantity = product_data['quantity']\n ... | [
"0.7063895",
"0.69440085",
"0.67643887",
"0.65815574",
"0.6523809",
"0.6515766",
"0.6399603",
"0.6360311",
"0.6360311",
"0.6360311",
"0.63217825",
"0.63090414",
"0.62958103",
"0.62820065",
"0.6253235",
"0.62510276",
"0.6211395",
"0.62001765",
"0.6191107",
"0.61584747",
"0.614... | 0.75911134 | 0 |
Mend aligns by input params. | def mend(aligns_dict, predictions, bound_info):
wav_names, bound_indices, times = zip(*bound_info)
print('bound_info length: %d' % len(bound_info))
print('predictions length: %d' % len(predictions))
df = pd.DataFrame({'wav_names': wav_names, 'bound_indices': bound_indices,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def align(self):\n ...",
"def align(args) :\n from aligner import align_reads\n align_reads(args)",
"def align(model,\n left,\n right,\n max_length = 512):\n inputs = preprocess(left, right, max_length)\n output = model(inputs)\n output = expand(output)\n scores, pat... | [
"0.7231606",
"0.67981696",
"0.6597057",
"0.6065707",
"0.60352206",
"0.6033263",
"0.59736323",
"0.5951408",
"0.5867845",
"0.58485246",
"0.58053076",
"0.5780781",
"0.5771312",
"0.57659185",
"0.57253075",
"0.57080555",
"0.5691342",
"0.56656057",
"0.56472176",
"0.5637257",
"0.563... | 0.0 | -1 |
Judge three predictions, decide new boundary time and frame distance | def __update_boundary(preds, old_frame_dist, old_time, fs=16000):
assert len(preds) == 3
new_frame_dist = old_frame_dist
new_time = old_time
moved = False
move_dist = None
func_map = {
'0-0-0': lambda t, d: (t+2*d/fs, d),
'0-0-1': lambda t, d: (t+... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_predictions(batch_size, tmd_detector, input_features):\n prediction_start_time = datetime.now()\n predictions = tmd_detector.predict(\n data_frame=input_features,\n batch_size=batch_size,\n verbose=0\n )\n prediction_time = datetime.now() - predi... | [
"0.59344226",
"0.5907747",
"0.58271396",
"0.5826764",
"0.57885784",
"0.5745873",
"0.574444",
"0.57349",
"0.57344997",
"0.5724456",
"0.5713037",
"0.569263",
"0.56828284",
"0.566919",
"0.5641135",
"0.5640334",
"0.56383985",
"0.5628863",
"0.5605123",
"0.55969495",
"0.558236",
... | 0.54329145 | 32 |
I change this column name ["", "", "", "", ""] | def changeName(name):
if name in ["<OPEN>", "<HIGH>", "<LOW>", "<CLOSE>"]:
# Frist charector is upper case
name = name.replace('<', '').replace('>', '')
#name = name[0] + name[1:].lower()
elif name in ["<VOL>"]:
#name = name.replace("<VOL>", "Volume")
name = name.replace("<VOL>", "VOLUME")
elif name in [... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __clean_column_names(self, columns):\r\n cols = []\r\n for column in columns:\r\n cols.append(column.replace('\"', ''))\r\n return cols",
"def _str_colnames(self):\n return ', '.join(self.galcat.colnames)",
"def initialize(self, col):\n\t\treturn []",
"def _str_coln... | [
"0.67438745",
"0.6026874",
"0.59722286",
"0.58937585",
"0.58894145",
"0.5864143",
"0.5821138",
"0.57198566",
"0.57062376",
"0.5703257",
"0.5650095",
"0.56361",
"0.55772233",
"0.5573053",
"0.55623305",
"0.55594975",
"0.55338067",
"0.5524322",
"0.5494165",
"0.5484127",
"0.54837... | 0.0 | -1 |
Read securities data for given symbols from CSV files. | def loadManySymbols(symbols, dates, column_name, base_dir):
df = pd.DataFrame(index=dates) # empty data frame that has indexs as dates
if 'SET' not in symbols: # add SET for reference, if absent
symbols = np.append(['SET'],symbols)
base_dir = join(DIR_CURRENT,base_dir)
for symbol in symbols:
# read CS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_from_csv(self, file_path):\n securities = []\n\n with open(file_path, \"r\") as f:\n # skip the first line (=column names)\n next(f)\n\n for line in f:\n security_code, num_shares = line.strip(\"\\n\").split(\",\")\n # omit the... | [
"0.70758045",
"0.6342294",
"0.63347614",
"0.6088766",
"0.6008428",
"0.5867371",
"0.57658195",
"0.5764524",
"0.574373",
"0.56270605",
"0.5578219",
"0.5574559",
"0.55543303",
"0.55240345",
"0.5507941",
"0.5496809",
"0.549038",
"0.5484136",
"0.54798716",
"0.54472065",
"0.5444511... | 0.0 | -1 |
Returns list of urls, or error string | def _find_impl(url, query, count, auto_complete):
try:
res = requests.get(
url,
params={"q": query, "count": count, "autoCorrect": ("true" if auto_complete else "false")},
)
except (requests.ConnectionError, requests.ConnectTimeout):
return "`connection error`"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def urls(self) -> list[str]:\r\n ...",
"def getURLs():",
"def get_urls():\r\n return []",
"def job(url):\n\n from urllib.parse import urlparse\n try:\n if urlparse(url).netloc.split('.')[-1] != 'org':\n raise TypeError(\"Nonvalid url: top level domain is not '.org': {}\"... | [
"0.69925624",
"0.6787655",
"0.67783505",
"0.65709436",
"0.6514724",
"0.64058846",
"0.6393377",
"0.6393377",
"0.63506687",
"0.61886406",
"0.61525303",
"0.61129975",
"0.6084383",
"0.608359",
"0.60652596",
"0.6063299",
"0.60621506",
"0.605111",
"0.6028378",
"0.59947616",
"0.5966... | 0.0 | -1 |
Find first suitable connection entry from yaml config | def find_connection(hint):
if not hint:
for con in connections:
yield con
else:
for con in connections:
for tag in con.get_hints():
if tag.find(hint) != -1:
yield con
break | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config(hostname=get_hostname()):\n for doc in load():\n if doc['name'] == hostname:\n return doc\n elif hostname == \"upload_tsm\":\n return hostname\n raise LookupError(\"Unknown host %s\" % hostname)",
"def read_auto_connect():\n path = os.path.dirname(verti... | [
"0.63480306",
"0.6143009",
"0.6014163",
"0.5998037",
"0.59677744",
"0.59520304",
"0.5819446",
"0.5767711",
"0.57654124",
"0.5715848",
"0.56998444",
"0.5584522",
"0.55842286",
"0.5579001",
"0.5482194",
"0.5459207",
"0.5435058",
"0.54290324",
"0.5413872",
"0.5412218",
"0.5329",... | 0.5773705 | 7 |
Resets defaults values when new file is opened | def set_initial_values(self):
#Stores each line of the text file in a list
self.text = []
#Scrolling distance
self.scroll = 0
#Zooming level (font size)
self.zoom = 12
#Factor by which is decrement self.zoom
self.factor = 0
#Number of ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_values(self):\n self.parse_config_file()",
"def reset( self ):\n self.conf = self.defaults",
"def reset(self):\n self.keyToFile=dict()",
"def reset_file_stat(self):\n # FIXME: this state does not make sense\n self.file_spdx_id_set = False\n self.file_commen... | [
"0.68603104",
"0.66013277",
"0.64490455",
"0.63831466",
"0.6246266",
"0.61875665",
"0.61627656",
"0.61585855",
"0.61492133",
"0.6111486",
"0.6111127",
"0.6110097",
"0.60785025",
"0.60501724",
"0.6042729",
"0.6037925",
"0.60298276",
"0.60199016",
"0.5993268",
"0.5968947",
"0.5... | 0.0 | -1 |
Sets up the cairo context and pango layout | def set_up_pangocairo(self, widget, event):
# Create the cairo context
self.cr = self.window.cairo_create()
#Create a pango layout
self.pg = self.cr.create_layout()
# Restrict Cairo to the exposed area; avoid extra work
self.cr.rectangle(event.area.x, event.ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_on_surface(surface):\n pangocairo_ctx = pangocairo.CairoContext(cairo.Context(surface))\n layout = pangocairo_ctx.create_layout()\n\n pango_ctx = layout.get_context()\n if language is not None:\n pango_ctx.set_language(pango.Language(language))\n\n if rtl:\n ... | [
"0.6378648",
"0.63250196",
"0.5820568",
"0.5630213",
"0.5574149",
"0.5553529",
"0.5505494",
"0.54557025",
"0.5414631",
"0.54144245",
"0.5352626",
"0.53398526",
"0.53367114",
"0.5331944",
"0.5321142",
"0.53158367",
"0.5298759",
"0.5253618",
"0.52352786",
"0.52059555",
"0.51881... | 0.7677612 | 0 |
Handles expose event. Sets up cairo and calls draw() to draw the text | def do_expose_event(self, widget, event):
self.set_up_pangocairo(widget, event)
self.draw(*self.window.get_size()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expose (self,widget,event):\n #Creating Cairo drawing context\n self.ctx = self.bin_window.cairo_create()\n #Setting context size to available size\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\n self.ctx.clip()\n self.ctx.transl... | [
"0.63333666",
"0.6331875",
"0.6298491",
"0.6249288",
"0.62065977",
"0.62057835",
"0.60598",
"0.6035482",
"0.5889406",
"0.58473253",
"0.5832056",
"0.58307505",
"0.5823392",
"0.5807295",
"0.579405",
"0.579405",
"0.579405",
"0.5785034",
"0.57550627",
"0.5724503",
"0.5721456",
... | 0.7019397 | 0 |
Decides if the current line is indented to the same number of tabs as the previous one. If not, sets self.indent to the current value. | def indentation(self, text):
tab = text.rfind(' '*4)
if tab != -1:
if tab%4 == 0:
if tab//4 + 1 == self.indent:
return True
else:
self.indent = tab//4 + 1
return False
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _increaseindentation(self):\n self._indentlist.append(self._curindent)\n if not self._equalsigns[-1]:\n self._curindent = self._curindent + self._indent",
"def tab_insert_indent():\n before_cursor = get_app().current_buffer.document.current_line_before_cursor\n\n return bool(be... | [
"0.7080106",
"0.69619274",
"0.66611207",
"0.6653787",
"0.6653787",
"0.6587194",
"0.65701425",
"0.6553675",
"0.6551975",
"0.65384454",
"0.6438995",
"0.6405378",
"0.6339694",
"0.63215977",
"0.6304247",
"0.62886304",
"0.62533724",
"0.6213156",
"0.6186852",
"0.61589515",
"0.61540... | 0.6743172 | 2 |
Builds a list of the indentation level in the text | def parse_text(self):
line_number = 0
line_min = 0
while line_number < self.line_count:
if self.indentation(self.text[line_number]):
self.tab_index.append(self.indent)
self.text[line_number] = self.text[line_number].strip()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addIndents(self, prevLevel, nextLevel):\n for num in range(self.level - prevLevel):\n self.textLines[0] = u'<div>%s' % self.textLines[0]\n for num in range(self.level - nextLevel):\n self.textLines[-1] = u'%s</div>' % self.textLines[-1]\n return self.level",
"def in... | [
"0.66050494",
"0.65871197",
"0.65823054",
"0.6440294",
"0.64322656",
"0.6333226",
"0.6261572",
"0.6217952",
"0.61256063",
"0.61097354",
"0.60586256",
"0.60115117",
"0.59732586",
"0.59445643",
"0.5935486",
"0.5909733",
"0.5906865",
"0.5904378",
"0.58506644",
"0.58386153",
"0.5... | 0.563083 | 42 |
Finds chunks of text with the same indentation level and renders it as one block Invokes cairo and pango to draw the text | def draw(self, width, height):
line_spacing = 20
#TODO:Smart algorithm to map mouse position to the scrolling speed
#zooming level should go here
if self.scroll > 20:
self.factor = self.scroll * 0.1
elif self.scroll < -20:
self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __indent_text_block(text):\n lines = text.splitlines()\n if len(lines) > 1:\n out = lines[0] + \"\\r\\n\"\n for i in range(1, len(lines)-1):\n out = out + \" \" + lines[i] + \"\\r\\n\"\n out = out + \" \" + lines[-1]\n return out\n return text",
"... | [
"0.6800062",
"0.63557124",
"0.61851245",
"0.6127625",
"0.6115382",
"0.6084938",
"0.60630584",
"0.6026112",
"0.6017145",
"0.60155404",
"0.5953256",
"0.59228796",
"0.59067875",
"0.58991575",
"0.5875876",
"0.5869328",
"0.5866471",
"0.58534825",
"0.5838097",
"0.58362037",
"0.5799... | 0.59040713 | 13 |
Invalidates the cairo area and updates the pango layout when text needs to be redrawn | def redraw_canvas(self, dy):
self.scroll = dy/20
if self.scroll > 0:
if self.min_cairo < -20:
self.min_cairo = 0
self.min_text += 1
self.max_text += 1
#When bottom of document is reached stop scrolling
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def invalidate_canvas(self):\n\n if self.window:\n x, y, w, h = self.get_allocation()\n self.window.invalidate_rect((0,0,w,h), False)\n self.cr = self.window.cairo_create()\n self.cr.update_layout(self.pg)",
"def rebuild(self):\n self.set_image(self.ui_ma... | [
"0.6700877",
"0.63284457",
"0.6169983",
"0.61484647",
"0.61177415",
"0.6110256",
"0.6046499",
"0.6024855",
"0.5980619",
"0.59752417",
"0.5955907",
"0.5922319",
"0.5891851",
"0.583136",
"0.58131385",
"0.57919127",
"0.5738633",
"0.5721444",
"0.57081723",
"0.5688249",
"0.5679972... | 0.0 | -1 |
Invalidates the canvas to allow cairo to redraw | def invalidate_canvas(self):
if self.window:
x, y, w, h = self.get_allocation()
self.window.invalidate_rect((0,0,w,h), False)
self.cr = self.window.cairo_create()
self.cr.update_layout(self.pg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def undraw(self):\n \n if not self.canvas: return\n if not self.canvas.isClosed():\n #self.canvas.delete(self.id)\n _tkExec(self.canvas.delete, self.id)\n if self.canvas.autoflush:\n #_root.update()\n _tkCall(_root.update)\n ... | [
"0.7170448",
"0.70177877",
"0.6811474",
"0.67474014",
"0.6741104",
"0.65798086",
"0.6572473",
"0.651364",
"0.64646524",
"0.6450033",
"0.64039034",
"0.6386848",
"0.6327218",
"0.62746847",
"0.62502813",
"0.6237061",
"0.6207101",
"0.612459",
"0.6124122",
"0.6107939",
"0.6056458"... | 0.8453374 | 0 |
Set up the window, events and the UIManager | def __init__(self):
__gsignals__ = { 'expose-event' : 'override'}
self.filename = ""
self.source_id = 0
self.dy = 0
# Create a top level window
self.window = gtk.Window()
#Get y position of mouse at start of drag
self.mouse_click_point... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initializeUI(self):\n self.setGeometry(100, 100, 300, 200)\n self.setWindowTitle('Event Handling Example')\n\n self.show()",
"def setupWindow(self):\n\n\t\tself.main_menu_window = MenuFrame.MainMenuFrame(self.uiCoordinator)\n\t\tself.menu_window = self.main_menu_window._mf\n\t\tself.scor... | [
"0.81075317",
"0.80308354",
"0.7943606",
"0.7784395",
"0.7664296",
"0.7630357",
"0.7612189",
"0.7465434",
"0.7305418",
"0.72996294",
"0.72887415",
"0.71909666",
"0.71893406",
"0.70785546",
"0.70698625",
"0.7056159",
"0.70504737",
"0.6988536",
"0.6979893",
"0.69747025",
"0.692... | 0.0 | -1 |
Calls redraw_cavas() and returns True | def continuous_scroll(self, context):
self.drawing.redraw_canvas(self.dy)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redraw(self):\r\n self.c.update()",
"def redraw(self):\n self.vispy_viewer.canvas.update()",
"def redraw_viz():\n\tglobal g_last_draw\n\tif (rospy.Time.now().to_sec() > (refresh_rate + g_last_draw)):\n\t\tg_last_draw = rospy.Time.now().to_sec()\n\t\t# redraw imu box\n\t\tdoDraw()",
"def red... | [
"0.6453343",
"0.62267697",
"0.6218675",
"0.60894597",
"0.60264426",
"0.5925996",
"0.58668894",
"0.5866463",
"0.575936",
"0.5751097",
"0.5726546",
"0.5658623",
"0.5649218",
"0.5599826",
"0.5599826",
"0.5561367",
"0.55488133",
"0.5458545",
"0.5447202",
"0.54120916",
"0.53936327... | 0.0 | -1 |
Calls continuous_scroll every 38 ms until drag stops and the gobject.source is removed | def start_refresh(self, widget, context):
self.source_id = gobject.timeout_add(38, self.continuous_scroll, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def continuous_scroll(self, context):\n\n self.drawing.redraw_canvas(self.dy)\n \n return True",
"def on_scroll(self, event):\n if event.button == 'up':\n self.generations += 4000\n elif event.button == 'down':\n if self.generations >= 4000:\n ... | [
"0.67773175",
"0.65299225",
"0.6115261",
"0.6041647",
"0.5851163",
"0.57974243",
"0.5567167",
"0.5549752",
"0.5510689",
"0.54062074",
"0.5401114",
"0.5395652",
"0.53080606",
"0.5282082",
"0.5279963",
"0.52645594",
"0.519223",
"0.5188579",
"0.517752",
"0.51675165",
"0.5145534"... | 0.65430206 | 1 |
Handles the drag event. Causes the canvas to be redrawn | def drag_motion(self, widget, context, x, y, t):
if self.mouse_click_point:
self.dy = y - self.mouse_click_point
else:
self.mouse_click_point = y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drag(self, event):\n\t\tif len(self.coord_list) > 0:\n\t\t\tself.canvas.create_line(event.x, event.y, \n\t\t\t\tself.coord_list[-1][0], self.coord_list[-1][1])\n\n\t\tself.coord_list.append([event.x, event.y])\n\n\t\tpoly_list = check_contained(self.coord_list) - self.drawn_list\n\t\tfor polygon in poly_list:\... | [
"0.6755301",
"0.66262746",
"0.6443391",
"0.6423392",
"0.64204735",
"0.64061475",
"0.6399093",
"0.6296843",
"0.6262739",
"0.61266",
"0.6086573",
"0.60591775",
"0.6016381",
"0.60085255",
"0.600779",
"0.6007358",
"0.60010016",
"0.5979957",
"0.5976792",
"0.5972171",
"0.59691787",... | 0.53998744 | 90 |
Resets the mouse y and t values so they can be reassigned at the start of the next drag | def stop_drag_motion(self, widget, context):
gobject.source_remove(self.source_id)
self.mouse_click_point = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n self.t = 0.0\n self.last_t = None\n self.current_y = np.copy(self.start_y)\n self.current_yd = np.copy(self.start_yd)",
"def drag_motion(self, widget, context, x, y, t):\n \n if self.mouse_click_point:\n self.dy = y - self.mouse_click_point\... | [
"0.70719177",
"0.66845477",
"0.6261427",
"0.62466776",
"0.61253417",
"0.60505104",
"0.60348666",
"0.60143536",
"0.59680414",
"0.58639413",
"0.58259994",
"0.578046",
"0.5754565",
"0.5749707",
"0.57274145",
"0.56919",
"0.568994",
"0.568535",
"0.5658506",
"0.56407124",
"0.563473... | 0.5843788 | 10 |
Opens a file chooser dialog and returns the filename. Canvas is redrawn if a valid file is opened | def open_file(self, widget, data=None):
#Displays a fiel chooser dialog
dialog = gtk.FileChooserDialog("Open..",None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dia... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_file():\r\n import tkinter\r\n from tkinter import filedialog\r\n\r\n root_window = tkinter.Tk()\r\n root_window.withdraw()\r\n\r\n return filedialog.askopenfilename()",
"def filepicker():\n import tkinter as tk\n from tkinter import filedialog\n\n root = tk.Tk()\n root.with... | [
"0.76964045",
"0.751905",
"0.7503324",
"0.72405404",
"0.7215795",
"0.7140923",
"0.71118176",
"0.70581174",
"0.704689",
"0.70024866",
"0.6878962",
"0.6876016",
"0.6872203",
"0.68558186",
"0.68206304",
"0.681948",
"0.67540073",
"0.67213887",
"0.6719352",
"0.67114747",
"0.670216... | 0.68085396 | 16 |
CPU kernel for 3d mesh to particles quantity interpolation | def mesh_to_particles_CPU_3d(mesh, mesh_quantity, indices, weights):
ip, jp, kp = indices
stridex = mesh.nx
stridey = mesh.ny
mq = np.ravel(mesh_quantity)
@np.vectorize
def check_outside(ip, jp, kp):
outside_idx = (jp < 0 or jp >= mesh.nx - 1 or
ip < 0 or ip >= me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init():\n\tN = np.int32(DIM) #prepare for stitching\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN)/DIM\n\tHII_scale = np.float32(BOX_LEN)/HII_DIM\n\tshape = (N,N,N)\n\t\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\n\tker... | [
"0.6445836",
"0.6372974",
"0.61668825",
"0.59983677",
"0.5791244",
"0.5653549",
"0.5652757",
"0.56389385",
"0.56339914",
"0.55467594",
"0.55444217",
"0.55392367",
"0.5479442",
"0.5449648",
"0.5441298",
"0.5424582",
"0.54130393",
"0.53808963",
"0.5377156",
"0.5375097",
"0.5365... | 0.6884111 | 0 |
CPU kernel for 3d mesh to particles quantity interpolation | def mesh_to_particles_CPU_2d(mesh, mesh_quantity, indices, weights):
ip, jp = indices
stridex = mesh.nx
mesh_quantity = np.ravel(mesh_quantity)
@np.vectorize
def check_outside(ip, jp):
outside_idx = (jp < 0 or jp >= mesh.nx - 1 or
ip < 0 or ip >= mesh.ny - 1)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mesh_to_particles_CPU_3d(mesh, mesh_quantity, indices, weights):\n ip, jp, kp = indices\n stridex = mesh.nx\n stridey = mesh.ny\n mq = np.ravel(mesh_quantity)\n\n @np.vectorize\n def check_outside(ip, jp, kp):\n outside_idx = (jp < 0 or jp >= mesh.nx - 1 or\n ip <... | [
"0.6884111",
"0.6445836",
"0.61668825",
"0.59983677",
"0.5791244",
"0.5653549",
"0.5652757",
"0.56389385",
"0.56339914",
"0.55467594",
"0.55444217",
"0.55392367",
"0.5479442",
"0.5449648",
"0.5441298",
"0.5424582",
"0.54130393",
"0.53808963",
"0.5377156",
"0.5375097",
"0.5365... | 0.6372974 | 2 |
Train and test in default environment | def train_and_test(resume_training=False, tensorboard_debug=False, cli_debug=False):
if tensorboard_debug:
# Open tf debug session connected to tensor board, this only really works well on linux
k.set_session(TensorBoardDebugWrapperSession(tf.Session(), '127.0.0.1:6064'))
elif cli_debug:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_training():\n assert init_engine('train', [\"config=first_run_test/default.yaml\"]).run() is None",
"def test_training(self):\n\t\tpass",
"def test_training(self):\n warnings.filterwarnings('ignore')\n example_args = example_args_parser()\n example_args.unittest = True\n ... | [
"0.7525882",
"0.7500203",
"0.7246843",
"0.71062607",
"0.69893485",
"0.6936413",
"0.6892855",
"0.68209904",
"0.68061465",
"0.68000853",
"0.6799948",
"0.6743294",
"0.67357713",
"0.67064327",
"0.66930574",
"0.66568553",
"0.66525966",
"0.665014",
"0.6642741",
"0.6628566",
"0.6626... | 0.6182469 | 70 |
reverses a sequence and returns it to the user | def reverse_this(seq):
r_seq = seq[::-1]
return r_seq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse(seq):\n return seq[::-1]",
"def reverse(seq):\n return seq[::-1]",
"def reverse(self):\n self._sequence.reverse()",
"def reverseComplement(seq):\n seq=seq.upper()\n # complement\n compl = complement(seq)\n # reverse\n return compl[::-1]",
"def _reverse_seq(sequence, ... | [
"0.796331",
"0.796331",
"0.7332736",
"0.6942727",
"0.6893406",
"0.68597776",
"0.6836763",
"0.67643976",
"0.6720687",
"0.6716236",
"0.6703137",
"0.669068",
"0.66748995",
"0.66173595",
"0.6607935",
"0.65751666",
"0.6458668",
"0.6386909",
"0.6376833",
"0.63744164",
"0.6360942",
... | 0.7664587 | 2 |
constructs a complement of the sequence and returns it to the user | def complement_this(seq):
compliment_dict = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}
rev_seq = ''
for nuc in seq:
if nuc in ['A', 'T', 'G', 'C']:
rev_seq += compliment_dict[nuc]
return rev_seq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complement(seq):\n if PY3:\n table = str.maketrans('ACTGNactg', 'TGACNtgac')\n elif PY2:\n table = string.maketrans('ACTGNactg', 'TGACNtgac')\n return str(seq).translate(table)",
"def complement(seq,transl=None):\n transl = string.maketrans('aAcCgGtTnNxX-\\t\\n ','tTgGcCaAnNxX-\\t\\... | [
"0.7661928",
"0.7610491",
"0.7571766",
"0.7463382",
"0.7420495",
"0.72710407",
"0.7256517",
"0.7193674",
"0.71363926",
"0.7096717",
"0.6944678",
"0.6880034",
"0.6877921",
"0.68603486",
"0.6837575",
"0.67390704",
"0.6724134",
"0.6708142",
"0.667533",
"0.6671418",
"0.665009",
... | 0.711648 | 9 |
Combines the reverse_this and complement_this function into one | def rev_comp(seq):
return(complement_this(reverse_this(seq))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complement_reverse(self):\n self._data.switch_complement(whether=False)\n return self",
"def reverse_complement(seq):\n seq = reverse(seq)\n seq = complement(seq)\n return seq",
"def __invert__(self):\n return self.reverse()",
"def reverseComplement(seq):\n seq=seq.upper(... | [
"0.6944674",
"0.6616649",
"0.65044445",
"0.64138985",
"0.6405666",
"0.6344894",
"0.6276499",
"0.62029034",
"0.61942494",
"0.6179005",
"0.6177534",
"0.61766183",
"0.61220694",
"0.6119256",
"0.6107478",
"0.61074305",
"0.6086203",
"0.6032122",
"0.6007763",
"0.5948127",
"0.591033... | 0.6428619 | 3 |
Log the best parameters from optimization to the parent experiment. | def log_best(run: mlflow.entities.Run,
metric: str) -> None:
client = mlflow.tracking.MlflowClient()
runs = client.search_runs(
[run.info.experiment_id],
"tags.mlflow.parentRunId = '{run_id}' ".format(run_id=run.info.run_id))
best_run = min(runs, key=lambda run: run.data.metri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_best_performer(self) -> None:\n best = self.get_highest_accuracy()\n self.logger.info(f\"\\n\\nThe model with the highest accuracy {best[0]} has the following characteristics: \\n\")\n for k, v in best[1].items():\n if k != 'best_performer':\n self.logger.info... | [
"0.63622415",
"0.6299336",
"0.61905897",
"0.6175902",
"0.61196154",
"0.60865855",
"0.60865855",
"0.60865855",
"0.6016687",
"0.6003699",
"0.5999502",
"0.5911572",
"0.5862312",
"0.58506644",
"0.58495724",
"0.5821478",
"0.5821416",
"0.58152115",
"0.57748735",
"0.5770013",
"0.576... | 0.0 | -1 |
Make a short score with pick up and two voices. | def makeScoreWithPickup(self):
sc = stream.Score()
num_voices = 2
pitches = ['C', 'A-']
for i in range(num_voices):
part = stream.Part()
part.id = 'part %d' % i
time_sig = meter.TimeSignature('4/4')
key_sig = key.Key('c')
# Add pickup measure.
pickup = stream.Measure... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeScore(self):\n sc = stream.Score()\n num_voices = 2\n pitches = ['C', 'A-']\n for i in range(num_voices):\n part = stream.Part()\n part.id = 'part %d' % i\n time_sig = meter.TimeSignature('4/4')\n key_sig = key.Key('c')\n\n # Make a note.\n n1 = music21_note.Note(p... | [
"0.6722317",
"0.58068377",
"0.5768385",
"0.57021904",
"0.56786025",
"0.56589353",
"0.5603751",
"0.55136603",
"0.549756",
"0.5485879",
"0.54847825",
"0.5401103",
"0.5356562",
"0.5330451",
"0.53275734",
"0.53220344",
"0.52828926",
"0.5266709",
"0.52593845",
"0.5259334",
"0.5244... | 0.70795625 | 0 |
Make a short score with pick up and two voices. | def makeScore(self):
sc = stream.Score()
num_voices = 2
pitches = ['C', 'A-']
for i in range(num_voices):
part = stream.Part()
part.id = 'part %d' % i
time_sig = meter.TimeSignature('4/4')
key_sig = key.Key('c')
# Make a note.
n1 = music21_note.Note(pitches[i])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeScoreWithPickup(self):\n sc = stream.Score()\n num_voices = 2\n pitches = ['C', 'A-']\n for i in range(num_voices):\n part = stream.Part()\n part.id = 'part %d' % i\n time_sig = meter.TimeSignature('4/4')\n key_sig = key.Key('c')\n\n # Add pickup measure.\n pickup ... | [
"0.70795625",
"0.58068377",
"0.5768385",
"0.57021904",
"0.56786025",
"0.56589353",
"0.5603751",
"0.55136603",
"0.549756",
"0.5485879",
"0.54847825",
"0.5401103",
"0.5356562",
"0.5330451",
"0.53275734",
"0.53220344",
"0.52828926",
"0.5266709",
"0.52593845",
"0.5259334",
"0.524... | 0.6722317 | 1 |
Check the key, mode, tonic pitch class extraction from key signature. | def testExtractionOfKeySignatureAttributes(self):
num_to_major_key = {0: 'C',
1: 'G',
2: 'D',
3: 'A',
4: 'E',
5: 'B',
6: 'F#',
7: 'C#',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_key(self, key):\n raise NotImplementedError",
"def __getKeyInformation( self , flaglist ):\n\t\tkeyinfo = 0\n\t\tif 'HMAC_MD5_RC4' in flaglist:\n\t\t\tkeyinfo = setBit( keyinfo , 0 )\n\t\tif 'HMAC_SHA1_AES' in flaglist:\n\t\t\tkeyinfo = setBit( keyinfo , 1 )\n\t\tif 'group' in flaglist:\n\t\t\t... | [
"0.5945108",
"0.57941103",
"0.57145506",
"0.56614727",
"0.55908537",
"0.557824",
"0.5512754",
"0.55084723",
"0.54874986",
"0.54785895",
"0.5465614",
"0.5448584",
"0.53911096",
"0.536824",
"0.53185785",
"0.5297847",
"0.529589",
"0.5281158",
"0.52718353",
"0.52686393",
"0.52467... | 0.66755116 | 0 |
Test pretty_music21 score by comparing to music21 score. | def testCompareScores(self):
for score_type, source in self.sources.iteritems():
simple_score = self.simple_scores[score_type]
# Check overall length.
self.assertAlmostEqual(source.duration.quarterLength / 2.0,
simple_score.total_time)
# Check number of parts.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_music21(music: \"Music\") -> Score:\n # Create a new score\n score = Score()\n\n # Metadata\n if music.metadata:\n score.append(to_music21_metadata(music.metadata))\n\n # Tracks\n for track in music.tracks:\n # Create a new part\n part = Part()\n part.partName =... | [
"0.6397026",
"0.61292386",
"0.60153556",
"0.5894335",
"0.5888303",
"0.584743",
"0.58399576",
"0.58220565",
"0.5753058",
"0.57522446",
"0.5727253",
"0.5703115",
"0.565216",
"0.5651552",
"0.5611833",
"0.5602852",
"0.5571321",
"0.5554371",
"0.54933465",
"0.544632",
"0.5432133",
... | 0.6417285 | 0 |
Test if notes are sorted by start time. | def testSortedNotes(self):
for simple_score in self.simple_scores.values():
notes = simple_score.sorted_notes
assert all(notes[i].start_time <= notes[i + 1].start_time
for i in range(len(notes) - 1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _can_add_note(self, start_step):\n return self.last_on is None or start_step - self.offset > self.last_on",
"def order_by_start(self):\n return self.order_by(\"start_time\")",
"def cmpBeginDate(artist1, artist2):\n return int(artist1['BeginDate']) < int(artist2['BeginDate'])",
"def cmpArtist... | [
"0.61224854",
"0.5865765",
"0.57295513",
"0.55280834",
"0.5441577",
"0.5399074",
"0.53915083",
"0.5378046",
"0.5370285",
"0.53318506",
"0.53177214",
"0.52837706",
"0.52716595",
"0.52472234",
"0.5236269",
"0.52277195",
"0.52230084",
"0.5207091",
"0.5160097",
"0.51134276",
"0.5... | 0.74918807 | 0 |
Runs the given command and gathers the output. If a callback is provided, then the output is sent to it, otherwise it is just returned. Optionally, the output of the command can be "watched" and whenever new output is detected, it will be sent to the given `callback`. | def run_cmd(cmd, callback=None, watch=False, background=False, shell=False):
if watch and not callback:
raise RuntimeError(
"You must provide a callback when watching a process."
)
output = None
if shell:
proc = subprocess.Popen(cmd, shell=True, stdout=subpro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AddOutputCallback(self, callback):\n self.output_callbacks.append(callback)",
"def execute():\n command_line_args = argv[1:]\n args = cli(command_line_args)\n\n callback = args.callback\n kwargs = {\n k: v\n for k, v in args.__dict__.items()\n if k != \"callback\"\n }\n... | [
"0.60572314",
"0.58634955",
"0.58029765",
"0.5787524",
"0.573274",
"0.5612282",
"0.5592784",
"0.5578011",
"0.5532359",
"0.5510294",
"0.55036664",
"0.54866433",
"0.5473412",
"0.5423298",
"0.5419067",
"0.5387715",
"0.53372276",
"0.5322813",
"0.53072083",
"0.53039205",
"0.527183... | 0.61989796 | 0 |
Composes artificial mixtures of host and pathogen reads | def __init__(self, composition: dict, reads: int = 10000, verbose: bool = False):
PoreLogger.__init__(self, level=logging.INFO if verbose else logging.ERROR)
self.composition = composition
self.reads = reads
self.check_proportions()
self.fastq: dict = self.prepare_fa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmaq_pa_master(paths_and_readers,tslice=None,kslice=None,jslice=None,islice=None):\n from ..pappt.kvextract import tops2shape,pblhghts2tops\n files=[]\n iprf = None\n concf = None\n for p,r in paths_and_readers:\n if not os.path.exists(p):\n raise ValueError, \"File at %s does ... | [
"0.5511749",
"0.53719014",
"0.5315182",
"0.531374",
"0.53083897",
"0.52912027",
"0.52875346",
"0.52785015",
"0.52527505",
"0.52501774",
"0.5247675",
"0.52469015",
"0.5245823",
"0.5242995",
"0.52415043",
"0.52280927",
"0.5213287",
"0.5211441",
"0.52108234",
"0.5204272",
"0.519... | 0.0 | -1 |
Checks file paths of input files and creates indices | def prepare_fastq(self) -> dict:
fastq = {}
for organism, data in self.composition.items():
file = data['file']
file_path = Path(file)
if not file_path.exists():
raise ValueError(f'File {file_path} does not exist.')
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_files():\n\n print(\"Indexing files\")\n\n for root, _, files in os.walk(image_directory):\n for item in files:\n for file_type in file_types:\n if file_type in item:\n images_in_directory.append(os.path.join(root, item))\n\n print(f'Finished i... | [
"0.6722114",
"0.6616186",
"0.64285046",
"0.6245991",
"0.61874163",
"0.6159094",
"0.611452",
"0.6091763",
"0.60779333",
"0.60487247",
"0.6039412",
"0.59922653",
"0.5976259",
"0.5961315",
"0.5959076",
"0.59473675",
"0.59240466",
"0.5910848",
"0.5897322",
"0.5875426",
"0.5875290... | 0.0 | -1 |
Check that proportions in composition file sum to 1 | def check_proportions(self):
proportions = [
v['proportion'] for k, v in self.composition.items()
]
if sum(proportions) < 1.0:
raise ValueError('Sum of proportions between host and pathogen must be 1.0.')
elif sum(proportions) > 1.0:
raise V... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_proportion(control, test):\n return set(control) == set(test) == {0, 1}",
"def __call__(self, read, info: ModificationInfo):\n n_count = read.sequence.lower().count('n')\n if self.is_proportion:\n if len(read) == 0:\n return False\n return n_count / l... | [
"0.6806141",
"0.6376372",
"0.63674873",
"0.6106981",
"0.59485376",
"0.59462976",
"0.5868693",
"0.58353674",
"0.5807831",
"0.5794899",
"0.57598245",
"0.57089925",
"0.56516993",
"0.5600838",
"0.55719936",
"0.5553505",
"0.5544299",
"0.5544022",
"0.5519452",
"0.55115443",
"0.5487... | 0.7553237 | 0 |
Compose an artifical mixture of reads Read names / decription headers are renamed according to sequentially numbered keys in the composition file, e.. saureus_0, saureus_1 ... to better distinguish between composition components later. | def compose(self, fout: Path, shuffle: bool = True):
self.logger.info('Sample and mix read data')
reads_out = []
for organism, fastq in self.fastq.items():
read_names = [read.name for read in fastq] # need to solve iterator for sampling, names avoid memory
sampl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rename_headers(reads: list, organism: str):\r\n\r\n i = 0\r\n read_strings = []\r\n for read in reads:\r\n read_str = read.raw.splitlines()\r\n read_str[0] = f'@{organism}_{i}'\r\n read_str = '\\n'.join(read_str)\r\n read_strings.append(read_str)... | [
"0.70786226",
"0.56654173",
"0.56248975",
"0.54763",
"0.5253606",
"0.52192986",
"0.51597726",
"0.5147048",
"0.51259553",
"0.50931907",
"0.5083531",
"0.5069386",
"0.5045505",
"0.50086147",
"0.49696004",
"0.4952995",
"0.49505538",
"0.49412456",
"0.4937527",
"0.48982477",
"0.489... | 0.48016357 | 29 |
Clean up the Fastq index files from Pyfastx | def clean(self):
for _, data in self.composition.items():
index_file = Path(data['file'] + '.fxi')
if index_file.exists():
index_file.unlink() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_index(self):\n if self.index_module:\n self.index_module = None\n gc.collect()",
"def cleanup(self):\n index_id = self.params[\"index_id\"]\n\n # Remove the index document from the database.\n self.db.indexes.delete_one({\"_id\": index_id})\n\n ... | [
"0.6486027",
"0.6483935",
"0.61997026",
"0.6186733",
"0.6184694",
"0.6120797",
"0.61112803",
"0.61034113",
"0.6067713",
"0.6043162",
"0.6007758",
"0.60064405",
"0.5943808",
"0.59250754",
"0.59225947",
"0.5922426",
"0.59017795",
"0.5857676",
"0.58406806",
"0.583989",
"0.583783... | 0.7508633 | 0 |
Rename read headers from the Pyfastx reads (readonly) | def rename_headers(reads: list, organism: str):
i = 0
read_strings = []
for read in reads:
read_str = read.raw.splitlines()
read_str[0] = f'@{organism}_{i}'
read_str = '\n'.join(read_str)
read_strings.append(read_str)
i += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _reset_header(self):\n new_header = []\n for col_name in self.header:\n is_left = self.left_cols.get(col_name)\n if is_left:\n new_header.append(col_name)\n self.header = new_header",
"def modify_bam_header(self, in_bam, out_bam):\n #bam_header... | [
"0.60041726",
"0.5952062",
"0.59352136",
"0.59297824",
"0.59085053",
"0.588155",
"0.58796203",
"0.5815924",
"0.5812585",
"0.56827",
"0.5642944",
"0.56334716",
"0.56306666",
"0.56273365",
"0.56152153",
"0.56103003",
"0.55797523",
"0.5561919",
"0.5546493",
"0.55092734",
"0.5469... | 0.7097539 | 0 |
Sample a list of Fastq reads / read names | def sample(fastq: list, reads: int = None, replacement: bool = False):
if replacement:
sampled_reads = random.choices(fastq, k=reads)
else:
sampled_reads = random.sample(fastq, k=reads)
return sampled_reads | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_read_list(samfile):\n read_sampler = ReadSampler()\n for line in samfile:\n line = sam_utils.SamAlignment(line)\n vals = line.get_aligned_blocks()\n if len(vals) > 1:\n logging.info(\"Skipping gapped read %s %s\"%(line.QNAME, str(vals))) \n read_sampler.a... | [
"0.6420504",
"0.6299379",
"0.5943049",
"0.5809539",
"0.5767165",
"0.5739098",
"0.57060987",
"0.5696739",
"0.5689907",
"0.56789887",
"0.55646765",
"0.55259854",
"0.5509567",
"0.5490724",
"0.54807556",
"0.5477975",
"0.54732245",
"0.547267",
"0.5464326",
"0.54481435",
"0.5440680... | 0.68244636 | 0 |
Set item in nested dictionary | def set_nested_item(data_dict: dict, key_list: tuple or list, value):
reduce(getitem, key_list[:-1], data_dict)[key_list[-1]] = value
return data_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setitem__(self, key, value):\n self.tree[key] = value",
"def visit_dict(self, sydict):\n self.current.update(sydict)",
"def set(cls, hierarchical_dict: dict, key: str, value: Any) -> None:\n # split according to '.'\n hierarchical_key = key.split(\".\")\n\n # go over th... | [
"0.66427284",
"0.65705705",
"0.6513432",
"0.650163",
"0.6474375",
"0.64307684",
"0.6408831",
"0.63907933",
"0.63844234",
"0.6381398",
"0.6353006",
"0.63405037",
"0.6324578",
"0.63165903",
"0.63117933",
"0.63100886",
"0.63035226",
"0.6276476",
"0.62579644",
"0.6254745",
"0.622... | 0.77281743 | 0 |
Plot the loss curves | def plot_history(trials, tid, scores=["loss", "f1", "accuracy"],
figsize=(15, 3)):
history = trials.train_history(tid)
fig = plt.figure(figsize=figsize)
for i, score in enumerate(scores):
plt.subplot(1, len(scores), i + 1)
plt.plot(history[score], label="train")
plt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_loss_curve(num_epochs, losses):\n plt.xlabel('Epochs')\n plt.ylabel('Loss') \n plt.title('Loss Curve') \n plt.plot(range(num_epochs), losses)\n plt.show()",
"def plot_loss():\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\n loss = df['loss'].values\n val_loss = df['v... | [
"0.8343297",
"0.8235588",
"0.8180274",
"0.7986687",
"0.79283375",
"0.7702147",
"0.769155",
"0.76334995",
"0.75938815",
"0.7522587",
"0.750068",
"0.7465745",
"0.745679",
"0.7422474",
"0.7414001",
"0.7325398",
"0.73173654",
"0.7295649",
"0.7292924",
"0.72741723",
"0.72360086",
... | 0.0 | -1 |
Return a table with model metrics as columns | def metrics_dt(m, datasets, add_eval_metrics={"auc": cem.auc, "auprc": cem.auprc}):
data = [{"dataset": k, **eval_model(m, d, add_eval_metrics)} for k, d in datasets.items()]
colorder = ["dataset"] + m.metrics_names + list(add_eval_metrics.keys())
return pd.DataFrame(data)[colorder] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_performance_table(self):\n table = Table()\n table.add_column(\"Classifier\", ratio=25)\n table.add_column(\"Score\", ratio=10, justify=\"center\", no_wrap=True)\n table.add_column(\"Params\", ratio=25, no_wrap=False)\n table.add_column(\"Model ID\",ratio=40, no_wrap=... | [
"0.68475515",
"0.67694277",
"0.6301734",
"0.62993044",
"0.6283047",
"0.6254017",
"0.6179174",
"0.6083647",
"0.6063116",
"0.6007498",
"0.60040426",
"0.5994601",
"0.5992395",
"0.5990162",
"0.5973742",
"0.5968707",
"0.59684587",
"0.5965415",
"0.595515",
"0.59278136",
"0.59160846... | 0.56586915 | 53 |
returns a list of axes of a variable mv | def allAxes( mv ):
if mv is None: return None
return mv.getAxisList() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_axes(self) -> VGroup:\n return self.axes",
"def get_axes(self) -> VGroup:\n return self.axes",
"def axes(self):\n return self._axes",
"def axes(self):\n return self._axes",
"def axes(*x: Iterable[int]):\n return [_ti_core.Axis(i) for i in x]",
"def axes(self) -> np.... | [
"0.6138203",
"0.6138203",
"0.6132842",
"0.6132842",
"0.6125584",
"0.6117667",
"0.6023415",
"0.59184104",
"0.5736616",
"0.5717504",
"0.57096046",
"0.55749345",
"0.54218215",
"0.5417657",
"0.54154396",
"0.5380405",
"0.52959144",
"0.5287406",
"0.52542454",
"0.5213043",
"0.519815... | 0.7132127 | 0 |
Sometimes we get time units which aren't compatible with cdtime. This function will (try to) fix them. The input argument is a string, e.g. "months since Jan 1979" and the return value is another string, e.g. | def fix_time_units( timeunits ):
imon = timeunits.find("months since ")
if imon==0:
since="months since "
else:
iday = timeunits.find("days since ")
if iday==0:
since="days since "
else:
ihour = timeunits.find("hours since ")
if ihour==0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(string):\n units = {'s':1, 'm':60, 'h':60*60, 'd':24*60*60, 'M':30*24*60*60}\n string = string.replace(' ','')\n p = re.compile('(\\d+)\\s*(\\w+)')\n num, unit = p.match(string).groups()\n num = float(num)\n return num * units[unit]",
"def clean_unit(unit):\n return 'M' if unit.lower() =... | [
"0.62871355",
"0.62632513",
"0.6058695",
"0.60543835",
"0.60210484",
"0.6020246",
"0.59578264",
"0.5928724",
"0.5863947",
"0.585928",
"0.5834382",
"0.57287663",
"0.56812316",
"0.5627189",
"0.5626828",
"0.5603379",
"0.5575414",
"0.55661714",
"0.5550087",
"0.5532709",
"0.550852... | 0.80670094 | 0 |
Input is a variable which depends on latitude. This function will copy it to a new variable, except that the new variable's latitude axis will be restricted to latmin<=lat<=latmax; and of course the data will be restricted to correspond. | def restrict_lat( mv, latmin, latmax ):
if latmin==-90: latmin = -91 # just to make sure
if latmax==90: latmax = 91
# axes
latax,idx = latAxis2(mv)
if latax is None: return None
imin = min( [i for i in range(len(latax)) if latax[i]>=latmin and latax[i]<=latmax ] )
imax = max( [i for i in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n return type(self)(self.lat_lon[0], self.lat_lon[1], **self._attrs)",
"def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n ... | [
"0.58231395",
"0.5813714",
"0.56509984",
"0.52055085",
"0.5196696",
"0.51875114",
"0.51552486",
"0.5142588",
"0.5094556",
"0.50887316",
"0.5085515",
"0.50473696",
"0.504018",
"0.49421754",
"0.4902313",
"0.48965225",
"0.4887742",
"0.486856",
"0.48649704",
"0.48557973",
"0.4848... | 0.7229858 | 0 |
returns the mean of the variable over the supplied latitude range (in degrees, based on values of lat, not lat_bnds) The computed quantity is a scalar but is returned as a cdms2 variable, i.e. a MV. The input mv is a cdms2 variable, assumed to be indexed as is usual for CFcompliant variables, i.e. mv(time,lat,lon). At ... | def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):
# For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.
# And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)
# If they aren't, it's best to use area from cell_measures a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n ilat = None\n for i,ax in enumerate(axes):\n if ax.id=='lat': ilat = i\n # reduce size of lat axis to (latmin,latmax)\n # Let's home a direct search will... | [
"0.67416596",
"0.6548467",
"0.6509797",
"0.62889326",
"0.6226794",
"0.6226794",
"0.6008768",
"0.59134054",
"0.5877358",
"0.57791483",
"0.5682933",
"0.5665746",
"0.55882084",
"0.55698764",
"0.55633837",
"0.55565643",
"0.55452055",
"0.55107474",
"0.5478772",
"0.54400945",
"0.53... | 0.6658991 | 1 |
returns the mean of the variable over the supplied latitude range (in degrees, based on values of lat, not lat_bnds) The computed quantity is a scalar but is returned as a cdms2 variable, i.e. a MV. The input mv is a cdms2 variable too. This function uses the cdms2 avarager() function to handle weights and do averages | def reduce2scalar_zonal( mv, latmin=-90, latmax=90, vid=None ):
if vid==None:
vid = 'reduced_'+mv.id
axes = allAxes( mv )
ilat = None
for i,ax in enumerate(axes):
if ax.id=='lat': ilat = i
# reduce size of lat axis to (latmin,latmax)
# Let's home a direct search will be fast enou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_me... | [
"0.6483892",
"0.6449936",
"0.63286823",
"0.6259683",
"0.6259683",
"0.60817444",
"0.59398943",
"0.5792978",
"0.5686484",
"0.5672774",
"0.5669752",
"0.5493353",
"0.548496",
"0.5436766",
"0.541976",
"0.541753",
"0.5412601",
"0.54037213",
"0.53908765",
"0.53008914",
"0.529571",
... | 0.65369064 | 0 |
averages mv over the full range all axes, to a single scalar. Uses the averager module for greater capabilities | def reduce2scalar( mv, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
axes = allAxes( mv )
axis_names = [ a.id for a in axes ]
axes_string = '('+')('.join(axis_names)+')'
avmv = averager( mv, axis=axes_string )
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))",
"def manual_mean(arr):\n my_sum = 0\n for i in range(0, arr.shape[0]):\n for j in range(0, arr.shape[1]):\n my_sum += arr[i,j]\n return my_sum / arr.si... | [
"0.6626889",
"0.63578427",
"0.625352",
"0.6220642",
"0.619339",
"0.6153601",
"0.61507607",
"0.61103404",
"0.61103404",
"0.6092938",
"0.60919166",
"0.6082729",
"0.602311",
"0.6023065",
"0.60227084",
"0.6014731",
"0.59958345",
"0.59730744",
"0.5966355",
"0.5960948",
"0.5960868"... | 0.6819693 | 0 |
returns the mean of the variable over all axes but latitude, as a cdms2 variable, i.e. a MV. The input mv is a also cdms2 variable, assumed to be indexed as is usual for CFcompliant variables, i.e. mv(time,lat,lon). At present, no other axes (e.g. level) are supported. At present mv must depend on all three axes. | def reduce2lat_old( mv, vid=None ):
# >>> For now, I'm assuming that the only axes are time,lat,lon
# And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)
# If they aren't, it's best to use area from cell_measures attribute if available; otherwise
# compute it with... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( m... | [
"0.6196711",
"0.61690545",
"0.6022679",
"0.5879041",
"0.57352066",
"0.56729776",
"0.5658441",
"0.56343806",
"0.56343806",
"0.5478811",
"0.54540074",
"0.5406501",
"0.5377368",
"0.53606015",
"0.53185415",
"0.5281884",
"0.52813756",
"0.5268177",
"0.525204",
"0.52350086",
"0.5188... | 0.6457875 | 0 |
as reduce2lat_old, but uses the averager module for greater capabilities | def reduce2lat( mv, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
axes = allAxes( mv )
axis_names = [ a.id for a in axes if a.id!='lat' ]
axes_string = '('+')('.join(axis_names)+')'
avmv = averager( mv, axis=axes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # comput... | [
"0.71746695",
"0.7159011",
"0.693063",
"0.6655468",
"0.6433842",
"0.60125995",
"0.59771603",
"0.5941421",
"0.5817719",
"0.57721925",
"0.57491624",
"0.57213616",
"0.5685925",
"0.5673032",
"0.559728",
"0.5517831",
"0.544977",
"0.5412728",
"0.53823274",
"0.53628594",
"0.5176197"... | 0.7389955 | 0 |
as reduce2lat, but averaging reduces coordinates to (lev,lat) | def reduce2levlat( mv, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
if levAxis(mv) is None: return None
if latAxis(mv) is None: return None
axes = allAxes( mv )
timeax = timeAxis(mv)
if timeax.getBounds()==No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2lat( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id!='lat' ]\n axes_string = '('+')('.join(axis_names)+')'\n\n avmv = averager( m... | [
"0.69857925",
"0.6807853",
"0.6773293",
"0.6564294",
"0.6501866",
"0.64869905",
"0.6404557",
"0.6294769",
"0.59781444",
"0.595413",
"0.5908495",
"0.5811801",
"0.5792106",
"0.577163",
"0.57321805",
"0.5651219",
"0.55763006",
"0.5573147",
"0.5571079",
"0.5546693",
"0.55466807",... | 0.6961548 | 1 |
as reduce2levlat, but data is averaged only for time restricted to the specified season; as in reduce2lat_seasona. | def reduce2levlat_seasonal( mv, seasons=seasonsyr, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
if levAxis(mv) is None: return None
if latAxis(mv) is None: return None
axes = allAxes( mv )
timeax = timeAxis(mv)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager fu... | [
"0.75936365",
"0.74594027",
"0.688166",
"0.6238695",
"0.61847365",
"0.6133317",
"0.60225564",
"0.5992159",
"0.58987415",
"0.5852854",
"0.5766803",
"0.5747153",
"0.555478",
"0.54478663",
"0.5436463",
"0.5383689",
"0.53339547",
"0.53088355",
"0.5280703",
"0.5271107",
"0.5259503... | 0.74663657 | 1 |
as reduce2lat, but averaging reduces coordinates to (lat,lon) | def reduce2latlon( mv, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
axes = allAxes( mv )
axis_names = [ a.id for a in axes if a.id!='lat' and a.id!='lon' ]
axes_string = '('+')('.join(axis_names)+')'
for ax in ax... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gavg(idata):\n\t\n\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\n\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\n\n\treturn ga",
"def _sum_over_lat_lon(arr):\n return arr.sum(internal_names.LAT_STR).sum(internal_names.LON_STR)",
"def reduce2lat( mv, vid=None ):\n if vid==None... | [
"0.6802166",
"0.6642348",
"0.6556299",
"0.6508638",
"0.6453023",
"0.6349028",
"0.63084924",
"0.6272458",
"0.61608815",
"0.6047154",
"0.59499687",
"0.591246",
"0.58452344",
"0.58440655",
"0.5839892",
"0.58179414",
"0.58040535",
"0.5800975",
"0.5782415",
"0.5766302",
"0.5753359... | 0.66085106 | 2 |
as reduce2lat, but averaging reduces only the time coordinate | def reduce_time( mv, vid=None ):
if vid==None: # Note that the averager function returns a variable with meaningless id.
vid = 'reduced_'+mv.id
axes = allAxes( mv )
axis_names = [ a.id for a in axes if a.id=='time' ]
axes_string = '('+')('.join(axis_names)+')'
if len(axes_string)>2:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2scalar_zonal_old( mv, latmin=-90, latmax=90, vid=None ):\n # For now, I'm assuming that the only axes are time,lat,lon - so that zm is a scalar.\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_me... | [
"0.6574507",
"0.65092766",
"0.6464141",
"0.6426075",
"0.6411295",
"0.61637866",
"0.61182755",
"0.59607893",
"0.5948452",
"0.59184855",
"0.590027",
"0.5854279",
"0.58315974",
"0.57817066",
"0.57384855",
"0.5659206",
"0.5647667",
"0.56162596",
"0.56059456",
"0.5603186",
"0.5548... | 0.5652815 | 16 |
as reduce2lat, but data is used only for time restricted to the specified season. The season is specified as an object of type cdutil.ties.Seasons, and defaults to the whole year. The returned variable will still have a time axis, with one value per season specified. | def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):
if vid==None:
vid = 'reduced_'+mv.id
# Note that the averager function returns a variable with meaningless id.
# The climatology function returns the same id as mv, which we also don't want.
# The slicers in time.py require getBounds()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager fu... | [
"0.67101383",
"0.61974657",
"0.6165893",
"0.57036895",
"0.54976517",
"0.5443406",
"0.5429207",
"0.5275951",
"0.5232346",
"0.52280706",
"0.5203124",
"0.5159468",
"0.515358",
"0.51510376",
"0.5138082",
"0.50527817",
"0.50496626",
"0.5037915",
"0.49941966",
"0.4983268",
"0.49606... | 0.6925929 | 0 |
as reduce2lat_seasonal, but both lat and lon axes are retained. | def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):
# This differs from reduce2lat_seasonal only in the line "axis_names ="....
# I need to think about how to structure the code so there's less cut-and-paste!
if vid==None:
vid = 'reduced_'+mv.id
# Note that the averager function retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2lat_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require ... | [
"0.7120988",
"0.65913016",
"0.5912345",
"0.58565855",
"0.5846651",
"0.5827005",
"0.5757517",
"0.5742788",
"0.56260955",
"0.5573889",
"0.5551024",
"0.5517785",
"0.5454073",
"0.5447219",
"0.5380435",
"0.5367206",
"0.53613245",
"0.5329884",
"0.52797866",
"0.527883",
"0.5270271",... | 0.7579458 | 0 |
as reduce2lat_seasonal, but all nontime axes are retained. | def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):
if vid==None:
vid = 'reduced_'+mv.id
# Note that the averager function returns a variable with meaningless id.
# The climatology function returns the same id as mv, which we also don't want.
# The slicers in time.py require getBounds(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2latlon_seasonal( mv, seasons=seasonsyr, vid=None ):\n # This differs from reduce2lat_seasonal only in the line \"axis_names =\"....\n # I need to think about how to structure the code so there's less cut-and-paste!\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager fu... | [
"0.74530834",
"0.70475537",
"0.6324904",
"0.59645534",
"0.5937632",
"0.58018863",
"0.57699883",
"0.57024586",
"0.5577448",
"0.5530543",
"0.54834914",
"0.54797405",
"0.5413724",
"0.5400654",
"0.5268981",
"0.51579803",
"0.5137244",
"0.5122184",
"0.5121492",
"0.5113712",
"0.5081... | 0.5721398 | 7 |
Input is a leveldependent variable mv and a level slev to select. slev is an instance of udunits thus it has a value and a units attribute. This function will create and return a new variable mvs without a level axis. The values of mvs correspond to the values of mv with level set to slev. Interpolation isn't done yet,... | def select_lev( mv, slev ):
levax = levAxis(mv)
# Get ig, the first index for which levax[ig]>slev
# Assume that levax values are monotonic.
dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax
if levax[0]<=levax[-1]:
ids = numpy.where( levax[:]>=slev.value ) # ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev... | [
"0.67565304",
"0.6339013",
"0.5813282",
"0.55218333",
"0.55123705",
"0.54566956",
"0.54150814",
"0.5345006",
"0.53043866",
"0.52986836",
"0.5298433",
"0.5282433",
"0.5152977",
"0.5144597",
"0.50879806",
"0.50478345",
"0.50315887",
"0.5008072",
"0.5002643",
"0.49997583",
"0.49... | 0.77553666 | 0 |
returns a transient variable which is dimensioned along the lat axis but whose values are the latitudes | def latvar( mv ):
# First get the axis. This is probably not as general as we'll need...
if mv is None: return None
lat_axis = latAxis(mv)
#latmv = mv.clone() # good if mv has only a lat axis
#latmv[:] = lat_axis[:]
latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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['long... | [
"0.67513454",
"0.66928744",
"0.6395381",
"0.63260347",
"0.61951125",
"0.61491525",
"0.613318",
"0.6064862",
"0.6063187",
"0.6053654",
"0.6050005",
"0.6028488",
"0.5952476",
"0.58669955",
"0.5862181",
"0.5862181",
"0.58513904",
"0.58510435",
"0.5826054",
"0.58009094",
"0.58002... | 0.74743557 | 0 |
returns a transient variable which is dimensioned along the lon axis but whose values are the longitudes | def lonvar( mv ):
# First get the axis. This is probably not as general as we'll need...
if mv is None: return None
lon_axis = lonAxis(mv)
latmv = cdms2.createVariable( lon_axis[:], axes=[lon_axis], id='lon',
attributes={'units':lon_axis.units},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def latvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lat_axis = latAxis(mv)\n #latmv = mv.clone() # good if mv has only a lat axis\n #latmv[:] = lat_axis[:]\n latmv = cdms2.createVariable( lat_axis[:], axes=[lat_axis], id='lat... | [
"0.67902434",
"0.6771255",
"0.67498714",
"0.6621353",
"0.6568897",
"0.6417901",
"0.617368",
"0.61442626",
"0.6087874",
"0.60350233",
"0.5941551",
"0.59397936",
"0.5933728",
"0.5912952",
"0.5898972",
"0.58715075",
"0.5850327",
"0.57997036",
"0.579611",
"0.5794126",
"0.57769763... | 0.7568185 | 0 |
returns a transient variable which is dimensioned along the lev (level) axis but whose values are the levels | def levvar( mv ):
# First get the axis. This is probably not as general as we'll need...
if mv is None: return None
lev_axis = levAxis(mv)
#levmv = mv.clone() # good if mv has only a lev axis
#levmv[:] = lev_axis[:]
levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.va... | [
"0.61772287",
"0.60954696",
"0.6019012",
"0.5921437",
"0.57173896",
"0.56935555",
"0.55191696",
"0.55090266",
"0.5501754",
"0.5488749",
"0.5447241",
"0.5427211",
"0.54218185",
"0.54218185",
"0.54218185",
"0.5372012",
"0.5331837",
"0.52983266",
"0.52873015",
"0.5285758",
"0.52... | 0.7218306 | 0 |
From a variable or axis of pressures, this function converts to millibars, and returns the result as a numpy array. | def pressures_in_mb( pressures ):
if not hasattr( pressures, 'units' ): return None
if pressures.units=='mb':
pressures.units = 'mbar' # udunits uses mb for something else
return pressures[:]
tmp = udunits(1.0,pressures.units)
s,i = tmp.how('mbar')
pressmb = s*pressures[:] + i
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale_mag_1(x):\n return np.array([np.true_divide(ui, mag(x)) for ui in x])",
"def cm2inch(x: Union[float, Sequence[float], NDArray]) -> Sequence[float]:\n return list(np.array(x) / 2.54)",
"def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n retu... | [
"0.50821847",
"0.50635743",
"0.5063201",
"0.5052912",
"0.50040376",
"0.49670303",
"0.48602846",
"0.47888026",
"0.47871676",
"0.47724292",
"0.47648123",
"0.47488585",
"0.46842295",
"0.46627557",
"0.46367168",
"0.46319687",
"0.4622999",
"0.46144953",
"0.46112272",
"0.45830104",
... | 0.5553397 | 0 |
returns a transient variable which is dimensioned along the lev (level) axis and whose values are the heights corresponding to the pressure levels found as the lev axis of mv. Levels will be converted to millibars. heights are returned in km | def heightvar( mv ):
if mv is None: return None
lev_axis = levAxis(mv)
heights = 0.001 * press2alt.press2alt( pressures_in_mb(lev_axis) ) # 1000 m = 1 km
heightmv = cdms2.createVariable( heights, axes=[lev_axis], id=mv.id,
attributes={'units':"km"} )
return heig... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def levvar( mv ):\n # First get the axis. This is probably not as general as we'll need...\n if mv is None: return None\n lev_axis = levAxis(mv)\n #levmv = mv.clone() # good if mv has only a lev axis\n #levmv[:] = lev_axis[:]\n levmv = cdms2.createVariable( lev_axis[:], axes=[lev_axis], id='lev... | [
"0.6776988",
"0.6006147",
"0.590526",
"0.5898939",
"0.55466783",
"0.54994154",
"0.547498",
"0.5466537",
"0.5447086",
"0.54124725",
"0.5391253",
"0.5389002",
"0.53862095",
"0.5358909",
"0.5290569",
"0.5286262",
"0.5192268",
"0.51763445",
"0.5174741",
"0.51733345",
"0.5168547",... | 0.77257425 | 0 |
returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest latitude points but whose values are the latitudes | def latvar_min( mv1, mv2 ):
if mv1 is None: return None
if mv2 is None: return None
lat_axis1 = latAxis(mv1)
lat_axis2 = latAxis(mv2)
if len(lat_axis1)<=len(lat_axis2):
lat_axis = lat_axis1
mv = mv1
else:
lat_axis = lat_axis2
mv = mv2
latmv = cdms2.createVaria... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lonvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lon_axis1 = lonAxis(mv1)\n lon_axis2 = lonAxis(mv2)\n if len(lon_axis1)<=len(lon_axis2):\n lon_axis = lon_axis1\n mv = mv1\n else:\n lon_axis = lon_axis2\n mv = mv2\n lonmv = c... | [
"0.69351184",
"0.62349105",
"0.6094042",
"0.5838326",
"0.5824384",
"0.58051234",
"0.57359993",
"0.5527261",
"0.5517576",
"0.5458443",
"0.54356056",
"0.5415327",
"0.54134643",
"0.54001105",
"0.5361201",
"0.52343124",
"0.52035445",
"0.51936215",
"0.5187855",
"0.51732856",
"0.51... | 0.73494667 | 0 |
returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest longitude points but whose values are the longitudes | def lonvar_min( mv1, mv2 ):
if mv1 is None: return None
if mv2 is None: return None
lon_axis1 = lonAxis(mv1)
lon_axis2 = lonAxis(mv2)
if len(lon_axis1)<=len(lon_axis2):
lon_axis = lon_axis1
mv = mv1
else:
lon_axis = lon_axis2
mv = mv2
lonmv = cdms2.createVaria... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def latvar_min( mv1, mv2 ):\n if mv1 is None: return None\n if mv2 is None: return None\n lat_axis1 = latAxis(mv1)\n lat_axis2 = latAxis(mv2)\n if len(lat_axis1)<=len(lat_axis2):\n lat_axis = lat_axis1\n mv = mv1\n else:\n lat_axis = lat_axis2\n mv = mv2\n latmv = c... | [
"0.68968886",
"0.66709334",
"0.6106323",
"0.59900844",
"0.5892058",
"0.57636064",
"0.57299185",
"0.5693455",
"0.5671543",
"0.56326985",
"0.5609396",
"0.5597439",
"0.5474902",
"0.5423528",
"0.5386049",
"0.53539693",
"0.5313379",
"0.5313333",
"0.53117704",
"0.53086036",
"0.5308... | 0.7268381 | 0 |
returns a transient variable which is dimensioned as whichever of mv1, mv2 has the fewest level points but whose values are the levels | def levvar_min( mv1, mv2 ):
if mv1 is None: return None
if mv2 is None: return None
lev_axis1 = levAxis(mv1)
lev_axis2 = levAxis(mv2)
if len(lev_axis1)<=len(lev_axis2):
lev_axis = lev_axis1
mv = mv1
else:
lev_axis = lev_axis2
mv = mv2
levmv = cdms2.createVaria... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_lev( mv, slev ):\n levax = levAxis(mv)\n # Get ig, the first index for which levax[ig]>slev\n # Assume that levax values are monotonic.\n dummy,slev = reconcile_units( levax, slev ) # new slev has same units as levax\n if levax[0]<=levax[-1]:\n ids = numpy.where( levax[:]>=slev.va... | [
"0.60400754",
"0.5711261",
"0.53916866",
"0.5316189",
"0.5314503",
"0.5262245",
"0.5258733",
"0.5256473",
"0.52382195",
"0.5228566",
"0.5206168",
"0.51694137",
"0.51330495",
"0.51280445",
"0.51269424",
"0.5126678",
"0.5115695",
"0.51080126",
"0.50934094",
"0.5042593",
"0.5039... | 0.65224934 | 0 |
interpolates a variable mv along its second axis, normally latitude, so as to match the new axis (which should be coarser, i.e. fewer points), and returns a numpy array of the interpolated values. The first axis is normally levels, and isn't expected to be very large (usually <20; surely <50) There shall be no more tha... | def interp2( newaxis1, mv ):
missing = mv.get_fill_value()
axes = allAxes(mv)
if len(newaxis1[:])>len(axes[1][:]): return mv
new_vals = numpy.ma.masked_all( ( len(axes[0]), len(newaxis1[:]) ) )
for i in range(len( axes[0] )):
new_vals[i,:] = numpy.interp( newaxis1[:], axes[1][:], mv[i,:], l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce2lat_old( mv, vid=None ):\n # >>> For now, I'm assuming that the only axes are time,lat,lon\n # And I'm assuming equal spacing in lon (so all longitudes contribute equally to the average)\n # If they aren't, it's best to use area from cell_measures attribute if available; otherwise\n # comput... | [
"0.6127793",
"0.61027855",
"0.6082101",
"0.59283215",
"0.5838112",
"0.57578194",
"0.5623196",
"0.5599504",
"0.55420876",
"0.54633516",
"0.5410154",
"0.5350282",
"0.5312561",
"0.52844816",
"0.52626956",
"0.5179751",
"0.5162937",
"0.5137714",
"0.5093342",
"0.5058199",
"0.503866... | 0.62990654 | 0 |
returns mv1[0,]mv2[0,]; they should be dimensioned alike. Attributes will be fixed up where I know how. | def aminusb0( mv1, mv2 ):
mv = mv1[0,] - mv2[0,]
if hasattr(mv,'long_name'):
if mv.long_name==mv1.long_name: # They're different, shouldn't have the same long_name
mv.long_name = ''
return mv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _gu_matvec(x1, x2):\n return (x1 @ x2[..., np.newaxis])[..., 0]",
"def get_molecular_matrix_and_vector(single_body, two_body):\n x, y = single_body.shape\n func = np.vectorize(round_custom)\n _new_dim = x * y\n single_one_dim = func(single_body.reshape(_new_dim, 1))\n two_body_two_dim = fun... | [
"0.5995994",
"0.5515784",
"0.5483453",
"0.5478269",
"0.5441555",
"0.5402159",
"0.5384988",
"0.5359179",
"0.52837175",
"0.5270582",
"0.5260968",
"0.5260383",
"0.525911",
"0.5228595",
"0.5210489",
"0.5195151",
"0.5183675",
"0.51530695",
"0.51313037",
"0.51037055",
"0.5097388",
... | 0.56507003 | 1 |
returns a transient variable representing mv1mv2, where mv1 and mv2 are variables with exactly two axes, with the first axis the same for each (but it's ok to differ only in units, which could be converted). To perform the subtraction, one of the variables is linearly interpolated in its second dimension to the second ... | def aminusb_ax2( mv1, mv2 ):
if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:
print "WARING: aminusb_ax2 is subtracting variables with different units!",mv1,mv1
axes1 = allAxes(mv1)
axes2 = allAxes(mv2)
# TO DO: convert, interpolate, etc. as needed to accomodate differi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1... | [
"0.6669163",
"0.64997256",
"0.6459063",
"0.6129442",
"0.59882194",
"0.5982143",
"0.59319377",
"0.59233034",
"0.58952814",
"0.5881865",
"0.585033",
"0.5835218",
"0.57343096",
"0.5712189",
"0.5709772",
"0.56709397",
"0.5657024",
"0.563904",
"0.56342083",
"0.5616154",
"0.5580523... | 0.6472477 | 2 |
returns a transient variable representing mv1mv2, where mv1 and mv2 are variables, normally transient variables, which depend on exactly two axes, typically lonlat. To perform the subtraction, the variables will be interpolated as necessary to the axes which are minimal (fewest points) in each direction. Note that if m... | def aminusb_2ax( mv1, mv2 ):
return mv2
mv1, mv2 = reconcile_units( mv1, mv2 )
missing = mv1.get_fill_value()
axes1 = allAxes(mv1)
axes2 = allAxes(mv2)
if axes1 is None or axes2 is None: return None
if len(axes1)!=2: print "ERROR @1, wrong number of axes for aminusb_2ax",axes1
if len(axe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aminusb_1ax( mv1, mv2 ):\n mv1, mv2 = reconcile_units( mv1, mv2 )\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARNING: aminusb_1ax1 is subtracting variables with different units!\",mv1,mv1\n if mv1 is None or mv2 is None: return None\n missing = mv1... | [
"0.6842053",
"0.6623479",
"0.6418362",
"0.6201654",
"0.6115403",
"0.6079604",
"0.6074351",
"0.588521",
"0.5873079",
"0.5828353",
"0.57805383",
"0.5740809",
"0.5714796",
"0.56725395",
"0.56446743",
"0.55954033",
"0.55467427",
"0.55024266",
"0.5496881",
"0.5487313",
"0.54748785... | 0.5110343 | 38 |
returns a transient variable representing mv1mv2, where mv1 and mv2 are variables, normally transient variables, which are required to depend only one axis. To perform the subtraction, one of the variables is linearly interpolated to the axis of the other. The axis used will be the coarsest (fewest points) of the two a... | def aminusb_1ax( mv1, mv2 ):
mv1, mv2 = reconcile_units( mv1, mv2 )
if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:
print "WARNING: aminusb_1ax1 is subtracting variables with different units!",mv1,mv1
if mv1 is None or mv2 is None: return None
missing = mv1.get_fill_va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def basic_sub(mv1, mv2):\n obj = expand(mv1.obj - mv2.obj)\n return MV(obj)",
"def displacement(cls, v1, v2):\n return np.array([v2 - v1])",
"def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is... | [
"0.6467121",
"0.6038152",
"0.60112774",
"0.598649",
"0.5940264",
"0.59214985",
"0.5907114",
"0.5860278",
"0.5774416",
"0.57667285",
"0.5750668",
"0.56914055",
"0.5675003",
"0.5616137",
"0.56054354",
"0.5589946",
"0.5553921",
"0.55365384",
"0.55223125",
"0.5514815",
"0.5504505... | 0.66377026 | 0 |
Returns time averages of the cems2 variable mv. The average is comuted only over times which lie in the specified season(s). The returned variable has the same number of dimensions as mv, but the time axis has been reduced to the number of seasons requested. The seasons are specified as an object of type cdutil.times.S... | def timeave_seasonal( mv, seasons=seasonsyr ):
return seasons.climatology(mv) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_time_seasonal( mv, seasons=seasonsyr, vid=None ):\n if vid==None:\n vid = 'reduced_'+mv.id\n # Note that the averager function returns a variable with meaningless id.\n # The climatology function returns the same id as mv, which we also don't want.\n\n # The slicers in time.py require... | [
"0.7113886",
"0.68064904",
"0.6650361",
"0.61950076",
"0.5758541",
"0.5734643",
"0.55560625",
"0.54895353",
"0.5439703",
"0.522154",
"0.51681584",
"0.5160492",
"0.5129565",
"0.5069776",
"0.50522226",
"0.50236505",
"0.4989968",
"0.49448606",
"0.49113876",
"0.48840415",
"0.4866... | 0.6935159 | 1 |
Returns a time average of the cdms2 variable mv. mv is a cdms2 variable, assumed to be timedependent and indexed as is usual for CFcompliant variables, i.e. mv(time,...). What's returned is a numpy array, not a cdms2 variable. (I may change this in the future). | def timeave_old( mv ):
# I haven't thought yet about how missing values would work with this...
# If time intervals be unequal, this will have to be changed...
sh = mv.shape # e.g. [312,90,144] for t,lat,lon
n = sh[0]
# BTW, this is the size of everything else:
# n2 = reduce( operator.mul, sh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string... | [
"0.58772254",
"0.569831",
"0.54306823",
"0.5339006",
"0.52570695",
"0.5178657",
"0.51458687",
"0.5114982",
"0.5073207",
"0.50591934",
"0.50121516",
"0.5010453",
"0.50002575",
"0.49653572",
"0.49469918",
"0.492515",
"0.492515",
"0.48782063",
"0.48579815",
"0.4835696",
"0.48353... | 0.5918535 | 0 |
returns a TransientVariable containing the minimum and maximum values of all the variables provided as arguments | def minmin_maxmax( *args ):
rmin = min( [ mv.min() for mv in args ] )
rmax = max( [ mv.max() for mv in args ] )
rmv = cdms2.createVariable( [rmin,rmax] )
return rmv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_minimum():\n return [\n convert_variables([0.78547, 0.78547, 0.78547]),\n ]",
"def __minimum_remaining_values(self, unassigned_vars):\n min_var = None\n for var in unassigned_vars:\n if min_var is None:\n min_var = var\n elif len... | [
"0.6460465",
"0.61516154",
"0.603381",
"0.5994661",
"0.5891523",
"0.5836747",
"0.58244497",
"0.57395023",
"0.5681477",
"0.5667921",
"0.56678796",
"0.5662136",
"0.56610906",
"0.5639008",
"0.562747",
"0.5615644",
"0.5598546",
"0.55895096",
"0.5584579",
"0.5576427",
"0.5575043",... | 0.7315337 | 0 |
If mv depends on an axis with just one value, create a copy of mv without that axis, and without the corresponding data dimension. Normally this happens when time has been averaged out, but there is still a onevalued time axis left (thus one would normally use id='time'). You can specify the axis id if there might be m... | def delete_singleton_axis( mv, vid=None ):
axes = allAxes(mv)
saxis = None
si = None
for i in range(len(axes)):
if len(axes[i])==1 and (vid==None or axes[i].id==vid):
saxis = axes[i]
si = i
del axes[si]
break
if saxis==None: return mv
data ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_time( mv, vid=None ):\n if vid==None: # Note that the averager function returns a variable with meaningless id.\n vid = 'reduced_'+mv.id\n axes = allAxes( mv )\n axis_names = [ a.id for a in axes if a.id=='time' ]\n axes_string = '('+')('.join(axis_names)+')'\n if len(axes_string... | [
"0.6247364",
"0.59301597",
"0.55981517",
"0.55702573",
"0.53490317",
"0.5049275",
"0.49913675",
"0.49404666",
"0.48569542",
"0.4843272",
"0.4835321",
"0.47630703",
"0.47483668",
"0.47441968",
"0.47385386",
"0.46919236",
"0.46870866",
"0.4654426",
"0.46510515",
"0.46408376",
"... | 0.71518254 | 0 |
Not much tested I decided against doing overlapping line plots this way. The input arguments are two variables (cdms2 MVs, normally TransientVariables), with whatever compatibility is needed for this function to work. New axes are computed which can be used for both variables. These axes are returned as a list of tuple... | def common_axes( mv1, mv2 ):
axes1 = [a[0] for a in mv1.getDomain()]
axes2 = [a[0] for a in mv2.getDomain()]
if len(axes1)!=len(axes2):
print "ERROR. common_axes requires same number of axes in",mv1," and",mv2
return None
axes3 = []
for i in range(len(axes1)):
axes3.append(c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_axes(self):\n fig = plt.figure(1)\n axs = fig.add_subplot(1, 1, 1)\n fig.clf()\n axs = plt.subplots(1, 2)\n ax1 : plt.axis = axs[0]\n ax2 : plt.axis = axs[1]\n fig.canvas.draw()\n \n line1_t, = ax1.plot([], label='train')\n line1_v, = ... | [
"0.57410544",
"0.57360107",
"0.5571669",
"0.55329823",
"0.5515343",
"0.54836935",
"0.5431624",
"0.5425385",
"0.5408111",
"0.5307821",
"0.5279651",
"0.5267647",
"0.52437675",
"0.52202445",
"0.51879686",
"0.5187689",
"0.51863897",
"0.5173515",
"0.51703244",
"0.5135122",
"0.5129... | 0.63710725 | 0 |
Not much tested I decided against doing overlapping line plots this way. The input arguments are two axes (AbstractAxis class), as compatible as necessary for the following to be sensible. This function has 3 return values. It returns a TransientAxis which includes all the points of the input axes. It may be one of the... | def common_axis( axis1, axis2 ):
if hasattr( axis1, 'units' ):
units1 = axis1.units.lower().replace(' ','_')
if axis1.isTime():
axis1.toRelativeTime( units1 ) #probably will change input argument
else:
units1 = None
if hasattr( axis2, 'units' ):
units2 = axis2.un... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def common_axes( mv1, mv2 ):\n axes1 = [a[0] for a in mv1.getDomain()]\n axes2 = [a[0] for a in mv2.getDomain()]\n if len(axes1)!=len(axes2):\n print \"ERROR. common_axes requires same number of axes in\",mv1,\" and\",mv2\n return None\n axes3 = []\n for i in range(len(axes1)):\n ... | [
"0.61138195",
"0.6088058",
"0.6041942",
"0.5724058",
"0.55722874",
"0.54428166",
"0.5421346",
"0.5317659",
"0.53087",
"0.52630603",
"0.5246884",
"0.521855",
"0.5203898",
"0.5200251",
"0.51671886",
"0.5156836",
"0.51552814",
"0.5126504",
"0.51036406",
"0.5095335",
"0.5079292",... | 0.69112474 | 0 |
Not much tested I decided against doing overlapping line plots this way. Returns a TransientVaraible made by replacing an axis axisold of a TransientVariable mv with a new axis. The new axis will have all points of the old axis, but may have more, thus requiring the new variable to have more missing data. The variable ... | def convert_axis( mv, axisold, axisindnew ):
(axisnew, indexina3) = axisindnew
axes = allAxes(mv)
kold = None
for k in range(len(axes)):
if axes[k]==axisold: kold=k
if kold==None:
print "ERROR. convert_axis cannot find axis",axisold," in variable",mv
if len(axisold)==len(axisnew)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_axis(self, dim:NamedIndex,\n mapping_or_old:'Union[Mapping[NamedIndex, NamedIndex], NamedIndex]',\n new:'Optional[NamedIndex]'=None):\n\n axes = self[dim] # disable idx_dim access\n # axes = self.get(dim) or self._dim_axes[dim] # dim:'Union[int, Nam... | [
"0.5527314",
"0.5408021",
"0.5342411",
"0.52576274",
"0.52193874",
"0.52078605",
"0.5200823",
"0.5182296",
"0.5143223",
"0.5039198",
"0.5026079",
"0.49834254",
"0.49665734",
"0.48400095",
"0.48353782",
"0.48336178",
"0.4820047",
"0.48099452",
"0.4761784",
"0.47465044",
"0.471... | 0.71285164 | 0 |
From a filename, extracts the first part of the filename as the possible name of a family of files; e.g. from 'ts_Amon_bcccsm11_amip_r1i1p1_197901200812.nc' extract and return 'ts_Amon_bcccsm11_amip_r1i1p1'. To distinguish between the end of a file family name and the beginning of the filespecific part of the filename,... | def extract_filefamilyname( self, filename ):
matchobject = re.search( r"^.*_\d\d", filename )
if matchobject is None:
return filename
else:
familyname = filename[0:(matchobject.end()-3)]
return familyname | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reFileName(str_):\n rv = 'None', str_\n m = re.match(r'((?:[a-zA-Z0-9-]){4,})_(.*)$', str_)\n if m:\n rv = m.group(1), m.group(2)\n else:\n m = re.match(r'(\\d+-\\d+)\\.-\\.(.*)$', str_)\n if m:\n rv = m.group(1), m.group(2)\n return rv",
"def parse_rarefaction_... | [
"0.7018564",
"0.68886405",
"0.6759327",
"0.6749364",
"0.6716706",
"0.6699516",
"0.6672866",
"0.66605604",
"0.6640363",
"0.65921485",
"0.6585",
"0.65480256",
"0.6478625",
"0.64543766",
"0.64543766",
"0.6446561",
"0.6443001",
"0.64351195",
"0.6385604",
"0.6374533",
"0.6354233",... | 0.7713043 | 0 |
Finds and opens the files containing data required for the variable, Applies the reduction function to the data, and returns an MV. When completed, this will treat missing data as such. At present only CFcompliant files are supported. | def reduce( self, vid=None ):
if vid is None:
vid = self._vid
rows = self._filetable.find_files( self.variableid, time_range=self.timerange,
lat_range=self.latrange, lon_range=self.lonrange,
level_range=sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_files(self):\n if not self.unbalanced:\n if not self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()... | [
"0.5547697",
"0.51804596",
"0.51175356",
"0.50851357",
"0.49448034",
"0.49235836",
"0.49108392",
"0.49066615",
"0.49041834",
"0.4902881",
"0.48873246",
"0.48858833",
"0.48858833",
"0.48857036",
"0.48537314",
"0.47822648",
"0.47778893",
"0.4767607",
"0.47633898",
"0.4755537",
... | 0.62348145 | 0 |
Prepare the file locker. Specify the file to lock and optionally the maximum timeout and the delay between each attempt to lock. | def __init__(self, file_name, timeout=10, delay=.05):
self.is_locked = False
#self.lockfile = os.path.join(os.getcwd(), "%s.lock" % file_name)
self.lockfile = file_name + '.lock'
self.file_name = file_name
self.timeout = timeout
self.delay = delay | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, file_name, timeout=10, delay=.05):\n self.is_locked = False\n self.lockfile = os.path.abspath(file_name)\n self.file_name = file_name\n self.timeout = timeout\n self.delay = delay\n self.fd = None",
"def __init__(self, protected_file_path, timeout=None... | [
"0.7269624",
"0.6982146",
"0.69293517",
"0.67427164",
"0.6594269",
"0.6411413",
"0.6381823",
"0.63453645",
"0.63121194",
"0.63120097",
"0.62144",
"0.6043685",
"0.59835607",
"0.5917388",
"0.5861188",
"0.577998",
"0.5779113",
"0.57543266",
"0.5674176",
"0.56467295",
"0.5624611"... | 0.72758126 | 0 |
Acquire the lock, if possible. If the lock is in use, it check again every `wait` seconds. It does this until it either gets the lock or exceeds `timeout` number of seconds, in which case it throws an exception. | def acquire(self):
start_time = time.time()
import getpass
userName = getpass.getuser()
import platform
computerName = platform.uname()[1]
while True:
try:
self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def acquire(self, timeout=None): \n if self._locked:\n raise RuntimeError(\"lock already locked\")\n result = False\n timer = self.timerClass(timeout)\n timer.start()\n if ExclusiveLock.acquire(self, timeout):\n try:\n while timer.haveT... | [
"0.71883535",
"0.7154213",
"0.7148563",
"0.7108066",
"0.70570654",
"0.70437825",
"0.6900739",
"0.68663",
"0.67674184",
"0.6726042",
"0.6638591",
"0.6588066",
"0.6562686",
"0.63730717",
"0.63200384",
"0.6303491",
"0.6290304",
"0.6253313",
"0.619019",
"0.6133735",
"0.612871",
... | 0.57434064 | 43 |
Get rid of the lock by deleting the lockfile. When working in a `with` statement, this gets automatically called at the end. | def release(self):
if self.is_locked:
os.close(self.fd)
os.unlink(self.lockfile)
self.is_locked = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def release_lock():\n lock_file = get_lock_file()\n if exists(lock_file):\n LOG.info('Removing lock file %r' % lock_file)\n os.unlink(lock_file)\n else:\n LOG.warning('Lock file %r did not exist.' % lock_file)",
"def release(self):\n fcntl.flock(self.lock_file, fcntl.LOCK_UN)... | [
"0.84547544",
"0.8364578",
"0.8101169",
"0.80762964",
"0.8035398",
"0.80157477",
"0.7947669",
"0.793357",
"0.788736",
"0.78680533",
"0.78488946",
"0.78055084",
"0.77679634",
"0.7763988",
"0.7752474",
"0.7686199",
"0.7607583",
"0.75954175",
"0.7480247",
"0.7437406",
"0.7421161... | 0.7873586 | 9 |
Activated when used in the with statement. Should automatically acquire a lock to be used in the with block. | def __enter__(self):
if not self.is_locked:
self.acquire()
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __enter__(self):\n return self._lock.__enter__()",
"async def __aenter__(self):\n self.acquired = True\n return self",
"def __enter__(self):\r\n self.acquire()\r\n return self",
"def __enter__(self):\n self.acquire()\n return self",
"def __enter__(self):... | [
"0.76681423",
"0.75623655",
"0.7512478",
"0.74385935",
"0.74385935",
"0.7426379",
"0.7235537",
"0.7198601",
"0.7103257",
"0.7099194",
"0.70519584",
"0.6976629",
"0.6971899",
"0.6971899",
"0.6871852",
"0.6831314",
"0.6821339",
"0.6815241",
"0.67311513",
"0.67223877",
"0.668817... | 0.7459506 | 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.