def SVGTransforms(s,pts): pts = [ np.reshape(p+[1],(3,1)) for p in pts ] transforms = re.findall("[a-zA-Z]+\([^\)]+\)",s.get('transform') or '') # reverse order because SVG transforms apply right-to-left transforms.reverse() mat = np.identity(3) for t in transforms: if t.startswith("matrix"): t = re.sub("[a-zA-Z]+\(([^\)]+)\)","\\1",t) mat = matrixTransform( [ float(n) for n in re.split("[ ,]",t) ], mat ) # TODO: translate, skewX, skewY transforms elif t.startswith("translate"): pass elif t.startswith("skew"): pass elif t.startswith("scale"): t = re.sub("[a-zA-Z]+\(([^\)]+)\)","\\1",t) n = re.split("[ ,]",t) sx = float(n[0]) sy = float(n[1]) if len(n)>1 else sx # y scale is optional mat = matrixTransform( [ sx,0,0,sy,0,0 ], mat ) elif t.startswith("rotate"): # TODO: rotate about a given point using translate() and this code t = re.sub("[a-zA-Z]+\(([^\)]+)\)","\\1",t) n = re.split("[ ,]",t) a = float(n[0]) x = float(n[1]) if len(n)>1 else None y = float(n[2]) if len(n)>1 else None mat = matrixTransform( [ np.cosd(a), np.sind(a), -np.sind(a), np.cosd(a) ], mat ) # this is gross return [ np.dot(mat,p)[0:2].transpose().tolist()[0] for p in pts ]
def SVGTransforms(s, pts): pts = [np.reshape(p + [1], (3, 1)) for p in pts] transforms = re.findall("[a-zA-Z]+\([^\)]+\)", s.get('transform') or '') # reverse order because SVG transforms apply right-to-left transforms.reverse() mat = np.identity(3) for t in transforms: if t.startswith("matrix"): t = re.sub("[a-zA-Z]+\(([^\)]+)\)", "\\1", t) mat = matrixTransform([float(n) for n in re.split("[ ,]", t)], mat) # TODO: translate, skewX, skewY transforms elif t.startswith("translate"): pass elif t.startswith("skew"): pass elif t.startswith("scale"): t = re.sub("[a-zA-Z]+\(([^\)]+)\)", "\\1", t) n = re.split("[ ,]", t) sx = float(n[0]) sy = float(n[1]) if len(n) > 1 else sx # y scale is optional mat = matrixTransform([sx, 0, 0, sy, 0, 0], mat) elif t.startswith("rotate"): # TODO: rotate about a given point using translate() and this code t = re.sub("[a-zA-Z]+\(([^\)]+)\)", "\\1", t) n = re.split("[ ,]", t) a = float(n[0]) x = float(n[1]) if len(n) > 1 else None y = float(n[2]) if len(n) > 1 else None mat = matrixTransform( [np.cosd(a), np.sind(a), -np.sind(a), np.cosd(a)], mat) # this is gross return [np.dot(mat, p)[0:2].transpose().tolist()[0] for p in pts]
def BuildSphericallyRectSource(ds, a, b, Rs, R): """ Implements a spherical curved rectangular acoustic source pattern ds: numeric stepsize a: width of the rect b: height of the rect Rs: radius of the source r: radius of the curvature Plot: Plotting source distribution """ alpha = np.arcsin(Rs / R) * 180 / np.pi L = np.pi * R / 180.0 * alpha H = R - np.sqrt(R**2 - Rs**2) S = 2 * np.pi * R * H l0 = ds * .5 r0, h0, s0, ll0 = GPSS.SphereSegment(R, l0) Xs = Ys = Zs = np.array([]) nRings = int(np.ceil((L - l0) / ds)) dRings = L / nRings l = l0 sprev = s0 nSource = 0 for iRing in range(1, nRings): l += dRings r, h, s, ll = GPSS.SphereSegment(R, l) sRing = s - sprev sprev = s nPieces = int(np.ceil(ll / ds)) dBeta = 360 / nPieces nSource += nPieces rh, hh, sh, llh = GPSS.SphereSegment(R, l + dRings * .5) for iPiece in range(0, nPieces): beta = iPiece * dBeta if ((np.abs(rh * np.cosd(beta)) < .5 * a) & (np.abs(rh * np.sind(beta)) < .5 * b)): Xs = np.append(Xs, rh * np.sind(beta)) Ys = np.append(Ys, rh * np.cosd(beta)) Zs = np.append(Zs, hh) return Xs, Ys, Zs
def calc_LRT_reflectance(lrt_radf, solar_interp, phase): mu = np.cosd(38.5) if phase == 'Liquid Water' else np.cosd(56) refl_lrt = [ np.pi / mu * lrt_radf.values[w] / solar_interp.values[w] for w in np.arange(0, len(lrt_radf.wavelength)) ] refl_lrt = xr.DataArray(refl_lrt, dims=['wavelength'], name='lrt reflectances', coords={'wavelength': lrt_radf.wavelength}) refl_lrt.attrs['COT'] = lrt_radf.attrs['COT'] refl_lrt.attrs['r_eff'] = lrt_radf.attrs['r_eff'] return refl_lrt
def psn_bow(lon_now, lat_now, ant2bow, co): # 경도, 위도, 안테나로부터 선수bow까지 거리(m), 침로 ant2bow = ant2bow / (1852 * 60) # meter로 입력받은 길이(m)를 도(deg) 단위로 변환 lon_psn_bow = lon_now + ant2bow * numpy.cosd( gyro2deg(co)) # 선수위치 보정 경도. 도(deg) 단위 lat_psn_bow = lat_now + ant2bow * numpy.sind( gyro2deg(co)) # 선수위치 보정 위도. 도(deg) 단위 return lon_psn_bow, lat_psn_bow
def psn_eca(lon_bow, lat_bow, co, spd, eca_time): # 선수위치 경도, 선수위치 위도, 침로, 선속, eca시간 eca_lon = lon_bow + spd / (60 * 60 * 60) * numpy.cosd( gyro2deg(co)) * eca_time # 몇 초뒤 선수위치 경도. 도(deg)단위 eca_lat = lat_bow + spd / (60 * 60 * 60) * numpy.sind( gyro2deg(co)) * eca_time # 몇 초뒤 선수위치 위도. 도(deg)단위 return eca_lon, eca_lat
def d_sec(co, spd): # 첫번째 60 : mile/hr를 deg/hr로 변환. # 두번째 60 : deg/hr를 deg/min로 변환. # 세번쨰 60 : deg/min를 deg/sec로 변환. lon_d_sec=spd/(60*60*60)*numpy.cosd(gyro2deg(co)) #초당 경도 이동거리 (도, deg) lat_d_sec=spd/(60*60*60)*numpy.sind(gyro2deg(co)) #초당 위도 이동거리 (도, deg) return lon_d_sec, lat_d_sec
def calc_HySICS_reflectance(datacube, solar_interp, phase, x, y): f = interp1d(datacube.wavelength, datacube.values[x, y, :], fill_value='NaN') hy_new = f(solar_interp.wavelength) mu = np.cosd(38.5) if phase == 'Liquid Water' else np.cosd(56) refl_HySICS = [ np.pi / mu * hy_new[w] / solar_interp.values[w] for w in np.arange(0, len(solar_interp.wavelength)) ] refl_hysics_pixel = xr.DataArray( refl_HySICS, dims=['wavelength'], name='HySICS reflectance', coords={'wavelength': solar_interp.wavelength}) return refl_hysics_pixel
# propiedades del material E = 2040 # ton/cm^2 k = E*A/L # rigidez de cada barra # %% se separa la memoria antes de los cálculos K = np.zeros((8,8)) T = 5*[None] # MATLAB = cell(5,1) -> separo memoria idx = 5*[None] #%% ensamblo la matriz de rigidez global for e in range(5): # para cada barra # saco los 4 gdls de la barra idx[e] = np.r_[gdl[LaG[e,NL1],:], gdl[LaG[e,NL2],:]] # matriz de transformacion de coordenadas para la barra e c = np.cosd(theta[e]); s = np.sind(theta[e]) # sin y cos de la inclinación T[e] = np.array([[ c, s, 0, 0], [-s, c, 0, 0], [ 0, 0, c, s], [ 0, 0, -s, c]]) # matriz de rigidez local expresada en el sistema de coordenadas locales # para la barra e Kloc = np.array([[ k[e], 0, -k[e], 0], [ 0, 0, 0, 0], [-k[e], 0, k[e], 0], [ 0, 0, 0, 0]]) # se ensambla la matriz de rigidez local Ke en la matriz de rigidez global K K[np.ix_(idx[e],idx[e])] += T[e].T@Kloc@T[e]
def computeRotWorld(self): ## Facc_calibNoOut, facc_out = rmo.rmoutliers_percentiles( self.Facc_Zero, 1.645, 1.645) Macc_calibNoOut, macc_out = rmo.rmoutliers_percentiles( self.Macc_Zero, 1.645, 1.645) Fgyr_calibNoOut, fgyr_out = rmo.rmoutliers_percentiles( self.Fgyr_Zero, 1.645, 1.645) Mgyr_calibNoOut, mgyr_out = rmo.rmoutliers_percentiles( self.Mgyr_Zero, 1.645, 1.645) # Localiser axe gravit� (approx) Facc_mean = np.mean(Facc_calibNoOut, axis=1) Macc_mean = np.mean(Macc_calibNoOut, axis=1) def normVec(V): v_norm = V / np.linalg.norm(V) #np.sqrt(np.dot(V,V)) return v_norm Fgref = normVec(Facc_mean) #Facc_mean / np.dot(Facc_mean,Facc_mean) Mgref = normVec(Macc_mean) #Macc_mean / np.dot(Macc_mean,Macc_mean) # KL - 06nov: ajustement ax gravit� Facc_offset = np.mean(Facc_calibNoOut, axis=1) - Fgref Macc_offset = np.mean(Macc_calibNoOut, axis=1) - Mgref Fgyr_offset = np.mean(Fgyr_calibNoOut, axis=1) Mgyr_offset = np.mean(Mgyr_calibNoOut, axis=1) # Remarque 1: ***Consid�rer le filtrage?*** # Remarque 2: En calibrant comme �a, on assume que c'est du bruit de # capteur et que ce n'est pas une erreur d'alignement interne... mais # bon... on va tenter de palier � tout cela en faisant une certaine # it�ration... Macc_offset2 = [0, 0, 0] Mgyr_offset2 = [0, 0, 0] ## np.cosd = lambda x: np.cos(np.deg2rad(x)) np.sind = lambda x: np.sin(np.deg2rad(x)) ## création de Cterrain Cterrain = [] angTerrain = [0, 0, 0] CterrainX = np.matrix( [[1, 0, 0], [0, np.cosd(angTerrain[0]), -np.sind(angTerrain[0])], [0, np.sind(angTerrain[0]), np.cosd(angTerrain[0])]]) CterrainY = np.matrix( [[np.cosd(angTerrain[1]), 0, np.sind(angTerrain[1])], [0, 1, 0], [-np.sind(angTerrain[1]), 0, np.cosd(angTerrain[1])]]) CterrainZ = np.matrix( [[np.cosd(angTerrain[0]), -np.sind(angTerrain[0]), 0], [np.sind(angTerrain[0]), np.cosd(angTerrain[0]), 0], [0, 0, 1]]) Cterrain = CterrainX * CterrainY * CterrainZ ## search offsets Cmobile = [] for icalib in range(20): Macc_offset = Macc_offset + Macc_offset2 Mgyr_offset = Mgyr_offset + Mgyr_offset2 ## Cr�ation de vecteurs de l'essai Facc_Zero = (Cterrain * self.Facc_Zero).T - Facc_offset Macc_Zero = (Cterrain * self.Macc_Zero).T - Macc_offset # Fgyr_Zero = self.Fgyr_Zero.T - Fgyr_offset # Mgyr_Zero = self.Mgyr_Zero.T - Mgyr_offset # Facc_Inclined = (Cterrain * self.Facc_Inclined).T - Facc_offset Macc_Inclined = (Cterrain * self.Macc_Inclined).T - Macc_offset # Fgyr_Inclined = self.Fgyr_Inclined.T - Fgyr_offset Mgyr_Inclined = self.Mgyr_Inclined.T - Mgyr_offset ## CALIBRATION POSITIONNEMENT STATIQUE # (1) Mesure statique # Facc_stat = np.mean(Facc_Zero, axis=0) Macc_stat = np.mean(Macc_Zero, axis=0) # (2) Inclinaison initiale des IMUs: # ** IMU mobile ** vecG = np.array([0, 0, 1]) Macc_stat_norm = normVec(np.array(Macc_stat)[0]) u = normVec(np.cross(vecG, Macc_stat_norm)) def angRot2Vec(vector_1, vector_2): unit_vector_1 = vector_1 / np.linalg.norm(vector_1) unit_vector_2 = vector_2 / np.linalg.norm(vector_2) dot_product = np.dot(unit_vector_1, unit_vector_2) angle = np.arccos(dot_product) return angle angRot = angRot2Vec(vecG, Macc_stat_norm) c = np.cos(angRot) s = np.sin(angRot) C1_mobile = np.linalg.inv( np.matrix([[ u[0]**2 + (1 - u[0]**2) * c, u[0] * u[1] * (1 - c) - u[2] * s, u[0] * u[2] * (1 - c) + u[1] * s ], [ u[0] * u[1] * (1 - c) + u[2] * s, u[1]**2 + (1 - u[1]**2) * c, u[1] * u[2] * (1 - c) - u[0] * s ], [ u[0] * u[2] * (1 - c) - u[1] * s, u[1] * u[2] * (1 - c) + u[0] * s, u[2]**2 + (1 - u[2]**2) * c ]])) # Correction capteurs dans IMU mobile # Macc_cor = (C1_mobile*Macc.T).T # Mgyr_cor = (C1_mobile*Mgyr.T).T Macc_Zero_cor = (C1_mobile * Macc_Zero.T).T # Mgyr_Zero_cor = (C1_mobile * Mgyr_Zero.T).T Macc_Inclined_cor = (C1_mobile * Macc_Inclined.T).T Mgyr_Inclined_cor = (C1_mobile * Mgyr_Inclined.T).T # (3) Axe de rotation (IMU mobile) pendant la bascule # Remarque: Trouver de fa�on autonome la p�riode de bascule... Macc_Zero_Dir = np.mean(Macc_Zero_cor, axis=0) Macc_Inclined_Dir = np.mean(Macc_Inclined_cor, axis=0) def vecBasc(Macc_Zero_Dir, Macc_Inclined_Dir): vector_1 = np.array([ Macc_Zero_Dir[0, 0], Macc_Zero_Dir[0, 1], Macc_Zero_Dir[0, 2] ]) vector_2 = np.array([ Macc_Inclined_Dir[0, 0], Macc_Inclined_Dir[0, 1], Macc_Inclined_Dir[0, 2] ]) vecRot = np.cross(vector_1, vector_2) unit_vecRot = vecRot / np.linalg.norm(vecRot) return np.matrix(unit_vecRot) vecRot = vecBasc(Macc_Zero_Dir, Macc_Inclined_Dir) # La bonne nouvelle c'est que la composante en z est presque nulle... # donc l'alignement avec acc�l�ro tiens la route... la petite # composante est soit un r�siduel de l'alignement vs offset initial, # soit la vibration carr�ment... pour l'instant, je mets de c�t�. # Trouvons l'angle de rotation autour de z qui permettra d'avoir une # bascule purement en "y". ang_Rotz = math.atan2(vecRot[0, 0], vecRot[0, 1]) Mat_Rotz = np.matrix([[np.cos(ang_Rotz), -np.sin(ang_Rotz), 0], [np.sin(ang_Rotz), np.cos(ang_Rotz), 0], [0, 0, 1]]) # v�rification axe bascule: # test = Mat_Rotz * vecRot.T # print(test) # OK... pas mal �a... reste la petite composante en z mais... # Matrice alignement principale (mobile) Cmobile = Mat_Rotz * C1_mobile # On va essayer d'optimiser un peu en validant pour 3 vecteurs... # (i) vecteur statique initial, normalis�... vecIni = np.mean(Macc_Zero, axis=0) # vecIni = vecIni / sqrt(vecIni*vecIni') vecIni_al = Cmobile * vecIni.T # (iii) Vecteur de bascule vecBascule = vecRot vecBascule_al = Cmobile * vecBascule.T # Avecteur devrait s'approcher de Adesire Avecteur = np.concatenate((vecIni_al.T, vecBascule_al.T)) Adesire = np.matrix([[0, 0, 1], [0, 1, 0]]) Macc_offset2 = Avecteur[0, :] - Adesire[0, :] Mgyr_offset2 = Avecteur[1, :] - Adesire[1, :] ## (4) Optimisation du d�couplage correction angulaire vs offset pour le # IMU fixe Fgyr_offset2 = [0, 0, 0] Facc_offset2 = [0, 0, 0] # # ORIGINAL # Facc_offset = np.mean(self.Facc_Zero, axis=1) - [0, 0, 1] # Fgyr_offset = np.mean(self.Fgyr_Zero, axis=1) # Filtre pour gyro # [B,A] = butter(3,0.3/0.5,"low") #a optimiser w = 0.3 / 0.5 # Normalize the frequency b, a = signal.butter(3, w, 'low') ntaps = max(len(a), len(b)) Facc = (Cterrain * self.Facc_Inclined).T - Facc_offset signalToFilter = (Cterrain * self.Fgyr_Inclined) if signalToFilter.shape[1] > ntaps: Fgyr = signal.filtfilt(a, b, signalToFilter).T - Fgyr_offset else: Fgyr = signalToFilter.T - Fgyr_offset # Macc = (Cterrain * self.Macc_Inclined).T - Macc_offset # signalToFilter = (Cterrain * self.Mgyr_Inclined) # if signalToFilter.shape[1] > ntaps: # Mgyr = signal.filtfilt(a, b, signalToFilter).T - Mgyr_offset # else: # Mgyr = signalToFilter.T - Mgyr_offset ## Cfixe = [] for j in range(20): # Fgyr_offset = Fgyr_offset + Fgyr_offset2 Facc_offset = Facc_offset + Facc_offset2 ## Cr�ation de vecteurs de l'essai Facc_Zero = (Cterrain * self.Facc_Zero).T - Facc_offset # Fgyr_Zero = self.Fgyr_Zero.T - Fgyr_offset # Inclinaison IMU fixe Facc_stat = np.mean(Facc_Zero, axis=0) vecG = np.array([0, 0, 1]) Facc_stat_norm = normVec(np.array(Facc_stat)[0]) u = normVec(np.cross(vecG, Macc_stat_norm)) def angRot2Vec(vector_1, vector_2): unit_vector_1 = vector_1 / np.linalg.norm(vector_1) unit_vector_2 = vector_2 / np.linalg.norm(vector_2) dot_product = np.dot(unit_vector_1, unit_vector_2) angle = np.arccos(dot_product) return angle angRot = angRot2Vec(vecG, Facc_stat_norm) c = np.cos(angRot) s = np.sin(angRot) C1_fixe = np.linalg.inv( np.matrix([[ u[0]**2 + (1 - u[0]**2) * c, u[0] * u[1] * (1 - c) - u[2] * s, u[0] * u[2] * (1 - c) + u[1] * s ], [ u[0] * u[1] * (1 - c) + u[2] * s, u[1]**2 + (1 - u[1]**2) * c, u[1] * u[2] * (1 - c) - u[0] * s ], [ u[0] * u[2] * (1 - c) - u[1] * s, u[1] * u[2] * (1 - c) + u[0] * s, u[2]**2 + (1 - u[2]**2) * c ]])) # Correction capteurs dans IMU fixe Facc_cor = (C1_fixe * Facc_Zero.T).T # Fgyr_cor = (C1_fixe * Fgyr_Zero.T).T Facc_offset2 = np.mean(Facc_cor, axis=0) - [0, 0, 1] # Fgyr_offset2 = np.mean(Fgyr_cor, axis=0) Cfixe = C1_fixe self.Cterrain = Cterrain self.Facc_offset = Facc_offset self.Fgyr_offset = Fgyr_offset self.Macc_offset = Macc_offset self.Mgyr_offset = Mgyr_offset self.Cfixe = Cfixe self.Cmobile = Cmobile self.isRotWorld = True print(self.getRotWorld()) self.saveToJson() self.computeAngle(self.Facc_Zero, self.Fgyr_Zero, self.Macc_Zero, self.Mgyr_Zero) self.computeAngle(self.Facc_Inclined, self.Fgyr_Inclined, self.Macc_Inclined, self.Mgyr_Inclined)
os_lat_now=[os_lat+i*d_sec(os_co,os_spd)[1] for i in range(0,time_limit)] # 출발지를 기준으로 매초 안테나 위치 위도 os_lon_bow=psn_bow(os_lon_now,os_lat_now,os_ant2bow,os_co)[0] # 각 시점의 선수위치 경도 os_lat_bow=psn_bow(os_lon_now,os_lat_now,os_ant2bow,os_co)[1] # 각 시점의 선수위치 경도 # 타선데이터 ts_lon_now=[ts_lon+i*d_sec(ts_co,ts_spd)[0] for i in range(0,time_limit)] # 출발지를 기준으로 매초 안테나 위치 경도 ts_lat_now=[ts_lat+i*d_sec(ts_co,ts_spd)[1] for i in range(0,time_limit)] # 출발지를 기준으로 매초 안테나 위치 위도 ts_lon_bow=psn_bow(ts_lon_now,ts_lat_now,ts_ant2bow,ts_co)[0] # 각 시점의 선수위치 경도 ts_lat_bow=psn_bow(ts_lon_now,ts_lat_now,ts_ant2bow,ts_co)[1] # 각 시점의 선수위치 위도 ts_lon_eca=psn_eca(ts_lon_bow,ts_lat_bow,ts_co,ts_spd,eca_time)[0] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 경도 ts_lat_eca=psn_eca(ts_lon_bow,ts_lat_bow,ts_co,ts_spd,eca_time)[1] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 위도 ' ECA_TIME뒤 본선과 상대선의 선수위치 시계열데이터 ' ts_lon_eca=ts_lon_bow+ts_spd/(60*60*60)*numpy.sind(ts_co)*eca_time # 타선의 eca_time(sec) 뒤 경도 ts_lat_eca=ts_lat_bow+ts_spd/(60*60*60)*numpy.cosd(ts_co)*eca_time # 타선의 eca_time(sec) 뒤 위도 import math ' 두 점의 상대방위를 구하는 함수 ' def rel_brg(pointA,pointB): pointA=tuple(pointA) pointB=tuple(pointB) lat1 = math.radians(pointA[1]) lat2 = math.radians(pointB[1]) diffLong = math.radians(pointB[0] - pointA[0]) x = math.sin(diffLong) * math.cos(lat2) y = math.cos(lat1) * math.sin(lat2) - (math.sin(lat1) * math.cos(lat2) * math.cos(diffLong))
ts_lat + i * d_sec(ts_co, ts_spd)[1] for i in range(0, time_limit) ] # 출발지를 기준으로 매초 안테나 위치 위도 ts_lon_bow = psn_bow(ts_lon_now, ts_lat_now, ts_ant2bow, ts_co)[0] # 각 시점의 선수위치 경도 ts_lat_bow = psn_bow(ts_lon_now, ts_lat_now, ts_ant2bow, ts_co)[1] # 각 시점의 선수위치 위도 ts_lon_eca = psn_eca(ts_lon_bow, ts_lat_bow, ts_co, ts_spd, eca_time)[0] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 경도 ts_lat_eca = psn_eca(ts_lon_bow, ts_lat_bow, ts_co, ts_spd, eca_time)[1] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 위도 ' 타선의 몇 분뒤 선수위치 시계열데이터 ' ts_lon_eca = ts_lon_bow + ts_spd / ( 60 * 60 * 60) * numpy.sind(ts_co) * eca_time # 타선의 eca_time(sec) 뒤 경도 ts_lat_eca = ts_lat_bow + ts_spd / ( 60 * 60 * 60) * numpy.cosd(ts_co) * eca_time # 타선의 eca_time(sec) 뒤 위도 ' 본선의 현재 선수위치와 상대선의 몇초뒤 선수위치 간의 상대방위 계산 예) 앞 0 뒤 180 좌 270 우 90 ' rel_brg = [ rel_brg([os_lon_bow[i], os_lat_bow[i]], [ts_lon_eca[i], ts_lat_eca[i]]) for i in range(0, time_limit) ] ' 본선의 현재 선수위치와 상대선의 몇초뒤 선수위치 간의 거리 계산 ' dist_eca = [ math.sqrt((os_lon_bow[i] - ts_lon_eca[i])**2 + (os_lat_bow[i] - ts_lat_eca[i])**2) for i in range(0, time_limit) ] # deg 단위 ' TCPA, DCPA 계산 알고리즘 - 한국해양대 제공본 수정 ----------------------------'
def vecX(xdeg): # For positive xdeg=cwRoll: +y=>+z; +z=>-y. c = np.cosd(xdeg) s = np.sind(xdeg) return np.array([[1, 0, 0], [0, c, -s], [0, +s, c]])
def ejecutar_trigo(self, funcion): if funcion.funcion == 'acos': try: return np.acos(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en acos ') return 0 elif funcion.funcion == 'acosd': try: return np.acosd(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en acosd ') return 0 elif funcion.funcion == 'asin': try: return np.asin(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en asin ') return 0 elif funcion.funcion == 'asind': try: return np.asind(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en asind ') return 0 elif funcion.funcion == 'atan': try: return np.atan(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores ') return 0 elif funcion.funcion == 'atand': try: return np.atand(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores atand ') return 0 elif funcion.funcion == 'atan2': try: return np.atan2(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en atan2 ') return 0 elif funcion.funcion == 'cos': try: return np.cos(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en cos ') return 0 elif funcion.funcion == 'cosd': try: return np.cosd(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores cosd cosd') return 0 elif funcion.funcion == 'cot': try: return np.cot(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores cot') return 0 elif funcion.funcion == 'cotd': try: return np.cotd(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en cotd ') return 0 elif funcion.funcion == 'sin': try: return np.sin(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en sin ') return 0 elif funcion.funcion == 'sind': try: return np.sind(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en sind ') return 0 elif funcion.funcion == 'tan': try: return np.tan(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en tan ') return 0 elif funcion.funcion == 'tand': try: return np.tand(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en tand') return 0 elif funcion.funcion == 'sinh': try: return np.sinh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en sinh') return 0 elif funcion.funcion == 'cosh': try: return np.cosh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en cosh ') return 0 elif funcion.funcion == 'tanh': try: return np.tanh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en tanh ') return 0 elif funcion.funcion == 'asinh': try: return np.asinh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en asinh') return 0 elif funcion.funcion == 'acosh': try: return np.acosh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en acosh ') return 0 elif funcion.funcion == 'atanh': try: return np.atanh(self.aritexc.ejecutar_operacion(funcion.op1)) except: errorsem.append('error al convertir valores en atanh ') return 0
def vecY(ydeg): # For positive ydeg=-elev: +z=>+x; +x=>-z. # do not overlook this minus sign: positive ydeg pitches downward. c = np.cosd(ydeg) s = np.sind(ydeg) return np.array([[c, 0, +s], [0, 1, 0], [-s, 0, c]])
def vecZ(zdeg): # For positive zdeg=+az: +x=>+y; +y=>-x. c = np.cosd(zdeg) s = np.sind(zdeg) return np.array([[c, -s, 0], [+s, c, 0], [0, 0, 1]])
ts_lat + i * d_sec(ts_co, ts_spd)[1] for i in range(0, time_limit) ] # 출발지를 기준으로 매초 안테나 위치 위도 ts_lon_bow = psn_bow(ts_lon_now, ts_lat_now, ts_ant2bow, ts_co)[0] # 각 시점의 선수위치 경도 ts_lat_bow = psn_bow(ts_lon_now, ts_lat_now, ts_ant2bow, ts_co)[1] # 각 시점의 선수위치 위도 ts_lon_eca = psn_eca(ts_lon_bow, ts_lat_bow, ts_co, ts_spd, eca_time)[0] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 경도 ts_lat_eca = psn_eca(ts_lon_bow, ts_lat_bow, ts_co, ts_spd, eca_time)[1] # 각 시점에서 eca_time(sec)가 지난 후 선수위치 위도 ' ECA_TIME뒤 본선과 상대선의 선수위치 시계열데이터 ' ts_lon_eca = ts_lon_bow + ts_spd / ( 60 * 60 * 60) * numpy.sind(ts_co) * eca_time # 타선의 eca_time(sec) 뒤 경도 ts_lat_eca = ts_lat_bow + ts_spd / ( 60 * 60 * 60) * numpy.cosd(ts_co) * eca_time # 타선의 eca_time(sec) 뒤 위도 import math ' 두 점의 상대방위를 구하는 함수 ' def rel_brg(pointA, pointB): pointA = tuple(pointA) pointB = tuple(pointB) lat1 = math.radians(pointA[1]) lat2 = math.radians(pointB[1]) diffLong = math.radians(pointB[0] - pointA[0]) x = math.sin(diffLong) * math.cos(lat2) y = math.cos(lat1) * math.sin(lat2) - (math.sin(lat1) * math.cos(lat2) *
fe = [np.array(v) for v in fe] # convierto todas esas listas a arrays de NumPy # %% separo la memoria K = np.zeros((ngdl, ngdl)) # matriz de rigidez global f = np.zeros(ngdl) # vector de fuerzas nodales equivalentes global Ke = nb * [None] # matriz de rigidez local en coordenadas globales T = nb * [None] # matriz de transfor(mación de coordenadas idx = np.zeros((nb, 6), dtype=int) # almacena los 6 gdls de las barras # %% ensamblo la matriz de rigidez global (K) y vector de fuerzas global (f) for e in range(nb): # para cada barra # saco los 6 gdls de la barra e idx[e] = np.r_[gdl[LaG[e, NL1], :], gdl[LaG[e, NL2], :]] # matriz de transformaciÓn de coordenadas para la barra e c = np.cosd(theta[e]) s = np.sind(theta[e]) T[e] = np.array([[c, s, 0, 0, 0, 0], [-s, c, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, c, s, 0], [0, 0, 0, -s, c, 0], [0, 0, 0, 0, 0, 1]]) # matriz de rigidez local expresada en el sistema de coordenadas locales # para la barra e AE = A[e] * E EI = E * I[e] L = long[e] L2 = long[e]**2 L3 = long[e]**3 Kloc = np.array( [[AE / L, 0, 0, -AE / L, 0, 0],