Пример #1
0
 def __init__(self, config, progress, restart):
     self.logger = logging.getLogger(self.__class__.__name__)
     self.progress = progress
     self.basedir = None
     self.random = config.get('randomization', False)
     if 'devices' not in config:
         raise ConfigError('"device" is required in the configuration')
     adb_path = config.get('adb_path', 'adb')
     self.devices = Devices(config['devices'],
                            adb_path=adb_path,
                            devices_spec=config.get('devices_spec'))
     self.replications = Tests.is_integer(config.get('replications', 1))
     self.paths = config.get('paths', [])
     self.profilers = Profilers(config.get('profilers', {}), config)
     monkeyrunner_path = config.get('monkeyrunner_path', 'monkeyrunner')
     self.scripts = Scripts(config.get('scripts', {}),
                            monkeyrunner_path=monkeyrunner_path)
     self.time_between_run = Tests.is_integer(
         config.get('time_between_run', 0))
     Tests.check_dependencies(self.devices, self.profilers.dependencies())
     self.output_root = paths.OUTPUT_DIR
     self.result_file_structure = None
     if restart:
         for device in self.devices:
             self.prepare_device(device, restart=True)
Пример #2
0
 def __init__(self, config, progress, restart):
     super(WebExperiment, self).__init__(config, progress, restart)
     self.browsers = [
         BrowserFactory.get_browser(b)(config)
         for b in config.get('browsers', ['chrome'])
     ]
     Tests.check_dependencies(self.devices,
                              [b.package_name for b in self.browsers])
     self.duration = Tests.is_integer(config.get('duration', 0)) / 1000
Пример #3
0
 def __init__(self, path, timeout=0, logcat_regex=None):
     self.logger = logging.getLogger(self.__class__.__name__)
     self.path = path
     self.filename = op.basename(path)
     if not op.isfile(path):
         raise FileNotFoundError(self.filename)
     self.timeout = float(Tests.is_integer(timeout)) / 1000
     self.logcat_event = logcat_regex
     if logcat_regex is not None:
         self.logcat_event = Tests.is_string(logcat_regex)
def cross_validate_parameters(dataset_name, train_set, test_set):
    dims = [i for i in range(1, 7)]
    sigmas = [0.001, 0.01, 0.1, 1, 2, 5]

    accuracies = []
    best_accu_and_dim = 0, 0
    max = 0

    for dim in dims:
        clf_poly = Perceptron.Perceptron(dataset_name,
                                         train_set[:, :-1],
                                         train_set[:, -1],
                                         _kernel_=2, epochs=10, _dim_=dim)
        accuracy, accuracy_index = tests.best_epoch(clf_poly, test_set, 10)

        # clf_poly.fit()
        # predicted = clf_poly.predict_set(test_set[:, :-1], test_set[:, -1])
        # accuracy = clf_poly.accuracy(test_set[:, -1], predicted)

        accuracies.append((accuracy, dim))

    for accu, dim in accuracies:
        if accu > max:
            max = accu
            best_accu_and_dim = accu, dim

    accuracies = []
    best_accu_and_sigma = 0, 0
    max = 0

    for sigma in sigmas:
        clf_gaussian = Perceptron.Perceptron(dataset_name,
                                             train_set[:, :-1],
                                             train_set[:, -1],
                                             _kernel_=3, epochs=10, _sigma_=sigma)
        accuracy, accuracy_index = tests.best_epoch(clf_gaussian, test_set, 10)

        # clf_gaussian.fit()
        # predicted = clf_gaussian.predict_set(test_set[:, :-1], test_set[:, -1])
        # accuracy = clf_gaussian.accuracy(test_set[:, -1], predicted)

        accuracies.append((accuracy, sigma))

    for accu, sigma in accuracies:
        if accu > max:
            max = accu
            best_accu_and_sigma = accu, sigma

    print("Best accuracy with associated dim: ", best_accu_and_dim, "\n",
          "Best accuracy with associated sigma :", best_accu_and_sigma)

    return best_accu_and_dim, best_accu_and_sigma
 def __init__(self, config):
     self.package = None
     self.duration = Tests.is_integer(config.get('duration', 0)) / 1000
     super(NativeExperiment, self).__init__(config)
     for apk in config.get('paths', []):
         if not op.isfile(apk):
             raise ConfigError('File %s not found' % apk)
Пример #6
0
def OnLoad():
	MessageWindow = GemRB.LoadWindow(0, GUICommon.GetWindowPack(), WINDOW_BOTTOM|WINDOW_HCENTER)
	MessageWindow.SetFlags (WF_BORDERLESS|IE_GUI_VIEW_IGNORE_EVENTS, OP_OR)
	MessageWindow.AddAlias("MSGWIN")
	MessageWindow.AddAlias("HIDE_CUT", 0)

	# set up some *initial* text (UpdateControlStatus will get called several times)
	TMessageTA = MessageWindow.GetControl(0)
	TMessageTA.SetFlags (IE_GUI_TEXTAREA_AUTOSCROLL|IE_GUI_TEXTAREA_HISTORY)
	TMessageTA.SetResizeFlags(IE_GUI_VIEW_RESIZE_ALL)
	TMessageTA.AddAlias("MsgSys", 0)
	TMessageTA.AddAlias("MTA", 0)
	TMessageTA.SetColor({'r' : 255, 'g' : 0, 'b' : 0}, TA_COLOR_OPTIONS)
	TMessageTA.SetColor({'r' : 255, 'g' : 255, 'b' : 255}, TA_COLOR_HOVER)
	
	results = Tests.RunTests ()
	TMessageTA.SetText ("[cap]D[/cap]emo " + "DEMO "*40 + "\n" + results)

	PauseButton = MessageWindow.GetControl (2)
	PauseButton.SetEvent (IE_GUI_BUTTON_ON_PRESS, lambda: GemRB.GamePause (2, 0))
	PauseButton.SetAnimation ("loading")
	PauseButton.SetFlags (IE_GUI_BUTTON_PICTURE|IE_GUI_BUTTON_NORMAL, OP_SET)

	MapButton = MessageWindow.GetControl (3)
	MapButton.SetText ("M")
	MapButton.SetEvent (IE_GUI_BUTTON_ON_PRESS, GUIMA.OpenMapWindow)
	MapButton.SetEvent (IE_GUI_BUTTON_ON_RIGHT_PRESS, lambda: GemRB.MoveToArea ("ar0110"))

	CenterButton = MessageWindow.GetControl (4)
	CenterButton.SetText ("C")
	CenterButton.SetEvent (IE_GUI_BUTTON_ON_PRESS, lambda: GemRB.GameControlSetScreenFlags (SF_CENTERONACTOR, OP_OR))

	InventoryButton = MessageWindow.GetControl (5)
	InventoryButton.SetText ("I")
	InventoryButton.SetEvent (IE_GUI_BUTTON_ON_PRESS, GUIINV.OpenInventoryWindow)
Пример #7
0
 def __init__(self, config):
     self.logger = logging.getLogger(self.__class__.__name__)
     self.basedir = None
     if 'devices' not in config:
         raise ConfigError('"device" is required in the configuration')
     adb_path = config.get('adb_path', 'adb')
     self.devices = Devices(config['devices'], adb_path=adb_path)
     self.replications = Tests.is_integer(config.get('replications', 1))
     self.paths = config.get('paths', [])
     self.profilers = Profilers(config.get('profilers', {}))
     monkeyrunner_path = config.get('monkeyrunner_path', 'monkeyrunner')
     self.scripts = Scripts(config.get('scripts', {}),
                            monkeyrunner_path=monkeyrunner_path)
     self.time_between_run = Tests.is_integer(
         config.get('time_between_run', 0))
     Tests.check_dependencies(self.devices, self.profilers.dependencies())
     self.output_root = paths.OUTPUT_DIR
Пример #8
0
def long_task(self):
    """Background task that runs a long function with progress reports."""

    Tests.client_code(testOne)
    message = ''
    total = random.randint(10, 50)
    for i in range(total):
        self.update_state(state='PROGRESS',
                          meta={
                              'current': i,
                              'total': total,
                              'status': message
                          })
        time.sleep(1)
    return {
        'current': 100,
        'total': 100,
        'status': 'Task completed!',
        'result': 42
    }
Пример #9
0
    def __init__(self, config):
        super(Batterystats, self).__init__(config)
        self.profile = False
        self.cleanup = config.get('cleanup')

        # "config" only passes the fields under "profilers", so config.json is loaded again for the fields below
        config_file = load_json(op.join(paths.CONFIG_DIR, 'config.json'))
        self.type = config_file['type']
        self.systrace = config_file.get('systrace_path', 'systrace')
        self.powerprofile = config_file['powerprofile_path']
        self.duration = Tests.is_integer(config_file.get('duration', 0)) / 1000
Пример #10
0
def main(argv):
    parser = argparse.ArgumentParser()
    parser.add_argument("-t","--translate",type=str,help="translates a Japanese sentence to English and writes it to a file")
    parser.add_argument("--batch-translate",action="store_true", help="translates each line in a file and writes translations to a file")
    parser.add_argument("--test",type=str, help="tests translation system using file containing test cases")
    parser.add_argument("--tt", type=str, help="tests the tokenizing using a file")
    parser.add_argument("-v","--verbose", action="store_true")
    parser.add_argument("-i", "--interactive", action="store_true", help="run an interactive version of the system")
    parser.add_argument("-p", "--paraphrase", action="store_true", help="count translations as correct during testing if they are paraphrases of the gold translation")
    parser.add_argument("--input", type=str, help="input file for translation", default=None)
    parser.add_argument("--output", type=str, help="output file for translation", default=None)

    args = parser.parse_args()

    Constants.VERBOSE = args.verbose
    Constants.PARAPHRASE = args.paraphrase

    if args.interactive:
        start_interactive()
    if args.translate:
        if args.output and args.translate != "":
            PrintTools.write_to_file(translate(args.translate), args.output)
        else:
            print("Please specify text to translate and output file")
    elif args.batch_translate:
        if args.input and args.output:
            batch_translate(args.input, args.output)
        else:
            print("Please specify input and output files")
    elif args.test:
        Tests.test_translator(args.test)
    elif args.tt:
        Tests.test_tokenizer(args.tt)
    else:
        print("Incorrect arguments")
        parser.print_help()
Пример #11
0
 def __init__(self, config):
     super(Android, self).__init__(config)
     self.profile = False
     available_data_points = ['cpu', 'mem']
     self.interval = float(
         Tests.is_integer(config.get('sample_interval', 0))) / 1000
     self.data_points = config['data_points']
     invalid_data_points = [
         dp for dp in config['data_points']
         if dp not in set(available_data_points)
     ]
     if invalid_data_points:
         self.logger.warning('Invalid data points in config: {}'.format(
             invalid_data_points))
     self.data_points = [
         dp for dp in config['data_points']
         if dp in set(available_data_points)
     ]
     self.data = [['datetime'] + self.data_points]
Пример #12
0
def OnLoad():
#	global PortraitWindow, OptionsWindow

	GemRB.GameSetPartySize(MAX_PARTY_SIZE)
	GemRB.GameSetProtagonistMode(1)
	GemRB.LoadWindowPack(GUICommon.GetWindowPack())

