def dirichlet(pair):
""" Calculate dirichlet between 2D and 3D triangle pair.
Arguments:
pair: This is a numpy array with pairs of 3d and 2d triangles
Returns:
dirichlet: returns the dirichlet energy between pair of tris
"""
# Assign values in triangle to vertices
fv1 = np.array(pair["2D"][0])
fv2 = np.array(pair["2D"][1])
fv3 = np.array(pair["2D"][2])
v1 = pair["3D"][0]
v2 = pair["3D"][1]
v3 = pair["3D"][2]
# Calc theta1, theta2, theta3
theta1 = calc_theta(v3 - v1, v3 - v2)
theta2 = calc_theta(v2 - v1, v2 - v3)
theta3 = calc_theta(v1 - v3, v1 - v2)
# Calc normalized euclidian vectors from points
dpart1 = magnitude(fv1 - fv2)**2
dpart2 = magnitude(fv1 - fv3)**2
dpart3 = magnitude(fv2 - fv3)**2
# Calc dirichlet
dirichlet = mpmath.cot(theta3) * dpart1 + \
mpmath.cot(theta2) * dpart2 + \
mpmath.cot(theta1) * dpart3
return (dirichlet)
def calculateInverseProblem(self):
try :
phi1 = math.radians(ast.literal_eval(self.ui.lineEdit_389.text()) + ast.literal_eval(
self.ui.lineEdit_390.text()) / 60 + ast.literal_eval(self.ui.lineEdit_387.text()) / 3600)
lambda1 = math.radians(ast.literal_eval(self.ui.lineEdit_391.text()) + ast.literal_eval(
self.ui.lineEdit_386.text()) / 60 + ast.literal_eval(self.ui.lineEdit_388.text()) / 3600)
phi2 = math.radians(ast.literal_eval(self.ui.lineEdit_402.text()) + ast.literal_eval(
self.ui.lineEdit_400.text()) / 60 + ast.literal_eval(self.ui.lineEdit_403.text()) / 3600)
lambda2 = math.radians(ast.literal_eval(self.ui.lineEdit_399.text()) + ast.literal_eval(
self.ui.lineEdit_404.text()) / 60 + ast.literal_eval(self.ui.lineEdit_401.text()) / 3600)
a = 6378249.2
b= 6356515
R = (2*a+b)/3
deltaLambda = lambda2 - lambda1
distanceD12 = math.acos( (math.sin(phi1)) * (math.sin(phi2)) + (math.cos(phi1)) * (math.cos(phi2)) * (math.cos(deltaLambda) ) )
distanceD12 = R * distanceD12
azimutDepart = math.degrees( mpmath.acot(
( ( (math.tan(phi2)) * math.cos(phi1) ) / math.sin(deltaLambda)) -
((math.sin(phi1)) * (mpmath.cot(deltaLambda))) ) )
azimutArrive = math.degrees( mpmath.acot( - ( ( (math.tan(phi1)) * math.cos(phi2) ) / (math.sin(deltaLambda)) -
( (math.sin(phi2)) * (mpmath.cot(deltaLambda) ) ) ) ) )
azimutDepart = UIFunctions.degdecimal2dms(azimutDepart)
azimutArrive = UIFunctions.degdecimal2dms(azimutArrive)
self.ui.lineEdit_393.setText(str("%.4f" % distanceD12))
self.ui.lineEdit_395.setText(str("%.f" % azimutDepart[0]))
self.ui.lineEdit_392.setText(str("%.f" % azimutDepart[1]))
self.ui.lineEdit_394.setText(str("%.4f" % azimutDepart[2]))
self.ui.lineEdit_398.setText(str("%.f" % azimutArrive[0]))
self.ui.lineEdit_396.setText(str("%.f" % azimutArrive[1]))
self.ui.lineEdit_397.setText(str("%.4f" % azimutArrive[2]))
except Exception :
UIFunctions.errorMsg(self,"Erreur\nressayer une autre fois ")
def Der_Phi_Phi_Basis_Fn(M_Coef,N_Coef, Theta, Phi): # M_Coef < 0 Corresonds to Z^|M|_N Der_Phi_Phi_Val = 0 if(M_Coef < 0): m_sph = -1*M_Coef Der_Phi_Phi_Val += m_sph*(m_sph*(mpmath.cot(Phi)**2) - (mpmath.csc(Phi)**2))*sph_harm(m_sph, N_Coef, Theta, Phi).imag if(m_sph < N_Coef): Der_Phi_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(2*m_sph + 1)*mpmath.cot(Phi)*(((e**(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).imag if(m_sph < (N_Coef -1) ): Der_Phi_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef-m_sph-1)*(N_Coef+m_sph+1)*(N_Coef+m_sph+2))*(((e**(-2j*Theta))*sph_harm(m_sph+2, N_Coef, Theta, Phi))).imag else: # M_Coef >= 0 m_sph = M_Coef Der_Phi_Phi_Val += m_sph*(m_sph*(mpmath.cot(Phi)**2) - (mpmath.csc(Phi)**2))*sph_harm(m_sph, N_Coef, Theta, Phi).real if(m_sph < N_Coef): Der_Phi_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(2*m_sph + 1)*mpmath.cot(Phi)*(((e**(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).real if(m_sph < (N_Coef -1) ): Der_Phi_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef-m_sph-1)*(N_Coef+m_sph+1)*(N_Coef+m_sph+2))*(((e**(-2j*Theta))*sph_harm(m_sph+2, N_Coef, Theta, Phi))).real return Der_Phi_Phi_Val
def Der_Phi_Basis_Fn(M_Coef,N_Coef, Theta, Phi): # M_Coef < 0 Corresonds to Z^|M|_N
Der_Phi_Val = []
# For Scalar Case, we use usual vectorization:
if(isscalar(Theta)):
#COPIED FROM SPH_DER_PHI_FN
Der_Phi_Val = 0
if(M_Coef == 0): #No Cotangent terms:
if(N_Coef > 0):
return sqrt((N_Coef)*(N_Coef+1))*(((e**(-1j*Theta))*sph_harm(1, N_Coef, Theta, Phi))).real
else:
return 0 #d_phi Y^0_0 = 0
elif(M_Coef < 0):
m_sph = -1*M_Coef
Der_Phi_Val += (m_sph*mpmath.cot(Phi))*sph_harm(m_sph, N_Coef, Theta, Phi).imag
if(m_sph < N_Coef):
Der_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(((e**(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).imag
else: # M_Coef >= 0
m_sph = M_Coef
Der_Phi_Val += (m_sph*mpmath.cot(Phi))*sph_harm(m_sph, N_Coef, Theta, Phi).real
if(m_sph < N_Coef):
Der_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(((e**(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).real
else: # array input case:
#COPIED FROM SPH_DER_PHI_FN
Der_Phi_Val = np.zeros_like(Theta)
if(M_Coef == 0): #No Cotangent terms:
if(N_Coef > 0):
return sqrt((N_Coef)*(N_Coef+1))*(((np.exp(-1j*Theta))*sph_harm(1, N_Coef, Theta, Phi))).real
else:
return 0 #d_phi Y^0_0 = 0
elif(M_Coef < 0):
m_sph = -1*M_Coef
Der_Phi_Val += (m_sph*(1./np.tan(Phi)))*sph_harm(m_sph, N_Coef, Theta, Phi).imag
if(m_sph < N_Coef):
Der_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(((np.exp(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).imag
else: # M_Coef >= 0
m_sph = M_Coef
Der_Phi_Val += (m_sph*(1./np.tan(Phi)))*sph_harm(m_sph, N_Coef, Theta, Phi).real
if(m_sph < N_Coef):
Der_Phi_Val += sqrt((N_Coef-m_sph)*(N_Coef+m_sph+1))*(((np.exp(-1j*Theta))*sph_harm(m_sph+1, N_Coef, Theta, Phi))).real
return Der_Phi_Val
def CurvePoints(xt, yt, xc, yc, Bte, Yle, Ate, dzte, zte, rle, b8, b0, b2, b15,
b17):
# Calculation of bezier control points 3434 parametrization
# Leading edge thickness curve [LET]
# LET : Matrix 4 columns [points] by 2 rows [x, y] of bezier points
LET = np.zeros((2, 4))
LET[0, 2] = -3 * b8**2 / (2 * rle)
LET[0, 3] = xt
LET[1, 1] = b8
LET[1, 2] = yt
LET[1, 3] = yt
# Leading edge camber curve [LEC]
# LEC: Matrix 4 columns [points] by 2 rows [x, y] of bezier points
LEC = np.zeros((2, 4))
LEC[0, 1] = b0
LEC[0, 2] = b2
LEC[0, 3] = xc
LEC[1, 1] = b0 * m.tan(Yle)
LEC[1, 2] = yc
LEC[1, 3] = yc
# Trailing edge thickness curve [TET]
# TET: Matrix 5 columns [points] by 2 rows [x, y] of bezier points
TET = np.zeros((2, 5))
TET[0, 0] = xt
TET[0, 1] = (7 * xt + 9 * b8**2 / (2 * rle)) / 4
TET[0, 2] = 3 * xt - 5 * LET[0, 2] / 2
TET[0, 3] = b15
TET[0, 4] = 1
TET[1, 0] = yt
TET[1, 1] = yt
TET[1, 2] = (yt + b8) / 2
TET[1, 3] = dzte + (1 - b15) * m.tan(Bte)
TET[1, 4] = dzte
# Trailing edge camber curve [TEC]
# TEC: Matrix 5 columns [points] by 2 rows [x, y] of bezier points
TEC = np.zeros((2, 5))
TEC[0, 0] = xc
TEC[0, 1] = (3 * xc - yc * mp.cot(Yle)) / 2
TEC[0, 2] = (-8 * yc * mp.cot(Yle) + 13 * xc) / 6
TEC[0, 3] = b17
TEC[0, 4] = 1
TEC[1, 0] = yc
TEC[1, 1] = yc
TEC[1, 2] = 5 * yc / 6
TEC[1, 3] = zte + (1 - b17) * m.tan(Ate)
TEC[1, 4] = zte
return LET, LEC, TET, TEC
def fuckin_freud(l, w, R, beta, dims):
a, b, c, d = dims
theta_input = float(atan(l / (R - w / 2)))
theta_output_ackerman = float(acot(cot(theta_input) + w / l))
def freudenstein_eq(theta_input):
theta_input_freud = (pi / 2) - beta - theta_input
J1 = d / a
J2 = d / c
J3 = (a**2 - b**2 + c**2 + d**2) / (2 * a * c)
A = J3 - J1 + (1 - J2) * cos(theta_input_freud)
B = -2 * sin(theta_input_freud)
C = J1 + J3 - (1 + J2) * cos(theta_input_freud)
theta_output_freud = float(2 * atan(
(-B - sqrt(B**2 - 4 * A * C)) / (2 * A)))
return (pi / 2) + beta - theta_output_freud
theta_output_freud = freudenstein_eq(theta_input)
error = (theta_output_freud - theta_output_ackerman)
return error, theta_input, theta_output_ackerman, theta_output_freud
def cos_gamma(_a: float, incl: float, tol=10e-5) -> float:
"""Calculate the cos of the angle gamma"""
if abs(incl) < tol:
return 0
else:
return mpmath.cos(_a) / mpmath.sqrt(
mpmath.cos(_a)**2 + mpmath.cot(incl)**2) # real
def BMEquation(gamma, mach_1, beta):
bm_equation = ""
if beta > 0:
bm_equation = (
2 * cot(beta) * ((pow(mach_1, 2) * pow(sin(beta), 2) - 1) / (pow(mach_1, 2) * (gamma + cos(2 * beta)) + 2))
)
return bm_equation
def test_gauss_digamma_theorem():
pi = mpmath.pi
r = 3
m = 5
y = (
-mpmath.euler - mpmath.log(2 * m) - pi / 2 * mpmath.cot(r * pi / m) +
2 * sum(
mpmath.cos(2 * pi * n * r / m) * mpmath.log(mpmath.sin(pi * n / m))
for n in range(1, (m - 1) // 2 + 1)))
x = digammainv(y)
assert mpmath.almosteq(x, mpmath.mpf(r) / m)
def getAntiprismSurfaceArea( n, k ):
if real( n ) < 3:
raise ValueError( 'the number of sides of the prism cannot be less than 3,' )
if not isinstance( k, RPNMeasurement ):
return getAntiprismSurfaceArea( n, RPNMeasurement( real( k ), 'meter' ) )
if k.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'antiprism_area\' argument 2 must be a length' )
result = getProduct( [ fdiv( n, 2 ), fadd( cot( fdiv( pi, n ) ), sqrt( 3 ) ), getPower( k, 2 ) ] )
return result.convert( 'meter^2' )
def get_coords(self, x, y): val = math.pi/4 + y/2 if round(val,4) == 0.0000: val = 0.00001 elif round(val, 4) >= 1.5708: val = 1.5707 elif round(val, 4) < 0: return (-10000, -10000) r = self.F * math.pow( mpmath.cot(val) , self.n) new_x = r * math.sin(self.n*x) new_y = - r * math.cos(self.n * x) return 80*new_x, 80*new_y
def getPrismVolume( n, k, h ):
if real( n ) < 3:
raise ValueError( 'the number of sides of the prism cannot be less than 3,' )
if not isinstance( k, RPNMeasurement ):
return getPrismVolume( n, RPNMeasurement( real( k ), 'meter' ), h )
if not isinstance( h, RPNMeasurement ):
return getPrismVolume( n, k, RPNMeasurement( real( h ), 'meter' ) )
if k.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'prism_volume\' argument 2 must be a length' )
if h.getDimensions( ) != { 'length' : 1 }:
raise ValueError( '\'prism_volume\' argument 3 must be a length' )
return getProduct( [ fdiv( n, 4 ), h, getPower( k, 2 ), cot( fdiv( pi, n ) ) ] ).convert( 'meter^3' )
def zeta(self, z):
# A+S 18.10.
from mpmath import pi, jtheta, exp, mpc, cot, sqrt
Delta = self.Delta
e1, _, _ = self.__roots
om = self.__periods[0] / 2
omp = self.__periods[1] / 2
if self.__ng3:
z = mpc(0, 1) * z
if Delta > 0:
tau = omp / om
# NOTE: here q has to be real.
q = (exp(mpc(0, 1) * pi() * tau)).real
eta = -(pi()**2 * jtheta(n=1, z=0, q=q, derivative=3)) / (
12 * om * jtheta(n=1, z=0, q=q, derivative=1))
v = (pi() * z) / (2 * om)
retval = (eta * z) / om + (pi() *
jtheta(n=1, z=v, q=q, derivative=1)) / (
2 * om * jtheta(n=1, z=v, q=q))
elif Delta < 0:
om2 = om + omp
om2p = omp - om
tau2 = om2p / (2 * om2)
# NOTE: here q will be pure imaginary.
q = mpc(0, (mpc(0, 1) * exp(mpc(0, 1) * pi() * tau2)).imag)
eta2 = -(pi()**2 * jtheta(n=1, z=0, q=q, derivative=3)) / (
12 * om2 * jtheta(n=1, z=0, q=q, derivative=1))
v = (pi() * z) / (2 * om2)
retval = (eta2 * z) / om2 + (pi() * jtheta(
n=1, z=v, q=q, derivative=1)) / (2 * om2 *
jtheta(n=1, z=v, q=q))
else:
g2, g3 = self.__invariants
if g2 == 0 and g3 == 0:
retval = 1 / z
else:
c = e1 / 2
A = sqrt(3 * c)
retval = c * z + A * cot(A * z)
if self.__ng3:
return mpc(0, 1) * retval
else:
return retval
def CTG(self, a):
x = Argument(int32_t)
y = Argument(int32_t)
try:
with Function("Cotangent", (x, y), int32_t) as asm_ctg:
reg_x = GeneralPurposeRegister32()
LOAD.ARGUMENT(reg_x, x)
CTG(reg_x)
RETURN(reg_x)
code_ctg = asm_ctg.finalize(abi.detect()).encode().load()
except:
code_ctg = round(mpmath.cot(a), 4)
return (code_ctg)
return (code_ctg(a))
def move(headX, faceWidth):
#Rotate robot
moveTime = abs(6000 - headX) / ANGULAR_VELOCITY
if headX < 6000:
moveRight(moveTime)
elif headX > 6000:
moveLeft(moveTime)
#Move robot
dist = mpmath.cot(mpmath.radians(62.2 * (w / 640) / 2))
moveTime = abs(dist - faceDistTarget) * VELOCITY
if dist < faceDistTarget:
moveBack(moveTime)
elif dist > faceDistTarget:
moveForward(moveTime)
client.sendData("Are you Sarah Connor?")
def calculateDirecteProblem(self):
try:
a = 6378249.2
b = 6356515
R = (2 * a + b) / 3
phi1 = math.radians(ast.literal_eval(self.ui.lineEdit_184.text()) + ast.literal_eval(
self.ui.lineEdit_185.text()) / 60 + ast.literal_eval(self.ui.lineEdit_182.text()) / 3600)
lambda1 = math.radians(ast.literal_eval(self.ui.lineEdit_186.text()) + ast.literal_eval(
self.ui.lineEdit_181.text()) / 60 + ast.literal_eval(self.ui.lineEdit_183.text()) / 3600)
azimut = math.radians(ast.literal_eval(self.ui.lineEdit_190.text()) + ast.literal_eval(
self.ui.lineEdit_187.text()) / 60 + ast.literal_eval(self.ui.lineEdit_189.text()) / 3600)
distanceD12 = (ast.literal_eval(self.ui.lineEdit_188.text()))/R
phi2 = math.degrees(math.asin(
(math.sin(phi1)) * (math.cos(distanceD12)) + (math.cos(phi1)) * (math.sin(distanceD12)) * (
math.cos(azimut))))
lambda2 =(math.degrees(lambda1)) + (math.degrees(mpmath.acot(((mpmath.cot(distanceD12)) * math.sin(
((math.pi / 2) - phi1)) - (math.cos((math.pi / 2) - phi1)) * math.cos(azimut)) * (1 / (math.sin(azimut))))))
azimutRetour = math.degrees(mpmath.acot(
( (math.cos(distanceD12)) * (math.cos(azimut)) - (math.tan(phi1)) * (math.sin(distanceD12)) ) * (1 / (math.sin(azimut))) ))
phi2 = UIFunctions.degdecimal2dms(phi2)
lambda2 = UIFunctions.degdecimal2dms(lambda2)
azimutRetour = UIFunctions.degdecimal2dms(azimutRetour)
self.ui.lineEdit_192.setText(str("%.f" % phi2[0]))
self.ui.lineEdit_198.setText(str("%.f" % phi2[1]))
self.ui.lineEdit_191.setText(str("%.4f" % phi2[2]))
self.ui.lineEdit_197.setText(str("%.f" % lambda2[0]))
self.ui.lineEdit_199.setText(str("%.f" % lambda2[1]))
self.ui.lineEdit_194.setText(str("%.4f" % lambda2[2]))
self.ui.lineEdit_195.setText(str("%.f" % azimutRetour[0]))
self.ui.lineEdit_196.setText(str("%.f" % azimutRetour[1]))
self.ui.lineEdit_193.setText(str("%.4f" % azimutRetour[2]))
except Exception :
UIFunctions.errorMsg(self,"Erreur\nressayer une autre fois ")
def zeta(self,z): # A+S 18.10. from mpmath import pi, jtheta, exp, mpc, cot, sqrt Delta = self.Delta e1, _, _ = self.__roots om = self.__periods[0] / 2 omp = self.__periods[1] / 2 if self.__ng3: z = mpc(0,1) * z if Delta > 0: tau = omp / om # NOTE: here q has to be real. q = (exp(mpc(0,1) * pi() * tau)).real eta = -(pi()**2 * jtheta(n=1,z=0,q=q,derivative=3)) / (12 * om * jtheta(n=1,z=0,q=q,derivative=1)) v = (pi() * z) / (2 * om) retval = (eta * z) / om + (pi() * jtheta(n=1,z=v,q=q,derivative=1)) / (2 * om * jtheta(n=1,z=v,q=q)) elif Delta < 0: om2 = om + omp om2p = omp - om tau2 = om2p / (2 * om2) # NOTE: here q will be pure imaginary. q = mpc(0,(mpc(0,1) * exp(mpc(0,1) * pi() * tau2)).imag) eta2 = -(pi()**2 * jtheta(n=1,z=0,q=q,derivative=3)) / (12 * om2 * jtheta(n=1,z=0,q=q,derivative=1)) v = (pi() * z) / (2 * om2) retval = (eta2 * z) / om2 + (pi() * jtheta(n=1,z=v,q=q,derivative=1)) / (2 * om2 * jtheta(n=1,z=v,q=q)) else: g2, g3 = self.__invariants if g2 == 0 and g3 == 0: retval = 1 / z else: c = e1 / 2 A = sqrt(3 * c) retval = c*z + A * cot(A*z) if self.__ng3: return mpc(0,1) * retval else: return retval
def getAntiprismSurfaceAreaOperator(n, k):
result = getProduct(
[fdiv(n, 2),
fadd(cot(fdiv(pi, n)), sqrt(3)),
getPower(k, 2)])
return result.convert('meter^2')
def getPrismSurfaceAreaOperator(n, k, h):
result = add(getProduct([fdiv(n, 2),
getPower(k, 2),
cot(fdiv(pi, n))]), getProduct([n, k, h]))
return result.convert('meter^2')
def calc_buff(faces, num_vert, coordinates, d, wDX):
"""
Calculates buffer distance between edge of DX tile and center of vertex.
Parameters
----------
faces : list
Fx2 cell matrix, where F is the number of faces.
The first column details how many vertices the face has
The second column details the vertex IDs of the face
num_vert : int
number of vertices, V
coordinates : numpy.ndarray
Vx3 matrix of spatial coordinates of vertices,
V = number of vertices
d : float
distance between two nucleotides, in angstroms
wDX : int
width of DX tile, in angstroms
Returns
-------
buff_nt
distance, in nucleotides, between edge of DX arm and vertex coordinate
"""
vert_angles = [[] for i in range(num_vert)]
# For each face
for curr_face in faces:
face_coords = coordinates[curr_face]
# for each vert
for face_vert_ID in range(len(curr_face)):
center_vert = curr_face[face_vert_ID]
center_coords = face_coords[face_vert_ID]
if face_vert_ID == 0: # if first
prev_coords = face_coords[-1]
else:
prev_coords = face_coords[face_vert_ID - 1]
if face_vert_ID == len(curr_face) - 1: # if last
next_coords = face_coords[0]
else:
next_coords = face_coords[face_vert_ID + 1]
a_vec = np.array(prev_coords - center_coords)
b_vec = np.array(next_coords - center_coords)
angle = math.atan2(np.linalg.norm(np.cross(a_vec, b_vec)),
np.dot(a_vec, b_vec))
vert_angles[center_vert] += [angle]
buff_nt = [0] * num_vert
# For creating no discontinuities
for vert_ID in range(num_vert):
sum_of_angles = sum(vert_angles[vert_ID])
theta_max = max(vert_angles[vert_ID])
theta_P_max = theta_max * (2. * np.pi / sum_of_angles)
r = float(wDX / 2. * mpmath.cot(theta_P_max / 2.))
if sum_of_angles <= 2. * np.pi:
s = r * (2. * np.pi / sum_of_angles)
else:
s = r
buff_nt[vert_ID] = int(np.ceil(s / d))
return buff_nt
def multiscale_X(fr, sig1, L1, sig2, L2, sig3, L3, thi, er):
er = er.conjugate()
sig1 = sig1 * 100 # change from m to cm scale
L1 = L1 * 100
sig2 = sig2 * 100 # change from m to cm scale
L2 = L2 * 100
sig3 = sig3 * 100 # change from m to cm scale
L3 = L3 * 100
sig12 = sig1**2
sig22 = sig2**2
sig32 = sig3**2
sigs2 = sig12 + sig22 + sig32
# - fr: frequency in GHz
# - sig: rms height of surface in cm
# - L: correlation length of surface in cm
# - theta_d: incidence angle in degrees
# - er: relative permittivity
# - sp: type of surface correlation function
error = 1.0e8
k = 2 * math.pi * fr / 30 # wavenumber in free space.Speed of light is in cm / sec
theta = thi * math.pi / 180 # transform to radian
ks = k * math.sqrt(sigs2) # roughness parameter
kl = k * L
ks2 = ks * ks
kl2 = kl**2
cs = math.cos(theta)
s = math.sin(theta + 0.001)
s2 = s**2
# -- calculation of reflection coefficints
rt = sqrt(er - s2)
rv = (er * cs - rt) / (er * cs + rt)
rh = (cs - rt) / (cs + rt)
rvh = (rv - rh) / 2
# print(rt, rv, rh, rvh)
# exit()
# -- rms slope values
sig_l = sig / L
wn = multi_roughness_spectrum(sig12, sig22, sig32, sigs2, L1, L2, L3, k, s,
Ts)
rss = sqrt(2) / sigs2 * (sig12 * sig1 / L1 + sig22 * sig2 / L2 +
sig32 * sig3 / L3)
# --- Selecting number of spectral components of the surface roughness
# if auto == 0:
n_spec = 15 # numberofterms to include in the surface roughness spectra
#
#
# if auto == 1:
# n_spec = 1
# while error > 1.0e-8:
# n_spec = n_spec + 1
# error = (ks2 * (2 * cs) ** 2) ** n_spec / math.factorial(n_spec)
# -- calculating shadow consideration in single scat(Smith, 1967)
ct = mpmath.cot(theta + 0.001)
farg = (ct / sqrt(2) / rss).real
gamma = 0.5 * (math.exp(-float(farg.real)**2) / 1.772 / float(farg.real) -
erfc(float(farg.real)))
Shdw = 1 / (1 + gamma)
# -- calculating multiple scattering contribution
# ------ a double integration function
math.factorials = {}
for number in np.arange(1, n_spec + 1):
math.factorials[number] = math.factorial(number)
svh = dblquad(
lambda phi, r: xpol_integralfunc_vec(
r, phi, sp, xx, ks2, cs, s, kl2, L, er, rss, rvh, n_spec, math.
factorials), 0.1, 1, lambda x: 0, lambda x: math.pi)[0]
svh = svh * 1.e-5 # # un - scale after rescalingin the integrand function.
sigvh = 10 * math.log10(svh * Shdw)
return (sigvh)
# -*- coding: utf-8 -*- """ Created by libsedmlscript v0.0.1 """ from sed_roadrunner import model, task, plot from mpmath import cot #---------------------------------------------- cot(0.5)
'sqrt': ['primitive', [lambda x, y: mp.sqrt(x), None]],
'cbrt': ['primitive', [lambda x, y: mp.cbrt(x), None]],
'root': ['primitive', [lambda x, y: mp.root(x, y[0]), None]], # y's root
'unitroots': ['primitive', [lambda x, y: Vector(mp.unitroots(x)),
None]], #
'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]],
def eval(self, z):
return mpmath.cot(z)
async def find_cot(event):
input_str = float(event.pattern_match.group(1))
output = mpmath.cot(input_str)
await event.edit(f"**Value of Cot {input_str}\n==>>**`{output}`")
def calculateShadow(self, ntimes):
shadow_length_tower = np.zeros((ntimes))
shadow_length_rotor_top = np.zeros((ntimes))
shadow_length_rotor_bot = np.zeros((ntimes))
for tt in range(0, ntimes):
shadow_length_tower[tt] = self.tower_height * cot(
np.radians(self.elevation_angle[tt]))
shadow_length_rotor_top[tt] = (
self.tower_height + self.rotor_radius) * cot(
np.radians(self.elevation_angle[tt]))
shadow_length_rotor_bot[tt] = (
self.tower_height - self.rotor_radius) * cot(
np.radians(self.elevation_angle[tt]))
shadow_length_tower[self.elevation_angle <= 0.0] = np.nan
shadow_length_rotor_top[self.elevation_angle <= 0.0] = np.nan
shadow_length_rotor_bot[self.elevation_angle <= 0.0] = np.nan
shadow_ang = self.azimuth_angle - 180.0
shadow_ang[self.elevation_angle <= 0.0] = np.nan
shadow_ang[shadow_ang < 0.0] += 360.0
shadow = np.ones(
(np.shape(self.xyc)[0], np.shape(self.xyc)[1], ntimes))
distance = np.sqrt(self.xyc**2 + self.yxc**2)
angle = np.degrees(np.arctan(self.xyc / self.yxc))
angle[self.yxc < 0.0] = angle[self.yxc < 0.0] + 180.0
angle[angle < 0.0] = angle[angle < 0.0] + 360.0
for toi in range(0, ntimes):
D = shadow_length_tower[toi]
theta = np.radians(shadow_ang[toi])
mask = np.ones(np.shape(self.xyc))
htw = self.tower_width / 2.0
# find the left and right edges of the tower shadow by adding/subtracting 90 degrees from the shadow angle
tower_left_xs, tower_left_ys = htw * np.sin(
np.radians(shadow_ang[toi] - 90.0)), htw * np.cos(
np.radians(shadow_ang[toi] - 90.0))
tower_rght_xs, tower_rght_ys = htw * np.sin(
np.radians(shadow_ang[toi] + 90.0)), htw * np.cos(
np.radians(shadow_ang[toi] + 90.0))
tower_left_xe, tower_left_ye = D * np.sin(
theta) + tower_left_xs, D * np.cos(theta) + tower_left_ys
tower_rght_xe, tower_rght_ye = D * np.sin(
theta) + tower_rght_xs, D * np.cos(theta) + tower_rght_ys
# Find the slopes & intercepts of these lines to find the cells that are between the two
tower_left_slope = (tower_left_ys - tower_left_ye) / (
tower_left_xs - tower_left_xe)
tower_rght_slope = (tower_rght_ys - tower_rght_ye) / (
tower_rght_xs - tower_rght_xe)
tower_left_int = tower_left_ys - tower_left_slope * tower_left_xs
tower_rght_int = tower_rght_ys - tower_rght_slope * tower_rght_xs
tower_axis_slope = (tower_left_ys - tower_rght_ys) / (
tower_left_xs - tower_rght_xs)
# Make is so that the angle is 0 in the direction of the shadow... remove 180 > A > 270
shadow_angle = angle - shadow_ang[toi]
shadow_angle[shadow_angle < 0.0] += 360.0
# Find points between the two lines...
mask[((self.yxc >= tower_left_slope * self.xyc + tower_left_int) &
(self.yxc <= tower_rght_slope * self.xyc + tower_rght_int)) |
((self.yxc <= tower_left_slope * self.xyc + tower_left_int) &
(self.yxc >= tower_rght_slope * self.xyc + tower_rght_int)
)] = (1.0 - self.tower_shadow_weight)
# Find points that are less than the shadow distance
mask[distance > shadow_length_tower[toi]] = 1.0
# Find points in the direction of the shadow
mask[(shadow_angle > 90.0) & (shadow_angle < 270.0)] = 1.0
# Define the ellipse!
g_ell_center = (D * np.sin(theta), D * np.cos(theta))
g_ell_height = self.rotor_radius
g_ell_width = shadow_length_rotor_top[
toi] - shadow_length_rotor_bot[toi]
ell_angle = np.degrees(
np.arctan2(D * np.cos(theta), D * np.sin(theta)))
# Get the angles of the axes
cos_angle = np.cos(np.radians(180. - ell_angle))
sin_angle = np.sin(np.radians(180. - ell_angle))
# Find the distance of each gridpoint from the ellipse
exc = self.xyc - g_ell_center[0]
eyc = self.yxc - g_ell_center[1]
exct = exc * cos_angle - eyc * sin_angle
eyct = exc * sin_angle + eyc * cos_angle
# Get the radial distance away from ellipse: cutoff at r = 1
rad_cc = (exct**2 /
(g_ell_width / 2.)**2) + (eyct**2 /
(g_ell_height / 2.)**2)
g_ellipse = patches.Ellipse(g_ell_center,
g_ell_width,
g_ell_height,
angle=ell_angle)
mask[rad_cc <= 1.0] = mask[rad_cc <= 1.0] * (
1.0 - self.rotor_shadow_weight)
shadow[:, :, toi] = mask
self.shadow = shadow
def run(self, context):
return mpmath.cot(self.body.run(context))
def I2EM_Bistat_model(
frequency,
sigma_h,
CL,
theta_i,
theta_scat,
phi_scat,
er, # Dielectric constant
sp,
xx):
error = 1.0e8
sigma_h = sigma_h * 100 # change from m to cm scale
CL = CL * 100
mu_r = 1 # relative permeability
k = 2 * math.pi * frequency / 30 # wavenumber in free space.\
# Speed of light is in cm / sec
theta = theta_i * math.pi / 180 # transform to radian
phi = 0
thetas = theta_scat * math.pi / 180
phis = phi_scat * math.pi / 180
ks = k * sigma_h # roughness parameter
kl = k * CL
ks2 = ks * ks
cs = math.cos(theta + 0.01)
s = math.sin(theta + 0.01)
sf = math.sin(phi)
cf = math.cos(phi)
ss = math.sin(thetas)
css = math.cos(thetas)
cfs = math.cos(phis)
sfs = math.sin(phis)
s2 = s**2
kx = k * s * cf
ky = k * s * sf
kz = k * cs
ksx = k * ss * cfs
ksy = k * ss * sfs
ksz = k * css
# -- reflection coefficients
rt = sqrt(er - s2)
Rvi = (er * cs - rt) / (er * cs + rt)
Rhi = (cs - rt) / (cs + rt)
wvnb = k * math.sqrt((ss * cfs - s * cf)**2 + (ss * sfs - s * sf)**2)
Ts = 1
while error > 1.0e-8:
Ts = Ts + 1
error = (ks2 * (cs + css)**2)**Ts / math.factorial(Ts)
# ---------------- calculating roughness spectrum - ----------
(wn, rss) = roughness_spectrum(sp, xx, wvnb, sigma_h, CL, Ts)
# ----------- compute R - transition - -----------
Rv0 = (sqrt(er) - 1) / (sqrt(er) + 1)
Rh0 = -Rv0
Ft = 8 * Rv0**2 * ss * (cs + sqrt(er - s2)) / (cs * sqrt(er - s2))
a1 = 0
b1 = 0
for n in np.arange(1, Ts + 1):
a0 = (ks * cs)**(2 * n) / math.factorial(n)
a1 = a1 + a0 * wn[n - 1]
b1 = b1 + a0 * (abs(Ft / 2 + 2**(n + 1) * Rv0 / cs *
math.exp(-(ks * cs)**2)))**2 * wn[n - 1]
St = 0.25 * (abs(Ft))**2 * a1 / b1
St0 = 1 / (abs(1 + 8 * Rv0 / (cs * Ft)))**2
Tf = 1 - St / St0
# ----------- compute average reflection coefficients - -----------
# -- these coefficients account for slope effects, especially near the
# brewster angle.They are not important if the slope is small.
sigx = 1.1 * sigma_h / CL
sigy = sigx
xxx = 3 * sigx
# print( cs, s, er, s2, sigx, sigy)
#######################
def complex_dblquad(func, a, b, c, d):
def real_func(x, y):
return np.real(func(x, y))
def imag_func(x, y):
return np.imag(func(x, y))
real_integral = dblquad(real_func, a, b, c, d)
imag_integral = dblquad(imag_func, a, b, c, d)
return (real_integral[0] + 1j * imag_integral[0])
#####################
Rav = complex_dblquad(lambda Zx, Zy: utils.Rav_integration(
Zx, Zy, cs, s, er, s2, sigx, sigy), -xxx, xxx, -xxx,
xxx) # Integrate over Zx, Zy
Rah = complex_dblquad(lambda Zx, Zy: utils.Rah_integration(
Zx, Zy, cs, s, er, s2, sigx, sigy), -xxx, xxx, -xxx,
xxx) # Integrate over Zx, Zy
Rav = Rav / (2 * math.pi * sigx * sigy)
Rah = Rah / (2 * math.pi * sigx * sigy)
# -- select proper reflection coefficients
if (theta_i == theta_scat) & (phi_scat
== 180): # i.e.operating in backscatter mode
Rvt = Rvi + (Rv0 - Rvi) * Tf
Rht = Rhi + (Rh0 - Rhi) * Tf
else: # in this case, it is the bistatic configuration and average R is used
# Rvt = Rav + (Rv0 - Rav) * Tf
# Rht = Rah + (Rh0 - Rah) * Tf
Rvt = Rav
Rht = Rah
fvv = 2 * Rvt * (s * ss - (1 + cs * css) * cfs) / (cs + css)
fhh = -2 * Rht * (s * ss - (1 + cs * css) * cfs) / (cs + css)
# ------- Calculate the Fppup(dn) i(s) coefficients - ---
(Fvvupi, Fhhupi) = utils.Fppupdn_is_calculations(+1, 1, Rvi, Rhi, er, k,
kz, ksz, s, cs, ss, css,
cf, cfs, sfs)
(Fvvups, Fhhups) = utils.Fppupdn_is_calculations(+1, 2, Rvi, Rhi, er, k,
kz, ksz, s, cs, ss, css,
cf, cfs, sfs)
(Fvvdni, Fhhdni) = utils.Fppupdn_is_calculations(-1, 1, Rvi, Rhi, er, k,
kz, ksz, s, cs, ss, css,
cf, cfs, sfs)
(Fvvdns, Fhhdns) = utils.Fppupdn_is_calculations(-1, 2, Rvi, Rhi, er, k,
kz, ksz, s, cs, ss, css,
cf, cfs, sfs)
qi = k * cs
qs = k * css
# ----- calculating Ivv and Ihh - ---
fvv = fvv.conjugate()
fhh = fhh.conjugate()
Fvvupi = Fvvupi.conjugate()
Fvvups = Fvvups.conjugate()
Fvvdni = Fvvdni.conjugate()
Fvvdns = Fvvdns.conjugate()
Fhhupi = Fhhupi.conjugate()
Fhhups = Fhhups.conjugate()
Fhhdni = Fhhdni.conjugate()
Fhhdns = Fhhdns.conjugate()
Ivv = np.zeros(Ts, dtype=np.complex_)
Ihh = Ivv.copy()
for n in np.arange(1, Ts + 1):
Ivv[n-1] = (kz + ksz) ** n * fvv *math.exp(-sigma_h ** 2 * kz * ksz) + \
0.25 * (Fvvupi * (ksz - qi) ** (n - 1) *math.exp(-sigma_h ** 2 * (qi ** 2 - qi * (ksz - kz))) +
Fvvdni* (ksz+qi) ** (n - 1) *math.exp(-sigma_h ** 2 * (qi ** 2 + qi * (ksz - kz))) +
Fvvups * (kz + qs) ** (n - 1) *math.exp(-sigma_h ** 2 * (qs ** 2 - qs * (ksz - kz))) +
Fvvdns * (kz - qs) ** (n - 1) *math.exp(-sigma_h ** 2 * (qs ** 2 + qs * (ksz - kz))))
Ihh[n-1] = (kz + ksz) ** n * fhh *math.exp(-sigma_h ** 2 * kz * ksz) + \
0.25 * (Fhhupi * (ksz - qi) ** (n - 1) *math.exp(-sigma_h ** 2 * (qi ** 2 - qi * (ksz - kz))) +
Fhhdni* (ksz+qi) ** (n - 1) *math.exp(-sigma_h ** 2 * (qi ** 2 + qi * (ksz - kz))) +
Fhhups * (kz + qs) ** (n - 1) *math.exp(-sigma_h ** 2 * (qs ** 2 - qs * (ksz - kz))) +
Fhhdns * (kz - qs) ** (n - 1) *math.exp(-sigma_h ** 2 * (qs ** 2 + qs * (ksz - kz))))
# -- Shadowing function calculations
if (theta_i == theta_scat) & (phi_scat
== 180): # i.e.working in backscatter mode
ct = mpmath.cot(theta)
cts = mpmath.cot(thetas)
rslp = rss
ctorslp = float((ct / sqrt(2) / rslp).real)
ctsorslp = float((cts / sqrt(2) / rslp).real)
shadf = 0.5 * (math.exp(-ctorslp**2) / sqrt(math.pi) / ctorslp -
erfc(ctorslp))
shadfs = 0.5 * (math.exp(-ctsorslp**2) / sqrt(math.pi) / ctsorslp -
erfc(ctsorslp))
ShdwS = 1 / (1 + shadf + shadfs)
else:
ShdwS = 1
# ------- calculate the values of sigma_note - -------------
sigmavv = 0
sigmahh = 0
for n in np.arange(1, Ts + 1):
a0 = wn[n - 1] / math.factorial(n) * sigma_h**(2 * n)
sigmavv = sigmavv + abs(Ivv[n - 1])**2 * a0
sigmahh = sigmahh + abs(Ihh[n - 1])**2 * a0
sigmavv = sigmavv * ShdwS * k**2 / 2 * math.exp(-sigma_h**2 *
(kz**2 + ksz**2))
sigmahh = sigmahh * ShdwS * k**2 / 2 * math.exp(-sigma_h**2 *
(kz**2 + ksz**2))
ssv = 10 * math.log10(sigmavv.real)
ssh = 10 * math.log10(sigmahh.real)
sigma_0_vv = ssv
sigma_0_hh = ssh
return sigma_0_vv, sigma_0_hh
def IEMX_model(fr, sig, L, theta_d, er, sp, xx, auto):
er = er.conjugate()
sig = sig * 100 # change to cm scale
L = L * 100 # change to cm scale
# - fr: frequency in GHz
# - sig: rms height of surface in cm
# - L: correlation length of surface in cm
# - theta_d: incidence angle in degrees
# - er: relative permittivity
# - sp: type of surface correlation function
error = 1.0e8
k = 2 * math.pi * fr / 30 # wavenumber in free space.Speed of light is in cm / sec
theta = theta_d * math.pi / 180 # transform to radian
ks = k * sig # roughness parameter
kl = k * L
ks2 = ks * ks
kl2 = kl**2
cs = math.cos(theta)
s = math.sin(theta + 0.001)
s2 = s**2
# -- calculation of reflection coefficints
rt = sqrt(er - s2)
rv = (er * cs - rt) / (er * cs + rt)
rh = (cs - rt) / (cs + rt)
rvh = (rv - rh) / 2
# print(rt, rv, rh, rvh)
# exit()
# -- rms slope values
sig_l = sig / L
if sp.lower() == 'math.exponential': # -- math.exponential correl func
rss = sig_l
if sp.lower() == 'gaussian': # -- Gaussian correl func
rss = sig_l * sqrt(2)
if sp.lower() == 'power_spec': # -- 1.5 - power spectra correl func
rss = sig_l * sqrt(2 * xx)
# --- Selecting number of spectral components of the surface roughness
if auto == 0:
n_spec = 15 # numberofterms to include in the surface roughness spectra
if auto == 1:
n_spec = 1
while error > 1.0e-8:
n_spec = n_spec + 1
error = (ks2 * (2 * cs)**2)**n_spec / math.factorial(n_spec)
# -- calculating shadow consideration in single scat(Smith, 1967)
ct = mpmath.cot(theta + 0.001)
farg = (ct / sqrt(2) / rss).real
gamma = 0.5 * (math.exp(-float(farg.real)**2) / 1.772 / float(farg.real) -
erfc(float(farg.real)))
Shdw = 1 / (1 + gamma)
# -- calculating multiple scattering contribution
# ------ a double integration function
math.factorials = {}
for number in np.arange(1, n_spec + 1):
math.factorials[number] = math.factorial(number)
svh = dblquad(
lambda phi, r: xpol_integralfunc_vec(
r, phi, sp, xx, ks2, cs, s, kl2, L, er, rss, rvh, n_spec, math.
factorials), 0.1, 1, lambda x: 0, lambda x: math.pi)[0]
svh = svh * 1.e-5 # # un - scale after rescalingin the integrand function.
sigvh = 10 * math.log10(svh * Shdw)
return (sigvh)
def phi_quadratic_exact(self, start_phi=0, final_phi=pi):
# Calculate 'temp' delta
delta = (final_phi - start_phi) / self.outer_points
# Increase starting point if start_phi = 0
if start_phi == 0:
start_phi = delta
# Decrease end point if final_phi = pi
if final_phi == pi:
final_phi = final_phi - delta
# Discretise the interval from start_phi to final_phi
discr_pi = linspace(start_phi, final_phi, self.outer_points)
# Solve Eq. 24 (Kager et al. 2004) on the range start_phi to final_phi
self.phi_exact_quadratic_forward = array(
[2 - 2 * phi * cot(phi) + 2 * 1j * phi for phi in discr_pi],
dtype=complex128)
# Create a properties string specifically for the phi exact solution
properties_string = "-".join([
str(prop) for prop in [
self.index, "PHI",
self.number_to_string(start_phi),
self.number_to_string(final_phi), self.outer_points
]
])
if self.save_data:
# Create a filename for the dat file
filename = EXACT_FORWARD_DATA_OUTPUT + properties_string + DATA_EXT
# Create a 2D array from the real and imaginary values of the results
results_array = column_stack(
(self.phi_exact_quadratic_forward.real,
self.phi_exact_quadratic_forward.imag))
# Save the array to the filesystem
self.save_to_dat(filename, results_array)
if self.save_plot:
# Clear any preexisting plots to be safe
plt.cla()
# Set the plot title
self.set_plot_title()
# Plo the values
plt.plot(self.phi_exact_quadratic_forward.real,
self.phi_exact_quadratic_forward.imag,
color='crimson')
# Set the axes labels
plt.xlabel(FOR_PLOT_XL)
plt.ylabel(FOR_PLOT_YL)
# Set the lower limit of the y-axis
plt.ylim(bottom=0)
# Save the plot to the filesystem
plt.savefig(EXACT_FORWARD_PLOT_OUTPUT + properties_string +
PLOT_EXT,
bbox_inches='tight')
def getPrismVolumeOperator(n, k, h):
return getProduct([fdiv(n, 4), h,
getPower(k, 2),
cot(fdiv(pi, n))]).convert('meter^3')
def precompute_values(self): self.n = (math.log(math.cos(self.phi1) * mpmath.sec(self.phi2)))/ math.log(math.tan(math.pi/4 + self.phi2/2) * mpmath.cot(math.pi/4 + self.phi1/2)) if self.n == 0.0000: self.n = 0.00001 self.F = (math.cos(self.phi1) * math.pow(math.tan(math.pi / 4 + self.phi1 / 2), self.n))/ self.n
def Multiscale_I2EM_Backscatter(fr, sig1, L1, sig2, L2, sig3, L3, thi, er):
ths = thi
phs = 180
error = 1.0e8
sig1 = sig1 * 100 # change from m to cm scale
L1 = L1 * 100
sig2 = sig2 * 100 # change from m to cm scale
L2 = L2 * 100
sig3 = sig3 * 100 # change from m to cm scale
L3 = L3 * 100
sig12 = sig1**2
sig22 = sig2**2
sig32 = sig3**2
sigs2 = sig12 + sig22 + sig32
mu_r = 1 # relative permeability
# Speed of light is in cm / sec
theta = thi * math.pi / 180 # transform to radian
k = 2 * math.pi * fr / 30 # wavenumber in free space.
phi = 0
thetas = ths * math.pi / 180
phis = phs * math.pi / 180
ks = k * math.sqrt(sigs2) # roughness parameter
kl1 = k * L1
ks2 = ks * ks
cs = math.cos(theta + 0.01)
s = math.sin(theta + 0.01)
sf = math.sin(phi)
cf = math.cos(phi)
ss = math.sin(thetas)
css = math.cos(thetas)
cfs = math.cos(phis)
sfs = math.sin(phis)
s2 = s * s
# sq = sqrt(er - s2)
kx = k * s * cf
ky = k * s * sf
kz = k * cs
ksx = k * ss * cfs
ksy = k * ss * sfs
ksz = k * css
# -- reflection coefficients
rt = sqrt(er - s2)
Rvi = (er * cs - rt) / (er * cs + rt)
Rhi = (cs - rt) / (cs + rt)
wvnb = k * sqrt((ss * cfs - s * cf)**2 + (ss * sfs - s * sf)**2)
Ts = 1
while error > 1.0e-8:
Ts = Ts + 1
error = (ks2.real * (cs + css)**2)**Ts / math.factorial(Ts)
# ---------------- calculating roughness spectrum - ----------
wn = utils.multi_roughness_spectrum(sig12, sig22, sig32, sigs2, L1, L2, L3,
k, s, Ts)
rss = sqrt(2) / sigs2 * (sig12 * sig1 / L1 + sig22 * sig2 / L2 +
sig32 * sig3 / L3)
# ----------- compute R - transition - -----------
Rv0 = (sqrt(er) - 1) / (sqrt(er) + 1)
Rh0 = -Rv0
Ft = 8 * Rv0**2 * ss * (cs + sqrt(er - s2)) / (cs * sqrt(er - s2))
a1 = 0
b1 = 0
for n in np.arange(1, Ts + 1):
a0 = (ks.real * cs)**(2 * n) / math.factorial(n)
a1 = a1 + a0 * wn[n - 1]
b1 = b1 + a0 * (abs(Ft / 2 + 2**(n + 1) * Rv0 / cs *
math.exp(-(ks * cs)**2)))**2 * wn[n - 1]
St = 0.25 * (abs(Ft))**2 * a1 / b1
St0 = 1 / (abs(1 + 8 * Rv0 / (cs * Ft)))**2
Tf = 1 - St / St0
# # ----------- compute average reflection coefficients - -----------
# # -- these coefficients account for slope effects
# # especially near the brewster angle.
# # They are not important if the slope is small.
#
# sigx = 1.1 * sig / L
# sigy = sigx
# xxx = 3 * sigx
#
# Rav = dblquad( @ (Zx, Zy)
# Rav_integration(Zx, Zy, cs, s, er, s2, sigx, sigy), -xxx, xxx, -xxx, xxx )
#
# Rah = dblquad( @ (Zx, Zy)
# Rah_integration(Zx, Zy, cs, s, er, s2, sigx, sigy), -xxx, xxx, -xxx, xxx )
#
# Rav = Rav / (2 *math.pi * sigx * sigy)
# Rah = Rah / (2 *math.pi * sigx * sigy)
#
# -- select proper reflection coefficients
# if thi == ths & & phs == 180, # i.e.operating in backscatter mode
Rvt = Rvi + (Rv0 - Rvi) * Tf
Rht = Rhi + (Rh0 - Rhi) * Tf
# else # in this case, it is the bistatic configuration and average R is used
# # Rvt = Rav + (Rv0 - Rav) * Tf
# # Rht = Rah + (Rh0 - Rah) * Tf
# Rvt = Rav
# Rht = Rah
# end
fvv = 2 * Rvt * (s * ss - (1 + cs * css) * cfs) / (cs + css)
fhh = -2 * Rht * (s * ss - (1 + cs * css) * cfs) / (cs + css)
# ------- Calculate the Fppup(dn) i(s) coefficients - ---
(Fvvupi, Fhhupi) = Fppupdn_is_calculations(+1, 1, Rvi, Rhi, er, k, kz, ksz,
s, cs, ss, css, cf, cfs, sfs)
(Fvvups, Fhhups) = Fppupdn_is_calculations(+1, 2, Rvi, Rhi, er, k, kz, ksz,
s, cs, ss, css, cf, cfs, sfs)
(Fvvdni, Fhhdni) = Fppupdn_is_calculations(-1, 1, Rvi, Rhi, er, k, kz, ksz,
s, cs, ss, css, cf, cfs, sfs)
(Fvvdns, Fhhdns) = Fppupdn_is_calculations(-1, 2, Rvi, Rhi, er, k, kz, ksz,
s, cs, ss, css, cf, cfs, sfs)
qi = k * cs
qs = k * css
# ----- calculating Ivv and Ihh - ---
Ivv = np.zeros(Ts, dtype=np.complex_)
Ihh = Ivv.copy()
for n in np.arange(1, Ts + 1):
Ivv[n-1] = (kz + ksz) ** n * fvv * math.exp(-sigs2 * kz * ksz) + \
0.25 * (Fvvupi * (ksz - qi) ** (n - 1) * math.exp(-sigs2 * (qi ** 2 - qi * (ksz - kz))) +
Fvvdni * (ksz+qi) ** (n - 1) * math.exp(-sigs2 * (qi ** 2 + qi * (ksz - kz))) +
Fvvups * (kz + qs) ** (n - 1) * math.exp(-sigs2 * (qs ** 2 - qs * (ksz - kz))) +
Fvvdns * (kz - qs) ** (n - 1) * math.exp(-sigs2 * (qs ** 2 + qs * (ksz - kz))))
Ihh[n-1] = (kz + ksz) ** n * fhh * math.exp(-sigs2 * kz * ksz) + \
0.25 * (Fhhupi * (ksz - qi) ** (n - 1) * math.exp(-sigs2 * (qi ** 2 - qi * (ksz - kz))) +
Fhhdni * (ksz+qi) ** (n - 1) * math.exp(-sigs2 * (qi ** 2 + qi * (ksz - kz))) +
Fhhups * (kz + qs) ** (n - 1) * math.exp(-sigs2 * (qs ** 2 - qs * (ksz - kz))) +
Fhhdns * (kz - qs) ** (n - 1) * math.exp(-sigs2 * (qs ** 2 + qs * (ksz - kz))))
# -- Shadowing function calculations
# if thi == ths & & phs == 180 # i.e.working in backscatter mode
ct = mpmath.cot(theta)
cts = mpmath.cot(thetas)
rslp = rss
ctorslp = float(ct / math.sqrt(2) / rslp)
ctsorslp = float(cts / math.sqrt(2) / rslp)
shadf = 0.5 * (math.exp(-ctorslp**2) / sqrt(math.pi) / ctorslp -
erfc(ctorslp))
shadfs = 0.5 * (math.exp(-ctsorslp**2) / sqrt(math.pi) / ctsorslp -
erfc(ctsorslp))
ShdwS = 1 / (1 + shadf + shadfs)
# ------- calculate the values of sigma_note - -------------
sigmavv = 0
sigmahh = 0
for n in np.arange(1, Ts + 1):
a0 = wn[n - 1] / math.factorial(n) * sigs2**(n)
sigmavv = sigmavv + abs(Ivv[n - 1])**2 * a0
sigmahh = sigmahh + abs(Ihh[n - 1])**2 * a0
sigmavv = sigmavv * ShdwS * k**2 / 2 * math.exp(-sigs2 * (kz**2 + ksz**2))
sigmahh = sigmahh * ShdwS * k**2 / 2 * math.exp(-sigs2 * (kz**2 + ksz**2))
if (abs(sigmavv.imag) + abs(sigmahh.imag)) > 0:
raise Exception('backscatter coeff must be real')
ssv = 10 * math.log10(sigmavv.real)
ssh = 10 * math.log10(sigmahh.real)
sigma_0_vv = ssv
sigma_0_hh = ssh
return (sigma_0_vv, sigma_0_hh)
from __future__ import division
import mpmath as math
from units import *
from copy import copy
def sqrt(x):
if hasattr(x,'unit'):
return math.sqrt(x.number) | x.unit**0.5
return math.sqrt(x)
#trigonometric convenience functions which are "unit aware"
sin=lambda x: math.sin(1.*x)
cos=lambda x: math.cos(1.*x)
tan=lambda x: math.tan(1.*x)
cot=lambda x: math.cot(1.*x)
asin=lambda x: math.asin(x) | rad
acos=lambda x: math.acos(x) | rad
atan=lambda x: math.atan(x) | rad
atan2=lambda x,y: math.atan2(x,y) | rad
#~ cos=math.cos
#~ sin=math.sin
#~ tan=math.tan
#~ cosh=math.cosh
#~ sinh=math.sinh
#~ tanh=math.tanh
#~ acos=math.acos
#~ asin=math.asin
#~ atan=math.atan
acosh=math.acosh
def eval(self, z):
return mpmath.cot(z)
def move(self, alpha, v, t):
if alpha == 0:
self.x1 += v * t
self.x2 += v * t
return
reverse_alpha = False
reverse_v = False
alpha = mpmath.radians(alpha)
if alpha < 0:
alpha = -alpha
reverse_alpha = True
if v < 0:
v = -v
reverse_v = True
R = self.l * mpmath.cot(alpha) + 0.5 * self.d # outer radius
r = self.l * mpmath.cot(alpha) - 0.5 * self.d # inner radius
w = v / R # angular velocity
beta = w * t # angle that has been turned after the move viewed from the center of the circle
assert (beta < mpmath.pi) # make sure it still forms a triangle
theta = 0.5 * beta # the angle of deviation from the original orientation
m = 2 * R * mpmath.sin(theta) # displacement of outer rear wheel
n = 2 * r * mpmath.sin(theta) # displacement of inner rear wheel
if not reverse_alpha and not reverse_v:
delta_x1, delta_y1 = mpmath.cos(theta) * m, mpmath.sin(theta) * m
delta_x2, delta_y2 = mpmath.cos(theta) * n, mpmath.sin(theta) * n
elif reverse_alpha and not reverse_v:
delta_x2, delta_y2 = mpmath.cos(theta) * m, -mpmath.sin(theta) * m
delta_x1, delta_y1 = mpmath.cos(theta) * n, -mpmath.sin(theta) * n
elif not reverse_alpha and reverse_v:
delta_x1, delta_y1 = -mpmath.cos(theta) * m, mpmath.sin(theta) * m
delta_x2, delta_y2 = -mpmath.cos(theta) * n, mpmath.sin(theta) * n
else:
delta_x2, delta_y2 = -mpmath.cos(theta) * m, -mpmath.sin(theta) * m
delta_x1, delta_y1 = -mpmath.cos(theta) * n, -mpmath.sin(theta) * n
delta_x1 = float(delta_x1)
delta_y1 = float(delta_y1)
delta_x2 = float(delta_x2)
delta_y2 = float(delta_y2)
# the current calculation is based on this relative reference system
# we need to map this coordinate in the relative reference system back to the absolute system
# use the dot product of the rear wheel line to find the rotation from the relative reference system to the absolute system
if self.y1 != 0 or self.y2 != 10: # no rotation is needed
bottom = np.sqrt(((self.x2 - self.x1) * (self.x2 - self.x1) +
(self.y2 - self.y1) * (self.y2 - self.y1))) * 10
top = (self.y2 - self.y1) * 10
cosine_value = float(top / bottom)
rotation = mpmath.acos(cosine_value)
# print(rotation)
if self.x1 < self.x2: # since arccos does not give direction, we need to do a check here
rotation = -rotation
# let A be the linear transformation that maps a relative referenced coordinate to an absolute referenced coordinate
A = np.asarray(
[[float(mpmath.cos(rotation)),
float(-mpmath.sin(rotation))],
[float(mpmath.sin(rotation)),
float(mpmath.cos(rotation))]])
# then we map delta_1 and delta_2 to the absolute reference system
relative_delta_1 = np.asarray([delta_x1, delta_y1])
relative_delta_2 = np.asarray([delta_x2, delta_y2])
absolute_delta_1 = np.matmul(A, relative_delta_1)
absolute_delta_2 = np.matmul(A, relative_delta_2)
delta_x1 = absolute_delta_1[0]
delta_y1 = absolute_delta_1[1]
delta_x2 = absolute_delta_2[0]
delta_y2 = absolute_delta_2[1]
# make vector addition in the absolute reference system
self.x1 += delta_x1
self.x2 += delta_x2
self.y1 += delta_y1
self.y2 += delta_y2
dist = mpmath.sqrt((self.x1 - self.x2) * (self.x1 - self.x2) +
(self.y2 - self.y1) * (self.y2 - self.y1))
assert abs(dist - self.d) <= self.d * 1e-4
