def pot_to_rpole_aligned(pot, sma, q, F, d, component=1): """ Transforms surface potential to polar radius """ q = q_for_component(q, component=component) Phi = pot_for_component(pot, q, component=component) logger.debug("libphobe.roche_pole(q={}, F={}, d={}, Omega={})".format(q, F, d, pot)) return libphoebe.roche_pole(q, F, d, pot) * sma
def pot_to_rpole_aligned(pot, sma, q, F, d, component=1): """ Transforms from equipotential to polar radius under the aligned roche case. Note: all inputs and output are floats, so it is important to pass values with consistent units. Note: if `component` is not 1, the mass-ratio `q` will be converted to the star's frame via <phoebe.distortions.roche.q_for_component> and the equipotential `pot` will be converted to the star's frame via <phoebe.distortions.roche.pot_for_component>. To avoid this behavior, pass `component=1`. See also: * <phoebe.distortions.roche.rpole_to_pot_aligned> Arguments ----------- * `pot` (float): the aligned roche equipotential * `sma` (float): semi-major axis of the orbit. To return polar radius in roche units, use `sma=1`. * `q` (float): the mass-ratio in the frame of the primary star (m2/m1). Do not call <phoebe.distortions.roche.q_for_component> first as this is called internally if `component=2`. * `F` (float): synchronicity parameter * `d` (float): instantaneous unitless distance between the two components * `component` (int, optional, default=1): whether the requested component is the primary (1) or secondary (2) component. Returns --------- * (float) the aligned roche equipotential """ q = q_for_component(q, component=component) Phi = pot_for_component(pot, q, component=component) logger.debug("libphobe.roche_pole(q={}, F={}, d={}, Omega={})".format( q, F, d, pot)) return libphoebe.roche_pole(q, F, d, pot) * sma
def discretize_wd_style(N, q, F, d, Phi): """ TODO: add documentation New implementation. I'll make this work first, then document. """ DEBUG = False Ts = [] potential = 'BinaryRoche' r0 = libphoebe.roche_pole(q, F, d, Phi) # The following is a hack that needs to go! pot_name = potential dpdx = globals()['d%sdx'%(pot_name)] dpdy = globals()['d%sdy'%(pot_name)] dpdz = globals()['d%sdz'%(pot_name)] if DEBUG: import matplotlib.pyplot as plt from matplotlib.path import Path import matplotlib.patches as patches fig = plt.figure() ax1 = fig.add_subplot(131) ax2 = fig.add_subplot(132) ax3 = fig.add_subplot(133) ax1.set_xlim(-0.3, 0.3) # -1.6 1.6 ax1.set_ylim(-0.3, 0.3) ax2.set_xlim(-0.3, 0.3) ax2.set_ylim(-0.3, 0.3) ax3.set_xlim(-0.3, 0.3) ax3.set_ylim(-0.3, 0.3) ax1.set_xlabel('x') ax1.set_ylabel('y') ax2.set_xlabel('x') ax2.set_ylabel('z') ax3.set_xlabel('y') ax3.set_ylabel('z') # Rectangle centers: theta = np.array([np.pi/2*(k-0.5)/N for k in range(1, N+2)]) phi = np.array([[np.pi*(l-0.5)/Mk for l in range(1, Mk+1)] for Mk in np.array(1 + 1.3*N*np.sin(theta), dtype=int)]) for t in range(len(theta)-1): dtheta = theta[t+1]-theta[t] for i in range(len(phi[t])): dphi = phi[t][1]-phi[t][0] # Project the vertex onto the potential; this will be our center point: rc = np.array((r0*sin(theta[t])*cos(phi[t][i]), r0*sin(theta[t])*sin(phi[t][i]), r0*cos(theta[t]))) vc = project_onto_potential(rc, potential, d, q, F, Phi).r # Next we need to find the tangential plane, which we'll get by finding the normal, # which is the negative of the gradient: nc = np.array((-dpdx(vc, d, q, F), -dpdy(vc, d, q, F), -dpdz(vc, d, q, F))) # Then we need to find the intercontext of +/-dtheta/dphi-deflected # radius vectors with the tangential plane. We do that by solving # # d = [(p0 - l0) \dot n] / (l \dot n), # # where p0 and l0 are reference points on the plane and on the line, # respectively, n is the normal vector, and l is the line direction # vector. For convenience l0 can be set to 0, and p0 is just vc. d # then measures the distance from the origin along l. l1 = np.array((sin(theta[t]-dtheta/2)*cos(phi[t][i]-dphi/2), sin(theta[t]-dtheta/2)*sin(phi[t][i]-dphi/2), cos(theta[t]-dtheta/2))) l2 = np.array((sin(theta[t]-dtheta/2)*cos(phi[t][i]+dphi/2), sin(theta[t]-dtheta/2)*sin(phi[t][i]+dphi/2), cos(theta[t]-dtheta/2))) l3 = np.array((sin(theta[t]+dtheta/2)*cos(phi[t][i]+dphi/2), sin(theta[t]+dtheta/2)*sin(phi[t][i]+dphi/2), cos(theta[t]+dtheta/2))) l4 = np.array((sin(theta[t]+dtheta/2)*cos(phi[t][i]-dphi/2), sin(theta[t]+dtheta/2)*sin(phi[t][i]-dphi/2), cos(theta[t]+dtheta/2))) r1 = np.dot(vc, nc) / np.dot(l1, nc) * l1 r2 = np.dot(vc, nc) / np.dot(l2, nc) * l2 r3 = np.dot(vc, nc) / np.dot(l3, nc) * l3 r4 = np.dot(vc, nc) / np.dot(l4, nc) * l4 # This sorts out the vertices, now we need to fudge the surface # area. WD does not take curvature of the equipotential at vc # into account, so the surface area computed from these vertex- # delimited surfaces will generally be different from what WD # computes. Thus, we compute the surface area the same way WD # does it and assign it to each element even though that isn't # quite its area: # # dsigma = || r^2 sin(theta)/cos(gamma) dtheta dphi ||, # # where gamma is the angle between l and n. cosgamma = np.dot(vc, nc)/np.sqrt(np.dot(vc, vc))/np.sqrt(np.dot(nc, nc)) dsigma = np.abs(np.dot(vc, vc)*np.sin(theta[t])/cosgamma*dtheta*dphi) # Temporary addition: triangle areas: ###################### side1 = sqrt((r1[0]-r2[0])**2 + (r1[1]-r2[1])**2 + (r1[2]-r2[2])**2) side2 = sqrt((r1[0]-r3[0])**2 + (r1[1]-r3[1])**2 + (r1[2]-r3[2])**2) side3 = sqrt((r2[0]-r3[0])**2 + (r2[1]-r3[1])**2 + (r2[2]-r3[2])**2) s = 0.5*(side1 + side2 + side3) dsigma_t_sq = s*(s-side1)*(s-side2)*(s-side3) dsigma_t = sqrt(dsigma_t_sq) if dsigma_t_sq > 0 else 0.0 ############################################################ if DEBUG: fc = 'orange' verts = [(r1[0], r1[1]), (r2[0], r2[1]), (r3[0], r3[1]), (r4[0], r4[1]), (r1[0], r1[1])] codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY] path = Path(verts, codes) patch = patches.PathPatch(path, facecolor=fc, lw=2) ax1.add_patch(patch) verts = [(r1[0], r1[2]), (r2[0], r2[2]), (r3[0], r3[2]), (r4[0], r4[2]), (r1[0], r1[2])] codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY] path = Path(verts, codes) patch = patches.PathPatch(path, facecolor=fc, lw=2) ax2.add_patch(patch) verts = [(r1[1], r1[2]), (r2[1], r2[2]), (r3[1], r3[2]), (r4[1], r4[2]), (r1[1], r1[2])] codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY] path = Path(verts, codes) patch = patches.PathPatch(path, facecolor=fc, lw=2) ax3.add_patch(patch) # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2]))) # # Instead of recomputing all quantities, just reflect over the y- and z-directions. # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r1[0], -r1[1], r1[2], r2[0], -r2[1], r2[2], r3[0], -r3[1], r3[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r3[0], -r3[1], r3[2], r4[0], -r4[1], r4[2], r1[0], -r1[1], r1[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r1[0], r1[1], -r1[2], r2[0], r2[1], -r2[2], r3[0], r3[1], -r3[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r3[0], r3[1], -r3[2], r4[0], r4[1], -r4[2], r1[0], r1[1], -r1[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r1[0], -r1[1], -r1[2], r2[0], -r2[1], -r2[2], r3[0], -r3[1], -r3[2], nc[0], -nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r3[0], -r3[1], -r3[2], r4[0], -r4[1], -r4[2], r1[0], -r1[1], -r1[2], nc[0], -nc[1], -nc[2]))) # FOR TESTING - report theta/phi for each triangle # uncomment the above original version eventually Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) # Instead of recomputing all quantities, just reflect over the y- and z-directions. Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r1[0], -r1[1], r1[2], r2[0], -r2[1], r2[2], r3[0], -r3[1], r3[2], nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r3[0], -r3[1], r3[2], r4[0], -r4[1], r4[2], r1[0], -r1[1], r1[2], nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r1[0], r1[1], -r1[2], r2[0], r2[1], -r2[2], r3[0], r3[1], -r3[2], nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r3[0], r3[1], -r3[2], r4[0], r4[1], -r4[2], r1[0], r1[1], -r1[2], nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r1[0], -r1[1], -r1[2], r2[0], -r2[1], -r2[2], r3[0], -r3[1], -r3[2], nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r3[0], -r3[1], -r3[2], r4[0], -r4[1], -r4[2], r1[0], -r1[1], -r1[2], nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) if DEBUG: plt.show() # Assemble a mesh table: table = np.array(Ts) return table
def discretize_wd_style_oc(N, q, F, d, Phi,recompute_neck=True): Ts = [] Tstart = [0,] # for testing of where things start to diverge: breaks0, breaks1 = [], [] vcs0, vcs1 = [], [] potential = 'BinaryRoche' q_1, Phi_1 = q, Phi q_2, Phi_2 = 1./q, Phi/q + 0.5*(q-1)/q xmin1, z1 = nekmin(Phi_1,q_1,0.5,0.05,0.05) # xmin1 = (xminz1+xminy1)/2. xmin2 = d - xmin1 #xminz2, xminy2, y2, z2 = nekmin(Phi_2,q_2,0.5,0.05,0.05) # first, find closest neck points to mark them for fractional area computation for obj, q, Phi, xmin in zip([0,1],[q_1,q_2],[Phi_1,Phi_2],[xmin1,xmin2]): r0 = libphoebe.roche_pole(q, F, d, Phi) # The following is a hack that needs to go! pot_name = potential dpdx = globals()['d%sdx'%(pot_name)] dpdy = globals()['d%sdy'%(pot_name)] dpdz = globals()['d%sdz'%(pot_name)] # Rectangle centers: theta = np.array([np.pi/2*(k-0.5)/N for k in range(1, N+2)]) phi = np.array([[np.pi*(l-0.5)/Mk for l in range(1, Mk+1)] for Mk in np.array(1 + 1.3*N*np.sin(theta), dtype=int)]) for t in range(len(theta)-1): dtheta = theta[t+1]-theta[t] for i in range(len(phi[t])): dphi = phi[t][1]-phi[t][0] # Project the vertex onto the potential; this will be our center point: rc = np.array((r0*sin(theta[t])*cos(phi[t][i]), r0*sin(theta[t])*sin(phi[t][i]), r0*cos(theta[t]))) vc = project_onto_potential(rc, potential, d, q, F, Phi).r if (vc[0] < 0. and vc[0] > -1.) or abs(vc[0]) <= xmin: # do this for separate components cause they may have different diverging strips if obj==0 and abs(vc[1])>=1e-16: vcs0.append(np.array([vc[0],vc[1],vc[2],theta[t]])) elif obj==1 and abs(vc[1])>=1e-16: vcs1.append(np.array([vc[0],vc[1],vc[2],theta[t]])) else: if obj==0 and abs(vc[1])>=1e-16: breaks0.append(theta[t]) elif obj==1 and abs(vc[1])>=1e-16: breaks1.append(theta[t]) vcs0,vcs1 = np.array(vcs0), np.array(vcs1) #breaks0, breaks1 = np.array(breaks0), np.array(breaks1) thetas0, thetas1 = set(breaks0), set(breaks1) vcs_breaks0 = [] vcs_breaks1 = [] # go through strips of thetas where things diverge and mark last created center for theta in thetas0: vcs_strip = vcs0[vcs0[:,-1]==theta] vcs_breaks0.append([vcs_strip[0][0],vcs_strip[0][1],vcs_strip[0][2]]) for theta in thetas1: vcs_strip = vcs1[vcs1[:,-1]==theta] vcs_breaks1.append([vcs_strip[0][0],vcs_strip[0][1],vcs_strip[0][2]]) vcs_breaks0 = np.array(vcs_breaks0) vcs_breaks1 = np.array(vcs_breaks1) for obj, q, Phi, xmin, vcs_breaks in zip([0,1],[q_1,q_2],[Phi_1,Phi_2],[xmin1,xmin2],[vcs_breaks0,vcs_breaks1]): r0 = libphoebe.roche_pole(q, F, d, Phi) # The following is a hack that needs to go! pot_name = potential dpdx = globals()['d%sdx'%(pot_name)] dpdy = globals()['d%sdy'%(pot_name)] dpdz = globals()['d%sdz'%(pot_name)] # Rectangle centers: theta = np.array([np.pi/2*(k-0.5)/N for k in range(1, N+2)]) phi = np.array([[np.pi*(l-0.5)/Mk for l in range(1, Mk+1)] for Mk in np.array(1 + 1.3*N*np.sin(theta), dtype=int)]) for t in range(len(theta)-1): dtheta = theta[t+1]-theta[t] for i in range(len(phi[t])): dphi = phi[t][1]-phi[t][0] # Project the vertex onto the potential; this will be our center point: # print "projecting center" rc = np.array((r0*sin(theta[t])*cos(phi[t][i]), r0*sin(theta[t])*sin(phi[t][i]), r0*cos(theta[t]))) vc = project_onto_potential(rc, potential, d, q, F, Phi).r if ((vc[0] < 0. and vc[0] > -1.) or abs(vc[0]) <= xmin) and abs(vc[1])>=1e-16: # Next we need to find the tangential plane, which we'll get by finding the normal, # which is the negative of the gradient: nc = np.array((-dpdx(vc, d, q, F), -dpdy(vc, d, q, F), -dpdz(vc, d, q, F))) # Then we need to find the intercontext of +/-dtheta/dphi-deflected # radius vectors with the tangential plane. We do that by solving # # d = [(p0 - l0) \dot n] / (l \dot n), # # where p0 and l0 are reference points on the plane and on the line, # respectively, n is the normal vector, and l is the line direction # vector. For convenience l0 can be set to 0, and p0 is just vc. d # then measures the distance from the origin along l. l1 = np.array((sin(theta[t]-dtheta/2)*cos(phi[t][i]-dphi/2), sin(theta[t]-dtheta/2)*sin(phi[t][i]-dphi/2), cos(theta[t]-dtheta/2))) l2 = np.array((sin(theta[t]-dtheta/2)*cos(phi[t][i]+dphi/2), sin(theta[t]-dtheta/2)*sin(phi[t][i]+dphi/2), cos(theta[t]-dtheta/2))) l3 = np.array((sin(theta[t]+dtheta/2)*cos(phi[t][i]+dphi/2), sin(theta[t]+dtheta/2)*sin(phi[t][i]+dphi/2), cos(theta[t]+dtheta/2))) l4 = np.array((sin(theta[t]+dtheta/2)*cos(phi[t][i]-dphi/2), sin(theta[t]+dtheta/2)*sin(phi[t][i]-dphi/2), cos(theta[t]+dtheta/2))) r1 = np.dot(vc, nc) / np.dot(l1, nc) * l1 r2 = np.dot(vc, nc) / np.dot(l2, nc) * l2 r3 = np.dot(vc, nc) / np.dot(l3, nc) * l3 r4 = np.dot(vc, nc) / np.dot(l4, nc) * l4 # This sorts out the vertices, now we need to fudge the surface # area. WD does not take curvature of the equipotential at vc # into account, so the surface area computed from these vertex- # delimited surfaces will generally be different from what WD # computes. Thus, we compute the surface area the same way WD # does it and assign it to each element even though that isn't # quite its area: # # dsigma = || r^2 sin(theta)/cos(gamma) dtheta dphi ||, # # where gamma is the angle between l and n. cosgamma = np.dot(vc, nc)/np.sqrt(np.dot(vc, vc))/np.sqrt(np.dot(nc, nc)) dsigma = np.abs(np.dot(vc, vc)*np.sin(theta[t])/cosgamma*dtheta*dphi) # Temporary addition: triangle areas: ###################### side1 = sqrt((r1[0]-r2[0])**2 + (r1[1]-r2[1])**2 + (r1[2]-r2[2])**2) side2 = sqrt((r1[0]-r3[0])**2 + (r1[1]-r3[1])**2 + (r1[2]-r3[2])**2) side3 = sqrt((r2[0]-r3[0])**2 + (r2[1]-r3[1])**2 + (r2[2]-r3[2])**2) s = 0.5*(side1 + side2 + side3) dsigma_t_sq = s*(s-side1)*(s-side2)*(s-side3) dsigma_t = sqrt(dsigma_t_sq) if dsigma_t_sq > 0 else 0.0 ############################################################ #if abs(r1[0]) <= xmin and abs(r2[0]) <= xmin and abs(r3[0]) <= xmin and abs(r4[0]) <= xmin: # check whether the trapezoids cross the neck and if so put them back into their place # do the same for end traezoids also if (np.array([abs(r1[0]),abs(r2[0]),abs(r3[0]),abs(r4[0])])>xmin).any() or vc in vcs_breaks: r1,r2,r3,r4,dsigma_t_new = wd_mesh_fill(xmin,y1,z1,r1,r2,r3,r4) if dsigma_t != 0: frac_area = dsigma_t_new/dsigma_t dsigma = dsigma*frac_area dsigma_t = dsigma_t*frac_area else: dsigma_t = dsigma_t_new dsigma = 2*dsigma_t_new if recompute_neck: #vc,nc,r1,r2,r3,r4,dsigma,dsigma_t,phi_half,dphi_new=wd_recompute_neck(r0,xmin,y1,z1,r1,r2,r3,r4,theta[t],dtheta,potential,d,q,F,Phi) disgma = wd_recompute_neck(r0,xmin,y1,z1,r1,r2,r3,r4,theta[t],dtheta,potential,d,q,F,Phi) #phi[t][i],dphi=phi_half,dphi_new # If all of the vertices are on one side of the minimum, keep trapezoids as they are # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2]))) # # Instead of recomputing all quantities, just reflect over the y- and z-directions. # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r1[0], -r1[1], r1[2], r2[0], -r2[1], r2[2], r3[0], -r3[1], r3[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r3[0], -r3[1], r3[2], r4[0], -r4[1], r4[2], r1[0], -r1[1], r1[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r1[0], r1[1], -r1[2], r2[0], r2[1], -r2[2], r3[0], r3[1], -r3[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r3[0], r3[1], -r3[2], r4[0], r4[1], -r4[2], r1[0], r1[1], -r1[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r1[0], -r1[1], -r1[2], r2[0], -r2[1], -r2[2], r3[0], -r3[1], -r3[2], nc[0], -nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r3[0], -r3[1], -r3[2], r4[0], -r4[1], -r4[2], r1[0], -r1[1], -r1[2], nc[0], -nc[1], -nc[2]))) # FOR TESTING - report theta/phi for each triangle # uncomment the above original version eventually # Temporary addition: vertex normals: ###################### # print "projecting vertices " v1 = project_onto_potential(r1, potential, d, q, F, Phi).r v2 = project_onto_potential(r2, potential, d, q, F, Phi).r v3 = project_onto_potential(r3, potential, d, q, F, Phi).r v4 = project_onto_potential(r4, potential, d, q, F, Phi).r n1 = np.array((-dpdx(v1, d, q, F), -dpdy(v1, d, q, F), -dpdz(v1, d, q, F))) n2 = np.array((-dpdx(v2, d, q, F), -dpdy(v2, d, q, F), -dpdz(v2, d, q, F))) n3 = np.array((-dpdx(v3, d, q, F), -dpdy(v3, d, q, F), -dpdz(v3, d, q, F))) n4 = np.array((-dpdx(v4, d, q, F), -dpdy(v4, d, q, F), -dpdz(v4, d, q, F))) ############################################################ # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2]))) # # Instead of recomputing all quantities, just reflect over the y- and z-directions. # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r1[0], -r1[1], r1[2], r2[0], -r2[1], r2[2], r3[0], -r3[1], r3[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r3[0], -r3[1], r3[2], r4[0], -r4[1], r4[2], r1[0], -r1[1], r1[2], nc[0], -nc[1], nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r1[0], r1[1], -r1[2], r2[0], r2[1], -r2[2], r3[0], r3[1], -r3[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r3[0], r3[1], -r3[2], r4[0], r4[1], -r4[2], r1[0], r1[1], -r1[2], nc[0], nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r1[0], -r1[1], -r1[2], r2[0], -r2[1], -r2[2], r3[0], -r3[1], -r3[2], nc[0], -nc[1], -nc[2]))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r3[0], -r3[1], -r3[2], r4[0], -r4[1], -r4[2], r1[0], -r1[1], -r1[2], nc[0], -nc[1], -nc[2]))) # FOR TESTING - report theta/phi for each triangle # uncomment the above original version eventually if obj==0: Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t, n3[0], n3[1], n3[2], n4[0], n4[1], n4[2], n1[0], n1[1], n1[2]))) Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t, n1[0], n1[1], n1[2], n2[0], n2[1], n2[2], n3[0], n3[1], n3[2]))) else: Ts.append(np.array((-vc[0]+d, vc[1], vc[2], dsigma/2, -r3[0]+d, r3[1], r3[2], -r4[0]+d, r4[1], r4[2], -r1[0]+d, r1[1], r1[2], -nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t, -n3[0], n3[1], n3[2], -n4[0], n4[1], n4[2], -n1[0], n1[1], n1[2]))) Ts.append(np.array((-vc[0]+d, vc[1], vc[2], dsigma/2, -r1[0]+d, r1[1], r1[2], -r2[0]+d, r2[1], r2[2], -r3[0]+d, r3[1], r3[2], -nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t, -n1[0], n1[1], n1[2], -n2[0], n2[1], n2[2], -n3[0], n3[1], n3[2]))) for T in reversed(Ts[Tstart[-1]:]): Ts.append(np.array((T[0], -T[1], T[2], T[3], T[4], -T[5], T[6], T[7], -T[8], T[9], T[10], -T[11], T[12], T[13], -T[14], T[15], T[16], -T[17], T[18], T[19], -T[20], T[21], T[22], -T[23], T[24], T[25], -T[26], T[27]))) Tstart.append(len(Ts)) for i in range(len(Tstart)-1): for T in Ts[Tstart[-2]:Tstart[-1]]: Ts.append(np.array((T[0], T[1], -T[2], T[3], T[4], T[5], -T[6], T[7], T[8], -T[9], T[10], T[11], -T[12], T[13], T[14], -T[15], np.pi-T[16], T[17], T[18], T[19], T[20], -T[21], T[22], T[23], -T[24], T[25], T[26], -T[27]))) Tstart.pop(-1) # if obj == 0: # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r1[0], r1[1], r1[2], r2[0], r2[1], r2[2], r3[0], r3[1], r3[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], vc[1], vc[2], dsigma/2, r3[0], r3[1], r3[2], r4[0], r4[1], r4[2], r1[0], r1[1], r1[2], nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) # # Instead of recomputing all quantities, just reflect over the y- and z-directions. # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r1[0], -r1[1], r1[2], r2[0], -r2[1], r2[2], r3[0], -r3[1], r3[2], nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], -vc[1], vc[2], dsigma/2, r3[0], -r3[1], r3[2], r4[0], -r4[1], r4[2], r1[0], -r1[1], r1[2], nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r1[0], r1[1], -r1[2], r2[0], r2[1], -r2[2], r3[0], r3[1], -r3[2], nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], vc[1], -vc[2], dsigma/2, r3[0], r3[1], -r3[2], r4[0], r4[1], -r4[2], r1[0], r1[1], -r1[2], nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r1[0], -r1[1], -r1[2], r2[0], -r2[1], -r2[2], r3[0], -r3[1], -r3[2], nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((vc[0], -vc[1], -vc[2], dsigma/2, r3[0], -r3[1], -r3[2], r4[0], -r4[1], -r4[2], r1[0], -r1[1], -r1[2], nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) # else: # Ts.append(np.array((-vc[0]+d, vc[1], vc[2], dsigma/2, -r1[0]+d, r1[1], r1[2], -r2[0]+d, r2[1], r2[2], -r3[0]+d, r3[1], r3[2], -nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, vc[1], vc[2], dsigma/2, -r3[0]+d, r3[1], r3[2], -r4[0]+d, r4[1], r4[2], -r1[0]+d, r1[1], r1[2], -nc[0], nc[1], nc[2], theta[t], phi[t][0], dsigma_t))) # # Instead of recomputing all quantities, just reflect over the y- and z-directions. # Ts.append(np.array((-vc[0]+d, -vc[1], vc[2], dsigma/2, -r1[0]+d, -r1[1], r1[2], -r2[0]+d, -r2[1], r2[2], -r3[0]+d, -r3[1], r3[2], -nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, -vc[1], vc[2], dsigma/2, -r3[0]+d, -r3[1], r3[2], -r4[0]+d, -r4[1], r4[2], -r1[0]+d, -r1[1], r1[2], -nc[0], -nc[1], nc[2], theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, vc[1], -vc[2], dsigma/2, -r1[0]+d, r1[1], -r1[2], -r2[0]+d, r2[1], -r2[2], -r3[0]+d, r3[1], -r3[2], -nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, vc[1], -vc[2], dsigma/2, -r3[0]+d, r3[1], -r3[2], -r4[0]+d, r4[1], -r4[2], -r1[0]+d, r1[1], -r1[2], -nc[0], nc[1], -nc[2], np.pi-theta[t], phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, -vc[1], -vc[2], dsigma/2, -r1[0]+d, -r1[1], -r1[2], -r2[0]+d, -r2[1], -r2[2], -r3[0]+d, -r3[1], -r3[2], -nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) # Ts.append(np.array((-vc[0]+d, -vc[1], -vc[2], dsigma/2, -r3[0]+d, -r3[1], -r3[2], -r4[0]+d, -r4[1], -r4[2], -r1[0]+d, -r1[1], -r1[2], -nc[0], -nc[1], -nc[2], np.pi-theta[t], -phi[t][0], dsigma_t))) # Assemble a mesh table: table = np.array(Ts) return table