#	GUICommonWindows.PortraitWindow = None
#	GUICommonWindows.ActionsWindow = None
#	GUICommonWindows.OptionsWindow = None
 
#	ActionsWindow = GemRB.LoadWindow(3)
#	OptionsWindow = GemRB.LoadWindow(0)
#	PortraitWindow = GUICommonWindows.OpenPortraitWindow(1)

#	GemRB.SetVar("PortraitWindow", PortraitWindow.ID)
#	GemRB.SetVar("ActionsWindow", ActionsWindow.ID)
#	GemRB.SetVar("OptionsWindow", OptionsWindow.ID)
	GemRB.SetVar("TopWindow", -1)
	GemRB.SetVar("OtherWindow", -1)
	GemRB.SetVar("FloatWindow", -1)
	GemRB.SetVar("PortraitPosition", 2) #Right
	GemRB.SetVar("ActionsPosition", 4) #BottomAdded
	GemRB.SetVar("OptionsPosition", 0) #Left
	GemRB.SetVar("MessagePosition", 4) #BottomAdded
	GemRB.SetVar("OtherPosition", 5) #Inactivating
	GemRB.SetVar("TopPosition", 5) #Inactivating
	
#	GUICommonWindows.OpenActionsWindowControls (ActionsWindow)
#	GUICommonWindows.SetupMenuWindowControls (OptionsWindow, 1, None)

##	GUICommon.GameWindow.SetVisible (WINDOW_VISIBLE)

	UpdateControlStatus()

	# set up some *initial* text (UpdateControlStatus will get called several times)
	TMessageTA.SetFlags (IE_GUI_TEXTAREA_AUTOSCROLL|IE_GUI_TEXTAREA_HISTORY)
	results = Tests.RunTests ()
	TMessageTA.SetText ("[cap]D[/cap]emo " + "DEMO "*40 + "\n" + results)
	print results
Пример #13
0
def test(dtb_url=default_dtb,
         schema="Football",
         market="1x2",
         margin='basic',
         csv=True,
         csvfile="",
         bookmakers=None):
    if bookmakers is None:
        bookmakers = default_bookmakers
    closed, opening, _, _ = load_data(dtb_url=dtb_url,
                                      schema=schema,
                                      market=market,
                                      to_numpy=False,
                                      csv=csv,
                                      csv_file=csvfile)
    if closed is None:
        return
    for bookmaker in bookmakers:
        closed_pom = closed[closed['Bookmaker'] == bookmaker]
        opening_pom = opening[opening['Bookmaker'] == bookmaker]
        closed_odds = to_odds(closed_pom, market=market)
        closed_results = closed_pom['results']
        opening_odds = to_odds(opening_pom, market=market)
        opening_results = opening_pom['results']
        test = Tests.Tests(closed_odds=closed_odds,
                           opening_odds=opening_odds,
                           market=market,
                           schema=schema,
                           margin=margin,
                           opening_results=opening_results,
                           closed_results=closed_results,
                           Bookmaker=bookmaker,
                           test_list=config.default_list,
                           txt_path=config.txt_path,
                           pickle_path=config.pickle_path,
                           png_path=config.png_path)
        test.test()
        test.save()
Пример #14
0
def testme(files=None):
    """
    Test function
    """
    import Tests
    from ROOT import TH1F,TFile
    if files != None:
        in1 = TFile( files[0] )
        in2 = TFile( files[1] )
        hname = "Spectra/hProtonSpectrum"
        h1=in1.Get( hname )
        h2=in2.Get( hname )
        print h1,h2
    else:
        h1 = TH1F("h1","h",100,-10,10)
        h2 = TH1F("h2","h",100,-10,10)
        h1.FillRandom("gaus")
        h2.FillRandom("gaus")
    from ROOT import TCanvas
    global c
    c=TCanvas()
    c.Divide(1,2)
    c.cd(1)
    h1.DrawCopy()
    h2.SetLineColor(2)
    h2.DrawCopy("same")
    from Utils import DataType
    #aTest = Tests.KolmogorovSmirnovTest( h1 , h2 , DataType.BINNED1D)
    aTest = Tests.Binned1DChi2Test(h1,h2)
    #print aTest.pval(),aTest.stat()
    aResult = Output("A-Test")
    anAlgo = Algorithm( aTest , aResult )
    c.cd(2)
    anAlgo.test.residuals.Draw()
    anAlgo.test.residuals.Draw()
    print anAlgo.check()
    print aResult
    return h1,h2,anAlgo.test.residuals
Пример #15
0
def deconstruct_field(original_ff_spectral,
                      kx_array,
                      kz_array,
                      Nm,
                      y,
                      c,
                      Re,
                      baseflow,
                      mean_profile,
                      sparse):
    ''' 
    Deconstruct given flow field and return the resolvent modes,
    forcing modes, singular values and amplitude coefficients 
    needed to reconstruct it.

    =================================================================
    INPUTS:
    =================================================================
    original_ff_spectral:           3D array of flow field to 
                                    approximate in xz spectral form 
                                    with Chebyshev nodes in 
                                    wall-normal direction 
                                    (Chebyshev spacing).
                                    Stacked in wall-normal direction:
                                    dimensions: (Nx, Nd*Ny, Nz).

    kx_array:                       1D array of streamwise Fourier 
                                    modes.

    kz_array:                       1D array of spanwise Fourier 
                                    modes.

    Nm:                             Number of interior Chebyshev nodes,
                                    i.e. Ny - 2 (endpoints removed).
                                    
    y:                              Grid points in the wall-normal 
                                    direction.

    c:                              Wavespeed.

    Re:                             Reynolds number based on laminar
                                    baseflow centreline velocity, i.e.
                                    Re = 1 / nu.

    baseflow:                       Base flow type: [laminar, Couette],
                                    laminar means Plane Poiseuille.

    mean_profile:                   1D array of streamwise velocity 
                                    profile of the turbulent mean in
                                    wall-normal direction, 
                                    (endpoints included).

    sparse:                         Boolean that determines whether to 
                                    use sparse or full SVD algorithm.

    =================================================================
    OUTPUTS:
    =================================================================
    A dictionary named 'deconstructed_dict' which contains:
    
    resolvent_modes:                4D array of resolvent modes
                                    at each Fourier mode combination:
                                        resolvent_modes[mx, mz, :, :] gives 
                                        column vectors of given rank, i.e.
                                        rank = resolvent_modes.shape[3].
    
    forcing_modes:                  4D array of forcing modes
                                    at each Fourier mode combination:=
                                        resolvent_modes[mx, mz, :, :] gives 
                                        column vectors of given rank, i.e.
                                        rank = resolvent_modes.shape[3].

    singular_values:                3D array of singular values
                                    at each Fourier mode combination:
                                        singular_values[mx, mz, :] gives
                                        1D array of singular values, where
                                        rank = len(singular_values[mx, mz, :]).

    coefficients:                   3D array of complex amplitude
                                    coefficients at each 
                                    Fourier mode combination:
                                        coefficients[mx, mz, :] gives
                                        1D array of coefficients, where
                                        rank = len(coefficients[mx, mz, :]).
    '''
    #===============================================================#
    #### Store the resolvent modes and amplitude coefficients    ####
    #    at each  Fourier mode pair                                 #
    #===============================================================#
    resolvent_modes_array = np.zeros((len(kx_array), len(kz_array), 3*Nm, 3*Nm), dtype=complex)
    forcing_modes_array = np.zeros((len(kx_array), len(kz_array), 3*Nm, 3*Nm), dtype=complex)
    coefficients_array = np.zeros((len(kx_array), len(kz_array), 3*Nm), dtype=complex)
    sing_vals_array = np.zeros((len(kx_array), len(kz_array), 3*Nm), dtype=float)
    #===============================================================#
    #### Calculate differentiation matrices and mean flow derivatives 
    #===============================================================#
    chebyshev_differentiation, mean_flow_derivatives = ps.calculate_derivatives(Nm+2, mean_profile, baseflow)
    #===============================================================#
    #### Loop through wavenumbers                                ####
    #===============================================================#
    startTime = datetime.now()
    for mx in range(0, len(kx_array)):
        kx = kx_array[mx]
#        print('\nkx:'+ str(kx))
        for mz in range(0, len(kz_array)):
            kz  = kz_array[mz]
#            sys.stdout.write(".")
#            sys.stdout.flush()
            if kx == 0 and kz == 0: # Zeroth Fourier modes
                resolvent_modes_array[mx, mz, :, 0] = original_ff_spectral[mx, :, mz]
                continue # Start the loop again
            #--------------------------------------------------------
            #### Calculate the state vectors                        -
            #--------------------------------------------------------
            omega = kx * c
            wegihted_transfer_function, w = ps.calculate_transfer_function(kx, kz, Re, Nm, omega, chebyshev_differentiation, mean_flow_derivatives)
            #--------------------------------------------------------
            #### Perform SVD                                        -
            #--------------------------------------------------------
            if sparse:
                weighted_resolvent_modes, singular_values, weighted_forcing_modes = svd(wegihted_transfer_function, full_matrices=False)
            else:
                weighted_resolvent_modes, singular_values, weighted_forcing_modes = svd(wegihted_transfer_function)
            #--------------------------------------------------------
            #### Test: SVD                                          -
            #--------------------------------------------------------
            Tests.SVD(weighted_resolvent_modes, singular_values, weighted_forcing_modes, wegihted_transfer_function, sparse)
            #--------------------------------------------------------
            #### Test: Orthogonality                                -
            #--------------------------------------------------------
            Tests.orthogonality(weighted_resolvent_modes)
            Tests.orthogonality(weighted_forcing_modes)
            #--------------------------------------------------------
            #### Test: Invertibility                                -
            #--------------------------------------------------------
            Tests.invertible(np.diag(singular_values))
            #--------------------------------------------------------
            #### Retrieve non-grid-weighted (physical) modes        -
            #--------------------------------------------------------
            weighted_resolvent_modes = np.asmatrix(weighted_resolvent_modes)
            weighted_forcing_modes = np.asmatrix(weighted_forcing_modes)
            resolvent_modes = np.linalg.solve(w, weighted_resolvent_modes)
            forcing_modes = np.linalg.solve(w, weighted_forcing_modes)
            #--------------------------------------------------------
            #### Tests: Continuity condition                        -
            #--------------------------------------------------------
            Tests.continuity(resolvent_modes, np.diag(singular_values), kx, kz, Nm, chebyshev_differentiation['D1'])
            #--------------------------------------------------------
            #### Fix phase of resolvent modes                       -
            # based on critical layer or centreline                 -
            #--------------------------------------------------------
            phase_shift = np.zeros((resolvent_modes.shape[1], resolvent_modes.shape[1]), dtype=np.complex128)
            ind0 = Nm/2 + 1 # Use centreline, unless
            if c < 1.0:
                inds = Tests.indices(mean_flow_derivatives['U'].diagonal(), lambda x: x > c)
                if len(inds) > 0:
                    ind0 = inds[0]

            np.fill_diagonal(phase_shift, np.exp(-1j * np.angle(resolvent_modes[ind0,:])))
            resolvent_modes *= phase_shift
            #--------------------------------------------------------
            #### Project resolvent modes to get coefficients        -
            #--------------------------------------------------------
            # Initialize amplitude coefficients vector
            xi = np.zeros((3*Nm, 1), dtype=complex)
            # Projection
            xi = inv(np.diag(singular_values)) * resolvent_modes.H * w.H * w * np.asmatrix(original_ff_spectral[mx, :, mz]).T
            Tests.projection(xi, np.diag(singular_values), resolvent_modes, np.asmatrix(original_ff_spectral[mx, :, mz]).T, 1e-10)
            #--------------------------------------------------------
            #### Store resolvent modes, singular values and coeffs. -
            #--------------------------------------------------------
            resolvent_modes_array[mx, mz, :, :] = resolvent_modes
            forcing_modes_array[mx, mz, :, :] = forcing_modes
            coefficients_array[mx, mz, :] = np.squeeze(np.asarray(xi))
            sing_vals_array[mx, mz, :] = singular_values
    calcTime = datetime.now() - startTime
