def get(self): global gl # return gl file_id = request.args.get('id') ch1 = request.args.get('ch1') ch2 = request.args.get('ch2') transformation = request.args.get('transformation') bins = request.args.get('bins') gl = { 'server_start_ts': dt.microsecond, 'id': file_id, 'ch1': ch1, 'bins': bins, 'transformation': transformation } if not file_id or not ch1 or not ch2: file_id = 'default' ch1 = 'HDR-T' ch2 = 'FSC-A' print('PLOTTING Default FCS and chs', ch1, ch2) else: print('PLOTTING RECEIVED FCS and chs', file_id, ch1, ch2) plotting = Plotting(file_id, ch1, ch2, transformation, bins) plots = plotting.get_plots() gl.update(plots) return plots
def play(): ( controller_parameters, visual, parameters, history, ) = process_game_parameters() controllers = Controllers( parameters, history, controller_parameters, ) result = Result(parameters, history, controllers) plotting = Plotting( visual, parameters, history, controllers, result, ) animation = Animation( visual, parameters, history, controllers, plotting, result, ) animation.run()
def plotFigure(self): config = self.getConfig() plotsconfig = self.getPlotsConfig() print("plotsconfig: ", plotsconfig) annotations = self.getAnnotations() plotting = Plotting(config, plotsconfig, annotations)
def main(): settings = Settings() settings.Initalize_Global_Settings() preprocess = Preprocess(settings) preprocess.Load_Into_Dataframes() analysis = Analysis(preprocess) experiments = Experiments(analysis) data = analysis.Core(experiments) data_experimentals = experiments.Run_Experiments() models, best_fit, gals_df = analysis.Mocks_And_Models(experiments) plotting = Plotting(preprocess) plotting.Plot_Core(data, models, best_fit) plotting.Plot_Experiments(data, data_experimentals, models, best_fit)
def evaluateVideos(seqs, tag): dh = DeviceHelper() print('Using ' + str(dh.device)) cp = Checkpointer(params.checkpoint_path, dh.device) model, _ = Driver.CreateModelAndOpt(params, dh, cp) for seq_info in seqs: seq, _, _ = seq_info print('Processing ' + seq) s = SingleVideo(params.image_dir, params.pose_dir, seq_info) ds = DeviceDataset(s) output = os.path.join(params.pred_dir, tag + '_' + seq + '.npy') Driver.evalOnVideo(model, ds, output) seq_list = [x for x, _, _ in seqs] Plotting.plot(params.pose_dir, params.pred_dir, tag + '_', params.result_dir, seq_list)
def __init__(self, filename, number_of_resamples=10000): """ Initializing the Bootstrapit class executes the resampling of the imported dataset. :param filename: The filename including filepath to the import data file. :param number_of_resamples: The number of resamples to perform. """ self.number_of_resamples = number_of_resamples # import dataset from file self.__fh = FileHandling() self.original_data_dict = self.__fh.import_spreadsheet(filename) # resample dataset self.__bootstrapper = Bootstrapper(self.original_data_dict, number_of_resamples) #init bootstrap analysis tools self.__analysis = BootstrapAnalysis(self.__bootstrapper) #init plotter self.__plotter = Plotting(self.__fh.export_order)
def __init__(self, param, grid): self.list_param = [ 'modelname', 'tend', 'fixed_dt', 'dt', 'cfl', 'plot_var', 'cax', 'colorscheme', 'plot_interactive', 'fixed_dt', 'dtmax', 'freq_save', 'freq_plot' ] param.copy(self, self.list_param) self.list_grid = ['dx', 'nh', 'msk'] grid.copy(self, self.list_grid) if param.modelname == 'euler': from euler import Euler self.model = Euler(param, grid) if param.modelname == 'advection': from advection import Advection self.model = Advection(param, grid) if param.modelname == 'boussinesq': from boussinesq import Boussinesq self.model = Boussinesq(param, grid) if param.modelname == 'quasigeostrophic': from quasigeostrophic import QG self.model = QG(param, grid) self.diag = Diag(param, grid) self.plotting = Plotting(param) # here's a shortcut to the model state self.state = self.model.var.state self.t = 0. self.kt = 0 self.output = Output(param, grid, self.diag)
def phat_data(inputs, object_mass=None): vsfhs, vsfh_kws = prepare_vsfh_run(inputs) nruns = len(vsfhs) * inputs.nsfhs if nruns > 10: os.system('ipcluster start -n=%i' % inputs.nprocs) time.wait(45) calibrate.main(vsfhs, vsfh_kws=vsfh_kws) os.system('ipcluster stop') opt_files, ir_files = load_data_files(inputs) for i, vsfh in enumerate(vsfhs): if nruns < 10: if inputs.dry_run is False: res_dict = vsfh.vary_the_SFH(object_mass=object_mass, dry_run=inputs.dry_run) vsfh.write_results(res_dict) pl = Plotting(vsfh) gal_kw = {'filetype': inputs.data_ftype, 'angst': False, 'hla': False} opt_gal = rsp.Galaxy(opt_files[i], filter1='F475W', filter2='F814W', **gal_kw) ir_gal = rsp.Galaxy(ir_files[i], filter1='F110W', filter2='F160W', **gal_kw) pl.compare_to_gal(opt_gal, ir_gal, 28, 28, narratio=False, ylim=(.1, 1e5))
def main(): parser = optparse.OptionParser() parser.add_option('-i', '--in', dest="phot_class", ) parser.add_option('-a', '--aperture', dest="aperture", ) parser.add_option('-o', '--output', dest="out_plot", ) options, remainder = parser.parse_args() print 'load ', options.phot_class photometry = pickle.load(open(options.phot_class)) plot = Plotting(photometry, options.out_plot) print 'Plot noise fire' plot.plot_noise(float(options.aperture))
def set_up_all(self): """ Run at the start of each test suite. PMD prerequisites. """ self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518] self.rxfreet_values = [0, 8, 16, 32, 64, 128] self.test_cycles = [{ 'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {} }, { 'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {} }, { 'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {} }, { 'cores': '1S/2C/2T', 'Mpps': {}, 'pct': {} }, { 'cores': '1S/4C/2T', 'Mpps': {}, 'pct': {} }] self.table_header = ['Frame Size'] for test_cycle in self.test_cycles: self.table_header.append("%s Mpps" % test_cycle['cores']) self.table_header.append("% linerate") self.blacklist = "" # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports() self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[ 'ip'] + HEADER_SIZE['udp'] self.ports_socket = self.dut.get_numa_id(self.dut_ports[0]) self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic) self.pmdout = PmdOutput(self.dut)
def main(): # First initiate preprocessor and read files which takes 1 - 2 minutes preprocessing = Preprocessing( config['weather_file_path'], config['fire_data_file_path'], ['Datetime'], [ 'dt_iso', 'temp', 'pressure', 'humidity', 'wind_speed', 'wind_deg', 'rain_1h', 'rain_3h', 'snow_1h', 'snow_3h', 'clouds_all' ]) # start preprocessing preprocessing.start_preprocessing() # pass joined weather and fire data to Data class data = Data(preprocessing.joined_data) # get train test split # train data contains 2014 to 2018 years # test data contains 2019 as prediction year train_x, train_y, test_x, test_y = data.get_train_test() xgb = Model((train_x, train_y, test_x, test_y)) xgb.fit() predictions, target = xgb.make_predict() description = 'xgb model which contains previous_calls as feature. It exludes weather description feature as it was incearing feature space and was not of importance' Plot = Plotting(predictions, target, description, xgb) Plot.start_plotting()
def run(self, max_iter=100): candidates = self.generate_descendence(self.initialize_chromosomes(), self.num_nc) self.plotting(candidates) best_candidate = candidates[0] score = min(candidates[:, -1]) prev_score = np.Inf for iteration in range(0, max_iter): if prev_score > score: candidates = self.generate_descendence( self.initialize_chromosomes(), self.num_nc) self.plotting(candidates) prev_score = score score = min(candidates[:, -1]) if prev_score > score: best_candidate = candidates[0] else: print( 'Convergence at iteration {}.\nCandidate Chromosome: {}.\nScore: {}\nCenters at: {}' .format( iteration, best_candidate[0], best_candidate[2], str(''.join( ['\n\t' + str(x) for x in best_candidate[1]])))) self.plotting(best_candidate, single_cluster=True) break w, r = self.get_hyperparameters(best_candidate[0]) it_best = gk(self.data_scaled, 3, w, r) points_closet_centroid = it_best.get_points_closet_centroid( best_candidate[1]) pt.schema(points_closet_centroid, best_candidate[1], points_closet_centroid[:, -1], best_candidate)
def set_up_all(self): """ Run at the start of each test suite. L2fwd prerequisites. """ self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518] self.test_queues = [{'queues': 1, 'Mpps': {}, 'pct': {}}, {'queues': 2, 'Mpps': {}, 'pct': {}}, {'queues': 4, 'Mpps': {}, 'pct': {}}, {'queues': 8, 'Mpps': {}, 'pct': {}} ] self.core_config = "1S/4C/1T" self.number_of_ports = 2 self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE['ip'] + \ HEADER_SIZE['udp'] self.dut_ports = self.dut.get_ports_performance() self.verify(len(self.dut_ports) >= self.number_of_ports, "Not enough ports for " + self.nic) self.ports_socket = self.dut.get_numa_id(self.dut_ports[0]) # compile out = self.dut.build_dpdk_apps("./examples/l2fwd") self.verify("Error" not in out, "Compilation error") self.verify("No such" not in out, "Compilation error") self.table_header = ['Frame'] for queue in self.test_queues: self.table_header.append("%d queues Mpps" % queue['queues']) self.table_header.append("% linerate") dts.results_table_add_header(self.table_header) self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic)
def main(): m = 5 use_cache = os.path.isfile( train_data_bow_file_name) and os.path.isfile( test_data_bow_file_name) and os.path.isfile( train_data_word2vec_file_name) and os.path.isfile( test_data_word2vec_file_name) print("Preparing data with min_occurrences=" + str(m)) training_data, word2vec_training_data, testing_data, word2vec_testing_data = preprare_data( m, use_cache, duration=None) log("********************************************************") log("Validating for {0} min_occurrences:".format(m)) if use_cache: col_names = [ "author", "title", "timestamp_ms", "summary", "sentiment", "sentiment_score" ] data = DataInitializer() data.initialize("data/clean_train_with_sentiments.csv", col_names=col_names) print("printing head:\n*******************************\n") data.processed_data = data.processed_data.reset_index(drop=True) # data.processed_data.rename(columns={"author": "timestamp_ms", "timestamp_ms", "summary"}) print(data.processed_data.head()) original_data = data.processed_data data.data_model = pd.read_csv(train_data_bow_file_name) data.wordlist = pd.read_csv("data/wordlist.csv") data = Plotting(data) data.plot() """ Naive Bayes """ print("***************************************************\n" "FOR NAIVE BAYES:\n" "***************************************************\n") print("testing_data shape: ", testing_data.shape) print("testing_data head: ", testing_data.head()) X_train, X_test, y_train, y_test = train_test_split( training_data.iloc[:, 1:], training_data.iloc[:, 0], train_size=0.7, stratify=training_data.iloc[:, 0], random_state=seed) if use_test_data: X_train = training_data.iloc[:, 1:] y_train = training_data.iloc[:, 0] X_test = testing_data.iloc[:, 1:] y_test = testing_data.iloc[:, 0] precision, recall, accuracy, f1 = Classification.test_classifier( X_train, y_train, X_test, y_test, BernoulliNB()) # nb_acc = Classification.cv(BernoulliNB(), training_data.iloc[:, 1:], training_data.iloc[:, 0]) """ Random Forest """ print("***************************************************\n" "FOR RANDOM FORESTS:\n" "***************************************************\n") X_train, X_test, y_train, y_test = train_test_split( training_data.iloc[:, 1:], training_data.iloc[:, 0], train_size=0.7, stratify=training_data.iloc[:, 0], random_state=seed) if use_test_data: X_train = training_data.iloc[:, 1:] y_train = training_data.iloc[:, 0] X_test = testing_data.iloc[:, 1:] y_test = testing_data.iloc[:, 0] precision, recall, accuracy, f1 = Classification.test_classifier( X_train, y_train, X_test, y_test, RandomForestClassifier(random_state=seed, n_estimators=403, n_jobs=-1)) # rf_acc = Classification.cv(RandomForestClassifier(n_estimators=403, n_jobs=-1, random_state=seed), training_data.iloc[:, 1:], # training_data.iloc[:, 0]) """ Word2Vec + Random Forest """ print("***************************************************\n" "FOR WORD2VEC WITH RANDOM FORESTS:\n" "***************************************************\n") X_train, X_test, y_train, y_test = train_test_split( word2vec_training_data.iloc[:, 2:], word2vec_training_data.iloc[:, 1], train_size=0.7, stratify=word2vec_training_data.iloc[:, 1], random_state=seed) # word2vec_training_data.drop(columns=['index'], inplace=True) # word2vec_testing_data.drop(columns=['index'], inplace=True) print("word2vec_training_data.columns: ", word2vec_training_data.columns) if use_test_data: X_train = word2vec_training_data.iloc[:, 3:] y_train = word2vec_training_data.iloc[:, 1] X_test = word2vec_testing_data.iloc[:, 3:] y_test = word2vec_testing_data.iloc[:, 1] precision, recall, accuracy, f1 = Classification.test_classifier( X_train, y_train, X_test, y_test, RandomForestClassifier(n_estimators=403, n_jobs=-1, random_state=seed)) print("***************************\n") print("For Regression\n") print("***************************\n") print("first five rows: ", word2vec_training_data.head()) X_train = word2vec_training_data.iloc[:, 4:] y_train = word2vec_training_data.iloc[:, 3] X_test = word2vec_testing_data.iloc[:, 4:] y_test = word2vec_testing_data.iloc[:, 3] regr = RandomForestRegressor(max_depth=2, random_state=0) regr.fit(X_train, y_train) # print(regr.feature_importances_) # print(regr.predict([[0, 0, 0, 0]])) predictions = regr.predict(X_test) print("predictions:\n*****************************", predictions, "\n****************************\n") print("Real values:\n*****************************", y_test, "\n****************************\n") print("score: ", regr.score(X_test, y_test)) redditposts_sentiment = pd.DataFrame() # Create a column from the datetime variable redditposts_sentiment['datetime'] = word2vec_testing_data[ "timestamp_ms"] redditposts_sentiment['sentiment_score'] = predictions # Convert that column into a datetime datatype redditposts_sentiment['datetime'] = pd.to_datetime( redditposts_sentiment['datetime']) # Set the datetime column as the index redditposts_sentiment.index = redditposts_sentiment['datetime'] reddit_posts = [ Scatter(x=redditposts_sentiment.resample('5Min').mean().index, y=redditposts_sentiment.resample('5Min').mean() ["sentiment_score"], mode="lines") ] plotly.offline.plot( { "data": reddit_posts, "layout": graph_objs.Layout(title="Reddit posts sentiment") }, filename='plots/redditposts_predicted_sentiment.html') print("***************************************************\n" "FOR KERAS:\n" "***************************************************\n") X_train, X_test, y_train, y_test = train_test_split( word2vec_training_data.iloc[:, 2:], word2vec_training_data.iloc[:, 1], train_size=0.7, stratify=word2vec_training_data.iloc[:, 1], random_state=seed) # word2vec_training_data.drop(columns=['index'], inplace=True) # word2vec_testing_data.drop(columns=['index'], inplace=True) print("word2vec_training_data.columns: ", word2vec_training_data.columns) if use_test_data: X_train = word2vec_training_data.iloc[:, 3:] y_train = word2vec_training_data.iloc[:, 1] X_test = word2vec_testing_data.iloc[:, 3:] y_test = word2vec_testing_data.iloc[:, 1] # params use_gpu = True config = tf.ConfigProto( intra_op_parallelism_threads=multiprocessing.cpu_count(), inter_op_parallelism_threads=multiprocessing.cpu_count(), allow_soft_placement=True, device_count={ 'CPU': 1, 'GPU': 1 if use_gpu else 0 }) session = tf.Session(config=config) K.set_session(session) model_location = './data/model/' # Keras convolutional model batch_size = 32 nb_epochs = 10 vector_size = 200 # Tweet max length (number of tokens) max_tweet_length = 15 print("X_train shape:", X_train.shape) print("Y_train shape:", y_train.shape) print("x_test shape:", X_test.shape) print("y_test shape:", y_test.shape) model = Sequential() model = Sequential() model.add(Dense(32, activation='relu', input_dim=204)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) # Fit the model model.fit(X_train, y_train, batch_size=batch_size, shuffle=True, epochs=nb_epochs, validation_data=(X_test, y_test), callbacks=[EarlyStopping(min_delta=0.00025, patience=2)]) score = model.evaluate(X_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) # Save the model # serialize model to JSON model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 model.save_weights("model.h5") print("Saved model to disk") print("****************************\n") print("Building a Neural Network\n") print("****************************\n") with open('sequences', 'rb') as fp: sequences = pickle.load(fp) with open('sentiments', 'rb') as fp: sentiments = pickle.load(fp) EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto') model = Sequential() model.add(Embedding(20000, 128, input_length=200)) model.add(Dropout(0.2)) model.add(Conv1D(64, 5, activation='relu')) model.add(MaxPooling1D(pool_size=4)) model.add(LSTM(128)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(sequences, np.array(sentiments), validation_split=0.5, epochs=10)
def pl_bokeh_js2(): bkh = Plotting(database_name) rend2 = bkh.bokeh_plot(1, 5) return json.dumps(json_item(rend2))
def pl_bokeh_js(): bkh = Plotting(database_name) rend1 = bkh.bokeh_plot(1, 4) return json.dumps(json_item(rend1))
def sweep_maxGain(log, f1, f2, nums, rstart, angle, rstop, tpolar, cpolar, spos=spos_default): # -------------------------------------------------------------------------- # Reset motor positions # motorSet[STAND_ROTATION].goto_zero() if spos: # Stand translation motorSet[S_TRANSLATION].rot_deg(STAND_OFFSET) set_polarization(log, motorSet, tpolar, cpolar, mycursor) # # End reset motor positions # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Move test antenna to start degree position # log.info("Start Position: " + str(rstart)) motorSet[M1].rot_deg(rstart) log.info("Motor setup complete") # # End move test antenna to start position # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Load state # analyzer.load_state() # # End load state # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Set network analyzer parameters # channel = 1 trace = 1 analyzer.setup(channel, trace) # analyzer.enable_display(False) # Set start frequency start = float(analyzer.set_start(channel, f1)) if f1 != start: msg = "WARNING: Invalid start frequency, using " + str(start) print(msg) log.warning(msg) # f1_old = f1 f1 = start # Set stop frequency stop = float(analyzer.set_stop(channel, f2)) if f2 != stop: msg = "WARNING: Invalid stop frequency, using " + str(stop) print(msg) log.warning(msg) # f2_old = f2 f2 = stop # Set number of points points = int(analyzer.set_points(channel, nums)) if nums != points: msg = "WARNING: Invalid number of steps, using " + str(points) print(msg) log.warning(msg) # nums_old = nums nums = points # Create csv files # d = datetime.today() # file_name = os.path.join(DATA_PATH, d.strftime("%Y%m%d%H%M%S")) # s21_filename = file_name + "_s21.csv" s21_filename = os.path.join(DATA_PATH, "S21.csv") s21File = open(s21_filename, "w") # # End set network analyzer parameters # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Check for network analyzer errors log.info("Checking network analyzer error queue") err_nums, err_msgs = analyzer.get_errors() if len(err_nums) > 0: msg = "Error in setting network analyzer parameters" print(msg) log.warning(msg) else: # No errors log.info("No network analyzer errors detected") # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Complete frequency sweep # log.info("Measuring S21") print("Starting S21 Measurement") print("Start Frequency: " + str(f1 / 1e9) + " GHz") print("Stop Frequency: " + str(f2 / 1e9) + " GHz") print("Number of Points: " + str(nums)) analyzer.set_measurement(channel, trace, 2, 1) analyzer.trigger() analyzer.update_display() analyzer.auto_scale(channel, trace) # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Retrieve and store data # # If first position, get frequency data s21Freq = analyzer.get_x(channel) s21File.write(s21Freq) # Get s21 data and write to file s21Data = analyzer.get_corr_data(channel) # s21Data = analyzer.get_form_data(channel) s21File.write(s21Data) # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Reset motor positions to zero index # motorSet[STAND_ROTATION].goto_zero() if spos: # Stand translation motorSet[S_TRANSLATION].rot_deg(-STAND_OFFSET) # # End reset motor positions # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Close csv files # s21File.close() # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Update database # if db.is_connected(): fstart = f1 / 1e9 fstop = f2 / 1e9 rowcount = mycursor.rowcount # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Antenna polarization # log.info("Updating tpolar and cpolar in sql database") update_config_db(log, mycursor, tpolar, "'antenna_polarization'") update_config_db(log, mycursor, cpolar, "'chamber_polarization'") # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Network analyzer parameters # log.info("Updating fstart, fstop, and nums in sql database") update_config_db(log, mycursor, fstart, "'frequency_start'") update_config_db(log, mycursor, fstop, "'frequency_stop'") update_config_db(log, mycursor, nums, "'num_steps'") # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Commit changes log.info("Committing changes") db.commit() if rowcount == mycursor.rowcount: log.warning("Failed to store updated antenna polarization data") # # End update database # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Call normalization function, plot data, and write zip # log.info("Normalized data written to file: " + S21Normalize(os.path.basename(s21_filename), maxGain=True)) Plotting(f1, f2, nums, rstart, angle, rstop, 0, 0, 0, 0, 0, 0, "maxGain") # # End normalization # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Check for network analyzer errors log.info("Checking network analyzer error queue") err_nums, err_msgs = analyzer.get_errors() if len(err_nums) > 0: msg = "Error measuring S21" print(msg) log.warning(msg) else: # No errors msg = "S21 Measurement Successful" print(msg) log.info(msg)
def __init__(self, hist_path: str, varname="b", video_path=None, visible=True): """Open the history file and load parts of it.""" # Initialize self.hist_file to prevent the destructor from failing self.hist_file = None self.tracers = False # Set parameters needed for Plotting that cannot be determined # so far; maybe make them command line arguments in the future param = { "figsize": (RESOLUTION[0] / DPI, RESOLUTION[1] / DPI), "aspect": "equal", "rotation_speed": 3, } if varname == "b": param["style"] = "b-interface" param["stable_stratification"] = True # TODO make this a command line argument elif varname == "t0": # This option is to plot only the first tracer and also a # shorter notation in the common case with only one tracer param["style"] = "tracer" param["n_tracers"] = 1 elif varname == "tracer": param["style"] = "tracer" self.tracers = True else: raise NotImplementedError("The given variable is not yet supported.") # Save necessary arguments self.video_path = video_path self.visible = visible # Create the metadata for the video if self.video_path: # Extract the name of the experiment exp_name = os.path.basename( hist_path[:-8] if hist_path.endswith("_hist.nc") else hist_path ) self.metadata = { "title": "Nyles experiment {}".format(exp_name), "artist": CREATOR, "genre": "Computational Fluid Dynamics (CFD)", "comment": "Created on {} with Nyles. Nyles is a Large Eddy " "Simulation written in Python. For more information" " visit https://github.com/pvthinker/Nyles." .format(time.strftime('%d %b %Y')), "date": time.strftime("%Y-%m-%d"), } # Open the history file and keep it open to allow sequential reading print("Loading history file {!r}:".format(hist_path)) self.hist_file = nc.Dataset(hist_path) print(self.hist_file) # Load the needed data if self.tracers: param["n_tracers"] = self.hist_file.n_tracers self.tracers_data = [ self.hist_file["t{}".format(i)] for i in range(self.hist_file.n_tracers) ] else: self.vardata = self.hist_file[varname] self.t = self.hist_file["t"] self.n = self.hist_file["n"] self.n_frames = self.n.size # Load parameters needed for Grid param["Lx"] = self.hist_file.Lx param["Ly"] = self.hist_file.Ly param["Lz"] = self.hist_file.Lz param["nx"] = self.hist_file.global_nx param["ny"] = self.hist_file.global_ny param["nz"] = self.hist_file.global_nz # Set parameters needed for Scalar param["nh"] = 0 param["neighbours"] = {} grid = Grid(param) # Create one or several Scalar variables as an interface for # passing data to the plotting module. Note: Scalar takes # actually a dimension instead of a unit, but that does not # matter because this information is not processed here. if self.tracers: tracer_list = [] self.arrays = [] for data in self.tracers_data: tracer = Scalar(param, data.long_name, data.name, data.units) tracer_list.append(tracer) self.arrays.append(tracer.view("i")) state = State(tracer_list) else: scalar = Scalar(param, self.vardata.long_name, varname, self.vardata.units) self.array = scalar.view("i") state = State([scalar]) self.p = Plotting(param, state, grid)
class Bootstrapit: """ The Bootstrapit class builds the API for the Bootstrapit application. The Methods inside this class can directly be used to interact with the application. """ def __init__(self, filename, number_of_resamples=10000): """ Initializing the Bootstrapit class executes the resampling of the imported dataset. :param filename: The filename including filepath to the import data file. :param number_of_resamples: The number of resamples to perform. """ self.number_of_resamples = number_of_resamples # import dataset from file self.__fh = FileHandling() self.original_data_dict = self.__fh.import_spreadsheet(filename) # resample dataset self.__bootstrapper = Bootstrapper(self.original_data_dict, number_of_resamples) #init bootstrap analysis tools self.__analysis = BootstrapAnalysis(self.__bootstrapper) #init plotter self.__plotter = Plotting(self.__fh.export_order) # TODO: Export bootstrapped data array to json or excel def export(self, *export_datasets_dicts, filename="bootstrapit_results.xlsx"): """ The export method does merge all data analysis result dictionaries and exports them using the FileHandler class. :param export_datasets_dicts: All result dictionaries from the bootstrapping analysis. :param filename: the export filename. """ merged_dict = self.__merge_dicts(*export_datasets_dicts) filetype_check = filename.split('.') filetype = filetype_check[-1] filename = filetype_check[0] if filetype == "xlsx": self.__fh.file_type = FileType.XLSX elif filetype == "xls": self.__fh.file_type = FileType.XLS elif filetype == "csv": self.__fh.file_type = FileType.CSV else: print("Error: Unsupported file type.") self.__fh.file_name = filename self.__fh.export(merged_dict) def __merge_dicts(self, *dict_args): """ Helper method to merge multiple result dictionaries. :param dict_args: List of dictionaries :return: The merged dictionary containing all results of the analysis. """ result = {} for dictionary in dict_args: result.update(dictionary) return result def mean(self): return self.__analysis.get_bootstrapped_mean() def median(self): return self.__analysis.get_bootstrapped_median() def SEM(self): return self.__analysis.get_SEM() def barchart(self, figure, data_dict, errorbar = {}): return self.__plotter.plot_barchart(figure, data_dict, errorbar) def set_axis_label(self, axes, title, xlabel, ylabel): self.__plotter.set_axis_labels(axes, title, xlabel, ylabel)
def test(): bytes_in_terabyte = 1099511627776 scrub_fraction = 1 sector_size = 512 num_sectors_per_disk = (585937500) * 1 num_tb_per_disk = mpf(sector_size * num_sectors_per_disk) / bytes_in_terabyte sector_error_rate = 4.096e-11 sector_writes_per_disk_per_hr = mpf(143750) / 24 writes_to_sector_per_hour = 0.0045 low_scrub = 168 high_scrub = 169 scrub_incr = 12 print writes_to_sector_per_hour x = [] y = [] dp = DataPoints() for i in range(low_scrub, high_scrub, scrub_incr): ssfm = RandomScrubSectorFailModel(num_sectors_per_disk, scrub_fraction*num_sectors_per_disk, i, sector_error_rate, writes_to_sector_per_hour, 1) #x.append(ssfm.disk_scrub_period) x.append(i) y.append(ssfm.prob_of_bad_sector(i)) dp.addDataSet(x,y,"Random Scrub Model") x = [] y = [] for i in range(low_scrub, high_scrub, scrub_incr): dsfm = DeterministicScrubSectorFailModel(num_sectors_per_disk, scrub_fraction*num_sectors_per_disk, i, sector_error_rate, writes_to_sector_per_hour, 1) #x.append(ssfm.disk_scrub_period) x.append(i) y.append(dsfm.prob_of_bad_sector(i)) print "Scrub", i, dsfm.prob_of_bad_sector(i) dp.addDataSet(x,y,"Deterministic Scrub Model") x = [] y = [] for i in range(low_scrub, high_scrub, scrub_incr): berfm = BERSectorFailModel(num_sectors_per_disk, scrub_fraction*num_sectors_per_disk, i, sector_error_rate, writes_to_sector_per_hour, 1) #x.append(ssfm.disk_scrub_period) x.append(i) y.append(berfm.prob_of_bad_sector()) print "BER", i, berfm.prob_of_bad_sector() dp.addDataSet(x,y,"BER Model") x = [] y = [] for i in range(low_scrub, high_scrub, scrub_incr): nsfm = NoScrubSectorFailModel(num_sectors_per_disk, scrub_fraction*num_sectors_per_disk, i, sector_error_rate, writes_to_sector_per_hour, 1) #x.append(ssfm.disk_scrub_period) x.append(i) y.append(nsfm.prob_of_bad_sector()) dp.addDataSet(x,y,"No Scrub Model") pl = Plotting(dp, "graphs/sector_fail_write_%.1f.%.3f.pdf" % (num_tb_per_disk, scrub_fraction), "Comparison of Sector Failure Models \n for %.1f TB Disk (Region %d Perc.)" % (num_tb_per_disk, 100*scrub_fraction), "Scrub Interval (hours)", "Probability of Sector Failure", type=Plotting.YLOG, legend_loc=2) pl.plot()
for i in range(len(channels_array)): id_chan = str(channels_array[i]) print("Processing channel: "+id_chan) series = Series(np.array(df[id_chan])) egxog = None if(is_egxog): egxog = df.drop([id_chan], axis=1, inplace=True, errors='ignore') model = SarimaModel([(0, 0, 0), (0, 0, 0, 10080), "n"]) rmse = model.evaluate_model(series, egxog, group_size) print(rmse) db.save_result(int(Method_type.Sarima_10080), int( Granulation.minute), id_chan, rmse) db = Database() plotting = Plotting() channels = db.get_channels() channels_array = np.array(channels["id_chan"]) df_grp_hours = db.get_grp_aggregated_hourly('1,2,3,4,5,6,7') df_grp_minute = db.get_grp_none_aggregated('1,2,3,4,5,6,7') group_size = 10080 create_series_plots(df_grp_hours, channels_array, True) create_acf_and_pacf_plots(df_grp_hours, channels_array, True) # for i in range(len(channels_array)): # id_chan = str(channels_array[i]) # series = Series(array(df_grp_hours[id_chan])) # test_stationarity(series, id_chan) run_sarima(df_grp_minute, channels_array, is_egxog=True)
def main(params): """This is the main loop which is repeated every timestep. Currently, this follows the Update Strain Last paradigm (does it?!?). :param mode: The name of the input file to use. :type mode: str :returns: int -- The return code. """ P, G, L = initialise.get_parameters(params) plot = Plotting() # if P.O.plot_material_points: plot.draw_material_points(L,P,G,'initial') while P.t <= P.t_f: # Time march G.wipe(P) # Discard previous grid P.update_forces() # update time dependent gravity L.update_forces(P, G) # pass body forces to material points L.get_reference_node(P, G) # Find node down and left L.get_basis_functions(P, G) # Make basis functions if P.O.check_positions: L.recover_position(P, G) # check basis functions L.get_nodal_mass_momentum(P, G) # Initialise from grid state if P.B.cyclic_lr: # G.apply_cyclic_BCs(P) G.make_cyclic(P, G, ['m', 'q']) L.update_stress_strain(P, G) # Update stress and strain L.get_nodal_forces(P, G) # Compute internal and external forces G.BCs(P) # Add external forces from BCs G.update_momentum(P) # Compute rate of momentum and update nodes G.calculate_gammadot(P, G) if P.segregate_grid: G.calculate_grad_gammadot(P, G) G.calculate_phi_increment(P) L.move_grainsize_on_grid(P, G) L.move_material_points( P, G) # Update material points (position and velocity) # Move/Remove any particles that have left the grid if P.B.outlet_left: L.outlet_left(P, G) if P.B.outlet_bottom: L.outlet_bottom(P, G) if P.B.inlet_right: L.inlet_right(P, G) if P.B.cyclic_lr: L.cyclic_lr(P, G) # Output related things if P.O.measure_energy: P.O.energy[P.tstep] = L.measure_elastic_energy(P, G) # measure energy print('{0:.4f}'.format(P.t * 100. / P.t_f) + '% Complete, t = ' + '{0:.4f}'.format(P.t) + ', g = ' + str(P.g), end='\r') if P.t % P.savetime < P.dt: if P.O.plot_gsd_mp: plot.draw_gsd_mp(L, P, G) if P.O.plot_gsd_grid: plot.draw_gsd_grid(L, P, G) # plot.draw_voronoi(P,G) if P.O.plot_continuum: plot.draw_continuum(G, P) if P.O.plot_material_points: plot.draw_material_points(L, P, G) if P.mode == 'anisotropy': plot.draw_gamma_dot(L, P, G) if P.O.measure_energy: P.O.measure_E(P, L) if P.O.save_u: plot.save_u(L, P, G) if P.O.save_s_bar: plot.save_s_bar(L, P, G) if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.store_p_q(P, G, L, P.tstep) if P.mode == 'pouliquen_unit_test': P.O.store_mu(P, G, L, P.tstep) # Increment time P.t += P.dt P.tstep += 1 # for p in range(P.phases): # if (P.S[p].law is 'von_mises' or P.S[p].law is 'dp') and not P.has_yielded: # if P.S[p].law is 'von_mises' and not P.has_yielded: # L.update_timestep(P) # Check for yielding and reduce timestep # Final things to do if P.O.plot_material_points: plot.draw_material_points(L, P, G, 'final') if P.O.measure_stiffness: P.O.measure_E(P, L) if P.O.measure_energy: plot.draw_energy(P) if P.O.plot_gsd_mp: plot.draw_gsd_mp(L, P, G) if P.O.plot_gsd_grid: plot.draw_gsd_grid(L, P, G) if P.O.save_u: plot.save_u(L, P, G) if P.O.save_s_bar: plot.save_s_bar(L, P, G) if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.draw_p_q(P, G, L, plot, P.tstep) if P.mode == 'pouliquen_unit_test': P.O.draw_mu(P, G, L, plot, P.tstep) print('') return 0
flux = P.c * f_c * g - P.D * dCdx flux[boundary] = 0 return flux #, boundary def increment_grainsize(P, G): return KT(P, G, 0) + KT(P, G, 1) # return NT(P,G,0) + NT(P,G,1) if __name__ == "__main__": import initialise from numpy import random, maximum, ones from plotting import Plotting plot = Plotting() P, G, L = initialise.get_parameters(['bi_seg_test', '22', '2']) G.wipe(P) L.get_reference_node(P, G) # Find node down and left L.get_basis_functions(P, G) # Make basis functions L.get_nodal_mass_momentum(P, G) # Initialise from grid state plot.draw_gsd_grid(L, P, G) G.grad_gammadot = -1. * ones([P.G.ny * P.G.nx, 3]) # G.grad_gammadot[:,1] = 0 # P.dt *= 10 # G.phi = zeros_like(G.phi) # G.phi[40:120,0] = 0.5 # G.phi[:,1] = 1- G.phi[:,0] # G.phi[40:100,1] = 0 # P.c *= 100
def main(params): """This is the main loop which is repeated every timestep. Currently, this follows the Update Strain Last paradigm (does it?!?). :param mode: The name of the input file to use. :type mode: str :returns: int -- The return code. """ P,G,L = initialise.get_parameters(params) plot = Plotting() # if P.O.plot_material_points: plot.draw_material_points(L,P,G,'initial') while P.t <= P.t_f:# Time march G.wipe(P) # Discard previous grid P.update_forces() # update time dependent gravity L.update_forces(P,G) # pass body forces to material points L.get_reference_node(P,G) # Find node down and left L.get_basis_functions(P,G) # Make basis functions if P.O.check_positions: L.recover_position(P,G) # check basis functions L.get_nodal_mass_momentum(P,G) # Initialise from grid state if P.B.cyclic_lr: G.make_cyclic(P,G,['m','q']) L.update_stress_strain(P,G) # Update stress and strain L.get_nodal_forces(P,G) # Compute internal and external forces G.BCs(P) # Add external forces from BCs G.update_momentum(P) # Compute rate of momentum and update nodes G.calculate_gammadot(P,G) if P.segregate_grid: G.update_pk(P,G) # NOTE: THIS IS BRAND NEW AND PROBABLY BROKEN #if P.B.cyclic_lr: G.make_cyclic(P,G,['phi','pk','s_bar']) # if P.B.cyclic_lr: G.make_cyclic(P,G,['pk']) # G.calculate_grad_gammadot(P,G) G.calculate_phi_increment(P) L.move_grainsize_on_grid(P,G) G.make_cyclic(P,G,['eta','dphi']) L.move_material_points(P,G) # Update material points (position and velocity) # Move/Remove any particles that have left the grid if P.B.outlet_left: L.outlet_left(P,G) if P.B.outlet_bottom: L.outlet_bottom(P,G) if P.B.inlet_right: L.inlet_right(P,G) if P.B.inlet_top: L.inlet_top(P,G) if P.B.cyclic_lr: L.cyclic_lr(P,G) # Output related things if P.O.measure_energy: P.O.energy[P.tstep] = L.measure_elastic_energy(P,G) # measure energy print('{0:.4f}'.format(P.t*100./P.t_f) + '% Complete, t = ' + '{0:.4f}'.format(P.t) + ', g = ' + str(P.g), end='\r') if P.t%P.savetime < P.dt: if P.O.plot_gsd_mp: plot.draw_gsd_mp(L,P,G) if P.O.plot_gsd_grid: plot.draw_gsd_grid(L,P,G) # plot.draw_voronoi(P,G) if P.O.plot_continuum: plot.draw_continuum(G,P) if P.O.plot_material_points: plot.draw_material_points(L,P,G) if P.mode == 'anisotropy': plot.draw_gamma_dot(L,P,G) if P.O.measure_energy: P.O.measure_E(L,P,G) # for [field,fieldname] in P.O.save_fields: P.O.save_field(L,P,G,field,fieldname) if P.O.save_u: plot.save_u(L,P,G) if P.O.save_s_bar: plot.save_s_bar(L,P,G) if P.O.save_density: plot.save_density(L,P,G) if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.store_p_q(P,G,L,P.tstep) if P.mode == 'pouliquen_unit_test': P.O.store_mu(P,G,L,P.tstep) # Increment time P.t += P.dt P.tstep += 1 if P.time_stepping == 'dynamic': P.update_timestep(P,G) # for p in range(P.phases): # if (P.S[p].law is 'von_mises' or P.S[p].law is 'dp') and not P.has_yielded: # if P.S[p].law is 'von_mises' and not P.has_yielded: # L.update_timestep(P) # Check for yielding and reduce timestep # Final things to do if P.O.plot_material_points: plot.draw_material_points(L,P,G,'final') if P.O.measure_stiffness: P.O.measure_E(L,P,G) if P.O.measure_energy: plot.draw_energy(P) if P.O.plot_gsd_mp: plot.draw_gsd_mp(L,P,G) if P.O.plot_gsd_grid: plot.draw_gsd_grid(L,P,G) if P.O.save_u: plot.save_u(L,P,G) if P.O.save_s_bar: plot.save_s_bar(L,P,G) if P.O.save_density: plot.save_density(L,P,G) if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.draw_p_q(P,G,L,plot,P.tstep) if P.mode == 'pouliquen_unit_test': P.O.draw_mu(P,G,L,plot,P.tstep) print('') return 0
sys.stdout.flush() # Logger logfile_path = '/home/pi/mu_code/monitoraggio_MP/new_files/monitoring_data/monitoring.log' logging.basicConfig(filename=logfile_path, filemode='w', level=logging.INFO) # Data Sampling Time # 10 min -> 600000 ms data_sampling_time = 1000 # ms # Graphical Sampling Time plot_sampling_time = 2.5 * data_sampling_time # ms # filename save = True #filename = '/home/pi/mu_code/monitoring_file.csv' if __name__ == '__main__': pm_sens = PMsensor(connect=True, logfile_path=logfile_path) data_manage = DataManagement(save=save, sensor=pm_sens, sampling_interval=data_sampling_time, logfile_path=logfile_path) plot = Plotting(sensor=pm_sens, update_time=plot_sampling_time) data_manage.start_measurement() plot.start_animation() # Buon divetimento Pablito! # Seba
def preprocess(data_path, is_testing, min_occurrences=5, cache_bow_output=None, cache_word2vec_output=None, duration=None): if duration: data = DataInitializer() data.initialize(data_path, is_testing, duration=duration) else: data = DataInitializer() data.initialize(data_path, is_testing) if os.path.isfile("data/BTC.csv"): prices_data = GetPricesData() prices_data.main() data = DataCleaning(data, is_testing) data.cleanup(DataCleaner(is_testing)) if is_testing: print("Testing data shape:", data.processed_data.shape) else: print("Training data shape:", data.processed_data.shape) data = Sentiments(data) data.sentiment_analysis_by_text() print("First five rows with sentiment: ", data.processed_data.head()) if is_testing: data.processed_data.to_csv("data/clean_test_with_sentiments.csv", sep=',', encoding='utf-8', index=False) # os.remove(data_path) else: data.processed_data.to_csv("data/clean_train_with_sentiments.csv", sep=',', encoding='utf-8', index=False) # os.remove(data_path) data = DataTokenize(data) data.tokenize() data.stem() data = WordList(data) data.build_wordlist(min_occurrences=min_occurrences) word2vec_data = data data = BagOfWords(data.processed_data, data.wordlist, is_testing) data.build_data_model() print("data model head: ", data.data_model.head(5)) """ Word 2 vec """ word2vec = Word2VecProvider() # REPLACE PATH TO THE FILE word2vec.load("../twitter/data/glove.twitter.27B.200d.txt") word2vec_data = RedditData(word2vec_data) word2vec_data.build_final_model(word2vec) word2vec_data_model = word2vec_data.data_model if "index" in word2vec_data_model.columns: word2vec_data_model.drop("index", axis=1, inplace=True) word2vec_data_model.dropna(axis=0, inplace=True) word2vec_data_model.reset_index(inplace=True) word2vec_data_model.index = word2vec_data_model['timestamp_ms'] print("final word2vec data model: \n", word2vec_data_model.head(), "\n") """ Tokenizing the data """ texts = [] sentiments = [] tokenized_data = pd.DataFrame() for text in data.processed_data["summary"]: texts.append(text) for sentiment in data.processed_data["sentiment"]: sentiments.append(sentiment) print("texts: ", texts[0:5]) tokenizer = Tokenizer(num_words=20000) tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts) padded_sequences = pad_sequences(sequences, maxlen=200) print( "\n\n##################################################\npadded sequence head: \n", padded_sequences[0:5]) print( "\n####################################################\n padded sequence length \n", len(padded_sequences)) if not is_testing: data = Plotting(data) data.plot() if cache_bow_output is not None: data.data_model.to_csv(cache_bow_output, index=False, float_format="%.6f") word2vec_data_model.to_csv(cache_word2vec_output, index=False, float_format="%.6f") with open('sequences', 'wb') as fp: pickle.dump(padded_sequences, fp) with open('sentiments', 'wb') as fp: pickle.dump(sentiments, fp) return data.data_model, word2vec_data_model
class Fluid2d(Param): def __init__(self, param, grid): self.list_param = [ 'modelname', 'tend', 'fixed_dt', 'dt', 'cfl', 'plot_var', 'cax', 'colorscheme', 'plot_interactive', 'fixed_dt', 'dtmax', 'freq_save', 'freq_plot' ] param.copy(self, self.list_param) self.list_grid = ['dx', 'nh', 'msk'] grid.copy(self, self.list_grid) if param.modelname == 'euler': from euler import Euler self.model = Euler(param, grid) if param.modelname == 'advection': from advection import Advection self.model = Advection(param, grid) if param.modelname == 'boussinesq': from boussinesq import Boussinesq self.model = Boussinesq(param, grid) if param.modelname == 'quasigeostrophic': from quasigeostrophic import QG self.model = QG(param, grid) self.diag = Diag(param, grid) self.plotting = Plotting(param) # here's a shortcut to the model state self.state = self.model.var.state self.t = 0. self.kt = 0 self.output = Output(param, grid, self.diag) def update_fig(self, *args): self.diag.integrals(self.model.var) # print(self.diag.ke) self.set_dt() self.model.step(self.t, self.dt) self.kt += 1 self.t = self.t + self.dt # print(self.t,self.dt) if (self.kt % self.freq_plot) == 0: #self.plot_freq)==0: self.z2d[self.plotting_msk == 0] = 0. # self.cax=self.get_cax(self.z2d) self.set_cax(self.z2d) self.im.set_array(self.z2d) self.im.set_clim(vmin=self.cax[0], vmax=self.cax[1]) #self.output.do(self.model.var.state,self.diag,self.t,self.kt) return self.im, def update_fig2(self, *args): self.diag.integrals(self.model.var) # print(self.diag.ke) self.set_dt() self.model.step(self.t, self.dt) self.kt += 1 self.t = self.t + self.dt # print(self.t,self.dt) if (self.kt % self.freq_plot) == 0: #self.plot_freq)==0: self.z2d[self.plotting_msk == 0] = 0. self.set_cax(self.z2d) self.im.set_array(self.z2d) self.im.set_clim(vmin=self.cax[0], vmax=self.cax[1]) self.output.do(self.model.var.state, self.diag, self.t, self.kt) self.ti.label = '%f4.2' % self.t #print(self.ti.label) return self.im, self.ti, def loop(self): nh = self.nh self.plotting_msk = self.msk[nh:-nh, nh:-nh] self.z2d = self.model.var.get(self.plot_var)[nh:-nh, nh:-nh] import matplotlib.pyplot as plt import matplotlib.animation as animation if not (self.plot_interactive): fig = plt.figure() self.ti = plt.title('') self.ti.animated = True self.im = plt.imshow(self.z2d, vmin=self.cax[0], vmax=self.cax[1], cmap=plt.get_cmap('jet'), origin='lower', interpolation='nearest') plt.colorbar() ani = animation.FuncAnimation(fig, self.update_fig, interval=0.0000001, blit=True) plt.show() self.plotting.set_im(self.z2d, self.plotting_msk, self.cax, ani=True, update=self.update_fig) else: self.diag.integrals(self.model.var) time_str = 'time = %-6.2f' fig = plt.figure(figsize=(10, 8)) ax1 = fig.add_subplot(1, 1, 1) ax1.cla() ax1.hold(True) ax1.set_title(time_str % self.t) ax1.set_xlabel('X') ax1.set_ylabel('Y') # ax2 = fig.add_subplot(1, 2, 2) # ax2.cla() # ax2.hold(True) # ax2.set_title( 'integral quantities') # ax2.set_xlabel('t') # ax2.set_ylabel('Ke') def on_press(event): print('stop') if self.ion: plt.ioff() else: plt.ion() plt.pause(1) self.ion = True #plt.ion() #plt.show()#False) im = ax1.imshow(self.z2d, vmin=self.cax[0], vmax=self.cax[1], cmap=plt.get_cmap('jet'), origin='lower', interpolation='nearest') time = [0] z = self.diag.ke y = [z] #line1, = ax2.plot(time, y, '.-', alpha=0.8, color="gray", markerfacecolor="red") cb = plt.colorbar(im) fig.show() fig.canvas.draw() background1 = fig.canvas.copy_from_bbox(ax1.bbox) cid = fig.canvas.mpl_connect('button_press_event', on_press) fig.canvas.key_press_event = on_press #background2 = fig.canvas.copy_from_bbox(ax2.bbox) self.output.do(self.model.var.state, self.diag, self.t, self.kt) while (self.t < self.tend): self.diag.integrals(self.model.var) self.set_dt() self.model.step(self.t, self.dt) self.t += self.dt self.kt += 1 self.output.do(self.model.var.state, self.diag, self.t, self.kt) #print(self.t) if self.kt % self.freq_plot == 0: time.append(self.t) y.append(self.diag.ke) if len(time) > 1000: del time[0] del y[0] #line1.set_xdata(time) #line1.set_ydata(y) im.set_array(self.z2d) ti = ax1.title ax1.set_title(time_str % self.t) self.set_cax(self.z2d) im.set_clim(vmin=self.cax[0], vmax=self.cax[1]) if False: fig.canvas.restore_region( background1) # restore background ax1.draw_artist(im) # redraw just the points #ax1.draw_artist(ti) # redraw just the points fig.canvas.blit(ax1.bbox) # fill in the axes rectangle ax2.axis([min(time), max(time), min(y), max(y)]) fig.canvas.restore_region( background2) # restore background ax2.draw_artist(line1) fig.canvas.blit(ax2.bbox) # fill in the axes rectangle else: fig.canvas.draw() def set_dt(self): if ((self.fixed_dt == 0) & (self.diag.maxspeed != 0)): dt = self.cfl * self.dx / self.diag.maxspeed # filter in time self.filter_coef = 1. self.dt = (1. - self.filter_coef) * self.dt + self.filter_coef * dt if self.dt > self.dtmax: # print('dt=%g'%self.dt) self.dt = self.dtmax # else: # print(self.dt) else: pass # transfer this information to the advection scheme self.model.ope.cst[2] = self.diag.maxspeed # print('dt=%g / cfl=%g'%(self.dt,self.cfl)) def set_cax(self, z): if self.colorscheme == 'minmax': self.cax = [min(z.ravel()), max(z.ravel())] if self.colorscheme == 'symmetric': mm = max(abs(z.ravel())) self.cax = [-mm, +mm] if self.colorscheme == 'imposed': #self.cax is already defined pass
from database import Database from mqtt_connection import ConnToSensors from plotting import Plotting data = Database('newdb.db') print(data.view_table()) #if __name__ == '__main__': wykres = Plotting('newdb.db') wykres.temp_hum() #plt.show() in plotting # def on_message(self, mqttc, obj, msg): # self.dict_msg = [] # #print(msg.topic+" "+str(msg.qos)+" "+str(msg.payload)) # #print(self.database.view_table() # self.dict_msg.append(msg.topic) # self.dict_msg.append(msg.payload) # # print(self.dict_msg)
def training(self, episodes): self.env.set_speed_mode(self.env.my_car_id, 0) state = None steps = 0 # reward_type = "collision" # reward_type = "horizon" reward_type = "security_distance" speed_limit = True plt_data = { "collisions": [], "space_headway": [], "relative_speed": [], "speed": [], "steps": 0 } while True: print(state) if state: plt_data["space_headway"].append(state.get("space_headway")) plt_data["relative_speed"].append( round(state.get("relative_speed") * 3.6, 0)) plt_data["speed"].append(round(state.get("speed") * 3.6, 0)) d_t, ds_t, s_t = \ self.framing(state.get('space_headway'), self.i_dict_space_headway), \ self.framing(state.get('relative_speed'), self.i_dict_relative_speed), \ self.framing(state.get('speed'), self.i_dict_speed) a = self.e_greedy_policy(d_t, ds_t, s_t) q_t = self.q[self.i_dict_space_headway.get(d_t), self.i_dict_relative_speed.get(ds_t), self.i_dict_speed.get(s_t), self.i_dict_action.get(self.action[a])] new_speed = self.new_speed(self.action[a], state.get('speed')) self.env.set_speed(self.env.my_car_id, new_speed) self.env.simulation_step() next_state = self.env.get_state(self.env.my_car_id) q_max_t1 = None if self.env.is_collided(self.env.my_car_id): self.set_reward_collision(reward_type) self.env.set_speed(self.env.my_car_id, 0) q_max_t1 = 0 state = None plt_data["collisions"].append(steps) elif next_state: """REWARD""" """ if reward_type == "horizon": self.set_reward_horizon_speed(next_state.get('space_headway'), next_state.get('speed'), speed_limit) """ if reward_type == "security_distance": self.set_reward_security_dist_speed( next_state.get('space_headway'), next_state.get('speed'), speed_limit) print(f"reward {self.reward}") d_t1, ds_t1, s_t1 = \ self.framing(next_state.get('space_headway'), self.i_dict_space_headway), \ self.framing(next_state.get('relative_speed'), self.i_dict_relative_speed), \ self.framing(next_state.get('speed'), self.i_dict_speed) q_max_t1 = np.max( self.q[self.i_dict_space_headway.get(d_t1), self.i_dict_relative_speed.get(ds_t1), self.i_dict_speed.get(s_t1)]) state = next_state if q_max_t1 is not None: self.q[ self.i_dict_space_headway.get(d_t), self.i_dict_relative_speed.get(ds_t), self.i_dict_speed.get(s_t), self.i_dict_action.get(self.action[a])] = \ (1 - self.alpha) * q_t + self.alpha * (self.reward + self.gamma * q_max_t1) """ PRINT Q""" print( f"q: {self.q[self.i_dict_space_headway.get(d_t), self.i_dict_relative_speed.get(ds_t), self.i_dict_speed.get(s_t)]}" ) steps += 1 self.epsilon_decay(steps) # print(steps) # print(f"time: {self.env.get_current_time()}") else: self.env.simulation_step() state = self.env.get_state(self.env.my_car_id) self.env.set_speed(self.env.my_car_id, 0) if steps > (episodes * 10000): time.sleep(.1) if steps == episodes * 10000: plt_data["steps"] = steps plotting = Plotting(self, plt_data) plotting.plot_()
dCdx,tt,tt1 = gradient(phi,P.G.dy) f_c = 1. - 1./(S_1_bar*S) flux = P.c*f_c*g - P.D*dCdx flux[boundary] = 0 return flux#, boundary def increment_grainsize(P,G): return KT(P,G,0) + KT(P,G,1) # return NT(P,G,0) + NT(P,G,1) if __name__ == "__main__": import initialise from numpy import random, maximum, ones from plotting import Plotting plot = Plotting() P,G,L = initialise.get_parameters(['bi_seg_test','22','2']) G.wipe(P) L.get_reference_node(P,G) # Find node down and left L.get_basis_functions(P,G) # Make basis functions L.get_nodal_mass_momentum(P,G) # Initialise from grid state plot.draw_gsd_grid(L,P,G) G.grad_gammadot = -1.*ones([P.G.ny*P.G.nx,3]) # G.grad_gammadot[:,1] = 0 # P.dt *= 10 # G.phi = zeros_like(G.phi) # G.phi[40:120,0] = 0.5 # G.phi[:,1] = 1- G.phi[:,0] # G.phi[40:100,1] = 0 # P.c *= 100
def set_up_all(self): """ Run at the start of each test suite. L3fwd Prerequisites """ # Based on h/w type, choose how many ports to use ports = self.dut.get_ports(socket=1) if not ports: ports = self.dut.get_ports(socket=0) # Verify that enough ports are available self.verify(len(ports) >= 2, "Insufficient ports for speed testing") # Verify that enough threads are available cores = self.dut.get_core_list("2S/4C/2T") self.verify(cores is not None, "Insufficient cores for speed testing") global valports valports = [_ for _ in ports if self.tester.get_local_port(_) != -1] self.verify(len(valports) >= 2, "Insufficient active ports for speed testing") pat = re.compile("P([0123])") # Prepare long prefix match table, replace P(x) port pattern lpmStr = "static struct ipv4_l3fwd_route ipv4_l3fwd_route_array[] = {\\\n" for idx in range(len(TestL3fwd.lpm_table)): TestL3fwd.lpm_table[idx] = pat.sub(self.portRepl, TestL3fwd.lpm_table[idx]) lpmStr = lpmStr + ' ' * 4 + TestL3fwd.lpm_table[idx] + ",\\\n" lpmStr = lpmStr + "};" self.logger.debug(lpmStr) # Prepare host route table, replace P(x) port pattern exactStr = "static struct ipv4_l3fwd_route ipv4_l3fwd_route_array[] = {\\\n" for idx in range(len(TestL3fwd.host_table)): TestL3fwd.host_table[idx] = pat.sub(self.portRepl, TestL3fwd.host_table[idx]) exactStr = exactStr + ' ' * 4 + TestL3fwd.host_table[idx] + ",\\\n" exactStr = exactStr + "};" self.logger.debug(exactStr) # Compile l3fwd with LPM lookup. self.dut.send_expect(r"sed -i '/ipv4_l3fwd_route_array\[\].*{/,/^\}\;/c\\%s' examples/l3fwd/main.c" % lpmStr, "# ") out = self.dut.build_dpdk_apps("./examples/l3fwd", "USER_FLAGS=-DAPP_LOOKUP_METHOD=1") self.verify("Error" not in out, "compilation error 1") self.verify("No such file" not in out, "compilation error 2") # Backup the LPM exe and clean up the build. self.dut.send_expect("mv -f examples/l3fwd/build/l3fwd examples/l3fwd/build/l3fwd_lpm", "# ") out = self.dut.send_expect("make clean -C examples/l3fwd", "# ") # Compile l3fwd with hash/exact lookup. self.dut.send_expect(r"sed -i -e '/ipv4_l3fwd_route_array\[\].*{/,/^\}\;/c\\%s' examples/l3fwd/main.c" % exactStr, "# ") out = self.dut.build_dpdk_apps("./examples/l3fwd", "USER_FLAGS=-DAPP_LOOKUP_METHOD=0") self.verify("Error" not in out, "compilation error 1") self.verify("No such file" not in out, "compilation error 2") # Backup the Hash/Exact exe. self.dut.send_expect("mv -f examples/l3fwd/build/l3fwd examples/l3fwd/build/l3fwd_exact", "# ") self.l3fwd_test_results = {'header': [], 'data': []} self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic)
def sweep_s11(log, f1, f2, nums, rstart, angle, rstop, tpolar, cpolar): # -------------------------------------------------------------------------- # Initialize values # ant_no = int( numpy.floor((rstop - rstart) / angle) + 1) # Number of degree steps # If meas 0-360, don't take measurement at 360 if (rstop == 360) and (rstart == 0): ant_no = ant_no - 1 # # End initialize values # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Reset motor positions # motorSet[STAND_ROTATION].goto_zero() set_polarization(log, motorSet, tpolar, cpolar, mycursor) # # End reset motor positions # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Move test antenna to start degree position # log.info("Start Position: " + str(rstart)) motorSet[M1].rot_deg(rstart) log.info("Motor setup complete") # # End move test antenna to start position # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Load state # analyzer.load_state() # # End load state # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Set network analyzer parameters # channel = 1 trace = 1 analyzer.setup(channel, trace) # analyzer.enable_display(False) # Set start frequency start = float(analyzer.set_start(channel, f1)) if f1 != start: msg = "WARNING: Invalid start frequency, using " + str(start) print(msg) log.warning(msg) # f1_old = f1 f1 = start # Set stop frequency stop = float(analyzer.set_stop(channel, f2)) if f2 != stop: msg = "WARNING: Invalid stop frequency, using " + str(stop) print(msg) log.warning(msg) # f2_old = f2 f2 = stop # Set number of points points = int(analyzer.set_points(channel, nums)) if nums != points: msg = "WARNING: Invalid number of steps, using " + str(points) print(msg) log.warning(msg) # nums_old = nums nums = points # Create csv files # d = datetime.today() # file_name = os.path.join(DATA_PATH, d.strftime("%Y%m%d%H%M%S")) # s11_filename = file_name + "_s11.csv" s11_filename = os.path.join(DATA_PATH, "S11.csv") s11File = open(s11_filename, "w") # # End set network analyzer parameters # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Check for network analyzer errors log.info("Checking network analyzer error queue") err_nums, err_msgs = analyzer.get_errors() if len(err_nums) > 0: msg = "Error in setting network analyzer parameters" print(msg) log.warning(msg) else: # No errors log.info("No network analyzer errors detected") # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Measure S11 (actually S22) # log.info("Measuring S11") print("Starting S11 Measurement") print("Start Frequency: " + str(f1 / 1e9) + " GHz") print("Stop Frequency: " + str(f2 / 1e9) + " GHz") print("Number of Points: " + str(nums)) analyzer.set_measurement(channel, trace, 2, 2) analyzer.trigger() analyzer.update_display() analyzer.auto_scale(channel, trace) s11Freq = analyzer.get_x(channel) s11Data = analyzer.get_corr_data(channel) # s11Data = analyzer.get_form_data(channel) # Write to csv file log.info("Writing s11 data to file") s11File.write(s11Freq) s11File.write(s11Data) # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Check for network analyzer errors log.info("Checking network analyzer error queue") err_nums, err_msgs = analyzer.get_errors() if len(err_nums) > 0: msg = "Error measuring S11" print(msg) log.warning(msg) else: # No errors msg = "S11 Measurement Successful" print(msg) log.info(msg) # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Reset motor positions # motorSet[STAND_ROTATION].goto_zero() # # End reset motor positions # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Close csv files # s11File.close() # # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Update database # if db.is_connected(): fstart = f1 / 1e9 fstop = f2 / 1e9 rowcount = mycursor.rowcount # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Antenna polarization # log.info("Updating tpolar and cpolar in sql database") update_config_db(log, mycursor, 0, "'antenna_polarization'") update_config_db(log, mycursor, 0, "'chamber_polarization'") # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Network analyzer parameters # log.info("Updating fstart, fstop, and nums in sql database") update_config_db(log, mycursor, fstart, "'frequency_start'") update_config_db(log, mycursor, fstop, "'frequency_stop'") update_config_db(log, mycursor, nums, "'num_steps'") # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Commit changes log.info("Committing changes") db.commit() if rowcount == mycursor.rowcount: log.warning("Failed to store updated antenna polarization data") # # End update database # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # Call plotting function and write zip file # Plotting(f1, f2, nums, rstart, angle, rstop, 0, 0, 0, 0, 0, 0, "s11")
class Animator: """Creator for animations and videos.""" def __init__(self, hist_path: str, varname="b", video_path=None, visible=True): """Open the history file and load parts of it.""" # Initialize self.hist_file to prevent the destructor from failing self.hist_file = None self.tracers = False # Set parameters needed for Plotting that cannot be determined # so far; maybe make them command line arguments in the future param = { "figsize": (RESOLUTION[0] / DPI, RESOLUTION[1] / DPI), "aspect": "equal", "rotation_speed": 3, } if varname == "b": param["style"] = "b-interface" param["stable_stratification"] = True # TODO make this a command line argument elif varname == "t0": # This option is to plot only the first tracer and also a # shorter notation in the common case with only one tracer param["style"] = "tracer" param["n_tracers"] = 1 elif varname == "tracer": param["style"] = "tracer" self.tracers = True else: raise NotImplementedError("The given variable is not yet supported.") # Save necessary arguments self.video_path = video_path self.visible = visible # Create the metadata for the video if self.video_path: # Extract the name of the experiment exp_name = os.path.basename( hist_path[:-8] if hist_path.endswith("_hist.nc") else hist_path ) self.metadata = { "title": "Nyles experiment {}".format(exp_name), "artist": CREATOR, "genre": "Computational Fluid Dynamics (CFD)", "comment": "Created on {} with Nyles. Nyles is a Large Eddy " "Simulation written in Python. For more information" " visit https://github.com/pvthinker/Nyles." .format(time.strftime('%d %b %Y')), "date": time.strftime("%Y-%m-%d"), } # Open the history file and keep it open to allow sequential reading print("Loading history file {!r}:".format(hist_path)) self.hist_file = nc.Dataset(hist_path) print(self.hist_file) # Load the needed data if self.tracers: param["n_tracers"] = self.hist_file.n_tracers self.tracers_data = [ self.hist_file["t{}".format(i)] for i in range(self.hist_file.n_tracers) ] else: self.vardata = self.hist_file[varname] self.t = self.hist_file["t"] self.n = self.hist_file["n"] self.n_frames = self.n.size # Load parameters needed for Grid param["Lx"] = self.hist_file.Lx param["Ly"] = self.hist_file.Ly param["Lz"] = self.hist_file.Lz param["nx"] = self.hist_file.global_nx param["ny"] = self.hist_file.global_ny param["nz"] = self.hist_file.global_nz # Set parameters needed for Scalar param["nh"] = 0 param["neighbours"] = {} grid = Grid(param) # Create one or several Scalar variables as an interface for # passing data to the plotting module. Note: Scalar takes # actually a dimension instead of a unit, but that does not # matter because this information is not processed here. if self.tracers: tracer_list = [] self.arrays = [] for data in self.tracers_data: tracer = Scalar(param, data.long_name, data.name, data.units) tracer_list.append(tracer) self.arrays.append(tracer.view("i")) state = State(tracer_list) else: scalar = Scalar(param, self.vardata.long_name, varname, self.vardata.units) self.array = scalar.view("i") state = State([scalar]) self.p = Plotting(param, state, grid) def __del__(self): """Close the history file in the destructor.""" if self.hist_file: self.hist_file.close() def init(self): """Show the inital frame.""" if self.tracers: print("Variable:", len(self.tracers_data), "tracer") else: print("Variable:", self.vardata.long_name) print("Number of frames:", self.n_frames) if self.video_path: print("Output file:", self.video_path, end="") if os.path.exists(self.video_path): print(" -- file exists already and will be overwritten!") else: print("") if not self.visible: print("Fast mode: no animation will be visible during the process.") else: print('Slow mode: call script with "--fast" to speed up the video creation.') else: print("No video will be created.") # Load the initial data and show it if self.tracers: for array, data in zip(self.arrays, self.tracers_data): array[...] = data[0] else: self.array[...] = self.vardata[0] self.p.init(self.t[0], self.n[0]) def run(self): """Create the animation and optionally save it.""" if not self.video_path: plt.ioff() self.anim = animation.FuncAnimation( self.p.fig, self.update, frames=self.n_frames, repeat=False, interval=0, ) if self.visible: plt.show() if self.video_path: self.anim.save( self.video_path, fps=FPS, dpi=DPI, bitrate=BPS, metadata=self.metadata, ) def update(self, frame): """Load the data of the given frame and display it.""" print("\rProcessing frame {} of {} ...".format(frame+1, self.n_frames), end="") # Load the data and show it if self.tracers: for array, data in zip(self.arrays, self.tracers_data): array[...] = data[frame] else: self.array[...] = self.vardata[frame] self.p.update(self.t[frame], self.n[frame], self.visible) # At the end if frame + 1 == self.n_frames: if self.video_path: print("\b\b\b-- saved.") else: print("\b\b\b-- finished.") plt.pause(0.5) plt.close(self.p.fig)