Пример #1
0
def Passgang(matrixnew,extractedstep):
    ACC = Init.getData(matrixnew,sensors=["RNS","LLL"],datas=["acc"],specifiedDatas="x")
    ACC2 = Init.getData(matrixnew,sensors=["LNS","RLL"],datas=["acc"],specifiedDatas="x")

    ACC = Ableitung(ACC[:,:],[2,3],1)[:,2:]
    ACC2 = Ableitung(ACC2[:,:],[2,3],1)[:,2:]
    zeitverschiebung =[]
    zeitverschiebunglinks =[]
    for i in range(0,len(extractedstep)):

        maxpos = (np.argmax(ACC2[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        minpos= (np.argmax(ACC2[(extractedstep[i,0]):(extractedstep[i,1]),1]))
        print abs(maxpos-minpos)
        print "_______"
        print (extractedstep[i,1]-extractedstep[i,0])
        zeitverschiebung.append(float(abs(maxpos-minpos))/float((extractedstep[i,1]-extractedstep[i,0])))
        maxpos = (np.argmax(ACC[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        minpos= (np.argmax(ACC[(extractedstep[i,0]):(extractedstep[i,1]),1]))
        zeitverschiebunglinks.append(float(abs(maxpos-minpos))/float((extractedstep[i,1]-extractedstep[i,0])))


    vereinigung=[]
    for j in range(0,len(zeitverschiebunglinks)):
        if(zeitverschiebung[j]>=zeitverschiebunglinks[j]):
            vereinigung.append(zeitverschiebunglinks[j])
        else: vereinigung.append(zeitverschiebung[j])
    plt.plot(vereinigung)
    plt.show()
    return vereinigung
Пример #2
0
def Random_dummy(atomlist, box):
    max_index = Rebuild.Max_index(atomlist)
    other_index = Random.Return_index_Other(atomlist)
    num_dummy = Calc_dummy(atomlist)
    choose_index, choose_list = [], []
    while len(choose_index) < num_dummy:
        new_index = nr.choice(other_index, 1)
        monoindex = atomlist.search_index(new_index).Monomer_print_index()
        for index in monoindex:
            if index in other_index: other_index.remove(index)
        choose_index.append(new_index)
        choose_list.append(atomlist.search_index(new_index))
    choose_list = Init.Atomlist(choose_list)
    dummylist = []
    for atom in choose_list.value:
        bx, by, bz = box.x, box.y, box.z
        carbon = atom.neighbour[0]
        rx, ry, rz = atom.x * bx, atom.y * by, atom.z * bz
        Rx, Ry, Rz = carbon.x * bx, carbon.y * by, carbon.z * bz
        vect1 = np.array([Rx - rx, Ry - ry, Rz - rz])
        vect1 = vect1 / np.linalg.norm(vect1) * 5  #Estimated Radii
        qx, qy, qz = (np.array([Rx, Ry, Rz]) + vect1).tolist()
        dummy = Dummy(qx / bx, qy / by, qz / bz,
                      'X' + str(max_index + 1) + 'x', max_index + 1)
        max_index = max_index + 1
        atomlist.value.append(dummy)
        dummylist.append(dummy)
    dummylist = Init.Atomlist(dummylist)
    print('Successful Creat Dummy Atoms')
    return atomlist, dummylist
Пример #3
0
def update_node_position(movement_matrix, node_position, start_t,
                         update_period, animation, nodelist, com_nodelist,
                         controller):

    print('开始时间:', start_t)
    active_route = []
    current_move = movement_matrix[np.nonzero(
        movement_matrix[:, 0].A == start_t)[0], :]
    print(current_move)
    for value in current_move:
        for i in range(2, 4):
            node_position[int(value[0, 1]), i + 2] = value[0, i]
    speed_x = node_position[:, 4] - node_position[:, 2]
    speed_y = node_position[:, 5] - node_position[:, 3]
    for i in range(0, int(1.0 / gp.update_period)):
        node_position[:, 2] = node_position[:, 2] + speed_x * gp.update_period
        node_position[:, 3] = node_position[:, 3] + speed_y * gp.update_period
        node_id_position = node_position[:, [1, 2, 3]]
        if nodelist == [] or com_nodelist == []:
            nodelist.extend(Init.init_node(node_id_position, controller))
            com_nodelist.extend(
                Init.get_communication_node(node_id_position.shape[0]))
            print('所有通信节点:', com_nodelist)


#         active_route = simulation(node_id_position,nodelist,com_nodelist,i,active_route)
#         print(active_route)
        if animation:
            plt.clf()
            plt.plot(node_position[:, 2], node_position[:, 3], '.m')
            plt.pause(0.01)
Пример #4
0
def Stockaufsatz(matrixnew,extractedstep,Einheitsvektor ="rE1"):
    re1 = Init.getData(matrixnew,sensors=["RNS","LNS"],datas=[ Einheitsvektor])
    ACC = Init.getData(matrixnew,sensors=["RNS","LNS"],datas=["acc"],specifiedDatas="x")
    ACCright =  Ableitung(ACC[:,:],[2],1)[:,2:]
    ACCleft = Ableitung(ACC[:,:],[3],1)[:,2:]


    Vektor = np.zeros((len(re1),3))
    Vektor[:,2] = 1
    anlematrixre1 = angle(re1[:,2:5],Vektor)
    anlematrixre = angle(re1[:,5:8],Vektor)
    anglestickright = anlematrixre1[:,0]
    anglestickleft = anlematrixre[:,0]

    rightpeak = []
    leftpeak = []
    for i in range(0,len(extractedstep)):
        posleft = (np.argmax(ACCleft[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        leftpeak.append(anglestickleft[(extractedstep[i,0])+posleft,0])
        posright = (np.argmax(ACCright[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        rightpeak.append(anglestickright[(extractedstep[i,0])+posright,0])


    print rightpeak

    return rightpeak,leftpeak
Пример #5
0
def BWError():
	if os.path.exists("Output/"):
		if Init.SystemJudge() == 0:
			os.system("rm -r Output")
		else:
			os.system("rmdir /s /q directory")

	NameArr = Pretreatment.FigureInput(1)
	try:
		if NameArr == -1:
			return
	except:
		pass

	#Figure traversal
	for kase in range(0, len(NameArr)):
		img = np.array(Image.open(NameArr[kase]).convert("L"))	
		"""		
		for i in range(0, len(img)):
			for j in range(0, len(img[i])):
				if random.randint(1, 50) == 1:
					img[i][j] += np.random.normal(img[i][j], 64)
					img[i][j] = max(0, img[i][j])
					img[i][j] = min(255, img[i][j])
		"""
		Name = "Figure_"
		Name += str(Init.GetTime())
		Name += ".png"
		Pretreatment.Output(img, Name, 2)
Пример #6
0
def lhc_study(i, scandir, cm=True):
    if type(scandir) in (tuple, list):
        cmdir, herwigdir = scandir
    else:
        herwigdir, cmdir = scandir, scandir
    name = 'lhc'
    hevents = osp.join(herwigdir, Init.ident_to_path(i))
    cmevents = osp.join(cmdir, Init.ident_to_path(i))

    cardname = osp.join(hevents, "MGcard.dat")
    Hcardname = osp.join(hevents, "H.dat")
    # Hruncardname = osp.join(events,"Hrun.dat")
    Hconfigtmp = osp.join(hevents, "herwigMRSSM")
    hepmcpath = osp.join(hevents, name + ".hepmc")

    CMfile = osp.join(cmevents, "CM.dat")
    slhafile = osp.join(cmevents, "SPheno.spc.MRSSM")
    SLHA.flavor_order(slhafile, toRSSM=True)
    lhepath = None

    # lhc.genlhe(slhafile,process,name,events,cardname,nofevents)
    # lhc.HerwigCM(slhafile,process,name,events,Hcardname,Hconfigtmp,Hconfigbase,
    #              Htemplate,lhepath,hepmcpath, analyses,CMfile,nofevents)

    Hconfigbase = Hconf_process
    lhc.full_herwig(slhafile, name, hevents, Hcardname, Hconfigtmp,
                    Hconfigbase, Htemplate, hepmcpath, nofevents)
    if cm:
        lhc.CM_run(name,
                   cmevents,
                   analyses,
                   hepmcpath,
                   CMfile,
                   nofevents,
                   cleanup=True)
Пример #7
0
def Read_Model(MODEL_FILE):
    import numpy as np
    from copy import deepcopy
    import os 
    import Init

    model_path = ""
    for i in range(0, len(MODEL_FILE)):
        model_path = os.path.join(model_path, MODEL_FILE[i])
    File = open(model_path, "r")
    FileLine = File.readline()
    information = FileLine[0: -1]
    print("Model Information:")
    print(information)
    FileLine = File.readline()
    initial_t, final_t, delta_t = Init.FileReadLine(FileLine, mode = "float")
    initial_val = []
    states = []
    Jacobian = []
    FileLine = File.readline()
    while 1:
        if not FileLine:
            break
        array = Init.FileReadLine(FileLine, mode = "float")
        if len(states) == 0:
            initial_val = deepcopy(array)
        if len(array) == len(initial_val):
            states.append(np.array(array))
        else:
            array = np.matrix(np.reshape(np.matrix(array), (len(initial_val), len(initial_val))))
            Jacobian.append(array)
        FileLine = File.readline()

    return information, initial_val, initial_t, final_t, delta_t, states, Jacobian
Пример #8
0
def lhc_study(i, scandir, cm=True):
    if type(scandir) in (tuple, list):
        cmdir, herwigdir = scandir
    else:
        herwigdir, cmdir = scandir, scandir
    name = 'lhc'
    hevents = osp.join(herwigdir, Init.ident_to_path(i))
    cmevents = osp.join(cmdir, Init.ident_to_path(i))

    cardname = osp.join(hevents, "MGcard.dat")
    Hcardname = osp.join(hevents, "H.dat")
    # Hruncardname = osp.join(events,"Hrun.dat")
    Hconfigtmp = osp.join(hevents, "herwigMSSM")
    hepmcpath = osp.join(hevents, name + ".hepmc")

    CMfile = osp.join(cmevents, "CM.dat")
    slhafile = osp.join(cmevents, "SPheno.spc.MSSM")
    SLHA.flavor_order(slhafile)
    lhepath = None
    Hconfigbase = Hconf_process
    lhc.full_herwig(slhafile, name, hevents, Hcardname, Hconfigtmp,
                    Hconfigbase, Htemplate, hepmcpath, nofevents)
    if cm:
        #sigma,Kfac = lhc.get_Kfac("SPheno.spc.MSSM", cmevents, "sqsum")
        #if sigma>0:
        #    lhc.CM_run(name,cmevents,analyses,hepmcpath,CMfile,
        #               nofevents,sigma=sigma,cleanup=False)
        #else:
        lhc.CM_run(name,
                   cmevents,
                   analyses,
                   hepmcpath,
                   CMfile,
                   nofevents,
                   cleanup=True)
Пример #9
0
def Start(inputfile='PVDF-model.cif', size=2000, dm=15, mv=[0, 0]):
    size = size / 2
    box, atomlist = Init.Split_file(inputfile)
    num = int(pow(size / len(atomlist.value), 1 / 2) + 1)
    print('Now Generating a Supercell of ', 1, '*', num, '*', num, '\n')
    print('######## Now Initializing Supercell ########\n')
    modbox = Modbox(box.x, box.y, box.z, num, dm)
    modbox.divide_box(mv)
    modbox.add_atomlist()
    #print('Though required size was ',size,', in total we make ',len(modbox.atomlist.value),' atoms\n')
    print('######## Now Generating Plasticizer ########\n')
    numplast = Dummy.Calc_dummy(modbox.atomlist1)
    Add_plastic(modbox, numplast)
    modbox.add_atomlist()
    print('Though required size was ', size * 2, ', in total we make ',
          len(modbox.atomlist1.value + modbox.atomlist2.value),
          ' atoms, including ', len(modbox.atomlist2.value),
          ' atoms from plasticizers\n')
    mass1 = Dummy.Calc_mass(modbox.atomlist1)
    mass2 = Dummy.Calc_mass(modbox.atomlist2)
    print('The actual Mass Ratio is ', mass2 / (mass1 + mass2) * 100, '\n')
    Build.build_poscar(modbox.atomlist1, modbox, filename='Polymer')
    Build.build_poscar(modbox.atomlist2, modbox, filename='Plastic')
    Build.build_poscar(Init.Atomlist(modbox.atomlist1.value +
                                     modbox.atomlist2.value),
                       modbox,
                       filename='Combine')
Пример #10
0
def _Init():
    "Initialize Cmtest"
    if Globals.Debug: print("In this Function %s" % __name__)
    global Linux_gbl
    global Erc
    global Force

    if not os.name == "nt":
        Linux_gbl = 'Ubuntu'
        # Added 3/4/10 to support Ubuntu install
        try:
            with open("/etc/*release", r) as fh:
                for line in fh:
                    if re.search(r"Ubuntu", line): Linux_gbl = 'Ubuntu'
                    elif re.search(r"Fedora", line): Linux_gbl = 'Fedora'
                    elif re.search(r"CentOS", line): Linux_gbl = 'CentOS'
                    else:
                        Linux_gbl = 'unknown'
                        print(
                            "Un-suported linux type found, I am going to die now"
                        )
                        exit()
        except:
            print(
                "Un-suported linux type found, are we Windows? I am going to die now"
            )
            if not Debug: exit()
    #else we are NT
    print("Debug in _Init %i" % Globals.Debug)
    Init.Init_All(0)
    Globals.Erc = 101

    Globals.Erc = 0
    Init.Init_Also(0)
    return
Пример #11
0
def scaninit():
    point = MSSM_LHC()
    points = []

    for x in range(1000, 5001, 400):  # m1
        for y in range(400, 2001, 200):  # msq
            pointtmp = point[:]
            pointtmp[0] = 0
            #pointtmp[13] = x
            #pointtmp[1] = y
            pointtmp[2] = 5000
            pointtmp[3] = x * x
            pointtmp[4] = y * y
            pointtmp[7] = x * x
            pointtmp[8] = y * y
            pointtmp[9] = x * x
            pointtmp[10] = y * y
            points.append(pointtmp)
    print len(points)
    switches = [0, 0, 1, 0, 0, 0, 0]
    print scanpath, dbdir
    Init.init_struc(points,
                    scanpath,
                    zip(parameter, para_types),
                    switches,
                    createSLHAinMSSMfull,
                    dbdir,
                    makedb=True)
Пример #12
0
    def fun(i, scanpath):
        j = 0
        lim = 3
        i = str(i)
        filename = osp.join(scanpath, Init.ident_to_path(i),
                            "SPheno.spc." + model)
        sphenofunc(i, scanpath)
        for m, val in enumerate(value):
            if type(val) in (list, tuple):
                result = SLHA.getvalues(filename, [val])
                value[m] = float(result[0])
                # interpret as SLHA line and return wanted value
        while j < lim:
            j += 1
            try:
                val = [float(x) for x in SLHA.getvalues(filename, outpar)]
                paramval = [float(x) for x in SLHA.getvalues(filename, param)]
        ## check if spectrum was created,

            except OSError as e:
                break
            print val, paramval
            if all([abs(x) < eps for x in measure(val, value)]):
                break
            else:
                os.remove(filename)
                newpar = func(val, value, paramval)
                pointpath = osp.join(scanpath, Init.ident_to_path(i))
                Init.changeSLHA(osp.join(pointpath, i + ".SLHA.in"),
                                createSLHAin, param, newpar)
                sphenofunc(i, scanpath)
Пример #13
0
def rerun_CM(i, scandir):
    if type(scandir) in (tuple, list):
        cmdir, herwigdir = scandir
    else:
        herwigdir, cmdir = scandir, scandir
    name = 'lhc'
    hevents = osp.join(herwigdir, Init.ident_to_path(i))
    cmevents = osp.join(cmdir, Init.ident_to_path(i))

    cardname = osp.join(hevents, "MGcard.dat")
    Hcardname = osp.join(hevents, "H.dat")
    # Hruncardname = osp.join(events,"Hrun.dat")
    Hconfigtmp = osp.join(hevents, "herwigMRSSM")
    hepmcpath = osp.join(hevents, name + ".hepmc")

    CMfile = osp.join(cmevents, "CM.dat")
    slhafile = osp.join(cmevents, "SPheno.spc.MRSSM")
    lhepath = None

    lhc.CM_run_no_delphes(name,
                          cmevents,
                          analyses,
                          hepmcpath,
                          CMfile,
                          nofevents,
                          lhepath=lhepath)
def main():
    Init.initialize()
    Financial.download()
    Financial.analyze()

    Draw.draw(where="1", order="roi", sort="DESC", draw_candle_stick=True, draw_roi=False, draw_share_holder=False,
              save_fig=True)
Пример #15
0
def wrapper(i, scandir):
    try:
        out = readHandW(i, scandir)
        #point = [i]+readHB(i,scandir)+readHS(i,scandir)
        print i
    except IOError:
        pass
    else:
        point = [int(i)] + [float(x) for x in out]
        Init.register_point(outdb, 'mhmw', point)
Пример #16
0
 def OnMenuFileMenuopenCaseMenu(self, event):
     import Init
     import dlgDataSource
     self.SetCursor(wx.HOURGLASS_CURSOR)
     Init.InitGlobals()
     dlg = wx.FileDialog(self, "Open Case", ".", "", "*.cfi", wx.OPEN)
     try:
         if dlg.ShowModal() == wx.ID_OK:
             success = True
             msg = ""
             Globals.CurrentCaseFile = dlg.GetPath().encode('utf-8', 'replace')
             busy = wx.BusyInfo("It might take some good few minutes depending on the evidence size...")
             wx.Yield()
             
             if DBFunctions.GetCaseSettings(Globals.CurrentCaseFile):
                 Init.InitAllDBFileNames()
                 DBFunctions.GetCaseEvidences(Globals.CurrentCaseFile)
                 
                 for key in Globals.EvidencesDict:
                     dlg = dlgDataSource.create(self, key)
                     dlg.ShowModal()
                     #print 'wait'
                 #Globals.MACFileName = Globals.CurrentCase.CaseName + Constants.MACExtension
                 #Globals.KeywordsFileName = Globals.CurrentCase.CaseName + Constants.KeywordsExtension
                 #Globals.TextCatFileName = Globals.CurrentCase.CaseName + Constants.TextCatExtension
                 
                 DBFunctions.LoadMACMinMaxValues()
                 
                 DBFunctions.UpdateDatabaseTables()
                     
             else:
                 msg = "Couldn't open Case File: %s!"%Globals.CurrentCaseFile
                 success = False
                 
             if not success:
                 dlg = wx.MessageDialog(self, msg ,
                   'Error', wx.OK | wx.ICON_ERROR)
                 try:
                     #Globals.CaseOpen = False
                     #self.ShowCaseProperties(False)
                     dlg.ShowModal()
                     #return
                 finally:
                     dlg.Destroy()
             else:
                 Globals.CaseOpen = True
                 self.SetTitle("MAKE2 - " + Globals.CurrentCaseFile)
                 #self.ShowDirectoryTreeView()
                 self.notebookCase.Show(True)
                 self.ShowCaseProperties(True)
                 
                 
     finally:
         dlg.Destroy()
     self.SetCursor(wx.STANDARD_CURSOR)
Пример #17
0
 def add_atomlist(self):
     atomlist_tot1 = []
     atomlist_tot2 = []
     for box in self.boxlist:
         atomlist_tot1 = atomlist_tot1 + box.atomlist.value
     for box in self.otherboxlist:
         atomlist_tot2 = atomlist_tot2 + box.atomlist.value
     self.atomlist1 = Init.Atomlist(atomlist_tot1)
     self.atomlist1.reindex()
     self.atomlist2 = Init.Atomlist(atomlist_tot2)
     self.atomlist2.reindex()
Пример #18
0
def __Init():
    global __init
    if __init != 1:
        Init.__Init()
        global redis_db
        redis_db = Init.redis_db
        __init_XYTGrid()
        __init = 1
    else:
        pass
    return 0
Пример #19
0
def read_CM2(i, scandir):
    """read all signal regions evaluated, first checks if result exists"""
    results = osp.join(scandir, Init.ident_to_path(i), 'lhc_cm', 'result.txt')
    if not osp.exists(results):
        print "s.th. wrong with CheckMATE, no result for " + i
        raise IOError
    results = osp.join(scandir, Init.ident_to_path(i), 'lhc_cm', "evaluation",
                       "best_signal_regions.txt")

    out = lhc.read_CMresults(results)
    print out
    return out
Пример #20
0
def Pretreatment(FileDir, SufixSet, ModelFolder, Parameter):
    import numpy as np
    from PIL import Image
    import cv2
    import os
    from keras.utils import to_categorical

    print("Train model start, data reading", end="\r")

    #Initial data set
    Data = []

    #Get files direction
    if not os.path.exists(FileDir):
        return 2, [], []
    if len(SufixSet) == 0:
        return 3, [], []
    for i in range(0, len(SufixSet)):
        if SufixSet[i] == "yuv":
            return 4, [], []
    if not os.path.exists(ModelFolder):
        return 6, [], []

    Files1 = Init.GetSufixFile(FileDir + "/0", SufixSet)
    Files2 = Init.GetSufixFile(FileDir + "/1", SufixSet)

    #Build the sign
    Result = [0 for n in range(len(Files1))]
    Files1 += Files2
    Result += [1 for n in range(len(Files2))]

    if len(Files1) == 0 or len(Files2) == 0:
        return 5, [], []

    #Get image data and down sample
    for i in range(0, len(Files1)):
        img = np.array(Image.open(Files1[i]).convert("L"))
        Data.append(cv2.resize(img, (Parameter[1], Parameter[2])))

    print("Data read succeed, training surround initial", end="\r")
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"

    Data = np.array(Data)
    Result = np.array(Result)

    Data = Data.reshape(-1, Parameter[1], Parameter[2], 1)
    Data = Data / 255

    Result = to_categorical(Result)
    return 0, np.array(Data), np.array(Result)
Пример #21
0
def write_more_wrapper(read_func, table, i, scandir, db):
    """
    higher order functions for all writing, expects a list of several
    entries for one parameter point
    """
    try:
        out = read_func(i, scandir)
        print i
    except IOError:
        print "IOError for" + i
        pass
    else:
        for part in out:
            point = [int(i)] + list(part)
            Init.register_point(db, table, point)
Пример #22
0
def read_param(param, spec_file, i, scandir):
    """
    specialized SLHA read functions from scan path naming 
    """
    i = str(i)
    filename = osp.join(scandir, Init.ident_to_path(i), spec_file)
    return SLHA.getvalues(filename, param)
Пример #23
0
def Fussabrollen(matrixnew,extractedstep):
    ACC = Init.getData(matrixnew,sensors=["RLL","LLL"],datas=["acc"],specifiedDatas="x")
    ACCright =  Ableitung(ACC[:,:],[2],1)[:,2:]
    ACCleft = Ableitung(ACC[:,:],[3],1)[:,2:]




    anlematrixre1 = winkelgesamt(matrixnew,Sensoren=["RUA","RLA"])
    anlematrixre = winkelgesamt(matrixnew,Sensoren=["LUA","LLA"])
    anglestickright = anlematrixre1
    anglestickleft = anlematrixre
    plt.plot(anglestickleft)
    plt.plot(anglestickright)
    plt.show()

    rightpeak = []
    leftpeak = []
    for i in range(0,len(extractedstep)):
        posleft = (np.argmax(ACCleft[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        leftpeak.append(anglestickleft[(extractedstep[i,0])+posleft])
        posright = (np.argmax(ACCright[(extractedstep[i,0]):(extractedstep[i,1]),0]))
        rightpeak.append(anglestickright[(extractedstep[i,0])+posright])


    print rightpeak

    return rightpeak,leftpeak
Пример #24
0
def aufrechtgehen(matrixnew, extractedstep):
        back = Init.getData(matrixnew,sensors=["STE","CEN"],datas=[ "rE1"])
        Vektor = np.zeros((len(back),3))
        Vektor[:,0] = 1
        angleSTEmovement = angle(back[:,2:5],Vektor)
        angleCENmovement = angle(back[:,5:8],Vektor)
        Vektor[:,0] = 0
        Vektor[:,2] = 1
        angleSTEupwards = angle(back[:,2:5],Vektor)
        angleCENupwards = angle(back[:,5:8],Vektor)
        angleSTEupwardsstep = []
        angleSTEmovementstep =[]
        angleSTEmovementstep = []
        angleCENupwardsstep = []
        for i in range(0,len(extractedstep)):
            angleCENupwardsstep.append(np.sum(angleCENupwards[(extractedstep[i,0]):(extractedstep[i,1])])/((extractedstep[i,1])-(extractedstep[i,0])))
            angleSTEupwardsstep.append(np.sum(angleSTEupwards[(extractedstep[i,0]):(extractedstep[i,1])])/((extractedstep[i,1])-(extractedstep[i,0])))


        plt.subplot(2,1,1)
        plt.plot(angleSTEupwardsstep)
        plt.subplot(2,1,2)

        plt.plot(angleCENupwardsstep)
        plt.show()
        difference = (np.absolute([x-y for x,y in zip(angleCENupwardsstep,angleSTEupwardsstep)]))
        return  angleSTEupwardsstep,angleCENupwardsstep, difference
Пример #25
0
def read_HS(i, scandir):
    """
    produces needed hs output
    """
    out = readfile(
        osp.join(scandir, Init.ident_to_path(i), "HiggsSignals_results.dat"))
    return out[-1][-7:]
Пример #26
0
def run_base(running_func,
             scanpath,
             db,
             parallel=True,
             method=None,
             ncores=20):
    runfunc = run_on_dir(scanpath, db=db)
    if not method:
        method = Init.get_allpointids(db, "points")
    if type(running_func) in (tuple, list):
        for func in running_func:
            try:
                runfunc(func, method=method, parallel=parallel, ncores=ncores)
            except Exception as err:
                #print "trouble with "+ func.__name__ + " for "+ db
                print err
                pass
    else:
        try:
            runfunc(running_func,
                    method=method,
                    parallel=parallel,
                    ncores=ncores)
        except Exception as err:
            #print "trouble with "+ running_func.__name__+ " for "+ db
            print err
            pass
Пример #27
0
def sensorwinkel(matrixnew, extractedstep, Sensoren= ["RUA","RLA"]):
    re1 = Init.getData(matrixnew,sensors=Sensoren,datas=[ "rE1","rE2","rE3"])
    anlematrixre1 = angle(re1[:,11:14],re1[:,2:5])
    anglearm = anlematrixre1[:,0]
    anlematrixre1 = angle(re1[:,14:17],re1[:,5:8])
    anglearm2 = anlematrixre1[:,0]
    anlematrixre1 = angle(re1[:,17:20],re1[:,8:11])
    anglearm3 = anlematrixre1[:,0]
    anglecomb= [ ]

    for i in range(0,len(anglearm)):
        anglecomb.append(np.sqrt((np.square(anglearm2[i,0]))+(np.square(anglearm[i,0]))+(np.square(anglearm3[i,0]))))

    print anglecomb
    maxanglearm = []
    minanglearm = []
    for i in range(0,len(extractedstep)):
        maxpos = (np.argmax(anglecomb[(extractedstep[i,0]):(extractedstep[i,1])]))
        maxanglearm.append((anglecomb[(extractedstep[i,0])+maxpos]))
        minpos= (np.argmin(anglecomb[(extractedstep[i,0]):(extractedstep[i,1])]))
        minanglearm.append(anglecomb[(extractedstep[i,0])+minpos])

    angleE = np.c_[minanglearm,maxanglearm]
    print "---------------------------------------------------------------------"
    angleE= 180-angleE
    return angleE
Пример #28
0
def MainFunction():
    #CRIEA Start!
    if os.path.exists("Output/"):
        if Init.SystemJudge() == 0:
            os.system("rm -r Output")
        else:
            os.system("rmdir /s /q directory")

    NameArr = Pretreatment.FigureInput(1)
    try:
        if NameArr == -1:
            return
    except:
        pass

    #Figure traversal
    for kase in range(0, len(NameArr)):
        img = np.array(Image.open(NameArr[kase]).convert("L"))
        img = Pretreatment.BFSmooth(img)

        [Tobimg, NodeInfo] = Algorithm.Toboggan(img)
        [Upground, Background] = Algorithm.HandSeed(Tobimg, img, Surround)
        Seeds = Upground | Background
        ProbBlock = []
        VarL = 0

        if Method == "Lap":
            NodeInfo, VarL = Functions.SeedFirst(NodeInfo, Seeds)
            LapEqu = Algorithm.Laplacian(NodeInfo, VarL)
            ProbBlock = Functions.LinearEquation(LapEqu,
                                                 len(NodeInfo) - VarL, VarL)
        """
Пример #29
0
def read_HB(i, scandir):
    """
    produces need hb output
    """
    out = readfile(
        osp.join(scandir, Init.ident_to_path(i), "HiggsBounds_results.dat"))
    return out[-1][-4:-1]
Пример #30
0
def FouriorTrans():
	if os.path.exists("Output/"):
		if Init.SystemJudge() == 0:
			os.system("rm -r Output")
		else:
			os.system("rmdir /s /q directory")

	NameArr = Pretreatment.FigureInput(1)
	try:
		if NameArr == -1:
			return
	except:
		pass

	#Figure traversal
	for kase in range(0, len(NameArr)):
		img = np.array(Image.open(NameArr[kase]).convert("L"))	
		Statistic = [0 for n in range(0, 260)]
		TTL = 0
		for i in range(0, len(img)):
			for j in range(0, len(img[i])):
				Statistic[img[i][j]] += 1
				TTL += 1

		#Drecrete PDE
		Prob = [0.00 for n in range(260)]
		for i in range(0, len(Prob)):
			Prob[i] = Statistic[i] / TTL
		
		#HF = np.fft.fft(Prob).real
		
		fig1 = plt.figure()
		ax = fig1.add_subplot(111)
		
		plt.xlim(-1, 260)
		plt.ylim(0, 0.2)

		#Printing loop
		for i in range(0, len(Prob)):
			ax.add_patch(patches.Rectangle((i, 0), 1, Prob[i], color = 'black'))

		Name = ""
		Hajimari = False
		for i in range(len(NameArr[kase]) - 1, -1, -1):
			if NameArr[kase][i] == ".":
				Hajimari = True
				continue
			elif NameArr[kase][i] == "/":
				break
			else:
				if Hajimari == False:
					continue
				else:
					Name = NameArr[kase][i] + Name

		Name += "_Histogram.png"
		print(Name)
		plt.savefig(Name)
		
	return
Пример #31
0
def control_movement(animation):
    np.set_printoptions(suppress=True)
    config_file_path = r'grid.config.tcl'
    mobile_file_path = r'tiexi.tcl'
    node_num, sim_time = get_sim_parameter(config_file_path)
    movement_matrix, init_position_matrix = get_position(mobile_file_path)
    init_position_arranged = init_position_matrix[np.lexsort(
        init_position_matrix[:, ::-1].T)]
    node_position = init_position_arranged[0]
    node_position = np.insert(node_position,
                              0,
                              values=np.zeros(node_num),
                              axis=1)
    node_position = np.column_stack((node_position, node_position[:, 2:4]))
    node_position = np.insert(node_position,
                              6,
                              values=np.zeros(node_num),
                              axis=1)
    plt.ion()
    nodelist = []
    com_nodelist = []
    controller = Init.init_controller(node_num)
    for i in range(0, sim_time + 1):
        update_node_position(movement_matrix, node_position, i, 0.1, animation,
                             nodelist, com_nodelist, controller)
Пример #32
0
def Initialize(pScene):
    # Init the scene
    global g_Engine
    g_Engine = Init.InitScene(pScene)

    # Start the engine
    g_Engine.StartStop(True)
Пример #33
0
def GetAve():
    import GetTRNG
    import os
    import Init
    FileName = "RandomNumberList"
    if not os.path.exists(FileName):
        GetTRNG.MainFunction(1000)
        GetAve()
        return       
    
    File = open(FileName, "r")
    FileLine = File.readline()
   
    if len(FileLine) <= 10:
        GetTRNG.MainFunction(1000)
        GetAve()
        return

    Str1 = ""
    Str2 = ""
    for i in range(0, len(FileLine)):
        if i < 8:
            Str1 += FileLine[i]
        else:
            Str2 += FileLine[i]

    File.close()

    os.remove(FileName)
    File = open(FileName, "a")
    File.write(Str2)
    File.close()
    Init.LogWrite("PRNG Initialization succeed", "0")

    Seed = 0
    try:
        Seed = int(Str1)
    except ValueError:
        Init.LogWrite("Saving TRNG error", "1")
        return

    RandNum = []
    for i in range(0, 1000):
        Seed = MT19937(Seed).extract_number()
        RandNum.append(Seed)

    return RandNum
def main():
    parameter = interval_para[0]
    y_min = 999999999
    y_max = -999999999
    para_list = [parameter]
    list_rem = 0
    fx_list = [[]]
    while 1:
        print(parameter, interval_para[1], end="\r")
        #x = [random.random(), random.random()]
        x = [0.1, 0.1]
        fx = f(x, parameter)
        #print("0 " + str(fx))
        for i in range(0, total_iteration_time):
            #plt.plot([x, fx], [fx, fx], color[kase])
            x = fx
            fx = f(x, parameter)
            if i > record_time:
                if not Block_min_max:
                    if y_min > fx[memory_dimension]:
                        y_min = fx[memory_dimension]
                    if y_max < fx[memory_dimension]:
                        y_max = fx[memory_dimension]
                fx_list[list_rem].append(fx[memory_dimension])

        parameter += distance_para
        if parameter > interval_para[1]:
            break
        para_list.append(parameter)
        fx_list.append([])
        list_rem += 1

    #Init.ArrOutput(fx_list, Mode = 0)
    print()
    #print(y_max, y_min)
    #print(para_list, int((y_max - y_min) / distance_y) + 1)
    if Block_min_max:
        y_min = min_max_boundary[0]
        y_max = min_max_boundary[1]
    img = [[255 for n in range(len(para_list))]
           for n in range(int((y_max - y_min) / distance_y) + 1)]
    print(len(para_list), len(fx_list))
    for i in range(0, len(para_list) - 2):
        #print(i, len(para_list), end = "\r")
        for j in range(0, len(fx_list[i]) - 1):
            #print(j, end = "\r")
            if fx_list[i][j] > y_max or fx_list[i][j] < y_min:
                continue
            loc_y = int((y_max - fx_list[i][j]) / distance_y)
            loc_x = i
            img[loc_y][loc_x] = 0
        #print()
    img = np.float32(img)
    #print()
    Init.ImageIO(file_dir="./img.png",
                 img=np.float32(img),
                 io="o",
                 mode="grey",
                 backend="opencv")
Пример #35
0
def write_wrapper(read_func, table, i, scandir, db):
    """
    higher order functions for all writing
    """
    try:
        out = read_func(i, scandir)
        # point = [i]+readHB(i,scandir)+readHS(i,scandir)
        print i
    except IOError:
        pass

    else:
        try:
            point = [int(i)] + out
            Init.register_point(db, table, point)
        except:
            pass
Пример #36
0
def findsync(dataMatrix):

    datamatrix = Init.getData(dataMatrix,sensors=["STE"],datas=[ "acc"])
    signal= dataMatrix[:,2]
    maxAbsValue, maxAbsFreq = FourierTransformation.maxAbsFreq(signal)
    Filtered = FeatureKonstruktion.filter(datamatrix,[2,3,4],maxAbsFreq)
    plt.plot(Filtered[:,2:])
    plt.show()
Пример #37
0
def winkelgesamt(matrixnew,Sensoren= ["RUA","RLA"]):
    re1 = Init.getData(matrixnew,sensors=Sensoren,datas=[ "rE1","rE2","rE3"])
    print len(matrixnew)
    anlematrixre1 = angle(re1[:,11:14],re1[:,2:5])
    anglearm = anlematrixre1[:,0]
    anlematrixre1 = angle(re1[:,14:17],re1[:,5:8])
    anglearm2 = anlematrixre1[:,0]
    anlematrixre1 = angle(re1[:,17:20],re1[:,8:11])
    anglearm3 = anlematrixre1[:,0]
    anglecomb= [ ]
    plt.plot(anglearm)
    plt.plot(anglearm2)
    plt.plot(anglearm3)
    plt.show()
    for i in range(0,len(anglearm)):
        anglecomb.append(np.sqrt((np.square(anglearm2[i,0]))+(np.square(anglearm[i,0]))+(np.square(anglearm3[i,0]))))
    print len(anglecomb)
    return anglecomb
Пример #38
0
import Init
import Display
import Action


if __name__ == '__main__':

    # PYGAME INIT
    pygame.init()
    Game.screen = pygame.display.set_mode((Const.windowHeight, Const.windowLength))
    Game.screen.fill(Colour.darkGrey)
    pygame.display.set_caption('SupNetwork')
    clock = pygame.time.Clock()

    # DISPLAY
    Init.array()
    Display.all_cell()

    # GAME LOOP
    while True:
        for event in pygame.event.get():
            clock.tick(30)

            if event.type == MOUSEBUTTONUP:
                x, y = event.pos
                if Const.margin < x < Const.margin+Const.cellSize*Const.gameSize \
                        and Const.margin < y < Const.margin+Const.cellSize*Const.gameSize:
                    Action.click(x, y)

            if event.type == QUIT:
                pygame.quit()
Пример #39
0
'''
Created on 2011-7-14

@author: zheng
'''

import Constant, Init, P4, Build, Sign, Upload, Email, Check

import sys



if __name__ == '__main__':
	
	Init.system_init()

	project=Init.init_choice(len(sys.argv))

	project.project_init()

	P4.download( project )

	P4.getDescribe (project , "1")
#	Check.check( project )
	
#	Build.build( project )

#	Sign.sign( project)		

#	Upload.upload( project )
Пример #40
0
 def __init__(self):
     Init._Init()
Пример #41
0
 def __del__(self):
     Init._Shutdown()
Пример #42
0
#
# Copyright (C) 2004 Daniel Larsson
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#

import Init

# Add the languages we support
Init.add_translation('remus-server', 'sv', 'Swedish',
                     'sv_SE.ISO8859-1', '/images/sv.png')
Init.add_translation('remus-server', 'en', 'English',
                     'en_US.ISO8859-1', '/images/en.png')
Пример #43
0
            Log.log("Game over, displaying game state")
            matrix = [
                    [(x, y) in board.blocks for x in xrange(board.blocks_width)]
                    for y in xrange(board.blocks_height)
                    ]
            Matrix.put(matrix, f="_")

            if ((len(self.highscores) < HIGHSCORES or any(board.score > score["score"] for score in self.highscores)) and 
                    not Shared.options.get("uber_tetromino") and not Shared.options.get("flip_tetromino")
                    ):
                self.addJob("name_inputbox", Jobs.InputBox(self, "New Highscore!\nName: "))
                self.running = self.getName
            else:
                self.addJob("window-game_over", Jobs.Notification(self, "window-game_over", "Game Over"))
                self.addJob("endtimer", Jobs.TimedExecution(self, self.quitGame, seconds=3, anykey=True))

    def eventHandler(self, event):
        if event.type == QUIT:
            self.quit()

        elif event.type == KEYDOWN:
            if event.key == Shared.keymap["game"]["pause"]:
                self.call(Menus.PauseMenu, sound_enabled=False, caption="Tetris - Paused")
            if event.key == Shared.keymap["game"]["player1"]["uber_tetromino"] and Shared.options["gameplay"].get("uber_tetromino"):
                self.jobs.interface.addJob("tetromino", makeUberTetromino(self.jobs.interface.jobs.board))

if __name__ == '__main__':
    import Init
    Init.initGame(TetrisGame, caption="Loltris").run()
Пример #44
0
doc = """
Usage:
    loltris [--loglevel=n] [--dev]
    loltris (-h | --help | --version | -v)

Options:
    loltris --help,-h        Loltris documentation
    loltris --version,-v     Print the loltris version and exit
    loltris --loglevel=n     Set loglevel, 0="ONLY CRITICAL" 5="ALL"
"""

import sys
import docopt

from Globals import *

nice_version = "Loltris v{}".format(VERSION)
args = docopt.docopt(doc, version=nice_version)

## Launch the game
if args["-h"] or args["--help"]:
    print(doc)
    sys.exit()
if args["-v"]:
    print(nice_version)
    sys.exit()

import Menus
import Init
Init.initGame(Menus.MainMenu, caption="Loltris").run()
#
# Copyright (C) 2004 Daniel Larsson
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#

import Init

# Add the languages we support
Init.add_translation('remus-audiostore', 'sv', 'Svenska',
                     'sv_SE.ISO8859-1', '/images/sv.png')
Init.add_translation('remus-audiostore', 'en', 'English',
                     'en_US.ISO8859-1', '/images/en.png')