#    print("\n\n\n")
#    print(calcTime)
#    print("\n\n\n")
    deconstructed_dict = {}
    deconstructed_dict['resolvent_modes'] = resolvent_modes_array
    deconstructed_dict['forcing_modes'] = forcing_modes_array
    deconstructed_dict['singular_values'] = sing_vals_array
    deconstructed_dict['coefficients'] = coefficients_array
    
    return deconstructed_dict
Пример #16
0
                            ff.x, ff.y, ff.velocityField[i, :, :, j].T, 
                            ":", ":", format(ff.z[j], '.2f'), 
                            ff.Re, 
                            "-", "-", str(j), 
                            ff.velocityField[m, :, :, j].T, 
                            ff.velocityField[p, :, :, j].T, 
                            "x", "y", velName,
                            vl_max, vl_min, args.Quiver, contour_levels,
                            printFullTitle, args.Small, args.Type)
#===================================================================#
#### If Co-Ordinate given                                        ####
#===================================================================#
printFullTitle = True
if args.Coordinate:
    if n == 0:
        coords = Tests.indices(ff.x, lambda m: m > float(args.Coordinate))
        x_coord = coords[0]
        x_directory = ut.make_Folder(images_directory, "x", False)
        ut.plot_Contour(x_directory, str(args.File[:-3]), 
                        ff.z, ff.y, ff.velocityField[i, x_coord, :, :], 
                        format(ff.x[x_coord], '.2f'), ":", ":", 
                        ff.Re, 
                        str(x_coord),  "-", "-",
                        ff.velocityField[m, x_coord, :, :], 
                        ff.velocityField[p, x_coord, :, :], 
                        "z", "y", velName,
                        vl_max, vl_min, args.Quiver, contour_levels,
                        printFullTitle, args.Small, args.Type)
    elif n == 1:
        coords = Tests.indices(ff.y, lambda m: m > float(args.Coordinate))
        y_coord = coords[-1]
Пример #17
0
 def test(self):
     r = jsonpickle.encode(Tests.testear(), unpicklable=False)
     return json.loads(r)
Пример #18
0
 def OnTest(self, event):
     import Tests
     Tests.test_wxFrame(self)
Пример #19
0
def resolvent_formulation(ff):
    #===============================================================#
    #### Initialize 3D array to store approximated velocity field ###
    #===============================================================#
    # Velocity field is stacked in the wall-normal direction.
    tmp = np.zeros((ff.Nx, ff.Nd*ff.Nm, ff.Nz), dtype=complex)
    # Note that the number of gridpoints in the wall-normal direction
    # are equal to the number of interior Chebyshev nodes. This is 
    # becasue when reshaped, the velocity field is missing its 
    # wall-boundaries, i.e. top and bottom xz-planes.
    #===============================================================#
    #### Calculate differentiation matrices and mean flow derivatives 
    #===============================================================#
    chebyshev_differentiation, mean_flow_derivatives = ps.calculate_derivatives(ff.Ny, [], ff.baseflow)
    #===============================================================#
    #### Loop through Wavepacket                                 ####
    #===============================================================#
    for triplet in range(0, len(ff.kx)):
        #===========================================================#
        #### Get fundamental wavenumbers from Wavepacket         ####
        #===========================================================#
        fund_alpha = ff.kx[triplet]
        fund_beta  = ff.kz[triplet]
        amplitude  = ff.chi_tilde[triplet]
        #===========================================================#
        #### Calculate first Fourier modes                       ####
        #===========================================================#
        kx_array = fund_alpha * ff.Mx
        kz_array = fund_beta * ff.Mz
        #===========================================================#
        #### Loop through the Fourier modes                      ####
        #===========================================================#
        for mx in range(0, len(kx_array)):
            kx = kx_array[mx] # Streamwise Fourier mode
            for mz in range(0, len(kz_array)):
                kz = kz_array[mz] # Spanwise Fourier mode
                if kx == 0 or kz == 0:
                    continue
                print('kx:\t'+ str(kx) + "\tkz:\t" + str(kz))
                #----------------------------------------------------
                #### Calculate the state vectors                    -
                #----------------------------------------------------
                omega = kx * ff.c
                wegihted_transfer_function, w = ps.calculate_transfer_function(kx, kz, ff.Re, ff.Nm, omega, chebyshev_differentiation, mean_flow_derivatives)
                #----------------------------------------------------
                #### Perform SVD                                    -
                #----------------------------------------------------
                weighted_resolvent_modes, singular_values, weighted_forcing_modes = svd(wegihted_transfer_function)
                #----------------------------------------------------
                #### Test: SVD                                      -
                #----------------------------------------------------
                Tests.SVD(weighted_resolvent_modes, singular_values, weighted_forcing_modes, wegihted_transfer_function, False)
                #----------------------------------------------------
                #### Test: Orthogonality                            -
                #----------------------------------------------------
                Tests.orthogonality(weighted_resolvent_modes)
                Tests.orthogonality(weighted_forcing_modes)
                #----------------------------------------------------
                #### Test: Invertibility                            -
                #----------------------------------------------------
                Tests.invertible(np.diag(singular_values))
                #----------------------------------------------------
                #### Retrieve non-grid-weighted (physical) modes    -
                #----------------------------------------------------
                weighted_resolvent_modes = np.asmatrix(weighted_resolvent_modes)
                weighted_forcing_modes = np.asmatrix(weighted_forcing_modes)
                resolvent_modes = np.linalg.solve(w, weighted_resolvent_modes)
                forcing_modes = np.linalg.solve(w, weighted_forcing_modes)
                #----------------------------------------------------
                #### Test: Continuity condition                     -
                #----------------------------------------------------
                Tests.continuity(resolvent_modes, np.diag(singular_values), kx, kz, ff.Nm, chebyshev_differentiation['D1'])
                #----------------------------------------------------
                #### Fix phase of resolvent modes                   -
                # based on critical layer or centreline             -
                #----------------------------------------------------
                phase_shift = np.zeros((resolvent_modes.shape[1], resolvent_modes.shape[1]), dtype=np.complex128)
                ind0 = ff.Nm/2 + 1 # Use centreline, unless
                if ff.c < 1.0:
                    inds = Tests.indices(mean_flow_derivatives['U'].diagonal(), lambda x: x > ff.c)
                    if len(inds) > 0:
                        ind0 = inds[0]
                np.fill_diagonal(phase_shift, np.exp(-1j * np.angle(resolvent_modes[ind0,:])))
                resolvent_modes *= phase_shift
                # Alternative Method:
                # # Non-weighted forcing modes (physical forcing modes)
                # unweighted_forcing_modes = np.linalg.solve(state_vecs['w'], forcing_modes_h.conjugate().T)
                # unweighted_forcing_modes *= phase_shift
                # unweighted_H = np.linalg.inv(state_vecs['w']) * state_vecs['H'] * state_vecs['w']
                # unweighted_vel_modes = unweighted_H * unweighted_forcing_modes * np.diag(1.0/singular_values)
                # delta_r = unweighted_vel_modes.real - resolvent_modes.real
                # delta_i = unweighted_vel_modes.imag - resolvent_modes.imag
                #----------------------------------------------------
                #### Calculate spectral velocity vector             -
                # u_tilde = psi * sigma * xi                        -
                # u_tilde = psi * chi                               -
                #----------------------------------------------------
                u_tilde = resolvent_modes[:, 0] * amplitude # Rank 1
            
                #----------------------------------------------------
                # Inverse fourier transform                         -
                #----------------------------------------------------
                u_tilde = np.asmatrix(u_tilde)
                physical_ff = np.zeros((ff.Nx, ff.Nd*ff.Nm, ff.Nz), dtype=complex)
                physical_ff = ps.my_ifft(u_tilde, kx, kz, ff)
                tmp += physical_ff
                
    return tmp
Пример #20
0
    print("COMMON: ")
    print(common)
    print("UNCOMMON: ")
    print(uncommon)
    print("ZEROS: ")
    print(zeros)
    analyzeKenoData.checkNums(testFile, maxDraw, 10, uncommon[:3])
#Run test proven in 3 with
if trigger == 4:
    testFolder = 'kenoData/kenoNum01-2015'
    print("Testing with " + testFolder)
    #f_count = 0
    #t_count = 0
    for filename in os.listdir(testFolder):
        fullPath = (testFolder+'/'+filename)
        earnings = Tests.test4(fullPath, 4)
        print("EARNINGS: " + str(earnings))

'''
        if(Tests.test3(fullPath)):
            t_count+=1
        else:
            f_count+=1
    print("TRUE: "+ str(t_count))
    print("FALSE: " + str(f_count))
'''

