def run(self, context): if isinstance(self.body, SinOperation): return math.asin(self.body.body.run(context)) if isinstance(self.body, CosOperation): return math.acos(self.body.body.run(context)) if isinstance(self.body, TanOperation): return math.atan(self.body.body.run(context)) if isinstance(self.body, SecOperation): return mpmath.asec(self.body.body.run(context)) if isinstance(self.body, CscOperation): return mpmath.acsc(self.body.body.run(context)) if isinstance(self.body, CotOperation): return mpmath.acot(self.body.body.run(context)) raise Exception("Unsupported inversion operation.")
# -*- coding: utf-8 -*- """ Created by libsedmlscript v0.0.1 """ from sed_roadrunner import model, task, plot from mpmath import asec #---------------------------------------------- asec(0.5)
def eval(self, z): return mpmath.asec(z)
'hypot': ['primitive', [lambda x, y: mp.hypot(x, y[0]), None]], # sqrt(x**2+y**2) # 'sin': ['primitive', [lambda x, y: mp.sin(x), None]], 'cos': ['primitive', [lambda x, y: mp.cos(x), None]], 'tan': ['primitive', [lambda x, y: mp.tan(x), None]], 'sinpi': ['primitive', [lambda x, y: mp.sinpi(x), None]], #sin(x * pi) 'cospi': ['primitive', [lambda x, y: mp.cospi(x), None]], 'sec': ['primitive', [lambda x, y: mp.sec(x), None]], 'csc': ['primitive', [lambda x, y: mp.csc(x), None]], 'cot': ['primitive', [lambda x, y: mp.cot(x), None]], 'asin': ['primitive', [lambda x, y: mp.asin(x), None]], 'acos': ['primitive', [lambda x, y: mp.acos(x), None]], 'atan': ['primitive', [lambda x, y: mp.atan(x), None]], 'atan2': ['primitive', [lambda x, y: mp.atan2(y[0], x), None]], 'asec': ['primitive', [lambda x, y: mp.asec(x), None]], 'acsc': ['primitive', [lambda x, y: mp.acsc(x), None]], 'acot': ['primitive', [lambda x, y: mp.acot(x), None]], 'sinc': ['primitive', [lambda x, y: mp.sinc(x), None]], 'sincpi': ['primitive', [lambda x, y: mp.sincpi(x), None]], 'degrees': ['primitive', [lambda x, y: mp.degrees(x), None]], #radian - >degree 'radians': ['primitive', [lambda x, y: mp.radians(x), None]], #degree - >radian # 'exp': ['primitive', [lambda x, y: mp.exp(x), None]], 'expj': ['primitive', [lambda x, y: mp.expj(x), None]], #exp(x*i) 'expjpi': ['primitive', [lambda x, y: mp.expjpi(x), None]], #exp(x*i*pi) 'expm1': ['primitive', [lambda x, y: mp.expm1(x), None]], #exp(x)-1 'power': ['primitive', [lambda x, y: mp.power(x, y[0]), None]], 'powm1': ['primitive', [lambda x, y: mp.powm1(x, y[0]),
def neighbours(syst0, SC1, SC2, sc1L, sc1R, sc2L, sc2R, Base_a1, Base_a2, a1p, a2p, N_ToT, a, b, a1, b1, f1, f2, delta_a, s1x, s1y, s2x, s2y, m1, m2): xm, ym, zm = SC1 / 2 + SC2 / 2 #n1,n2=(np.array([[1/sqrt(3),-1],[1/sqrt(3),1]])@np.array([xm,ym])).astype(int) n1m, n2m = ((np.array((np.matrix([Base_a1[:2], Base_a2[:2]]).T).I)) @ np.array([xm, ym])).astype(int) n1pm, n2pm = ((np.array( (np.matrix([a1p[:2], a2p[:2]]).T).I)) @ np.array([xm, ym])).astype(int) ri = a(n1m, n2m).pos ria_tag = a(n1m, n2m).tag xi, yi, zi = ri ria = np.array([xi * f1, yi * f1, zi * f2]) ri = b(n1m, n2m).pos rib_tag = b(n1m, n2m).tag xi, yi, zi = ri rib = np.array([xi * f1, yi * f1, zi * f2]) ri = a1(n1pm, n2pm).pos ria1_tag = a1(n1pm, n2pm).tag xi, yi, zi = ri ria1 = np.array([xi * f1, yi * f1, zi * f2]) ri = b1(n1pm, n2pm).pos rib1_tag = b1(n1pm, n2pm).tag xi, yi, zi = ri rib1 = np.array([xi * f1, yi * f1, zi * f2]) # f1=sqrt(3)*delta_a; # f2=d_0; nns_a_tag = [] nns_b_tag = [] nns_a1_tag = [] nns_b1_tag = [] for nj in range(N_ToT): rj0 = syst0.sites[nj].pos xj, yj, zj = rj0 rj_abs = np.array([xj * f1, yj * f1, zj * f2]) rj_tag = syst0.sites[nj].tag rjtag_1, rjtag_2 = rj_tag if sum(abs(a(rjtag_1, rjtag_2).pos - rj0)) < 10**-8: which_sublattice = 0 if sum(abs(b(rjtag_1, rjtag_2).pos - rj0)) < 10**-8: which_sublattice = 1 if sum(abs(a1(rjtag_1, rjtag_2).pos - rj0)) < 10**-8: which_sublattice = 2 if sum(abs(b1(rjtag_1, rjtag_2).pos - rj0)) < 10**-8: which_sublattice = 3 #print('which_sublattice=',which_sublattice) #for st in {'a','b','a1','b1'}: ss = ria - rj_abs dis = sqrt(np.dot(ss, ss)) if (dis < 5 * delta_a): ss1 = rj_tag - ria_tag ss1 = list(ss1) ss1.append(which_sublattice) nns_a_tag.append(tuple(ss1)) ss = rib - rj_abs dis = sqrt(np.dot(ss, ss)) if (dis < 5 * delta_a): ss1 = rj_tag - rib_tag ss1 = list(ss1) ss1.append(which_sublattice) nns_b_tag.append(tuple(ss1)) ss = ria1 - rj_abs dis = sqrt(np.dot(ss, ss)) if (dis < 5 * delta_a): ss1 = rj_tag - ria1_tag ss1 = list(ss1) ss1.append(which_sublattice) nns_a1_tag.append(tuple(ss1)) ss = rib1 - rj_abs dis = sqrt(np.dot(ss, ss)) if (dis < 5 * delta_a): ss1 = rj_tag - rib1_tag ss1 = list(ss1) ss1.append(which_sublattice) nns_b1_tag.append(tuple(ss1)) n1i, n2i = syst0.sites[0].tag n1f, n2f = syst0.sites[N_ToT - 1].tag for i in range(N_ToT): n1, n2 = syst0.sites[i].tag if n1 < n1i: n1i = n1 if n1 > n1f: n1f = n1 if n2 < n2i: n2i = n2 if n2 > n2f: n2f = n2 #print('n1i,n1f,n2i,n2f',n1i,n1f,n2i,n2f) # nn1 = n1f - n1i + 1 nn2 = n2f - n2i + 1 tag2id = np.ones((nn1, nn2, 4), dtype=int) * (-100) #tags of B sublattice id2tag = [[] for i in range(N_ToT)] def xyz_for_sublattice_i(n1, n2, which_i): if which_i == 0: return a(n1, n2).pos elif which_i == 1: return b(n1, n2).pos elif which_i == 2: return a1(n1, n2).pos else: #which_j==3: return b1(n1, n2).pos i = 0 #id2tag=np.zeros(N_ToT,dtype=int) for which_i in range(4): for n1 in range(n1i, n1f + 1): for n2 in range(n2i, n2f + 1): xR, yR, zR = xyz_for_sublattice_i(n1, n2, which_i) ss1 = s1x * xR + s1y * yR ss2 = s2x * xR + s2y * yR if (sc1L <= ss1 < sc1R) & (sc2L <= ss2 < sc2R): tag2id[n1 - n1i, n2 - n2i, which_i] = i #array indices should be >=0 id2tag[i] = (n1, n2, which_i) i += 1 # for which_i in range(4): # for n1 in range(n1i,n1f+1): # for n2 in range(n2i,n2f+1): # xR,yR,zR=xyz_for_sublattice_i(n1,n2,which_i) # ss1=s1x*xR+s1y*yR; # ss2=s2x*xR+s2y*yR; # if (sc1L<=ss1<sc1R)&(sc2L<=ss2<sc2R): # print('tag2id=',n1,n2,which_i,tag2id[n1-n1i,n2-n2i,which_i]) # # print('correct numbering0') # sys.exit() # for n1 in range(n1i,n1f+1): # for n2 in range(n2i,n2f+1): # xR,yR,zR=a(n1,n2).pos # ss1=s1x*xR+s1y*yR; # ss2=s2x*xR+s2y*yR; # if (sc1L<=ss1<sc1R)&(sc2L<=ss2<sc2R): # tag2id[n1-n1i,n2-n2i,0]=i #array indices should be >=0 # id2tag[i]=(n1,n2,0) # i+=1 # # for n1 in range(n1i,n1f+1): # for n2 in range(n2i,n2f+1): # xR,yR,zR=b(n1,n2).pos # ss1=s1x*xR+s1y*yR; # ss2=s2x*xR+s2y*yR; # if (sc1L<=ss1<sc1R)&(sc2L<=ss2<sc2R): # tag2id[n1-n1i,n2-n2i,1]=i #array indices should be >=0 # id2tag[i]=(n1,n2,1) # i+=1 # for n1 in range(n1i,n1f+1): # for n2 in range(n2i,n2f+1): # xR,yR,zR=a1(n1,n2).pos # ss1=s1x*xR+s1y*yR; # ss2=s2x*xR+s2y*yR; # if (sc1L<=ss1<sc1R)&(sc2L<=ss2<sc2R): # tag2id[n1-n1i,n2-n2i,2]=i #array indices should be >=0 # id2tag[i]=(n1,n2,2) # i+=1 # # for n1 in range(n1i,n1f+1): # for n2 in range(n2i,n2f+1): # xR,yR,zR=b1(n1,n2).pos # ss1=s1x*xR+s1y*yR; # ss2=s2x*xR+s2y*yR; # if (sc1L<=ss1<sc1R)&(sc2L<=ss2<sc2R): # tag2id[n1-n1i,n2-n2i,3]=i #array indices should be >=0 # id2tag[i]=(n1,n2,3) # i+=1 # if (i != N_ToT): print('total number not right') sys.exit() print('correct numbering') #sys.exit() def nn_pos_for_ni(n1, n2, nnjs, nj): n1R_j = n1 + nnjs[nj][0] n2R_j = n2 + nnjs[nj][1] which_j = nnjs[nj][2] if which_j == 0: return a(n1R_j, n2R_j).pos, n1R_j, n2R_j, which_j elif which_j == 1: return b(n1R_j, n2R_j).pos, n1R_j, n2R_j, which_j elif which_j == 2: return a1(n1R_j, n2R_j).pos, n1R_j, n2R_j, which_j else: #which_j==3: return b1(n1R_j, n2R_j).pos, n1R_j, n2R_j, which_j boundary_sites = [] bulk_B = [[] for i in range(N_ToT)] # nn_length=[[] for i in range(4)]; #nn_length[0]=len(nns_a_tag); nn_length[1]=len(nns_b_tag); #nn_length[2]=len(nns_a1_tag);nn_length[3]=len(nns_b1_tag); nns = [[] for i in range(N_ToT)] nnjs = [[] for i in range(4)] nnjs[0] = nns_a_tag nnjs[1] = nns_b_tag nnjs[2] = nns_a1_tag nnjs[3] = nns_b1_tag nn_length = [len(nnjs[i]) for i in range(4)] print('nn_length=', nn_length) num_nn = [0 for i in range(N_ToT)] a1p_a1 = 1 / 2 * (1 + np.sqrt( (m1**2 - m2**2)**2 / (m1**2 + m1 * m2 + m2**2)**2) + (3 * m1 * m2) / (m1**2 + m1 * m2 + m2**2)) a2p_a1 = -( (2 * cos(pi / 6 + asec(2 - (6 * m1 * m2) / (m1**2 + 4 * m1 * m2 + m2**2)))) / sqrt(3)) a1p_a2 = -a2p_a1 a2p_a2 = np.sqrt((m1**2 - m2**2)**2 / (m1**2 + m1 * m2 + m2**2)**2) for n1 in range(n1i, n1f + 1): for n2 in range(n2i, n2f + 1): for which in range(4): xR, yR, zR = xyz_for_sublattice_i(n1, n2, which) ss1 = s1x * xR + s1y * yR ss2 = s2x * xR + s2y * yR #kk+=1;print(kk) if (sc1L <= ss1 < sc1R) & (sc2L <= ss2 < sc2R): nn_count = 0 for nj in range(nn_length[which]): (xR_j, yR_j, zR_j), n1R_j, n2R_j, which_j = nn_pos_for_ni( n1, n2, nnjs[which], nj) ss1_j = s1x * xR_j + s1y * yR_j ss2_j = s2x * xR_j + s2y * yR_j for n1s in range(-1, 2): for n2s in range(-1, 2): if (sc1L <= ss1_j - n1s * (sc1R - sc1L) < sc1R) & (sc2L <= ss2_j - n2s * (sc2R - sc2L) < sc2R): if which_j in [0, 1]: n1R_js = n1R_j - n1s * (int( round(sc1R - sc1L))) * m1 - n2s * ( int(round(sc2R - sc2L))) * (-m2) n2R_js = n2R_j - n1s * (int( round(sc1R - sc1L) )) * (m2) - n2s * (int( round(sc2R - sc2L))) * (m1 + m2) #print('n1R_js=',n1R_js,'n2R_js=',n2R_js) nns[tag2id[ n1 - n1i, n2 - n2i, which]].append( (tag2id[n1R_js - n1i, n2R_js - n2i, which_j], n1s, n2s) ) #array indices should be >=0 elif which_j in [2, 3]: mm11 = int( round(m1 * a1p_a1 + m2 * a1p_a2)) mm21 = int( round(-m2 * a1p_a1 + (m1 + m2) * a1p_a2)) mm12 = int( round(m1 * a2p_a1 + m2 * a2p_a2)) mm22 = int( round(-m2 * a2p_a1 + (m1 + m2) * a2p_a2)) #print(mm11,mm21,mm12,mm22) #sys.exit() n1R_js = n1R_j - n1s * (int( round(sc1R - sc1L) )) * mm11 - n2s * (int( round(sc2R - sc2L))) * mm21 n2R_js = n2R_j - n1s * (int( round(sc1R - sc1L) )) * mm12 - n2s * (int( round(sc2R - sc2L))) * mm22 #print('n1R_js=',n1R_js,'n2R_js=',n2R_js) nns[tag2id[ n1 - n1i, n2 - n2i, which]].append( (tag2id[n1R_js - n1i, n2R_js - n2i, which_j], n1s, n2s) ) #array indices should be >=0 #bulk_B[tag2id[n1R_j-n1i,n2R_j-n2i,which_j].append(tag2id[n1-n1i,n2-n2i,which]) nn_count += 1 num_nn[tag2id[n1 - n1i, n2 - n2i, which]] = nn_count #print('num_nn=',num_nn) #sys.exit() boundary_sites = [] for i in range(N_ToT): n1, n2, which = id2tag[i] if ((num_nn[i]) != nn_length[which]): boundary_sites.append(i) print('boundary_sites=', len(boundary_sites)) # for ni in boundary_sites: # ri0=syst0.sites[ni].pos; xi,yi,zi=ri0; ri=np.array([xi*f1,yi*f1,zi*f2]); # for nj in boundary_sites: # rj0=syst0.sites[nj].pos; # for n1 in range(-1,2): # for n2 in range(-1,2): # if not((n1==0)&(n2==0)): # rjn=rj0+(n1*SC1+n2*SC2); xj,yj,zj=rjn; # rj_abs=np.array([xj*f1,yj*f1,zj*f2]); # ss=ri-rj_abs; # dis=sqrt(np.dot(ss,ss)); # if (dis<5*delta_a): # nns[ni].append((nj,n1,n2)) for ni in range(N_ToT): n1, n2, which = id2tag[ni] if (len(nns[ni]) != nn_length[which]): print(len(nns[ni]), nn_length[which]) print('number of neighbors not equal to len[nns[ni]]: wrong!') sys.exit() return nns_a_tag, nns_b_tag, nns_a1_tag, nns_b1_tag, tag2id, n1i, n1f, n2i, n2f, nns