#Step 1: Get Data from MA Keno site
#Get Yesterday's URL
'''
today = date.today()
Пример #21
0
def run():
    """ Get Test suite and run it """
    suite = Tests.suite()
    TextTestRunner(verbosity = 2 ).run(suite)
Пример #22
0
#================================================================
ff_original = ffClass.FlowFieldChannelFlow( file_info['Nd'],
                                            file_info['Nx'],
                                            file_info['Ny'],
                                            file_info['Nz'],
                                            file_info['Lx'],
                                            file_info['Lz'],
                                            file_info['alpha'],
                                            file_info['beta'],
                                            details['c'],
                                            details['bf'],
                                            details['Re'],
                                            file_info['ff'],
                                            "pp")

Tests.fft_ifft(ff_original)


#================================================================
#### Check velocity profile
#================================================================
# Create empty 4D array to store mean flow field
mean = np.zeros((file_info['Nd'], file_info['Nx'], file_info['Ny'], file_info['Nz']))
mean_profile = []

if args.MeanProfile: # Velocity profile given
    #------------------------------------------------
    #### Read velocity profile
    vel_profile = ut.read_Vel_Profile(parent_directory, args.MeanProfile)
    # Check to see if it is a mean profile or a deviation profile.
    deviation = any(n < 0 for n in vel_profile)
Пример #23
0
def main(File, Details, VelComponent, SpatialComponent, Coordinate,
         Full, SpatiallyAveraged, Quiver, Levels):
    #===================================================================#
    #### Format current directory path                               ####
    #===================================================================#
    pwd = ut.format_Directory_Path(os.getcwd())
    #===================================================================#
    #### Read file and details file                                  ####
    #===================================================================#
    file_info, original_attrs = ut.read_H5(File)
    details = ut.read_Details(Details)
    #===================================================================#
    #### Make output directory for images and change into it         ####
    #===================================================================#
    images_directory = ut.make_Folder(pwd, "images_" + str(File)[:-3], False)
    os.chdir(images_directory)
    #===================================================================#
    #### Initialise flow field class with given file                 ####
    #===================================================================#
    ff = ffClass.FlowFieldChannelFlow(  file_info['Nd'],
                                        file_info['Nx'],
                                        file_info['Ny'],
                                        file_info['Nz'],
                                        file_info['Lx'],
                                        file_info['Lz'],
                                        file_info['alpha'],
                                        file_info['beta'],
                                        details['c'],
                                        details['bf'],
                                        details['Re'],
                                        file_info['ff'],
                                        "pp")
    #===================================================================#
    #### Set velocity and spatial components                         ####
    #===================================================================#
    i = VelComponent
    n = SpatialComponent
    m=n+1; p=n-1
    if m==3:
        m=0
    if p==-1:
        p=2
    velName = ""
    if i==0:
        velName = "u"
    elif i==1:
        velName = "v"
    elif i==2:
        velName = "w"
    #===================================================================#
    #### Start plotting                                              ####
    #===================================================================#
    print("Plotting...")
    vl_max = np.amax(ff.velocityField[i, :, :, :])
    vl_min = np.amin(ff.velocityField[i, :, :, :])
    
    printFullTitle = True
    if Levels:
        contour_levels = Levels
    else:
        contour_levels = 20
    #===================================================================#
    #### If Full selected                                            ####
    #===================================================================#
    if Full:
        if n == 0:
            x_directory = ut.make_Folder(images_directory, "x", False)
            for j in range(0, ff.Nx):
                ut.plot_Contour(x_directory, str(File[:-3]), 
                                ff.z, ff.y, ff.velocityField[i, j, :, :], 
                                format(ff.x[j], '.2f'), ":", ":", 
                                ff.Re, 
                                str(j),  "-", "-",
                                ff.velocityField[m, j, :, :], 
                                ff.velocityField[p, j, :, :], 
                                "z", "y", velName,
                                vl_max, vl_min, Quiver, contour_levels,
                                printFullTitle)
        elif n == 1:
            y_directory = ut.make_Folder(images_directory, "y", False)
            for j in range(0, ff.Ny):
                ut.plot_Contour(y_directory, str(File[:-3]), 
                                ff.z, ff.x, ff.velocityField[i, :, j, :], 
                                ":", format(ff.y[j], '.2f'), ":", 
                                ff.Re, 
                                "-", str(j), "-", 
                                ff.velocityField[m, :, j, :], 
                                ff.velocityField[p, :, j, :], 
                                "z", "x", velName,
                                vl_max, vl_min, Quiver, contour_levels,
                                printFullTitle)
        elif n == 2:
            z_directory = ut.make_Folder(images_directory, "z", False)
            for j in range(0, ff.Nz):
                ut.plot_Contour(z_directory, str(File[:-3]), 
                                ff.x, ff.y, ff.velocityField[i, :, :, j].T, 
                                ":", ":", format(ff.z[j], '.2f'), 
                                ff.Re, 
                                "-", "-", str(j), 
                                ff.velocityField[m, :, :, j].T, 
                                ff.velocityField[p, :, :, j].T, 
                                "x", "y", velName,
                                vl_max, vl_min, Quiver, contour_levels,
                                printFullTitle)
    #===================================================================#
    #### If Co-Ordinate given                                        ####
    #===================================================================#
    printFullTitle = True
    if Coordinate:
        if n == 0:
            coords = Tests.indices(ff.x, lambda m: m > float(Coordinate))
            x_coord = coords[0]
            x_directory = ut.make_Folder(images_directory, "x", False)
            ut.plot_Contour(x_directory, str(File[:-3]), 
                            ff.z, ff.y, ff.velocityField[i, x_coord, :, :], 
                            format(ff.x[x_coord], '.2f'), ":", ":", 
                            ff.Re, 
                            str(x_coord),  "-", "-",
                            ff.velocityField[m, x_coord, :, :], 
                            ff.velocityField[p, x_coord, :, :], 
                            "z", "y", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
        elif n == 1:
            coords = Tests.indices(ff.y, lambda m: m > float(Coordinate))
            y_coord = coords[-1]
            y_directory = ut.make_Folder(images_directory, "y", False)
            ut.plot_Contour(y_directory, str(File[:-3]), 
                            ff.z, ff.x, ff.velocityField[i, :, y_coord, :], 
                            ":", format(ff.y[y_coord], '.2f'), ":", 
                            ff.Re, 
                            "-", str(y_coord), "-", 
                            ff.velocityField[m, :, y_coord, :], 
                            ff.velocityField[p, :, y_coord, :], 
                            "z", "x", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
        elif n == 2:
            coords = Tests.indices(ff.z, lambda m: m > float(Coordinate))
            z_coord = coords[0]
            z_directory = ut.make_Folder(images_directory, "z", False)
            ut.plot_Contour(z_directory, str(File[:-3]), 
                            ff.x, ff.y, ff.velocityField[i, :, :, z_coord].T, 
                            ":", ":", format(ff.z[z_coord], '.2f'), 
                            ff.Re, 
                            "-", "-", str(z_coord), 
                            ff.velocityField[m, :, :, z_coord].T, 
                            ff.velocityField[p, :, :, z_coord].T, 
                            "x", "y", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
    #===================================================================#
    #### If Spatially averaging selected                             ####
    #===================================================================#
    printFullTitle = False
    if SpatiallyAveraged:
        if n == 0:
            # Average the flow field in teh streamwise direction.
            x_averaged_ff = np.zeros((ff.Nd, ff.Ny, ff.Nz))
            for nd in range(0, ff.Nd):
                for nx in range(0, ff.Nx):
                    x_averaged_ff[nd, :, :] += ff.velocityField[nd, nx, :, :]
            x_averaged_ff *= (1.0 / ff.Nx)
            vl_max = np.amax(x_averaged_ff[i, :, :])
            vl_min = np.amin(x_averaged_ff[i, :, :])
            fileName = str(File)[:-3] + "_x_avgd_"
            ut.plot_Contour(images_directory, fileName, 
                            ff.z, ff.y, x_averaged_ff[i, :, :], 
                            "avg", ":", ":", 
                            ff.Re, 
                            "x-avg",  "-", "-",
                            x_averaged_ff[m, :, :], 
                            x_averaged_ff[p, :, :], 
                            "z", "y", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
        elif n == 1:
            # Average the flow field in teh streamwise direction.
            y_averaged_ff = np.zeros((ff.Nd, ff.Nx, ff.Nz))
            for nd in range(0, ff.Nd):
                for ny in range(0, ff.Ny):
                    y_averaged_ff[nd, :, :] += ff.velocityField[nd, :, ny, :]
            y_averaged_ff *= (1.0 / ff.Ny)
            vl_max = np.amax(y_averaged_ff[i, :, :])
            vl_min = np.amin(y_averaged_ff[i, :, :])
            fileName = str(File)[:-3] + "_y_avgd_"
            ut.plot_Contour(images_directory, fileName, 
                            ff.z, ff.x, y_averaged_ff[i, :, :], 
                            ":", "avg", ":", 
                            ff.Re, 
                            "-", "y-avg", "-", 
                            y_averaged_ff[m, :, :], 
                            y_averaged_ff[p, :, :], 
                            "z", "x", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
        elif n == 2:
            # Average the flow field in teh streamwise direction.
            z_averaged_ff = np.zeros((ff.Nd, ff.Nx, ff.Ny))
            for nd in range(0, ff.Nd):
                for nz in range(0, ff.Nz):
                    z_averaged_ff[nd, :, :] += ff.velocityField[nd, :, :, nz]
            z_averaged_ff *= (1.0 / ff.Nz)
            vl_max = np.amax(z_averaged_ff[i, :, :])
            vl_min = np.amin(z_averaged_ff[i, :, :])
            fileName = str(File)[:-3] + "_z_avgd_"
            ut.plot_Contour(images_directory, fileName,
                            ff.x, ff.y, z_averaged_ff[i, :, :].T, 
                            ":", ":", "avg", 
                            ff.Re, 
                            "-", "-", "z-avg", 
                            z_averaged_ff[m, :, :].T, 
                            z_averaged_ff[p, :, :].T, 
                            "x", "y", velName,
                            vl_max, vl_min, Quiver, contour_levels,
                            printFullTitle)
    ut.print_EndMessage()
Пример #24
0
    'switches': SYS.BPM.switches,
    'switch_val': SYS.BPM.switch_val,
    'attenuation': SYS.BPM.attn,
    'dsc': SYS.BPM.dsc,
    'kx': SYS.BPM.kx,
    'ky': SYS.BPM.ky
}

with open(subdirectory + "initial_BPM_state.json", 'w') as write_file:
    json.dump(data_out, write_file)

Tests.beam_position_equidistant_grid_raster_scan_test(
    test_system_object=SYS,
    rf_frequency=dls_RF_frequency,
    power_level=-40,
    nominal_attenuation=10,
    x_points=3,
    y_points=3,
    settling_time=settling_time,
    sub_directory=subdirectory)

Tests.beam_power_dependence(test_system_object=SYS,
                            frequency=dls_RF_frequency,
                            power_levels=np.arange(-40, -100, -10),
                            settling_time=settling_time,
                            sub_directory=subdirectory)

# Tests.fixed_voltage_amplitude_fill_pattern_test(test_system_object=SYS,
#                                                 frequency=dls_RF_frequency,
#                                                 max_power=-40,
#                                                 duty_cycles=np.arange(1, 0, -0.1),
Пример #25
0
def main(File, Rank, Directory, MeanProfile, Sparse, Testing):
    
    
    #================================================================
    #### Check file type
    #================================================================
    if File[-3:] == ".h5":
        print("HDF5 file given.")
        #------------------------------------------------------------
        #### Read the HDF5 and details file
        #------------------------------------------------------------
        file_info, original_attrs = ut.read_H5(File)
        details = ut.read_Details("eq1_Details.txt")
    
        #------------------------------------------------------------
        #### Copy geometry file into rank-temp
        #------------------------------------------------------------
        command = "field2ascii ../" + str(File) + " " + str(File)[:-3]
        os.system(command)
    
    elif File[-3:] == ".ff":
        #------------------------------------------------------------
        #### Convert the binary file to ascii
        #------------------------------------------------------------
        command = "field2ascii -p ../" + str(File) + " " + str(File)[:-3]
        print(command)
        os.system(command)
        #------------------------------------------------------------
        #### Read ASCII file and details file
        #------------------------------------------------------------
        file_info = ut.read_ASC_channelflow("", str(File)[:-3])
        details = ut.read_Details("", "u0_Details.txt")
    
    
    elif File[-3:] == "asc":
        #------------------------------------------------------------
        #### Read ASCII file and details file
        #------------------------------------------------------------
        file_info = ut.read_ASC_PP("", str(File)[:-7])
        details = ut.read_Details("", "u0_Details.txt")
    
    
    else: # No file type given.
        ut.error("Invalid file given.")
    
    
    
    #================================================================
    #### Initialise flow field object for field (to approximate)
    #================================================================
    ff_original = ffClass.FlowFieldChannelFlow( file_info['Nd'],
                                                file_info['Nx'],
                                                file_info['Ny'],
                                                file_info['Nz'],
                                                file_info['Lx'],
                                                file_info['Lz'],
                                                file_info['alpha'],
                                                file_info['beta'],
                                                details['c'],
                                                details['bf'],
                                                details['Re'],
                                                file_info['ff'],
                                                "pp")
    
    Tests.fft_ifft(ff_original)
    
    
    #================================================================
    #### Check velocity profile
    #================================================================
    # Create empty 4D array to store mean flow field
    mean = np.zeros((file_info['Nd'], file_info['Nx'], file_info['Ny'], file_info['Nz']))
    mean_profile = []
    
    if MeanProfile: # Velocity profile given
        #------------------------------------------------------------
        #### Read velocity profile
        #------------------------------------------------------------
        vel_profile = ut.read_Vel_Profile("", MeanProfile)
        # Check to see if it is a mean profile or a deviation profile.
        deviation = any(n < 0 for n in vel_profile)
        if deviation: # Deviation profile given
            # Add baseflow to deviation
            baseflow = []
            if details['bf'] == "lam": # Laminary base flow
                baseflow = 1.0 - ff_original.y**2.0
            elif details['bf'] == "cou": # Couette base flow
                baseflow = ff_original.y
    
            # Add baseflow to deviation to get turbulent mean profile
            mean_profile = vel_profile + np.asarray(baseflow)
    
        else: # Turbulent mean profile given
            mean_profile = vel_profile
    
        #------------------------------------------------------------
        #### Construct 4D array from mean_profile
        #------------------------------------------------------------
        mean = ut.make_ff_from_profile(vel_profile, 
                                       ff_original.Nd, 
                                       ff_original.Nx, 
                                       ff_original.Nz)
    else:
        #------------------------------------------------------------
        #### Use base flow only
        #------------------------------------------------------------
        # Add baseflow to deviation
        baseflow = []
        if details['bf'] == "lam": # Laminary base flow
            baseflow = 1.0 - ff_original.y**2.0
        elif details['bf'] == "cou": # Couette base flow
            baseflow = ff_original.y
    
        #------------------------------------------------------------
        #### Construct 4D array from mean_profile
        #------------------------------------------------------------
        mean = ut.make_ff_from_profile(np.asarray(baseflow), ff_original.Nd, ff_original.Nx, ff_original.Nz)

    
    #================================================================
    #### Initialize mean flow field object
    #================================================================
    ff_mean = ffClass.FlowFieldChannelFlow( file_info['Nd'],
                                            file_info['Nx'],
                                            file_info['Ny'],
                                            file_info['Nz'],
                                            file_info['Lx'],
                                            file_info['Lz'],
                                            file_info['alpha'],
                                            file_info['beta'],
                                            details['c'],
                                            details['bf'],
                                            details['Re'],
                                            mean,
                                            "pp")
    
    
    #================================================================
    #### ---- Remove the wall boundaries
    #================================================================
    # Removing the xz-planes at y=1 and y=-1,
    # so that the chebyshev nodes can be used to construct 
    # the transfer function.
    ff_original.remove_wall_boundaries()
    ff_mean.remove_wall_boundaries()
    
    
    #================================================================
    #### ---- Fourier transform in xz directions
    #================================================================
    ff_original.make_xz_spectral()
    ff_mean.make_xz_spectral()
    
    
    #================================================================
    #### ---- Stack velocity fields in the wall-normal direction
    #================================================================
    ff_original.stack_ff_in_y()
    ff_mean.stack_ff_in_y()
    
    
    #================================================================
    #### Create arrays of Fourier modes to use
    #================================================================
    # Modes multiplied with fundamental wavenumbers
    #(Modes: the physical modes, i.e. the grid points)
    kx_array = ff_original.Mx * ff_original.alpha
    kz_array = ff_original.Mz * ff_original.beta
    
        
#    Tests.checkHermitianSymmetry(ff_original.velocityField[:,0:ff_original.numModes,:],
#                                 ff_original.Nx, 
#                                 ff_original.Nz)
#    Tests.checkHermitianSymmetry(ff_original.velocityField[:,ff_original.numModes:ff_original.numModes*2,:],
#                                 ff_original.Nx, 
#                                 ff_original.Nz)
#    Tests.checkHermitianSymmetry(ff_original.velocityField[:,2*ff_original.numModes:ff_original.numModes*3,:],
#                                 ff_original.Nx, 
#                                 ff_original.Nz)

    
    #================================================================
    #### Ensure valid rank is specified
    #================================================================
    rank = min(Rank, 3*ff_original.numModes)
    
    
    
    #### -!-!- TESTING -!-!-:   Zeroth mode differences
    if MeanProfile:
        spectral_mean_profile = np.zeros((3*ff_original.numModes),dtype=complex)
        mean_profile_sp = np.fft.fft(mean_profile)
        spectral_mean_profile[1:ff_original.numModes] = mean_profile_sp[1:ff_original.numModes]
        origFF = ff_original.velocityField[0, :, 0]
        diffs = spectral_mean_profile - origFF
        
        diffsn = np.linalg.norm(diffs)
    #    print("%.2E" % diffsn)
        
    
    
    #### -!-!- TESTING -!-!-:   Synthesizing a Fourier domain flow field
#    fake_field = ff_original.velocityField
##    fake_field *= 0.0+0.0j
##    fake_field[1,:,1] += 1.0+2.0j
##    fake_field[1,:,-1] += 1.0-2.0j
#    
    
    
    #================================================================
    #### Deconstruct original flow field
    #================================================================
    deconstructed_field = cr.test_deconstruct_field(ff_original.velocityField,
                                                      kx_array,
                                                      kz_array,
                                                      ff_original.numModes,
                                                      ff_original.y,
                                                      ff_original.c,
                                                      ff_original.Re,
                                                      ff_original.baseflow,
                                                      mean_profile,
                                                      Sparse)


    #================================================================
    #### Reconstruct approximated flow field
    #================================================================
    approximated_ff_spectral = cr.test_construct_field(deconstructed_field['resolvent_modes'],
                                                          deconstructed_field['singular_values'],
                                                          deconstructed_field['coefficients'],
                                                          kx_array,
                                                          kz_array,
                                                          ff_original.numModes,
                                                          rank,
                                                            mean_profile,
                                                            ff_original.baseflow,
                                                            ff_original.y)






    #### -!-!- TESTING -!-!-:   Synthesizing a Fourier domain flow field
    # The retrieved field should be the same as the fak_field...
    retrieved_difference = approximated_ff_spectral - ff_original.velocityField
    retrieved_difference_n = np.linalg.norm(retrieved_difference)


    #================================================================
    #### Initialize approximated flow field object
    #================================================================
    ff_approximated = ffClass.FlowFieldChannelFlow( file_info['Nd'],
                                                    file_info['Nx'],
                                                    ff_original.numModes, # the velocity field is missing wall boundaries
                                                    file_info['Nz'],
                                                    file_info['Lx'],
                                                    file_info['Lz'],
                                                    file_info['alpha'],
                                                    file_info['beta'],
                                                    details['c'],
                                                    details['bf'],
                                                    details['Re'],
                                                    approximated_ff_spectral,
                                                    "sp")
    

    
    
    # If not symmetric: you need to filter the negative frequencies in the approximated result.
    # This will introduce hermitian symmetry.


    #================================================================
    #### ---- Unstack velocity fields in the wall-normal direction
    #================================================================
    ff_approximated.unstack_ff()
    ff_mean.unstack_ff()
    ff_original.unstack_ff()
    
    
    #================================================================
    #### ---- Inverse Fourier transform approximated and mean velocity fields in xz directions
    #================================================================
    ff_approximated.make_xz_physical()
    ff_mean.make_xz_physical()
    ff_original.make_xz_physical()

    
    #================================================================
    #### ---- Add wall boundaries
    #================================================================
    ff_approximated.add_wall_boundaries()
    ff_mean.add_wall_boundaries()
    ff_original.add_wall_boundaries()
    

    #================================================================
    #### Remove mean flow from approximated field (if mean used to reconstruct)
    #================================================================
#    approximated_field = ff_approximated.velocityField.real - ff_mean.velocityField.real
#    ff_approximated.set_ff(approximated_field, "pp")
#
#    difference = np.linalg.norm(approximated_field - ff_approximated.velocityField)



    #### -!-!- TESTING -!-!-:   Full-Rank decomposition and recomposition: (Real Domain)
    u_a = ff_approximated.velocityField[0,:,:,:].real
    u_o = ff_original.velocityField[0,:,:,:].real
    difference = np.linalg.norm(ff_original.velocityField.real - ff_approximated.velocityField.real)
    print("")
    print("The norm of the difference is " + str(difference))
    print("")
    
    #### -!-!- TESTING -!-!-:   Projections
    if Testing:
        #### Remove boundaries
        ff_approximated.remove_wall_boundaries()
        #### FFT
        ff_approximated.make_xz_spectral()
        #### stack in y
        ff_approximated.stack_ff_in_y()
        #### Deconstruct the approximated flow field.
        deconstructed_approximated = cr.deconstruct_field(ff_approximated.velocityField,
                                                          kx_array,
                                                          kz_array,
                                                          ff_approximated.numModes,
                                                          ff_approximated.c,
                                                          ff_approximated.Re,
                                                          ff_approximated.baseflow,
                                                          rank,
                                                          mean_profile,
                                                          Sparse,
                                                          False)
        #### Reconstruct projected approximated flow field.
        doubly_approximated_ff_spectral = cr.construct_field( deconstructed_approximated['resolvent_modes'],
                                                              deconstructed_approximated['singular_values'],
                                                              deconstructed_approximated['coefficients'],
                #                                             ff_mean.velocityField,
                                                              kx_array,
                                                              kz_array,
                                                              ff_approximated.numModes)

        #### Initialize projected approximated flow field object.
        ff_doubly_approximated = ffClass.FlowFieldChannelFlow(  file_info['Nd'],
                                                                file_info['Nx'],
                                                                ff_approximated.numModes, # the velocity field is missing wall boundaries
                                                                file_info['Nz'],
                                                                file_info['Lx'],
                                                                file_info['Lz'],
                                                                file_info['alpha'],
                                                                file_info['beta'],
                                                                details['c'],
                                                                details['bf'],
                                                                details['Re'],
                                                                doubly_approximated_ff_spectral,
                                                                "sp")

        #### unstack
        ff_doubly_approximated.unstack_ff()
        ff_approximated.unstack_ff()
        #### IFFT
        ff_doubly_approximated.make_xz_physical()
        ff_approximated.make_xz_physical()
        #### add wall boundaries
        ff_doubly_approximated.add_wall_boundaries()
        ff_approximated.add_wall_boundaries()


        #### check differences between modes/sing vals/coeffs
        del_sigma = deconstructed_approximated['singular_values'] - deconstructed_field['singular_values']
        del_sigmaR = del_sigma.real
        del_sigmaI = del_sigma.imag
        del_sigma_n = np.linalg.norm(del_sigma)
        print("\n\n||sigma_tilde - sigma|| = " + str(del_sigma_n))
    
        del_psi = deconstructed_approximated['resolvent_modes'] - deconstructed_field['resolvent_modes']
        del_psiR = del_psi.real
        del_psiI = del_psi.imag
        del_psi_n = np.linalg.norm(del_psi)
        print("\n\n||psi_tilde - psi|| = " + str(del_psi_n))
    
        del_xi = deconstructed_approximated['coefficients'] - deconstructed_field['coefficients']
        del_xiR = del_xi.real
        del_xiI = del_xi.imag
        del_xi_n = np.linalg.norm(del_xi)
        print("\n\n||xi_tilde - xi|| = " + str(del_xi_n))
        
        
        del_ff = ff_doubly_approximated.velocityField.real - ff_approximated.velocityField.real
        dim_a = ff_approximated.velocityField.shape
        print("\nDimension of approximated ff: " + str(dim_a))

        dim_da = ff_doubly_approximated.velocityField.shape
        print("\nDimension of doubly approximated ff: " + str(dim_da))

        del_ff_n = np.linalg.norm(del_ff)
        print("\n\n||u_tilde_tilde - u_tilde|| = " + str(del_ff_n))
    
    
    
    
    
    #================================================================
    #### Create a folder to store the approximated velocity field in
    #================================================================
    os.chdir(parent_directory) # Go up one directory
    rank_folder = File[:-3]+"_rank_" + str(rank) + "/"
    rank_folder = parent_directory + rank_folder
    
    #if a rank directory does exist, delete it:
    if os.path.exists(rank_folder):
        command = "rm -rf " + rank_folder
        os.system(command)
    
    #if a rank directory doesn't exist, create one:
    if not os.path.exists(rank_folder):
        os.mkdir(rank_folder)
    
    # Change into the new rank directory
    os.chdir(rank_folder)
    
    
    #================================================================
    #### Save flow field to file
    #================================================================
    # Check file type
    if File[-3:] == ".h5":
        #------------------------------------------------------------
        # Write the file to disk in H5 format
        #------------------------------------------------------------
        fileName = File[:-3] + "_rnk_" + str(rank)
        ut.write_ASC(ff_approximated, rank_folder, fileName)
        #------------------------------------------------------------
        # Write binary file
        #------------------------------------------------------------
        command = "ascii2field -p false -ge ../rank-temp/" + str(File)[:-3] + ".geom " + fileName + ".asc " + fileName + ".h5"
        print(command)
        os.system(command)
    
    
    elif File[-3:] == ".ff":
        #------------------------------------------------------------
        # Write physical ascii file
        #------------------------------------------------------------
        fileName = File[:-3] + "_rnk_" + str(rank)
        ut.write_ASC(ff_approximated, rank_folder, fileName)
    
        #------------------------------------------------------------
        # Write binary file
        #------------------------------------------------------------
        command = "ascii2field -p false -ge ../rank-temp/" + str(File)[:-3] + ".geom " + fileName + ".asc " + fileName + ".ff"
        print(command)
        os.system(command)
    
    
    elif File[-3:] == "asc":
        #------------------------------------------------------------
        # Write physical ascii file
        #------------------------------------------------------------
        fileName = File[:-3] + "_rnk_" + str(rank)
        ut.write_ASC_Py(ff_approximated, rank_folder, fileName)
    
    
    #================================================================
    #### Write decomposed flow field to HDF5 object.
    #================================================================
    fileName = File[:-3] + "_coeffs"
    ut.write_amplitude_coefficients(ff_approximated, rank_folder, fileName, deconstructed_field['coefficients'])
    
    ut.write_Deconstructed_Field(deconstructed_field, ff_approximated, parent_directory, File[:-3])
    
    
    
    #================================================================
    # Remove ascii file and temporary folder
    #================================================================
    #    os.system("rm *.asc")
    os.chdir(parent_directory)
#    command = "rm -rf " + temp_rank_folder
#    os.system(command)
    
    
    print("\nFinished")
from scripts import PharaohConvert
from src import Constants
import Tests
import PrintTools

convert = PharaohConvert.get_alignments()
sentences = Tests.read_test_data(
    r"/home/nikolaj/PycharmProjects/LitteralJapaneseTranslation/data/sentences_dev.txt"
)
sentences = Tests.merge_word_endings(sentences)
scores = []

i = 1
for sentence in sentences:
    system = [(k, v) for k, v in convert.get(i).items()]
    gold = sentence.tokens
    score = Tests.translation_sentence_score(gold, system)
    PrintTools.print_translated_sentence(sentence, system, gold, score)
    scores.append(Tests.TranslationScore(len(gold), score))
    i += 1

avg = Tests.TranslationScore.make_average(scores)
print("#### average result (Levenshtein distance) ####")
avg.print()
Пример #27
0
	data = client.post(request, headers)

	# print(json.dumps(data, indent=4))

	return data


################
# Main Program
################

if __name__ == "__main__":

	# check program usage
	if len(sys.argv) < 2:
		print("Usage: Bitfinex.py key.txt\n")
		print("key.txt format:")
		print("LINE 1: public key")
		print("LINE 2: private key")
		exit()

	# TICKER: get IOTA/USD pair state
	#data = b.get(url)
	#print(json.dumps(data, indent=4))

	# passing bitfinex obj to test module
	T.run_tests()



import pygame
import Tests as RN
import variables as var
import numpy as np

ancho = 700
alto = 500

if __name__ == "__main__":

    #----------------Inicio----------------
    pygame.init()
    RN.iniciar()
    pantalla = pygame.display.set_mode([ancho, alto])
    fin = False
    #------------------------------------------------
    Tancho = ancho / 2
    en_x = 85
    en_y = 150
    for elemento_vertical in range(len(var.segmentos_verticales)):
        var.segmentos_verticales[elemento_vertical].rect.x = en_x
        var.segmentos_verticales[elemento_vertical].rect.y = en_y

        if elemento_vertical < 1:
            en_y += 105
        elif (elemento_vertical >= 1 and elemento_vertical < 2):
            en_x += 120
        else:
            en_y -= 105

    #-----------------------------------------------------
import LiteralJapanese
import Tests
from Similarity import init_similarity
import Dictionary
import Equality
import Translator
from Grammar import Grammar

sentences = Tests.read_test_data(
    r"C:\Users\Nikolaj\PycharmProjects\LitteralJapaneseTranslation\data\sentences_dev.txt"
)
init_similarity()
wrong_def = 0
wrong_word = 0
particle_error = 0
other = 0

for sentence in sentences:
    system = LiteralJapanese.translate(sentence.japanese,
                                       translation=sentence.english)
    gold = sentence.tokens
    min_len = min(len(system), len(gold))
    for i in range(min_len - 1):
        s_token = system[i]
        g_token = gold[i]
        if s_token.japanese == g_token.japanese:
            is_particle = False
            if s_token.token.grammar == Grammar.PARTICLE:
                is_particle = True

            if not Equality.equals(
ff1.make_xz_spectral()
ff2.make_xz_spectral()
#===================================================================#
#### ---- Stack velocity fields in the wall-normal direction     ####
#===================================================================#
ff1.stack_ff_in_y()
ff2.stack_ff_in_y()
#===================================================================#
#### Calculate amplitude/phase difference                        ####
#===================================================================#
tolerance = 1e-9
print("==========================================")
print("Differences between " + args.File1[:-3] + " and " + args.File2[:-3])
print("==========================================")
message = "Amplitude difference between " + args.File1[:-3] + " and " + args.File2[:-3]
diff_A = Tests.difference(abs(ff1.velocityField), abs(ff2.velocityField), tolerance, message)
diff_P = mean(angle(ff1.velocityField,deg=True) - angle(ff2.velocityField,deg=True))
print("Amplitude diff \t\t%.2E" % diff_A)
print("")
print("Field 1 (deg) \t\t%.6f (avg)" % mean(angle(ff1.velocityField,deg=True)))
print("Field 2 (deg) \t\t%.6f (avg)" % mean(angle(ff2.velocityField,deg=True)))
print("Phase diff (deg) \t%.6f (avg)" % diff_P)
print("")
#===================================================================#
#### Euler form of Fourier transformed field                     ####
#===================================================================#
print("==========================================")
print("Reconstructed using Euler formula")
print("==========================================")
test_ff1 = abs(ff1.velocityField) * exp(1j * angle(ff1.velocityField))
test_ff2 = abs(ff2.velocityField) * exp(1j * angle(ff2.velocityField))
Пример #31
0
import Constants
import logging
import time

# Instantiate objects.
constant = Constants.ConstantsHandle()
# Set logger configuration.
logging.basicConfig(filename=constant.log_file_location +
                    time.strftime("%Y-%m-%d", time.localtime()) + '.log',
                    format="%(asctime)s:%(levelname)s:%(message)s",
                    level=logging.DEBUG)
# Instantiate logger.
log = logging.getLogger(__name__)

# Instantiate objects.
test = Tests.TestHandle()

# Log event.
log.info('Starting DQSEGDB Regression Test Suite (' + constant.app_version +
         ')...')

# Init.
loop = True

try:
    # Loop.
    while loop:
        # Begin attempt.
        try:
            test.run_test_suite()
        # If user stops server.
Пример #32
0
# Author: Gavrila Andrei
# Scope: Fundamentals of Programming homework

import Tests
import App

Tests.run()
App.run()
print("Come again!")
Пример #33
0
def test_deconstruct_field(original_ff_spectral,
                             kx_array,
                             kz_array,
                             Nm,
                             y,
                             c,
                             Re,
                             baseflow,
                             mean_profile,
                             sparse):

    #===============================================================#
    #### Store the resolvent modes and amplitude coefficients    ####
    #    at each  Fourier mode pair                                 #
    #===============================================================#
    resolvent_modes_array = np.zeros((len(kx_array), len(kz_array), 3*Nm, 3*Nm), dtype=np.complex128)
    forcing_modes_array = np.zeros((len(kx_array), len(kz_array), 3*Nm, 3*Nm), dtype=np.complex128)
    coefficients_array = np.zeros((len(kx_array), len(kz_array), 3*Nm), dtype=np.complex128)
    sing_vals_array = np.zeros((len(kx_array), len(kz_array), 3*Nm), dtype=np.float64)

    #================================================================
    #### Loop through wavenumbers 
    #================================================================
    chebyshev_differentiation, mean_flow_derivatives = ps.calculate_derivatives(Nm+2, mean_profile, baseflow)


    #================================================================
    #### FFT mean profile
    #================================================================
    spectral_deviation_profile = np.zeros((3*Nm),dtype=complex)
    if len(mean_profile) == 0:
        spectral_deviation_profile = original_ff_spectral[0,:,0]
    
    else:
        # Remove baseflow from turbulent mean profile
        baseflow_profile = []
        if baseflow == "lam": # Laminary base flow
            baseflow_profile = 1.0 - y**2.0
        elif baseflow == "cou": # Couette base flow
            baseflow_profile = y

        # Remove baseflow from mean to get turbulent deviation profile
        vel_profile = mean_profile - np.asarray(baseflow_profile)
        deviation_profile_sp = np.fft.fft(vel_profile)
        spectral_deviation_profile[1:Nm] = deviation_profile_sp[1:Nm]
    
    
    #================================================================
    #### Loop through wavenumbers 
    #================================================================
    startTime = datetime.now()
    for mx in range(0, len(kx_array)):
        kx = kx_array[mx]
        print('\n\nkx:'+ str(kx))

        for mz in range(0, len(kz_array)):
            kz  = kz_array[mz]
            sys.stdout.write(".")
            sys.stdout.flush()

            if kx == 0 and kz == 0: # Zeroth Fourier modes
                resolvent_modes_array[mx, mz, :, 0] = spectral_deviation_profile
                continue # Start the loop again


            #--------------------------------------------------------
            #### Calculate the state vectors
            #--------------------------------------------------------
            omega = kx * c
            wegihted_transfer_function, w = ps.calculate_transfer_function(kx, kz, Re, Nm, omega, chebyshev_differentiation, mean_flow_derivatives)


            #--------------------------------------------------------
            #### Perform SVD
            #--------------------------------------------------------
            if sparse:
                weighted_resolvent_modes, singular_values, weighted_forcing_modes = svd(wegihted_transfer_function, full_matrices=False)
            else:
                weighted_resolvent_modes, singular_values, weighted_forcing_modes = svd(wegihted_transfer_function)


            #--------------------------------------------------------
            #### Test: SVD
            #--------------------------------------------------------
            Tests.SVD(weighted_resolvent_modes, singular_values, weighted_forcing_modes, wegihted_transfer_function, sparse)


            #--------------------------------------------------------
            #### Test: Orthogonality
            #--------------------------------------------------------
            Tests.orthogonality(weighted_resolvent_modes)
            Tests.orthogonality(weighted_forcing_modes)


            #--------------------------------------------------------
            #### Test: Invertibility
            #--------------------------------------------------------
            Tests.invertible(np.diag(singular_values))
            
            
            #--------------------------------------------------------
            #### Retrieve non-grid-weighted (physical) modes
            #--------------------------------------------------------
            weighted_resolvent_modes = np.asmatrix(weighted_resolvent_modes)
            weighted_forcing_modes = np.asmatrix(weighted_forcing_modes)
            resolvent_modes = np.linalg.solve(w, weighted_resolvent_modes)
            forcing_modes = np.linalg.solve(w, weighted_forcing_modes)
            
            
            #--------------------------------------------------------
            #### Check that the continuity condition is satisfied
            #--------------------------------------------------------
            Tests.continuity(resolvent_modes, np.diag(singular_values), kx, kz, Nm, chebyshev_differentiation['D1'])


            #--------------------------------------------------------
            #### Fix phase of resolvent modes based on critical layer or centreline
            #--------------------------------------------------------
            phase_shift = np.zeros((resolvent_modes.shape[1], resolvent_modes.shape[1]), dtype=np.complex128)
            ind0 = Nm/2 + 1 # Use centreline, unless
            if c < 1.0:
                inds = Tests.indices(mean_flow_derivatives['U'].diagonal(), lambda x: x > c)
                if len(inds) > 0:
                    ind0 = inds[0]

            np.fill_diagonal(phase_shift, np.exp(-1j * np.angle(resolvent_modes[ind0,:])))
            resolvent_modes *= phase_shift


            #--------------------------------------------------------
            #### Project resolvent modes to get amplitude coefficients
            #--------------------------------------------------------
            # Initialize amplitude coefficients vector
            ampl_coeffs = np.zeros((3*Nm, 1), dtype=np.complex128)    

            # Projection
            ampl_coeffs = inv(np.diag(singular_values)) * resolvent_modes.H * w.H * w * np.asmatrix(original_ff_spectral[mx, :, mz]).T
            Tests.projection(ampl_coeffs, np.diag(singular_values), resolvent_modes, np.asmatrix(original_ff_spectral[mx, :, mz]).T, 1e-10)
            
#            phase_test = False
#            norm_test  = False
#            xi_norm = np.linalg.norm(xi)
#            if kz == 2.0 or kz == -2.0: 
#            #xi_norm >= 1e-10:
#                # Phase test
#                if phase_test:
#                    print("\nApplying phase shift at: " + str(kz) + "\n ")
#                    # shift the field by pi/3
#                    xi += 1.0j*(np.pi/3.0)
#
#                # Norm test
#                if norm_test:
#                    print("\nApplying norm doubling.")
#                    # Double the energy of the field
#                    xi *= np.sqrt(2.0) + 1.0j*np.sqrt(2.0)
#
#                # Fix xi to see if same coefficients are retrieved from projection
#                if fixXi:
#                    xi[0] = 1.0
#                    xi[1] = 0.0
#                    print("\nXI:")
#                    print("norm: " + str(xi_norm))
#                    print(xi)
#                    print("")
#                print(xi)


            #--------------------------------------------------------
            #### Store resolvent modes, singular values and amplitude coeffs.
            #--------------------------------------------------------
            resolvent_modes_array[mx, mz, :, :] = resolvent_modes
            forcing_modes_array[mx, mz, :, :] = forcing_modes
            coefficients_array[mx, mz, :] = np.squeeze(np.asarray(ampl_coeffs))
            sing_vals_array[mx, mz, :] = singular_values


    calcTime = datetime.now() - startTime
    print("\n\n\n")
    print(calcTime)
    print("\n\n\n")
    deconstructed_dict = {}
    deconstructed_dict['resolvent_modes'] = resolvent_modes_array
    deconstructed_dict['forcing_modes'] = forcing_modes_array
    deconstructed_dict['singular_values'] = sing_vals_array
    deconstructed_dict['coefficients'] = coefficients_array


    return deconstructed_dict
Пример #34
0
def tests_for_single_bpm(test_sys,
                         data_location,
                         rf_frequency,
                         settling_time=0.1):
    root_path = '/'.join(
        (data_location, test_sys.BPM.mac_address.replace(':', '-'),
         time.strftime("%d-%m-%Y_T_%H-%M")))
    if not os.path.exists(root_path):
        os.makedirs(root_path)

    subdirectory = ''.join((root_path, '/'))

    data_out = {
        'epics_id': test_sys.BPM.epics_id,
        'rf_id': test_sys.rf_id,
        'prog_atten_id': test_sys.prog_atten_id,
        'mac_address': test_sys.BPM.mac_address,
        'first_turn': test_sys.BPM.ft,
        'agc': test_sys.BPM.agc,
        'delta': test_sys.BPM.delta,
        'switches': test_sys.BPM.switches,
        'switch_val': test_sys.BPM.switch_val,
        'attenuation': test_sys.BPM.attn,
        'dsc': test_sys.BPM.dsc,
        'kx': test_sys.BPM.kx,
        'ky': test_sys.BPM.ky,
        'bpm_spec': test_sys.BPM.spec
    }

    with open(subdirectory + "initial_BPM_state.json", 'w') as write_file:
        json.dump(data_out, write_file)

    Tests.adc_test(test_system_object=test_sys,
                   frequency=rf_frequency,
                   output_power_level=-4,
                   settling_time=settling_time,
                   sub_directory=subdirectory)

    Tests.adc_int_atten_sweep_test(test_system_object=test_sys,
                                   frequency=rf_frequency,
                                   output_power_level=-4,
                                   settling_time=settling_time,
                                   sub_directory=subdirectory)

    Tests.beam_power_dependence(test_system_object=test_sys,
                                frequency=rf_frequency,
                                output_power_levels=range(-4, -30, -5),
                                settling_time=settling_time,
                                samples=100,
                                sub_directory=subdirectory)

    Tests.beam_position_equidistant_grid_raster_scan_test(
        test_system_object=test_sys,
        rf_frequency=rf_frequency,
        output_power_level=-6,
        x_points=3,
        y_points=3,
        settling_time=settling_time,
        samples=100,
        sub_directory=subdirectory)
    print '\nData stored in ', subdirectory
    return subdirectory
Пример #35
0
import Tests

if __name__ == '__main__':
    print "WoWLootSimulator::Begin"

    numberOfFreshGearingRuns = 10000
    numberOfRaidWeeks = 40
    lootSimulationTest = Tests.Tests(numberOfFreshGearingRuns,
                                     numberOfRaidWeeks)

    #lootSimulationTest.Test_Realistic()
    lootSimulationTest.Test_Realistic_BalancedRoster()
    #lootSimulationTest.Test_PerfectLootCouncil_BalancedRoster()
    #lootSimulationTest.Test_NoPersonalLootItemTrading()

    print "WoWLootSimulator::End"
Пример #36
0
import pyglet
from pyglet.gl import gl
import Tests
import os
import qatrack
import copy


# copies files from qa folder and puts it in our directory
os.system("del_copy.bat")

# get all our test names and get unique parent tests (i.e ML11 from ML11_e and ML11_p)
tests = Tests.tests()
unique_tests = list(set([t.split('_')[0] for t in tests.test_info.keys()]))
unique_tests.sort()
organized_tests = {}

for t in tests.test_info:
    parent_test = t.split('_')[0]
    if parent_test not in organized_tests:
        organized_tests[parent_test] = [t]
    else:
        organized_tests[parent_test].append(t)

print organized_tests

background_color = (0.98, 0.98, 0.98, 1)


class Rectangle(object):
    '''Draws a rectangle into a batch.'''
Пример #37
0
                  " State: " + str(self.state) + "\n" +
                  " Country: " + str(self.country) + "\n")

        def delLastName(self):
            # TODO this is broken because dict key
            self.lastname = ''

# testing
if __name__ == '__main__':

    # Book class
    bookobj = Book('jfb_000')

    # add first contact
    Tests.testbook(bookobj=bookobj, firstname='Jesse', lastname='Bowman',
        phonenumber='423.555.3443', emailaddress='*****@*****.**',
        street='1506 12th Ave Unit 420', city='Seattle', state='WA',
        country='USA')

    # add second contact
    Tests.testbook(bookobj=bookobj, firstname='Clandor', lastname='Dinkles', phonenumber='555.341.3443',
                   emailaddress='*****@*****.**', street='1414', city='Bristol', state='TN', country='USA')

    # add third contact with shared values
    Tests.testbook(bookobj=bookobj, firstname='Jesse\'s', lastname='GF', phonenumber='205.555.1123',
                   emailaddress='*****@*****.**', street='', city='Seattle', state='WA',
                   country='USA')

    # add a fourth contact with different shared values (want to test searching by some matches and some not)
    Tests.testbook(bookobj=bookobj, firstname='Jesse', lastname='Other', phonenumber='423.555.3443',
                   emailaddress='*****@*****.**', street='1506 12th Ave Unit 421', city='Seattle', state='WA',
                   country='USA')
Пример #38
0
import generadores as gn
import Tests as ts
import numpy.matlib as np
import random

gen = gn.ranGen()
testers = ts.tests()
nrosRandomLFG = gen.randLFG(6,7,100)
nrosRandomGLC = gen.randGCL(15,100)
nrosRandomPy = []
for i in range(100):
    nrosRandomPy.append(random.random())
#testers.testCorridas(nrosRandom)
print('------------------------------------------------------------------------------')
print('| Generadores \ Test | Chi Cuadrado | Kolmogorov-Smirnov | Corridas | Series |')
print('|--------------------|--------------|--------------------|----------|--------|')
print('|         GLC        |   '+testers.chiSqTest(nrosRandomGLC)+'   |      '+testers.testKS(nrosRandomGLC)+'      | '+testers.testCorridas(nrosRandomGLC)+' |   '+testers.series(nrosRandomGLC)+'|')
print('|--------------------|--------------|--------------------|----------|--------|')
print('|         LFG        |    '+testers.chiSqTest(nrosRandomLFG)+'     |       '+testers.testKS(nrosRandomLFG)+'        |   '+testers.testCorridas(nrosRandomLFG)+'  |   '+testers.series(nrosRandomLFG)+'|')
print('|--------------------|--------------|--------------------|----------|--------|')
print('|      randrange     |   '+testers.chiSqTest(nrosRandomPy)+'   |      '+testers.testKS(nrosRandomPy)+'      | '+testers.testCorridas(nrosRandomPy)+' |   '+testers.series(nrosRandomPy)+'|')
print('------------------------------------------------------------------------------')

#for i in nrosRandom:
#   print(i)





Пример #39
0
 def OnTest(self, event):
     import Tests
     Tests.test_wxFrame(self)
Пример #40
0
 def debug(self):
     r = jsonpickle.encode(Tests.test_puntuacion(), unpicklable=False)
     return json.loads(r)
def main(File, Details, MeanProfile, Sparse):
    #================================================================
    #### Format the output directory
    #================================================================
    if File[-3:] == ".h5":
    #    print("HDF5 file given.")
        #------------------------------------------------------------
        #### Read the HDF5 and details file
        #------------------------------------------------------------
        file_info, original_attrs = ut.read_H5(File)
        details = ut.read_Details(Details)
    elif File[-3:] == ".ff":
    #    print("Channelflow binary file given.")
        #------------------------------------------------------------
        #### Convert from .ff to .h5
        #------------------------------------------------------------
        command = "fieldconvert " + File + " " + File[:-3] + ".h5"
        #------------------------------------------------------------
        #### Read the HDF5 and details file
        #------------------------------------------------------------
        file_info = ut.read_H5(File)
        details = ut.read_Details(Details)
    else: # No file type given.
        ut.error("Invalid file given.")
    field_u = file_info['ff'][0,:,:,:]
    field_v = file_info['ff'][1,:,:,:]
    field_w = file_info['ff'][2,:,:,:]
    
    #================================================================
    #### Initialise flow field object for field (to approximate)
    #================================================================
    ff_original = ffClass.FlowFieldChannelFlow( file_info['Nd'],
                                                file_info['Nx'],
                                                file_info['Ny'],
                                                file_info['Nz'],
                                                file_info['Lx'],
                                                file_info['Lz'],
                                                file_info['alpha'],
                                                file_info['beta'],
                                                details['c'],
                                                details['bf'],
                                                details['Re'],
                                                file_info['ff'],
                                                "pp")
    Tests.fft_ifft(ff_original)
    #================================================================
    #### Check velocity profile
    #================================================================
    # Create empty 4D array to store mean flow field
    mean = np.zeros((file_info['Nd'], file_info['Nx'], file_info['Ny'], file_info['Nz']))
    mean_profile = []
    if MeanProfile: # Velocity profile given
        #------------------------------------------------------------
        #### Read velocity profile
        #------------------------------------------------------------
        vel_profile = ut.read_Vel_Profile(MeanProfile)
        # Check to see if it is a mean profile or a deviation profile.
        deviation = any(n < 0 for n in vel_profile)
        if deviation: # Deviation profile given
            # Add baseflow to deviation
            baseflow = []
            if details['bf'] == "lam": # Laminary base flow
                baseflow = 1.0 - ff_original.y**2.0
            elif details['bf'] == "cou": # Couette base flow
                baseflow = ff_original.y
            # Add baseflow to deviation to get turbulent mean profile
            mean_profile = vel_profile + np.asarray(baseflow)
        else: # Turbulent mean profile given
            mean_profile = vel_profile
    #================================================================
    #### ---- Remove the wall boundaries
    #================================================================
    # Removing the xz-planes at y=1 and y=-1,
    # so that the chebyshev nodes can be used to construct 
    # the transfer function.
    ff_original.remove_wall_boundaries()
    #================================================================
    #### ---- Fourier transform in xz directions
    #================================================================
    ff_original.make_xz_spectral()
    #================================================================
    #### ---- Stack velocity fields in the wall-normal direction
    #================================================================
    ff_original.stack_ff_in_y()
    #================================================================
    #### Create arrays of Fourier modes to use
    #================================================================
    # Modes multiplied with fundamental wavenumbers
    #(Modes: the physical modes, i.e. the grid points)
    kx_array = ff_original.Mx * ff_original.alpha
    kz_array = ff_original.Mz * ff_original.beta
    #================================================================
    #### Deconstruct original flow field
    #================================================================
    deconstructed_field = cr.deconstruct_field(ff_original.velocityField,
                                               kx_array,
                                               kz_array,
                                               ff_original.numModes,
                                               ff_original.y,
                                               ff_original.c,
                                               ff_original.Re,
                                               ff_original.baseflow,
                                               mean_profile,
                                               Sparse)
    #================================================================
    #### Write decomposed flow field to disk as an HDF5 file
    #================================================================
    ut.write_H5_Deconstructed(deconstructed_field, original_attrs, ff_original, File[:-3])
Пример #42
0
    time.sleep(2)
    
    TCP_IP = '10.42.0.10'
    TCP_PORT = 5000
    
    BUFFER_SIZE = 1024
    
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect((TCP_IP,TCP_PORT))
    
    s.close()
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect((TCP_IP,TCP_PORT))
    
    passed = Tests.test0(s)
    print ('0: ' + str(passed))
    if (passed == False):
        exit()
    
    print ('1: ' + str(Tests.test1(s)))
    
    print ('2: ' + str(Tests.test2(s)))
    
    print ('3: ' + str(Tests.test3(s)))

    print ('4: ' + str(Tests.test4(s)))
    
    print ('5: ' + str(Tests.test5(s)))
    
    print ('6: ' + str(Tests.test6(s)))
Пример #43
0
def main(repo,
         repourl,
         build,
         branch,
         buildtype,
         url=None,
         profile="minimal",
         readonlymode=""):
    # We need to iterate through the options in the map and find the right host based on
    # whether the repo name matches any of the options, as they may not be exactly identical
    if config.has_section(buildtype):
        for option in config.options(buildtype):
            line = config.get(buildtype, option)
            line = line.split(',')
            for entry in line:
                if option.strip() in repo:
                    env.host = entry.strip()
                    print "===> Host is %s" % env.host
                    break

    # Didn't find any host in the map for this project.
    if env.host is None:
        raise ValueError(
            "===> You wanted to deploy a build but we couldn't find a host in the map file for repo %s so we're aborting."
            % repo)

    user = "******"

    # Set our host_string based on user@host
    env.host_string = '%s@%s' % (user, env.host)

    # Set SSH key if needed
    ssh_key = None
    if "*****@*****.**" in repourl:
        ssh_key = "/var/lib/jenkins/.ssh/id_rsa_github"

    # Set a URL if one wasn't already provided
    if url is None:
        url = "%s.%s.%s" % (repo, branch, env.host)

    # Run the tasks.
    # --------------
    # If this is the first build, attempt to install the site for the first time.
    with settings(warn_only=True):
        if run('drush sa | grep \'^@\?%s_%s$\' > /dev/null' %
               (repo, branch)).failed:
            fresh_install = True
        else:
            fresh_install = False

    if fresh_install == True:
        print "===> Looks like the site %s doesn't exist. We'll try and install it..." % url
        try:
            common.Utils.clone_repo(repo, repourl, branch, build, None,
                                    ssh_key)
            InitialBuild.initial_build(repo, url, branch, build, profile)
            AdjustConfiguration.adjust_drushrc_php(repo, branch, build)
            common.Services.clear_php_cache()
            common.Services.clear_varnish_cache()
            common.Services.reload_webserver()
            InitialBuild.generate_drush_alias(repo, url, branch)
            Drupal.generate_drush_cron(repo, branch)
        except:
            e = sys.exc_info()[1]
            raise SystemError(e)
    else:
        print "===> Looks like the site %s exists already. We'll try and launch a new build..." % url
        # Grab some information about the current build
        previous_build = common.Utils.get_previous_build(
            repo, cleanbranch, build)
        previous_db = common.Utils.get_previous_db(repo, cleanbranch, build)

        Drupal.backup_db(repo, branch, build)
        common.Utils.clone_repo(repo, repourl, branch, build, None, ssh_key)
        Updates.merge_prod(repo, branch, build)
        AdjustConfiguration.adjust_settings_php(repo, branch, build,
                                                previous_build, buildtype)
        AdjustConfiguration.adjust_drushrc_php(repo, branch, build)
        AdjustConfiguration.adjust_files_symlink(repo, branch, build)
        Drupal.drush_status(repo, branch, build)
        Drupal.go_offline(repo, branch, build, readonlymode)
        # No need for this, drush_up does it later
        #    drush_updatedb(repo, branch, build)            # This will revert the database if it fails
        common.Utils.adjust_live_symlink(
            repo, branch, build)  # This will revert the database if it fails
        Updates.drush_up(repo, branch)
        Drupal.drush_status(
            repo, branch, build, revert=True
        )  # This will revert the database if it fails (maybe hook_updates broke ability to bootstrap)
        Updates.add_push_updates(repo, branch, build)
        Drupal.go_online(
            repo, branch, build, previous_build, readonlymode
        )  # This will revert the database and switch the symlink back if it fails
        common.Services.clear_php_cache()
        common.Services.clear_varnish_cache()
        Drupal.generate_drush_cron(repo, branch)
        Tests.run_tests(repo, branch, build)
        #run_behat_tests(repo, branch, build)
        #commit_new_db(repo, repourl, url, build, branch)
        common.Utils.remove_old_builds(repo, branch)
        Updates.send_update_notification(repo, branch)

        script_dir = os.path.dirname(os.path.realpath(__file__))
        if put(script_dir + '/../util/revert', '/home/jenkins',
               mode=0755).failed:
            print "####### BUILD COMPLETE. Could not copy the revert script to the application server, revert will need to be handled manually"
        else:
            print "####### BUILD COMPLETE. If you need to revert this build, run the following command: sudo /home/jenkins/revert -b %s -d %s -s /var/www/live.%s.%s -a %s_%s" % (
                previous_build, previous_db, repo, branch, repo, branch)