def getGeoMag1YVar(geometry, feature, parent): geom_pt = geometry.asPoint() today = datetime.datetime.now() y1 = today + datetime.timedelta(days=365) geomag_now = geomag.declination(geom_pt.y(), geom_pt.x()) geomag_y1 = geomag.declination(geom_pt.y(), geom_pt.x(), time=y1.date()) return geomag_y1 - geomag_now
def getNorthAngle(latitude, longitude): magDec = gm.declination(latitude, longitude) accel_mag = get_accel_mag() acceleration = accel_mag["acceleration"] magnetic = accel_mag["magnetic"] while (acceleration[0]**2 + acceleration[1]**2 + acceleration[2]**2 < 56.25 or acceleration[0]**2 + acceleration[1]**2 + acceleration[2]**2 > 156.25): accel_mag = get_accel_mag() acceleration = accel_mag["acceleration"] magnetic = accel_mag["magnetic"] if (magnetic[0] != 0): magNorth = degrees(atan(magnetic[1] / magnetic[0])) if (magnetic[0] < 0): magNorth += 180 if (magNorth < 0): magNorth += 360 else: if (magnetic[1] < 0): magNorth = 270 else: magNorth = 90 trueNorth = magNorth + magDec if (trueNorth < 0): trueNorth += 360 elif (trueNorth > 360): trueNorth -= 360 return trueNorth
def mag_var(netCDFfile): print(netCDFfile) ds = Dataset(netCDFfile, 'a') lat = ds.variables['LATITUDE'][:] lon = ds.variables['LONGITUDE'][:] nom_depth = ds.variables['NOMINAL_DEPTH'][:] time = ds.variables['TIME'] dt = num2date(time[:], units=time.units, calendar=time.calendar) len_time = len(dt) time_mid = dt[int(len_time/2)] date = time_mid.date() # geomag wants date object not datetime dec = geomag.declination(lat, lon, time=date) print("calc for ", time_mid, lat, lon, dec) ds.setncattr("geomagnetic_varition", dec) ds.setncattr("geomagnetic_varition_comment", "calculation for %s at LATITUDE and LONGITUDE using https://pypi.org/project/geomag/" % date) ds.close() return netCDFfile
def updated(self, channel): if self.gps_utc - self.last_time > 10: self.last_time = self.gps_utc self.magnetic_declination = declination(self.gps_lat, self.gps_lng, self.gps_altitude) self.publish() print("Magnetic Declination: %.1f" % (self.magnetic_declination, ))
def MagDeclin(gLat, gLong): declin = geomag.declination(gLat,gLong) MagDeclinlination = round(declin,2) if MagDeclinlination < 0: Cardinal ="W" else: Cardinal ="E" MagDecTxt = str(abs(MagDeclinlination)) + " " + Cardinal return(MagDecTxt)
def unit_vectors(exif_obj): """Compute east and north unit vectors given the camera yaw.""" camera_yaw = exif_obj["camera_yaw"] lat, lon = exif_obj["img_lat"], exif_obj["img_lon"] declination = geomag.declination(lat, lon) camera_yaw += declination # compensate for magnetic variation alpha = camera_yaw * np.pi / 180 n = [-np.cos(alpha), -np.sin(alpha)] e = [-np.sin(alpha), np.cos(alpha)] return np.array(n), np.array(e)
def updateGui(self): if self.hasNewPayloadGps: self.parent.ids.station_lat.text = str(self.latDeg) self.parent.ids.station_long.text = str(self.lonDeg) self.parent.ids.station_alt.text = str(self.altMeters) self.parent.ids.station_trueHeading.text = str(self.imuX) self.parent.ids.station_time.text = str(self.gpsTime) self.magneticVariation = geomag.declination( dlat=self.latDeg, dlon=self.lonDeg, h=self.altMeters ) self.hasNewPayloadGps = False
def calculate_mag_var(position, date): if position[0] and position[2] and date: try: var=float(geomag.declination(position[0], position[2], 0, date)) var=round(var,1) if var >= 0.0: mag_var=[var,'E'] if var < 0.0: mag_var=[var*-1,'W'] except: mag_var=['',''] else: mag_var=['',''] return mag_var
def satellite_finder(params): # si la dirección viene definida, se obtiene latitud y longitud via Google API if params.address: address, lat, lng = google_geocode(params.address) # si no hay dirección, lat/lng son obligatorios elif params.lat and params.lng: address = None lat = convert_float('lat', params.lat, -90, 90) lng = convert_float('lng', params.lng, -180, 180) else: raise SatError("Alguno de los parámetros 'address' o 'lat/lng' tiene que estar definido") # si la altura no viene definida, se obtiene via Google API if params.alt: alt = convert_float('alt', params.alt, -500, 9000) else: alt = google_elevation(lat, lng) # obtiene la longitud del satélite (su latitud es cero) if params.sat: sat = Satellites.get(params.sat.upper(), None) if not sat: sat = convert_float('sat', params.sat, -180, 180) else: raise SatError("El parámetro 'sat' tiene que estar definido") # obtiene declinación magnética, en grados magn = geomag.declination(lat, lng, alt / Foot) # cálculo de coordenadas antena (x, y, z) lat_rad = math.radians(lat) r_ant = radio_elipse(lat_rad, Radio_Ecuat, Radio_Polar) + alt coord_ant = r_ant * math.cos(lat_rad), 0, r_ant * math.sin(lat_rad) # cálculo de coordenadas satélite (x, y, z) lng_rad = math.radians(lng - sat) r_sat = Radio_Ecuat + Orbita_Geo coord_sat = r_sat * math.cos(lng_rad), r_sat * math.sin(lng_rad), 0 # cálculo de distancia al satélite, en km distance = norma_eucl(coord_ant, coord_sat) / 1000 # cálculo de azimut y elevacion, en grados azimuth = 180 + math.degrees(math.atan2(math.tan(lng_rad), math.sin(lat_rad))) alfa = math.sqrt((r_sat * math.cos(lng_rad) - r_ant * math.cos(lat_rad)) ** 2 + r_sat ** 2 * math.sin( lng_rad) ** 2 + r_ant ** 2 * math.sin(lat_rad) ** 2) elevation = math.degrees(math.asin((r_sat * math.cos(lng_rad) * math.cos(lat_rad) - r_ant) / alfa)) return OrderedDict([('address', address), ('lat', '%7.4f' % lat), ('lng', '%7.4f' % lng), ('alt', '%5.1f' % alt), ('sat', '%5.1f' % sat), ('distance', '%5.1f' % distance), ('elevation', '%5.2f' % elevation), ('azimuth_true', '%5.2f' % azimuth), ('azimuth_magn', '%5.2f' % (azimuth - magn))])
def setHeading(self, heading): curtime = time.time() if curtime - self.last_mag_update > 60 or self.magnetic_declination is None: # update every minute at the most if not (self.missing_lat or self.missing_lng): self.last_mag_update = curtime self.magnetic_declination = declination (self.lat, self.lng, self.altitude) md = self.magnetic_declination if md is None: md = 0 self.pov.update_heading (heading + md) if not self.rendering_prohibited: self.pov.render(self)
def __init__(self, location, magnetic, accel): ''' sensor is a gyro or magnetic sensor device like HMC5883L location is triple (long(°), lat(°), altitude(m)) ''' lon = location[0] lat = location[1] alt = location[2] self.magnetic = magnetic self.accel = accel self.declination = geomag.declination(dlat=lat, dlon=lon, h=3.2808399 * alt)
def __init__(self, time, seconds, lat, lon, alt, trackingMethod, groundLat, groundLon, groundAlt): self.time = time self.seconds = seconds self.lat = lat self.lon = lon self.alt = alt self.trackingMethod = trackingMethod ### Calculate pointing values and distances ### distanceToTarget = haversine(groundLat, groundLon, self.lat, self.lon) self.bear = bearing(groundLat, groundLon, self.lat, self.lon) self.ele = elevationAngle(self.alt, groundAlt, distanceToTarget) self.los = losDistance(self.alt, groundAlt, distanceToTarget) self.magDec = geomag.declination( dlat=self.lat, dlon=self.lon, h=self.alt)
def calculate_mag_var(position, date): if position[0] and position[2] and date: try: lat=lat_DM_to_DD(position[0]) if position[1]=='S': lat = lat * -1 lon=lon_DM_to_DD(position[2]) if position[3]=='W': lon = lon * -1 var=float(geomag.declination(lat, lon, 0, date)) var=round(var,1) if var >= 0.0: mag_var=[var,'E'] if var < 0.0: mag_var=[var*-1,'W'] except: mag_var=['',''] else: mag_var=['',''] return mag_var
def calculate_declination(self): baddblsb = self.p.badDblSpinBoxValue p = re.compile('\d+\.\d+') x = self.decXDblSpinBx.value() xok = (int(x) != 0 and p.match(str(x)) is not None) self.decXDblSpinBx.setStyleSheet("" if xok else baddblsb) y = self.decXDblSpinBx.value() yok = (int(y) != 0 and p.match(str(y)) is not None) self.decYDblSpinBx.setStyleSheet("" if yok else baddblsb) # NOTE: elevation value can be 0; approx. value will increase accuracy if not (xok or yok): self.clear_declination_values() return # transform UTM point to WGS 84, lat/lon pt = QgsPoint(self.decXDblSpinBx.value(), self.decYDblSpinBx.value()) wgs84 = QgsCoordinateReferenceSystem(4326) # QgsMessageLog.logMessage("wgs84: {0}".format(wgs84.authid()), # self.tr("Fdt"), QgsMessageLog.INFO) mapcrs = self.canvas.mapRenderer().destinationCrs() # QgsMessageLog.logMessage("mapcrs: {0}".format(mapcrs.authid()), # self.tr("Fdt"), QgsMessageLog.INFO) xform = QgsCoordinateTransform(mapcrs, wgs84) wgspt = xform.transform(pt) # QgsMessageLog.logMessage( # "wgspt:\n {0}\n {1}".format(wgspt.y(), wgspt.x()), # self.tr("Fdt"), QgsMessageLog.INFO) # ensure height is in US feet h = self.decElevDblSpnBx.value() hinm = self.decElevUnitsCmbBx.currentIndex() # 0 = ft, 1 = m elev = h if not hinm else h * 3.281 gmdec = geomag.declination(wgspt.y(), wgspt.x(), elev) nb = self.calculate_mag_bearing(0, gmdec) eb = self.calculate_mag_bearing(90, gmdec) sb = self.calculate_mag_bearing(180, gmdec) wb = self.calculate_mag_bearing(270, gmdec) self.decCurrentDblSpinBox.setValue(gmdec) self.decNBearingDblSpnBx.setValue(nb) self.decEBearingDblSpnBx.setValue(eb) self.decSBearingDblSpnBx.setValue(sb) self.decWBearingDblSpnBx.setValue(wb)
def __init__(self, time, seconds, lat, lon, alt, trackingMethod, groundLat, groundLon, groundAlt): self.time = time self.seconds = seconds self.lat = lat self.lon = lon self.alt = alt self.trackingMethod = trackingMethod ### Calculate pointing values and distances ### distanceToTarget = haversine(groundLat, groundLon, self.lat, self.lon) self.bear = bearing(groundLat, groundLon, self.lat, self.lon) self.ele = elevationAngle(self.alt, groundAlt, distanceToTarget) self.los = losDistance(self.alt, groundAlt, distanceToTarget) self.magDec = geomag.declination(dlat=self.lat, dlon=self.lon, h=self.alt)
def getCenterBearing(self, s2): """ Acquire a center bearing and a GPS location from the calibration arduino """ s2.flushInput() # Clear the buffer so it can read new info # Read from GPS module and populate temp_gps[] tempLat = temp_gps[1] # Get ground station latitude tempLon = temp_gps[2] # Get ground station longitude tempAlt = temp_gps[3] # Get ground station altitude # Get the offset for the center bearing tempoffsetDegrees = temp_arduino[4] tempLat = tempLat.split(".") # Convert the lat to decimal degrees as a float self.groundLat = float(tempLat[0]) + float(tempLat[1]) / 10000000 tempLon = tempLon.split(".") # Convert the lon to decimal degrees as a float self.groundLon = float(tempLon[0]) - float(tempLon[1]) / 10000000 tempAlt = tempAlt.split(".") # Get the altitude to the floor(foot) self.groundAlt = int(tempAlt[0]) self.centerBear = float(tempoffsetDegrees) declination = float(geomag.declination( dlat=self.groundLat, dlon=self.groundLon, h=self.groundAlt)) self.centerBear = (self.centerBear + declination) if self.centerBear > 360: self.centerBear -= 360 elif self.centerBear < 0: self.centerBear += 360 print ("Local Latitude: \t", self.groundLat) print ("Local Longitude:\t", self.groundLon) print ("Local Altitude: \t", self.groundAlt) print ("Offset Degrees: \t", self.centerBear) print ("Declination: \t", declination) print ("Offset + Dec: \t", self.centerBear) print ("-------------------------------------------------------") self.antennaBear = self.centerBear # Lets the program know that the center bearing has been set before self.centerBearSet = True
def calculate_mag_var(position, date): if position[0] and position[2] and date: try: lat = lat_DM_to_DD(position[0]) if position[1] == "S": lat = lat * -1 lon = lon_DM_to_DD(position[2]) if position[3] == "W": lon = lon * -1 var = float(geomag.declination(lat, lon, 0, date)) var = round(var, 1) if var >= 0.0: mag_var = [var, "E"] if var < 0.0: mag_var = [var * -1, "W"] except: mag_var = ["", ""] else: mag_var = ["", ""] return mag_var
def calcTiltHeading(self, ax, ay, az): fNormAcc = math.sqrt(ax*ax + ay*ay + az*az) fSinRoll = ay/fNormAcc fCosRoll = math.sqrt(1.0-(fSinRoll * fSinRoll)) fSinPitch = ax/fNormAcc fCosPitch = math.sqrt(1.0-(fSinPitch * fSinPitch)) fTiltedX = self.m[0]*fCosPitch + self.m[2]*fSinPitch fTiltedY = self.m[0]*fSinRoll*fSinPitch + self.m[1]*fCosRoll - self.m[2]*fSinRoll*fCosPitch fcosf= fTiltedX / math.sqrt(fTiltedX*fTiltedX+fTiltedY*fTiltedY) if fTiltedY>0: HeadingValue = math.acos(fcosf)*180/math.pi else: HeadingValue =360-math.acos(fcosf)*180/math.pi import geomag HeadingValue -= geomag.declination(37,128) if HeadingValue>360: HeadingValue=HeadingValue-360 return HeadingValue
def calcTiltHeading(self): fNormAcc = math.sqrt(math.fsum(i * i for i in self.a)) fSinRoll = self.a[1] / fNormAcc fCosRoll = math.sqrt(1.0 - (fSinRoll * fSinRoll)) fSinPitch = self.a[0] / fNormAcc fCosPitch = math.sqrt(1.0 - (fSinPitch * fSinPitch)) fTiltedX = self.m[0] * fCosPitch + self.m[2] * fSinPitch fTiltedY = self.m[0] * fSinRoll * fSinPitch + self.m[1] * fCosRoll - self.m[2] * fSinRoll * fCosPitch fcosf = fTiltedX / math.sqrt(fTiltedX * fTiltedX + fTiltedY * fTiltedY) if fTiltedY > 0: HeadingValue = math.acos(fcosf) * 180 / math.pi else: HeadingValue = 360 - math.acos(fcosf) * 180 / math.pi # HeadingValue -= -8 HeadingValue -= geomag.declination(37, 128) if HeadingValue > 360: HeadingValue = HeadingValue - 360 return HeadingValue
def calcTiltHeading(self): fNormAcc = math.sqrt(sum(i*i for i in self.a)) fSinRoll = self.a[1]/fNormAcc fCosRoll = math.sqrt(1.0-(fSinRoll * fSinRoll)) fSinPitch = self.a[0]/fNormAcc fCosPitch = math.sqrt(1.0-(fSinPitch * fSinPitch)) fTiltedX = self.m[0]*fCosPitch + self.m[2]*fSinPitch fTiltedY = self.m[0]*fSinRoll*fSinPitch + self.m[1]*fCosRoll - self.m[2]*fSinRoll*fCosPitch fcosf= fTiltedX / math.sqrt(fTiltedX*fTiltedX+fTiltedY*fTiltedY) if fTiltedY>0: HeadingValue = math.acos(fcosf)*180/math.pi else: HeadingValue =360-math.acos(fcosf)*180/math.pi import geomag #HeadingValue -= -8 HeadingValue -= geomag.declination(37,128) if HeadingValue>360: HeadingValue=HeadingValue-360 return HeadingValue
def gprmc(lat, lon): # Assuming the Land of Oz today = datetime.utcnow() time = today.strftime("%H%M%S.%f").rstrip('0') warning = "A" # "A" for good, "V" for bad. I'm an optimist. latD = dd2dm(lat) if lat < 0: latH = "S" else: latH = "N" lonD = dd2dm(lon) if lon < 0: lonH = "W" else: lonH = "E" speed = "0" # ? course = "" # ? dateUTC = today.strftime("%d%m%y") # Using UTC time. mag = geomag.declination(lat, lon, time=today.date()) # See geomag library magD = "E" if mag < 0 else "W" # West or East declination? mag = abs(mag) # Data stored in magD gprmcData = "GPRMC,%s,%s,%s,%s,%s,%s,%s,%s,%s,%f.00,%s" % ( time, warning, latD, latH, lonD, lonH, speed, course, dateUTC, mag, magD, ) check = checksum(gprmcData) gprmcFormat = "$%s*%X\r\n" % (gprmcData, check) return gprmcFormat
def gprmc(lat,lon): # Assuming the Land of Oz today=datetime.utcnow() time= today.strftime("%H%M%S.%f").rstrip('0') warning="A" # "A" for good, "V" for bad. I'm an optimist. latD=dd2dm(lat) if lat<0: latH="S" else: latH="N" lonD=dd2dm(lon) if lon<0: lonH="W" else: lonH="E" speed="0" # ? course="" # ? dateUTC=today.strftime("%d%m%y") # Using UTC time. mag=geomag.declination(lat,lon,time=today.date() ) # See geomag library magD="E" if mag<0 else "W" # West or East declination? mag=abs(mag) # Data stored in magD gprmcData="GPRMC,%s,%s,%s,%s,%s,%s,%s,%s,%s,%f.00,%s"%( time, warning, latD, latH, lonD, lonH, speed, course, dateUTC, mag, magD, ) check=checksum(gprmcData) gprmcFormat="$%s*%X\r\n"%(gprmcData,check) return gprmcFormat
def string_notes(system, run=0.0, stationClass = 1): """page 5""" name, usaf = geo.closestUSAF( geo.zipToCoordinates(system.zipcode), stationClass) mintemp = epw.minimum(usaf) twopercentTemp = epw.twopercent(usaf) ac_rated = 0.0 dc_rated = 0.0 for i in system.shape: dc_rated += i.array.Pmax try: if i.phase == 1: ac_rated += i.current * i.ac_voltage else: ac_rated += i.phase * i.current * i.ac_voltage/ 3**.5 except: ac_rated += i.Paco pass notes = [] notes.append("%s KW AC RATED" % round(ac_rated/1000.0,2)) notes.append("%s KW DC RATED" % round(dc_rated/1000.0,2)) #BUG: This doesn't work for unbalanced 3 phase if system.phase == 1: Aac = round(ac_rated/i.ac_voltage,1) else: Aac = round(ac_rated/i.ac_voltage/3**.5,1) notes.append( "System AC Output Current: %s A" % Aac) notes.append("Nominal AC Voltage: %s V" % i.ac_voltage) notes.append("") notes.append("Minimum Temperature: %s C" % mintemp) notes.append("2 Percent Max Temperature: %s C" % twopercentTemp) notes.append("Weather Source: %s %s" % (name, usaf)) notes.append("") di, dp = system.describe() aMax = 0 for i in system.shape: if dp.has_key(i.array.panel.model): notes.append( "PV Module Ratings @ STC") notes.append("Module Make: %s" % i.array.panel.make) notes.append("Module Model: %s" % i.array.panel.model) notes.append("Quantity: %s" % dp[i.array.panel.model]) notes.append("Max Power-Point Current (Imp): %s A" % i.array.panel.Impp) notes.append("Max Power-Point Voltage (Vmp): %s V" % i.array.panel.Vmpp) notes.append("Open-Circuit Voltage (Voc): %s V" % i.array.panel.Voc) notes.append("Short-Circuit Current (Isc): %s A" % i.array.panel.Isc) notes.append("Maximum Power (Pmax): %s W" % round(i.array.panel.Pmax,1)) #notes.append("Module Rated Max Voltage: %s V" % i.array.panel.Vrated) notes.append("") dp.pop(i.array.panel.model) if di.has_key(i.model): notes.append("Inverter Make: %s" % i.make) notes.append("Inverter Model: %s" % i.model) notes.append("Quantity: %s" % di[i.model]) notes.append("Max Power: %s KW" % round(i.Paco/1000.0,1)) #this is hack... This should be calculated based upon power cores if hasattr(i,'current'): notes.append("Max AC Current: %s A" % round(i.current,1)) elif i.ac_voltage == 480: notes.append("Max AC Current: %s A" % round(i.Paco*1.0/i.ac_voltage/3**.5,1)) else: notes.append("Max AC Current: %s A" % round(i.Paco*1.0/i.ac_voltage,1)) #greater than 1 in parallel if len(i.array.shape) > 1: pass notes.append("DC Operating Current: %s A" % \ round(i.array.panel.Impp*len(i.array.shape),1)) notes.append("DC Short Circuit Current: %s A" % \ round(i.array.panel.Isc*len(i.array.shape),1)) #greater than 1 in series if max(i.array.shape)> 1: notes.append("DC Operating Voltage: %s V" % round(i.array.Vdc(),1)) notes.append("System Max DC Voltage: %s V" % round(i.array.Vmax(mintemp),1)) if i.array.Vmax(mintemp) > 600: print "WARNING: Array exceeds 600V DC" notes.append("Pnom Ratio: %s" % round((i.array.Pmax/i.Paco),2)) if (i.array.Vdc(twopercentTemp) *.9) < i.mppt_low: print "WARNING: Array IV Knee drops out of Inverter range" if (i.array.Pmax/i.Paco) < 1.1: print "WARNING: Array potentially undersized" notes.append("") di.pop(i.model) if i.array.Vmax(mintemp) > aMax: aMax = i.array.Vmax(mintemp) notes.append("Array Azimuth: %s Degrees" % system.azimuth) notes.append("Array Tilt: %s Degrees" % system.tilt) s9 = system.solstice(9) s15 = system.solstice(15) notes.append("December 21 9:00 AM Sun Azimuth: %s Degrees" % \ (round(degrees(s9[1]),1))) notes.append("December 21 9:00 AM Sun Altitude: %s Degrees" % \ (round(degrees(s9[0]),1))) notes.append("December 21 3:00 PM Sun Azimuth: %s Degrees" % \ (round(degrees(s15[1]),1))) notes.append("December 21 3:00 PM Sun Altitude: %s Degrees" % \ (round(degrees(s9[0]),1))) if 'geomag' in sys.modules: notes.append("Magnetic declination: %s Degrees" % \ round(geomag.declination(dlat=system.place[0],dlon=system.place[1]))) notes.append("Minimum Row space ratio: %s" % \ round(system.minRowSpace(1.0),2)) print "\n".join(notes) print "" print "Minimum Bundle" minC = vd.vd(Aac,5,verbose=False) try: ee.assemble(minC,Aac,conduit='STEEL') if run > 0: print "Long Run" minC = vd.vd(Aac,run,v=i.ac_voltage,tAmb=15,pf=.95,material='AL',verbose=False) ee.assemble(minC,Aac,conduit='PVC') except: print "Warning: Multiple sets of conductors" return notes
targetlatDeg = 44.587746 targetlonDeg = -123.096098 targetaltMeters = 200 #lat = input('Enter latitude of target: ') #lon = input('Enter longitude of target: ') #alt = input('Enter altitude of target: ') else: target.update() tracker.update() bearing = ServoControl.bearing( tracker.latDeg, tracker.lonDeg, targetlatDeg, targetlonDeg ) if(bearing): tracker.imuX = (tracker.imuX + 360)%360 # print "The tracker heading is ", tracker.imuX declination = geomag.declination( dlat=tracker.latDeg, dlon=tracker.lonDeg, h=tracker.altMeters ) # print "Magnetic declination is ", declination tracker.imuX = (tracker.imuX + declination) % 360 print "Tracker heading after declination: ", tracker.imuX print "The solution bearing is: ", bearing solution = (bearing - tracker.imuX + 360) % 360 print "Tracker needs to move ", solution print "In servo, that's ", ServoControl.degToServo(solution) print tracker.imuX, tracker.imuMag, tracker.imuSys time.sleep(5)
sdata = data.decode().split(",") if sdata[2] == 'V': print("no satellite data available") # print("---Parsing GPVTG---") tracking_true = sdata[1] # tracking_mag = sdata[3] #Theoretically the GPS might have a lookup table for magnetic declination. If it does this line might work # if there is no data (for example the gps is not moving) return a crazy large number to indicate that if tracking_true == "": tracking_true = "32768" tracking_mag = "32768" # Since our GPS receiver does not have the lookup table for declination, we use the geomag library if int(tracking_true) >=0 and int(tracking_true)<=360: tracking_mag = tracking_true + geomag.declination(lat/1000000, lon/1000000) speed = sdata[5] if speed == "": speed = "32768" if alt == "": alt = "15000" GPS_data = bytearray([int(float(speed)) & 0xFF, int(float(speed))>>8, int(float(alt)*conv_m2ft) & 0xFF, int(float(alt)*conv_m2ft)>>8, int(float(tracking_true)) & 0xFF, int(float(tracking_true))>>8, int(float(tracking_mag)) & 0xFF, int(float(tracking_mag))>>8]) msg = can.Message(arbitration_id=100, data=GPS_data, extended_id=False) Msg_Ready = True # print("Speed: %s, Alt : %s, tracking_true: %s, tracking_mag: %s" % (speed, alt, tracking_true, tracking_mag)) if Msg_Ready: try: bus.send(msg)
else: arcpy.AddWarning("Warning: Need to add Planning Point or ICP prior to updating map layout\n") unProjCoordSys = "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]" desc = arcpy.Describe(fc1) shapefieldname = desc.ShapeFieldName rows1 = arcpy.SearchCursor(fc1, '', unProjCoordSys) k = 0 declin = 0 for row1 in rows1: feat = row1.getValue(shapefieldname) pnt = feat.getPart() latitude = pnt.Y longitude = pnt.X declin = geomag.declination(latitude,longitude) + declin k+=1 del rows1 del row1 declin_avg = declin / k MagDeclinlination = round(declin_avg,2) if MagDeclinlination < 0: Cardinal ="W" else: Cardinal ="E" MagDecTxt = str(abs(MagDeclinlination)) + " " + Cardinal arcpy.AddMessage(MagDecTxt) try: #Update Incident Name and Number with the file name and dataframe name IncName = df.name
def cal_magnetic_declination(course: SailingCourse): declination = geomag.declination(course.latitude, course.longitude, time=convert_str_to_date(course.date)) return round(declination)
IMUheadingAverage = sum(IMUheadingList)/movingAverageRange IMUrollAverage = sum(IMUrollList)/movingAverageRange IMUpitchAverage = sum(IMUpitchList)/movingAverageRange AMEwindangleAverage = sum(AMEwindangleList)/movingAverageRange targetWaypointLatitude = waypointLatitudeList[waypointCounter] targetWaypointLongitude = waypointLongitudeList[waypointCounter] distanceToWaypoint, bearingToWaypoint = findDistanceandBearing(GPSlatitudeAverage, GPSlongitudeAverage, targetWaypointLatitude, targetWaypointLongitude) #if (distanceToWaypoint <= acceptWaypointDistance) and (waypointCounter < numberOfWaypoints - 1): if ((cycleCounter % 20) == 0) and (waypointCounter < numberOfWaypoints - 1): waypointCounter += 1 magneticDeclination = geomag.declination(GPSlatitudeAverage, GPSlongitudeAverage) IMUheadingCorrected = IMUheadingAverage + magneticDeclination headingMode = 0 if (GPSspeedAverage > 1.5) and ((range(IMUheadingList) < 15) or (range(IMUheadingList) > 345)) and (GPSfix == 1): heading = GPSheadingAverage headingMode = 1 else: heading = IMUheadingCorrected if cycleCounter > 10: try: print("\n\n") print("Time: %s"%(time)) print("Waypoint\t|\tNumber: %d\tDistance: %d\t\tBearing: %d"%(waypointCounter, distanceToWaypoint, bearingToWaypoint))
#!/usr/bin/env python3 import socket, json, geomag HOST = '127.0.0.1' # The server's hostname or IP address PORT = 9999 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(b'gps') data = s.recv(1024) jdata = data.decode('utf-8') obj = json.loads(jdata) decl = geomag.declination(dlat=obj['lat'], dlon=obj['lon'],h=obj['alt']) print(decl)
def string_notes(system, run=0.0): """page 5""" stationClass = 3 name, usaf = geo.closestUSAF( geo.zipToCoordinates(system.zipcode), stationClass) mintemp = epw.minimum(usaf) twopercentTemp = epw.twopercent(usaf) ac_rated = 0 dc_rated = 0 for i in system.shape: dc_rated += i.array.Pmax ac_rated += i.Paco notes = [] notes.append("%s KW AC RATED" % round(ac_rated/1000.0,2)) notes.append("%s KW DC RATED" % round(dc_rated/1000.0,2)) #BUG: This doesn't work for 3 phase if system.phase == 1: Aac = round(sum([i.Paco for i in system.shape])/i.ac_voltage,1) else: Aac = round(sum([i.Paco for i in system.shape])/i.ac_voltage/3**.5,1) notes.append( "System AC Output Current: %s A" % Aac) notes.append("Nominal AC Voltage: %s V" % i.ac_voltage) notes.append("") notes.append("Minimum Temperature: %s C" % mintemp) notes.append("2 Percent Max Temperature: %s C" % twopercentTemp) notes.append("") di, dp = system.describe() aMax = 0 for i in system.shape: if dp.has_key(i.array.panel.model): notes.append( "PV Module Ratings @ STC") notes.append("Module Make: %s" % i.array.panel.make) notes.append("Module Model: %s" % i.array.panel.model) notes.append("Quantity: %s" % dp[i.array.panel.model]) notes.append("Max Power-Point Current (Imp): %s A" % i.array.panel.Impp) notes.append("Max Power-Point Voltage (Vmp): %s V" % i.array.panel.Vmpp) notes.append("Open-Circuit Voltage (Voc): %s V" % i.array.panel.Voc) notes.append("Short-Circuit Current (Isc): %s A" % i.array.panel.Isc) notes.append("Maximum Power (Pmax): %s W" % round(i.array.panel.Pmax,1)) #notes.append("Module Rated Max Voltage: %s V" % i.array.panel.Vrated) notes.append("") dp.pop(i.array.panel.model) if di.has_key(i.model): notes.append("Inverter Make: %s" % i.make) notes.append("Inverter Model: %s" % i.model) notes.append("Quantity: %s" % di[i.model]) notes.append("Max Power: %s KW" % round(i.Paco/1000.0,1)) #this is hack... This should be calculated based upon power cores if i.ac_voltage == 480: notes.append("Max AC Current: %s A" % round(i.Paco*1.0/i.ac_voltage/3**.5,1)) else: notes.append("Max AC Current: %s A" % round(i.Paco*1.0/i.ac_voltage,1)) #greater than 1 in parallel if len(i.array.shape) > 1: pass notes.append("DC Operating Current: %s A" % \ round(i.array.panel.Impp*len(i.array.shape),1)) notes.append("DC Short Circuit Current: %s A" % \ round(i.array.panel.Isc*len(i.array.shape),1)) #greater than 1 in series if max(i.array.shape)> 1: notes.append("DC Operating Voltage: %s V" % round(i.array.Vdc(),1)) notes.append("System Max DC Voltage: %s V" % round(i.array.Vmax(mintemp),1)) notes.append("Pnom Ratio: %s" % round((i.array.Pmax/i.Paco),2)) notes.append("") di.pop(i.model) if i.array.Vmax(mintemp) > aMax: aMax = i.array.Vmax(mintemp) notes.append("Array Azimuth: %s Degrees" % system.azimuth) notes.append("Array Tilt: %s Degrees" % system.tilt) notes.append("December 21 9:00 AM Sun Azimuth: %s Degrees" % \ int(round(degrees(system.solstice(9)[1]),0))) notes.append("December 21 3:00 PM Sun Azimuth: %s Degrees" % \ int(round(degrees(system.solstice(15)[1]),0))) if sys.modules['geomag']: notes.append("Magnetic declination: %s Degrees" % \ round(geomag.declination(dlat=system.place[0],dlon=system.place[1]))) notes.append("Minimum Row space ratio: %s" % \ round(system.minRowSpace(1.0),2)) print "\n".join(notes) print "" print "Minimum Bundle" minC = vd.vd(Aac,5) ee.assemble(minC,Aac,conduit='STEEL') if run > 0: print "Long Run" minC = vd.vd(Aac,run,v=i.ac_voltage,tAmb=15,pf=.95,material='AL') ee.assemble(minC,Aac,conduit='PVC') return notes
def arduinoGround(): #Gather data from arduino mounted on ground station global groundAlt, groundLat, groundLon, centerBear, antennaBear, calibrationGoal if arduinoAttached: s2 = serial.Serial(str(arduinoCOM), baudrate=arduinoBaud, timeout=arduinoTimeout) time.sleep(5) temp_arduino = "0" calibration = 0 x = 64 y = 70 bad = 0 while (calibration < int(calibrationGoal)): temp_arduino = "0" s2.flushInput() time.sleep(0.05) while (temp_arduino[0] != '~'): temp_arduino = s2.readline() print temp_arduino temp_arduino = temp_arduino.split(',') try: calibration = int(temp_arduino[8]) + int( temp_arduino[7]) + int(temp_arduino[6]) + int( temp_arduino[5]) finally: print "Calibration: ", calibration, " // Goal of ", int( calibrationGoal) if (x > 191): x = 64 time.sleep(3) else: x += 10 if (y < 70): y = 127 else: y -= 3 movePanServo(x) moveTiltServo(y) moveToCenterPos() time.sleep(10) temp_arduino = "0" s2.flushInput() while (temp_arduino[0] != '~'): temp_arduino = s2.readline() print temp_arduino temp_arduino = temp_arduino.split(',') print "Requesting Latitude" tempLat = temp_arduino[1] print tempLat print "Requesting Longitude" tempLon = temp_arduino[2] print tempLon print "Requesting Altitude" tempAlt = temp_arduino[3] tempoffsetDegrees = "0.00" print tempAlt print "Requesting Orientation" tempoffsetDegrees = temp_arduino[4] print tempoffsetDegrees tempLat = tempLat.split(".") groundLat = float(tempLat[0]) + float(tempLat[1]) / 10000000 tempLon = tempLon.split(".") groundLon = float(tempLon[0]) - float(tempLon[1]) / 10000000 tempAlt = tempAlt.split(".") groundAlt = int(tempAlt[0]) #tempoffsetDegrees = tempoffsetDegrees.split(".") centerBear = float(tempoffsetDegrees) declination = float( geomag.declination(dlat=groundLat, dlon=groundLon, h=groundAlt)) s2.close() else: print "Error: Arduino set in Settings as not connected" print "Local Latitude: \t", groundLat print "Local Longitude:\t", groundLon print "Local Altitude: \t", groundAlt print "Offset Degrees: \t", centerBear print "Declination: \t", declination centerBear = (centerBear + declination) if centerBear > 360: centerBear = centerBear - 360 elif centerBear < 0: centerBear = centerBear + 360 print "Offset + Dec: \t", (centerBear) print "-------------------------------------------------------" antennaBear = (centerBear)
def string_notes(system, run=0.0, station_class=3): """page 5""" name, usaf = geo.closest_usaf(geo.zip_coordinates(system.zipcode), \ station_class) mintemp = eere.minimum(usaf) twopercent_temp = eere.twopercent(usaf) ac_kva_rated = 0.0 dc_rated = 0.0 ac_kw = 0.0 for i in system.shape: dc_rated += i.array.p_max try: if i.phase == 1: ac_kva_rated += i.current * i.ac_voltage else: ac_kva_rated += i.phase * i.current * i.ac_voltage / 3**.5 except Exception: ac_kva_rated += i.p_aco ac_kw += i.p_aco notes = [] notes.append("%s KVA AC RATED" % round(ac_kva_rated / 1000.0, 2)) notes.append("%s KW AC RATED" % round(ac_kw / 1000.0, 2)) notes.append("%s KW DC RATED" % round(dc_rated / 1000.0, 2)) #BUG: This doesn't work for unbalanced 3 phase if system.phase == 1: a_ac = round(ac_kva_rated / i.ac_voltage, 1) else: a_ac = round(ac_kva_rated / i.ac_voltage / 3**.5, 1) notes.append("System AC Output Current: %s A" % a_ac) notes.append("Nominal AC Voltage: %s V" % i.ac_voltage) notes.append("") notes.append("Minimum Temperature: %s C" % mintemp) notes.append("2 Percent Max Temperature: %s C" % twopercent_temp) notes.append("Weather Source: %s %s" % (name, usaf)) notes.append("") d_inverters, d_panels = system.describe() a_max = 0 for i in system.shape: module_name = i.array.dump()['panel'] if d_panels.has_key(module_name): module = modules.Module(module_name) notes.append("PV Module Ratings @ STC") notes.append("Module Make: %s" % module.make) notes.append("Module Model: %s" % module.model) notes.append("Quantity: %s" % d_panels[module_name]) notes.append("Max Power-Point Current (Imp): %s A" % module.i_mpp) notes.append("Max Power-Point Voltage (Vmp): %s V" % module.v_mpp) notes.append("Open-Circuit Voltage (Voc): %s V" % module.v_oc) notes.append("Short-Circuit Current (Isc): %s A" % module.i_sc) notes.append("Maximum Power (Pmax): %s W" % round(module.p_max, 1)) notes.append("") d_panels.pop(module_name) if d_inverters.has_key(i.model): notes.append("Inverter Make: %s" % i.make) notes.append("Inverter Model: %s" % i.model) notes.append("Quantity: %s" % d_inverters[i.model]) notes.append("Max Power: %s KW" % round(i.p_aco / 1000.0, 1)) #this is hack... This should be calculated based upon power cores if hasattr(i, 'current'): notes.append("Max AC Current: %s A" % round(i.current, 1)) elif i.ac_voltage == 480: notes.append("Max AC Current: %s A" % \ round(i.p_aco*1.0/i.ac_voltage/3**.5, 1)) else: notes.append("Max AC Current: %s A" % \ round(i.p_aco*1.0/i.ac_voltage, 1)) #greater than 1 in parallel if i.array.mcount() > 1: notes.append("DC Operating Current: %s A" % \ round(i.array.i_mpp(), 1)) notes.append("DC Short Circuit Current: %s A" % \ round(i.array.i_sc(), 1)) #greater than 1 in series if i.array.mcount() > 1: notes.append("DC Operating Voltage: %s V" % \ round(i.array.v_dc(), 1)) notes.append("System Max DC Voltage: %s V" % \ round(i.array.v_max(mintemp), 1)) if i.array.v_max(mintemp) > 600: logger.warning("WARNING: Array exceeds 600V DC") notes.append("Pnom Ratio: %s" % \ round((i.array.p_max/i.p_aco), 2)) if (i.array.v_dc(twopercent_temp) * .9) < i.mppt_low: logger.warning("WARNING: " \ "Array IV Knee drops out of Inverter range") if (i.array.p_max / i.p_aco) < 1.1: logger.warning("WARNING: Array potentially undersized") notes.append("") d_inverters.pop(i.model) if i.array.v_max(mintemp) > a_max: a_max = i.array.v_max(mintemp) notes.append("Array Azimuth: %s Degrees" % system.azimuth) notes.append("Array Tilt: %s Degrees" % system.tilt) sols_9 = system.solstice(9) sols_15 = system.solstice(15) notes.append("December 21 9:00 AM Sun Azimuth: %s Degrees" % \ (round(degrees(sols_9[1]), 1))) notes.append("December 21 9:00 AM Sun Altitude: %s Degrees" % \ (round(degrees(sols_9[0]), 1))) notes.append("December 21 3:00 PM Sun Azimuth: %s Degrees" % \ (round(degrees(sols_15[1]), 1))) notes.append("December 21 3:00 PM Sun Altitude: %s Degrees" % \ (round(degrees(sols_9[0]), 1))) if 'geomag' in sys.modules: notes.append("Magnetic declination: %s Degrees" % \ round(geomag.declination(dlat=system.place[0], \ dlon=system.place[1]))) notes.append("Minimum Row space ratio: %s" % \ round(system.min_row_space(1.0), 2)) if __name__ == '__main__': print "\n".join(notes) else: logger.info("Plant Details:\n" + "\n".join(notes)) print "" print "Minimum Bundle" min_c = vd.vd(a_ac, 5, verbose=False) try: ee.assemble(min_c, a_ac, conduit='STEEL') if run > 0: print "Long Run" min_c = vd.vd(a_ac, run, v=i.ac_voltage, t_amb=15, pf=.95, \ material='AL', verbose=False) ee.assemble(min_c, a_ac, conduit='PVC') except: print "Warning: Multiple sets of conductors" return notes
def bearing_true(self, lat, lon, alt=0, date=datetime.date.today()): #CB wmm = WorldMagneticModel() #CB declination = wmm.calc_mag_field(lat, lon, alt, date).declination declination = geomag.declination(lat, lon) #CB return self._bearing + declination
def get_declination(): owm = pyowm.OWM( '6a4296ddd0988dee8222522a8656542c') # You MUST provide a valid API key latitude = g.lat longitude = g.lng geolocator = Nominatim() location = geolocator.reverse((str(g.lat) + "," + str(g.lng))) print('HERE') new_location = str(location).split(',') print(new_location[3]) print('HERE') #y = str(location).split(",") #print(y) # need to fix this part country = "US" city = str(new_location[3]) cc = city + ',' + country # Have a pro subscription? Then use: # owm = pyowm.OWM(API_key='your-API-key', subscription_type='pro') # Search for current weather in ANYWHERE! observation = owm.weather_at_place(cc) #observation = owm.weather_at_place(cc) #observation = owm.weather_at_place('Seattle, US')) observation = owm.weather_at_place(cc) w = observation.get_weather() print(w) # Weather details #print(w.get_wind()) # {'speed': 4.6, 'deg': 330} #print(w.get_humidity()) # 87 #print(w.get_temperature('fahrenheit')) # {'temp_max': 10.5, 'temp': 9.7, 'temp_min': 9.0} print(w.get_wind()) # {'speed': 4.6, 'deg': 330} print(w.get_humidity()) # 87 print(w.get_temperature( 'fahrenheit')) # {'temp_max': 10.5, 'temp': 9.7, 'temp_min': 9.0} # Search current weather observations in the surroundings of # lat=22.57W, lon=43.12S (Rio de Janeiro, BR) observation_list = owm.weather_around_coords(latitude, longitude) print(type(observation_list)) #print(observation_list) #w = observation_list.get_weather() weather = Weather(Unit.CELSIUS) lookup = weather.lookup_by_latlng(latitude, longitude) condition = lookup.condition #print(condition.text) # magnetic declination, temp in celcius print(str(geomag.declination(latitude, longitude))) return str(city + '\r') + str(latitude) + str( longitude) + "Magnetic declination" + str( geomag.declination(latitude, longitude)) + str( w.get_temperature('fahrenheit')) + "Humidity: " + str( w.get_humidity()) + str( w.get_wind()) + str(' ') + str( condition.text) print(condition.text) # magnetic declination, temp in celcius print(str(geomag.declination(latitude, longitude))) return str(condition.text)
desc = arcpy.Describe(fc1) shapefieldname = desc.ShapeFieldName arcpy.AddMessage("Checking for Planning Point\n") try: cPlanPt =arcpy.GetCount_management(fc1) if int(cPlanPt.getOutput(0)) > 0: rows1 = arcpy.SearchCursor(fc1, '', unProjCoordSys) k = 0 declin = 0 for row1 in rows1: feat = row1.getValue(shapefieldname) pnt = feat.getPart() latitude = pnt.Y longitude = pnt.X declin = geomag.declination(latitude,longitude) + declin k+=1 del rows1 del row1 declin_avg = declin / k MagDeclinlination = round(declin_avg,2) if MagDeclinlination < 0: Cardinal ="W" else: Cardinal ="E" MagDecTxt = str(abs(MagDeclinlination)) + " " + Cardinal arcpy.AddMessage(MagDecTxt) try: cIncident=arcpy.GetCount_management("Incident_Information")
def get_mag_decl(): update_state() return geomag.declination(dlat=state['lat'], dlon=state['lon'], h=state['alt'])
def process_capture(meta, path, write_to_disk=False, guess=False, clockwise=True, macs=None): """ Process a captured data set :param meta: meta dict containing capture results :param write_to_disk: bool designating whether to write to disk :param guess: bool designating whether to return a table of guessed bearings for detected BSSIDs :param clockwise: direction antenna was moving during the capture, :param macs: list of macs to filter on :return: (_beacon_count, _results_path): """ module_logger.info("Processing capture (meta: {})".format(str(meta))) _beacon_count = 0 _beacon_failures = 0 # Correct bearing to compensate for magnetic declination #CB _declination = WorldMagneticModel()\ #CB .calc_mag_field(float(meta[meta_csv_fieldnames[6]]), #CB float(meta[meta_csv_fieldnames[7]]), #CB date=date.fromtimestamp(float(meta["start"])))\ #CB .declination lat = float(meta[meta_csv_fieldnames[6]]) # CB lon = float(meta[meta_csv_fieldnames[7]]) # CB start_date = date.fromtimestamp(float(meta["start"])) # CB alt = 0 _declination = geomag.declination(lat, lon, alt, start_date) # CB # Read results into a DataFrame # Build columns _default_columns = [ 'capture', 'pass', 'duration', 'hop-rate', 'timestamp', 'bssid', 'ssid', 'encryption', 'cipher', 'auth', 'ssi', 'channel', 'bearing_magnetic', 'bearing_true', 'lat', 'lon', 'alt', 'lat_err', 'lon_error', 'alt_error', ] _rows = [] _pcap = os.path.join(path, meta[meta_csv_fieldnames[16]]) # Build filter string _filter = 'wlan' #CB: 'wlan[0] == 0x80' # Override any provide mac filter list if we have one in the capture metadata if meta_csv_fieldnames[19] in meta and meta[meta_csv_fieldnames[19]]: macs = [meta[meta_csv_fieldnames[19]]] if macs: _mac_string = ' and (' _mac_strings = ['wlan.bssid == ' + mac for mac in macs] _mac_string += ' or '.join(_mac_strings) _mac_string += ')' _filter += _mac_string packets = pyshark.FileCapture(_pcap, display_filter=_filter, keep_packets=False, use_json=True) for packet in packets: try: # Get time, bssid & db from packet pbssid = packet.wlan.bssid ptime = parser.parse(packet.sniff_timestamp).timestamp() pssid = next((tag.ssid for tag in packet.wlan_mgt.tagged.all.tag if hasattr(tag, 'ssid')), None) pssi = int(packet.wlan_radio.signal_dbm) if hasattr( packet.wlan_radio, 'signal_dbm') else int( packet.radiotap.dbm_antsignal) pchannel = next((int(tag.current_channel) for tag in packet.wlan_mgt.tagged.all.tag if hasattr(tag, 'current_channel')), None) if not pchannel: pchannel = int(packet.wlan_radio.channel) if hasattr( packet.wlan_radio, 'channel') else int( packet.radiotap.channel.freq) # Determine AP security, if any https://ccie-or-null.net/2011/06/22/802-11-beacon-frames/ pencryption = None pcipher = None pauth = None _cipher_tree = None _auth_tree = None # Parse Security Details # Check for MS WPA tag _ms_wpa = next( (i for i, tag in enumerate(packet.wlan_mgt.tagged.all.tag) if hasattr(tag, 'wfa.ie.wpa.version')), None) if _ms_wpa is not None: pencryption = "WPA" if hasattr(packet.wlan_mgt.tagged.all.tag[_ms_wpa].wfa.ie.wpa, 'akms.list'): _auth_tree = packet.wlan_mgt.tagged.all.tag[ _ms_wpa].wfa.ie.wpa.akms.list.akms_tree if hasattr(packet.wlan_mgt.tagged.all.tag[_ms_wpa].wfa.ie.wpa, 'ucs.list'): _cipher_tree = packet.wlan_mgt.tagged.all.tag[ _ms_wpa].wfa.ie.wpa.ucs.list.ucs_tree # Check for RSN Tag _rsn = next( (i for i, tag in enumerate(packet.wlan_mgt.tagged.all.tag) if hasattr(tag, 'rsn')), None) if _rsn is not None: pencryption = "WPA" if hasattr(packet.wlan_mgt.tagged.all.tag[_rsn].rsn, 'akms.list') and _auth_tree is None: _auth_tree = packet.wlan_mgt.tagged.all.tag[ _rsn].rsn.akms.list.akms_tree if hasattr(packet.wlan_mgt.tagged.all.tag[_rsn].rsn, 'pcs.list') and _cipher_tree is None: _cipher_tree = packet.wlan_mgt.tagged.all.tag[ _rsn].rsn.pcs.list.pcs_tree # Parse _auth_tree if _auth_tree: try: _type = _auth_tree.type == '2' except AttributeError: _type = next( (_node.type for _node in _auth_tree if hasattr(_node, 'type') and (_node.type == '2' or _node.type == '3')), False) if _type == '3': pauth = "FT" elif _type == '2': pauth = "PSK" # Parse _cipher_tree if _cipher_tree: _types = [] try: _types.append(_cipher_tree.type) except AttributeError: _types += [ _node.type for _node in _cipher_tree if hasattr(_node, 'type') ] if _types: _types_str = [] for _type in _types: if _type == '4': _types_str.append("CCMP") elif _type == '2': _types_str.append("TKIP") pcipher = "+".join(_types_str) if not pencryption: # WEP pencryption = "WEP" if packet.wlan_mgt.fixed.all.capabilities_tree.has_field( "privacy" ) and packet.wlan_mgt.fixed.all.capabilities_tree.privacy == 1 else "Open" if pencryption == "WEP": pcipher = "WEP" except AttributeError as e: module_logger.warning("Failed to parse packet: {}".format(e)) _beacon_failures += 1 continue # Antenna correlation # Compute the timespan for the rotation, and use the relative packet time to determine # where in the rotation the packet was captured # This is necessary to have a smooth antenna rotation with microstepping total_time = float(meta["end"]) - float(meta["start"]) pdiff = ptime - float(meta["start"]) if pdiff <= 0: pdiff = 0 cw = 1 if clockwise else -1 pprogress = pdiff / total_time pbearing_magnetic = (cw * pprogress * float(meta["degrees"]) + float(meta["bearing"])) % 360 pbearing_true = (pbearing_magnetic + _declination) % 360 _rows.append([ meta[meta_csv_fieldnames[0]], meta[meta_csv_fieldnames[1]], meta[meta_csv_fieldnames[4]], meta[meta_csv_fieldnames[5]], ptime, str(pbssid), str(pssid), pencryption, pcipher, pauth, pssi, pchannel, pbearing_magnetic, pbearing_true, meta[meta_csv_fieldnames[6]], meta[meta_csv_fieldnames[7]], meta[meta_csv_fieldnames[8]], meta[meta_csv_fieldnames[9]], meta[meta_csv_fieldnames[10]], meta[meta_csv_fieldnames[11]], ]) _beacon_count += 1 _results_df = pd.DataFrame(_rows, columns=_default_columns) # Add mw column _results_df.loc[:, 'mw'] = dbm_to_mw(_results_df['ssi']) module_logger.info("Completed processing {} beacons ({} failures)".format( _beacon_count, _beacon_failures)) # If asked to guess, return list of bssids and a guess as to their bearing if guess: _columns = [ 'ssid', 'bssid', 'channel', 'security', 'strength', 'method', 'bearing' ] _rows = [] with futures.ProcessPoolExecutor() as executor: _guess_processes = {} for names, group in _results_df.groupby(['ssid', 'bssid']): _channel = group.groupby('channel').count()['capture'].idxmax() _encryption = pd.unique(group['encryption'])[0] # _cipher = pd.unique(group['cipher'])[0] # _auth = pd.unique(group['auth'])[0] _strength = group['ssi'].max() if not names[0]: names = ('<blank>', names[1]) _row = [names[0], names[1], _channel, _encryption, _strength] _guess_processes[executor.submit(locate.interpolate, group, int(meta['degrees']))] = _row for future in futures.as_completed(_guess_processes): _row = _guess_processes[future] _guess, _method = future.result() _rows.append(_row + [_method, _guess]) guess = pd.DataFrame(_rows, columns=_columns).sort_values('strength', ascending=False) # If a path is given, write the results to a file if write_to_disk: _results_path = os.path.join( path, time.strftime('%Y%m%d-%H-%M-%S') + "-results" + ".csv") _results_df.to_csv(_results_path, sep=',', index=False) module_logger.info("Wrote results to {}".format(_results_path)) write_to_disk = _results_path return _beacon_count, _results_df, write_to_disk, guess
def get_tru_heading(raw, lat, lon): return raw - geomag.declination(lat,lon)*ephem.degree
def parseAccelMag(mag, accel, lat, lon): """ Parse the accelerometer and magnetometer, calculating a heading. :param mag: The magetometer sensor object. :param accel: The accelerometer sensor object. :param lat: The current latitude, to use to calculate the magnetic declination. :param lon: The current longitude, to use to calculate the magnetic declination. """ # Set magnetometer offset magOffset = [14.699999999999996, 26.55, -5.324999999999999] # Get sensor data accels = accel.acceleration mags = mag.magnetic accx = accels[0] accy = accels[1] accz = accels[2] magx = mags[0] + magOffset[0] magy = mags[1] + magOffset[1] magz = mags[2] + magOffset[2] # Convert in terms of g g = 9.81 gx = accx / g gy = accy / g gz = accz / g # Calculate roll and pitch from accel data if abs(gx) > 1: gx = math.copysign(1, gx) pitch = math.asin(-gx) checkVal = gy / math.cos(pitch) if (abs(checkVal) <= 1.0): roll = math.asin(checkVal) else: roll = 0 # Calculate compass heading - compensate for tilt, require pitch, roll from accel magNorm = math.sqrt(magx**2 + magy**2 + magz**2) mxn = magx / magNorm myn = magy / magNorm mzn = magz / magNorm # Project onto x-y plane mx2 = (mxn * math.cos(pitch)) + (mzn * math.sin(pitch)) my2 = (mxn * math.sin(roll) * math.sin(pitch)) + (myn * math.cos(roll)) - ( mzn * math.sin(roll) * math.cos(pitch)) mz2 = (-mzn * math.cos(roll) * math.sin(pitch)) + ( myn * math.sin(roll)) + (mzn * math.cos(roll) * math.cos(pitch)) # Calc heading heading = 0 if (mx2 > 0 and my2 > 0): heading = math.atan(my2 / mx2) elif mx2 < 0: heading = math.pi + math.atan(my2 / mx2) elif (mx2 > 0 and my2 <= 0): heading = 2 * math.pi + math.atan(my2 / mx2) elif my2 < 0: # mx2 == 0 heading = math.pi / 2.0 elif my2 > 0: # mx2 == 0 heading = 3 * math.pi / 2.0 headingMagCompass = (-180.0 * heading / math.pi + 180.0) % 360 # Adjust for magnetic declination currDeclination = geomag.declination(lat, lon) headingMagTrue = (heading + currDeclination) % 360 # Convert pitch and roll to degs pitch = math.degrees(pitch) roll = math.degrees(roll) return accx, accy, accz, magx, magy, magz, pitch, roll, headingMagCompass, headingMagTrue
def compute_current_weather(self): ts = [] icaos = [] lats = [] lons = [] alts = [] temps = [] vgs = [] trks = [] vas = [] hdgs = [] magdev = [] update_acs = self.get_updated_aircraft() for icao, ac in list(update_acs.items()): # only last updated # ac = self.acs[icao] # print(ac['icao']) if ('tpos' not in ac) or ('tv' not in ac) or ('t60' not in ac) or \ ('t50' not in ac) or ('gs' not in ac): continue if (self.t - ac['tpos'] > 5) or (self.t - ac['t60'] > 5) or (self.t - ac['t50'] > 5) or \ (self.correction and ac['roll'] > 5): continue h = ac['alt'] * aero.ft vtas = ac['tas'] * aero.kts vias = ac['ias'] * aero.kts mach = ac['mach'] if h < 11000: p = 101325 * (1 + (-0.0065 * h) / 288.15)**(-9.81 / (-0.0065 * 287.05)) if h >= 11000: # up to 20000 m p = 22632 * np.exp(-(9.81 * (h - 11000) / (287.05 * 216.65))) if mach < 0.3: temp = vtas**2 * p / (vias**2 * aero.rho0 * aero.R) rho = p / (aero.R * temp) vtas2 = vias * np.sqrt(aero.rho0 / rho) else: temp = vtas**2 * aero.T0 / (mach**2 * aero.a0**2) vtas2 = mach * aero.a0 * np.sqrt(temp / aero.T0) va = vtas if ac['t50'] > ac['t60'] else vtas2 ts.append(ac['tpos']) icaos.append(icao) lats.append(ac['lat']) lons.append(ac['lon']) alts.append(ac['alt']) temps.append(temp) vgs.append(ac['gs'] * 0.5144) trks.append(np.radians(ac['trk'])) vas.append(va) hdgs.append(np.radians(ac['hdg'])) magdev.append(np.radians(ac['magdev'])) if GEO_MAG_SUPPORT: d_hdgs = [] for i, hdg in enumerate(hdgs): d_hdg = np.radians( geomag.declination(lats[i], lons[i], alts[i])) d_hdgs.append(d_hdg) hdgs = hdgs - np.array(d_hdgs) + magdev vgx = vgs * np.sin(trks) vgy = vgs * np.cos(trks) vax = vas * np.sin(hdgs) vay = vas * np.cos(hdgs) wx = vgx - vax wy = vgy - vay self.weather = OrderedDict() self.weather['ts'] = np.array(ts) self.weather['icao'] = np.array(icaos) self.weather['lat'] = np.array(lats) self.weather['lon'] = np.array(lons) self.weather['alt'] = np.array(alts) self.weather['wx'] = wx self.weather['wy'] = wy self.weather['temp'] = temps # very important to reset the buffer self.reset_updated_aircraft() # return the new weather dataframe df_weather = pd.DataFrame.from_dict(self.weather) return df_weather if df_weather.shape[0] > 0 else None
def updateMapLayout(): mxd, df = getDataframe() dfSpatial_Ref = df.spatialReference.name dfSpatial_Type = df.spatialReference.type # Get UTM and USNG Zones # Get declination from Incident Information fc1 = "Plan_Point" fc2 = "Incident_Information" fc3 = "Assets" cPlanPt = arcpy.GetCount_management(fc1) cBasePt = arcpy.GetCount_management(fc3) if int(cPlanPt.getOutput(0)) > 0: cPlanPt = cPlanPt intLyr = "1 Incident_Group\Planning Point" elif int(cBasePt.getOutput(0)) > 0: cPlanPt = cBasePt fc1 = fc3 intLyr = "2 Incident Assets\Assets" else: arcpy.AddError("Warning: Need to add Planning Point or ICP prior to updating map layout.\n") arcpy.AddError("Warning: Map Layout COULD NOT be updated.\n") sys.exit(0) desc = arcpy.Describe(fc1) unProjCoordSys = "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]" shapefieldname = desc.ShapeFieldName #First determine the grid north value fld_gNorth = "gNORTH" field_type = "FLOAT" gNorth_Check(fc1, fld_gNorth, field_type) if fc1 == "Assets": where0 = '"Asset_Type" = 1' else: where0 = "" rows0 = arcpy.SearchCursor(fc1, where0, unProjCoordSys) k = 0.0 gridNorth = 0.0 for row0 in rows0: gridN = row0.getValue(fld_gNorth) arcpy.AddMessage('Grid North: {0}'.format(gridN)) gridNorth += float(gridN) k+=1.0 del row0 del rows0 del k rows1 = arcpy.SearchCursor(fc1, where0, unProjCoordSys) k = 0 declin = 0.0 for row1 in rows1: feat = row1.getValue(shapefieldname) pnt = feat.getPart() latitude = pnt.Y longitude = pnt.X declin = geomag.declination(latitude,longitude) + declin k+=1 del rows1 del row1 gridN = round((gridNorth / k),2) if gridN > 0: gCard ="W" else: gCard ="E" gNorthTxt = str(abs(gridN)) + " " + gCard # Rotate data frame to adjust map layout for True North vs Grid North. # Grid North is parallel with the edge of the page. The "True North" arrow # should be rotated to TRUE NORTH. try: df.rotation = 0.0 if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "gNorth"): gridNorth=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "gNorth")[0] gridNorth.text = gNorthTxt # Remove field dropField=[fld_gNorth] arcpy.DeleteField_management(fc1, dropField) except: pass declin_avg = declin / k MagDeclinlination = round(declin_avg,2) if MagDeclinlination < 0: Cardinal ="W" bearingTuple=('ADD','SUBTRACT') else: Cardinal ="E" bearingTuple=('SUBTRACT','ADD') MagDecTxt = str(abs(MagDeclinlination)) + " " + Cardinal ## try: #Update Incident Name and Number with the file name and dataframe name IncName = df.name IncNumA = mxd.filePath.split("\\") IncNum=IncNumA[-1].strip(".mxd") arcpy.AddMessage("\nThe Incident Name is " + IncName) arcpy.AddMessage("The Incident Number is: " + IncNum + "\n") if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "MapName"): MapName=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "MapName")[0] MapName.text = " " if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "PlanNum"): PlanNum=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "PlanNum")[0] PlanNum.text = " " if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "AssignNum"): AssignNum=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "AssignNum")[0] AssignNum.text = " " fld2 = "Incident_Name" fld3 = "Incident_Number" cursor = arcpy.UpdateCursor(fc2) for row in cursor: incidName=row.getValue(fld2) if incidName != IncName: row.setValue(fld2, IncName) row.setValue(fld3, IncNum) cursor.updateRow(row) del incidName del cursor, row del IncName, IncNum, fld2, fld3 ## except: ## arcpy.AddMessage("Error: Update Incident Name and Number manually\n") arcpy.AddMessage("The Coordinate System for the dataframe is: " + dfSpatial_Type) arcpy.AddMessage("The Datum for the dataframe is: " + dfSpatial_Ref) if dfSpatial_Type=='Projected': arcpy.AddMessage("Be sure to turn on USNG Grid in Data Frame Properties.\n") arcpy.AddMessage("Updating UTM and USNG grid info on map layout") ## try: for llyr in arcpy.mapping.ListLayers(mxd, "*",df): if str(llyr.name) == "MRGS_UTM_USNG": mapLyr=arcpy.mapping.ListLayers(mxd, "MRGS_UTM_USNG",df)[0] elif str(llyr.name) == "MRGSZones_World": mapLyr=arcpy.mapping.ListLayers(mxd, "MGRSZones_World",df)[0] arcpy.SelectLayerByLocation_management(mapLyr,"INTERSECT", intLyr) #"1 Incident_Group\Planning Point") cursor=arcpy.SearchCursor(mapLyr) for row in cursor: if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "UTMZone"): UTMZn=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "UTMZone")[0] UTMZn.text = row.getValue("GRID1MIL") UTMzone = str(UTMZn.text) else: UTMzone = "" if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "USNGZone"): USNGZn=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "USNGZone")[0] USNGZn.text = row.getValue("GRID100K") USNGzone = str(USNGZn.text) else: USNGzone ="" arcpy.AddMessage("UTM Zone is {0} and USNG Grid is {1}".format(UTMzone,USNGzone)) del cursor try: del row except: pass del mapLyr ## except: ## arcpy.AddMessage("Error: Update USNG Grid and UTM Zone text fields on map layout manually\n") arcpy.AddMessage("Grid North correction to True North based on location of IPP or ICP is: {0}".format(gNorthTxt)) try: cIncident=arcpy.GetCount_management("Incident_Information") # Get list of fields in Incident Information fieldList = arcpy.ListFields(fc2) field=[] for fld in fieldList: field.append(fld.name.encode('ascii','ignore')) fld_gNorth = "gNORTH" fldType = "STRING" checkFields(fc2, fld_gNorth, fldType) fld_MagDec = "MagDec" fldType = "STRING" checkFields(fc2, fld_MagDec, fldType) if int(cIncident.getOutput(0)) > 0: cursor = arcpy.UpdateCursor(fc2) for row in cursor: row.setValue(fld_MagDec, MagDecTxt) row.setValue(fld_gNorth, gNorthTxt) cursor.updateRow(row) if arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "MagDecl"): MagDeclin=arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "MagDecl")[0] MagDeclin.text = MagDecTxt arcpy.AddMessage("Magnetic Declination is {0}\n".format(MagDeclin.text)) del MagDeclin del cursor, row else: arcpy.AddWarning("No Incident Information provided\n") try: if arcpy.mapping.ListLayoutElements(mxd,"TEXT_ELEMENT","bearingConv"): bearingConv=arcpy.mapping.ListLayoutElements(mxd,"TEXT_ELEMENT","bearingConv")[0] bcText=bearingConv.text # Even though the templates have %s in them, we may have # clobbered them in a previous run. So put 'em back. bcText=bcText.replace('ADD','%s') bcText=bcText.replace('SUBTRACT','%s') bearingConv.text= bcText % bearingTuple del bearingConv except: arcpy.AddMessage("Failed to update bearing conversion text.") except: arcpy.AddMessage("Error: Update Magnetic Declination Manually\n") try: fld2 = "MapDatum" fld3 = "MapCoord" cursor = arcpy.UpdateCursor(fc2) for row in cursor: row.setValue(fld2, dfSpatial_Ref) ## row.setValue(fld3, dfSpatial_Type) if "UTM_ZONE" in field: row.setValue("UTM_ZONE", UTMZn.text) if "USNG_GRID" in field: row.setValue("USNG_GRID", USNGZn.text) cursor.updateRow(row) del cursor, row except: arcpy.AddMessage("Error: Update Map Datum and Map Coordinates (Projected/Geogrpahic) Manually\n") try: del UTMZn del USNGZn except: pass del mxd del df, dfSpatial_Ref, dfSpatial_Type return
def test_timedistance_v0(dlat, dlng, alt, date, dec): assert round(declination(dlat, dlng, alt, date), 2) == dec
def refresh(self): global recievedTime, losLog, bearingLog, elevationLog if (useRFD): self.updateIncoming(0, 0, rfdTime) self.updateIncoming(0, 1, rfdLat) self.updateIncoming(0, 2, rfdLon) self.updateIncoming(0, 3, round(rfdAlt, 2)) self.updateIncoming(0, 4, round(rfdEle, 2)) self.updateIncoming(0, 5, round(rfdBear, 2)) self.updateIncoming(0, 6, round(rfdLOS, 2)) self.updateIncoming( 0, 7, round( float( geomag.declination(dlat=rfdLat, dlon=rfdLon, h=rfdAlt))), 2) else: #Incoming Data Table self.updateIncoming(0, 0, iridiumTime) self.updateIncoming(0, 1, iridiumLat) self.updateIncoming(0, 2, iridiumLon) self.updateIncoming(0, 3, round(iridiumAlt, 2)) self.updateIncoming(0, 4, round(iridiumEle, 2)) self.updateIncoming(0, 5, round(iridiumBear, 2)) self.updateIncoming(0, 6, round(iridiumLOS, 2)) self.updateIncoming( 0, 7, round( geomag.declination(dlat=iridiumLat, dlon=iridiumLon, h=iridiumAlt), 2)) #Ground Station Data Table (unlikely to change but what the heck) self.updateGround(0, 0, groundLat) self.updateGround(0, 1, groundLon) self.updateGround(0, 2, groundAlt) self.updateGround(0, 3, centerBear) #Antenna current "intended" position self.updateGround(0, 4, trackBearOffset) self.updateGround(0, 5, trackTiltOffset) self.updateGround(0, 6, antennaBear) self.updateGround(0, 7, antennaEle) if settingsUpdated: testarray = np.array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 ]) testdata = np.array([ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7 ]) if len(receivedAlt) > 0: # create an axis ALTPLOT = self.figure.add_subplot(221) LOSPLOT = self.figure.add_subplot(222) ELEPLOT = self.figure.add_subplot(223) BEARPLOT = self.figure.add_subplot(224) # discards the old graph ALTPLOT.hold(False) LOSPLOT.hold(False) ELEPLOT.hold(False) BEARPLOT.hold(False) # plot data ALTPLOT.plot(receivedTime - receivedTime[0], receivedAlt, 'r-') ALTPLOT.set_ylabel('Altitude (ft)') LOSPLOT.plot(receivedTime - receivedTime[0], losLog, 'g-') LOSPLOT.set_ylabel('Line-of-Sight (km)') ELEPLOT.plot(receivedTime - receivedTime[0], elevationLog, 'b-') ELEPLOT.set_ylabel('Elevation Angle') BEARPLOT.plot(receivedTime - receivedTime[0], bearingLog, 'y-') BEARPLOT.set_ylabel('Bearing Angle') # refresh canvas self.canvas.draw()
def updateMapLayout(aprx, df, lyt, mf): fc1 = "Planning_Points" fc2 = "Incident_Info" fc3 = "AssetPts" IncidPP = path.join(wrkspc, fc1) desc = arcpy.Describe(IncidPP) dfSpatial_Ref = desc.spatialReference.name dfSpatial_Type = desc.spatialReference.type # Get UTM and USNG Zones # Get declination from Incident Information cPlanPt = arcpy.GetCount_management(fc1) cBasePt = arcpy.GetCount_management(fc3) if int(cPlanPt.getOutput(0)) > 0: cPlanPt = cPlanPt intLyr = "Incident\Planning_Points" elif int(cBasePt.getOutput(0)) > 0: cPlanPt = cBasePt fc1 = fc3 intLyr = "Assets\Assets" else: arcpy.AddError( "Warning: Need to add Planning Point or ICP prior to updating map layout.\n" ) arcpy.AddError("Warning: Map Layout COULD NOT be updated.\n") sys.exit(0) unProjCoordSys = "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]" shapefieldname = desc.ShapeFieldName # Determine grid North (if applicable) and declination fld_gNorth = "gNORTH" field_type = "FLOAT" if fc1 == "Assets": where0 = '"Asset_Type" = 1' else: where0 = "" if dfSpatial_Type == "Projected": cMeridian = desc.spatialReference.centralmeridian gridConv = [] deClinat = [] for row in arcpy.da.SearchCursor(fc1, ["SHAPE@XY"], where0, unProjCoordSys): x, y = row[0] if dfSpatial_Type == "Projected": gridConv.append(atan(tan(x - cMeridian) + sin(y))) else: gridConv.append(0.0) deClinat.append(declination(y, x)) # Grid North determination gridNorth = mean(gridConv) gridN = round(gridNorth, 2) if gridN > 0: gCard = "W" else: gCard = "E" gNorthTxt = str(abs(gridN)) + " " + gCard arcpy.AddMessage('Grid North: {0}'.format(gNorthTxt)) # Magnetic Declination declin = mean(deClinat) MagDeclinlination = round(declin, 2) if MagDeclinlination < 0: Cardinal = "W" else: Cardinal = "E" MagDecTxt = str(abs(MagDeclinlination)) + " " + Cardinal # Rotate data frame to adjust map layout for True North vs Grid North. # Grid North is parallel with the edge of the page. The "True North" arrow # should be rotated to TRUE NORTH. # Rotate the map by grid north - or do I need to rotate to -gridN? mf.camera.heading = gridN try: if lyt.listElements('TEXT_ELEMENT', 'MagDec'): magNorth = lyt.listElements('TEXT_ELEMENT', 'MagDec')[0] magNorth.text = MagDecTxt if lyt.listElements('TEXT_ELEMENT', 'gNorth'): gNorth = lyt.listElements('TEXT_ELEMENT', 'gNorth')[0] gNorth.text = gNorthTxt except: pass ## try: #Update Incident Name and Number with the file name and dataframe name IncidName = " " IncNum = " " flds = ['IncidName', 'IncidNum'] with arcpy.da.SearchCursor(fc2, flds) as cursor: for row in cursor: IncidName = row[0] IncNum = row[1] arcpy.AddMessage("\nThe Incident Name is " + IncidName) arcpy.AddMessage("The Incident Number is: " + IncNum + "\n") if lyt.listElements("TEXT_ELEMENT", "MapTitle"): MapTitle = lyt.listElements("TEXT_ELEMENT", "MapTitle")[0] MapTitle.text = " " if lyt.listElements("TEXT_ELEMENT", "RefNum"): RefNum = lyt.listElements("TEXT_ELEMENT", "RefNum")[0] RefNum.text = " " del cursor, row del IncidName, IncNum, flds ## except: ## arcpy.AddMessage("Error: Update Incident Name and Number manually\n") arcpy.AddMessage( "Grid North correction to True North based on location of IPP or ICP is: {0}" .format(gNorthTxt)) # try: cIncident = arcpy.GetCount_management(fc2) # Get list of fields in Incident Information fieldList = arcpy.ListFields(fc2) field = [] for fld in fieldList: field.append(fld.name.encode('ascii', 'ignore')) fld2 = "MapDatum" fld3 = "MapCoord" incdFlds = ["MagDec", "gNorth", "UTM_ZONE", "USNG_GRID", "MapDatum"] #,fld2, fld3] if int(cIncident.getOutput(0)) > 0: with arcpy.da.UpdateCursor(fc2, incdFlds) as cursor: for row in cursor: row[0] = MagDecTxt row[1] = gNorthTxt # row[2]=UTMZn.text # row[3]=USNGZn.text # row[4]=dfSpatial_Ref cursor.updateRow(row) del cursor, row else: arcpy.AddWarning("No Incident Information provided\n") # except: # arcpy.AddMessage("Error: Update Magnetic Declination Manually\n") return
def string_notes(system, run=0.0, station_class=3): """page 5""" name, usaf = geo.closest_usaf(geo.zip_coordinates(system.zipcode), \ station_class) mintemp = eere.minimum(usaf) twopercent_temp = eere.twopercent(usaf) ac_kva_rated = 0.0 dc_rated = 0.0 ac_kw = 0.0 for i in system.shape: dc_rated += i.array.p_max try: if i.phase == 1: ac_kva_rated += i.current * i.ac_voltage else: ac_kva_rated += i.phase * i.current * i.ac_voltage / 3**.5 except Exception: ac_kva_rated += i.p_aco ac_kw += i.p_aco notes = [] notes.append("%s KVA AC RATED" % round(ac_kva_rated/1000.0, 2)) notes.append("%s KW AC RATED" % round(ac_kw/1000.0, 2)) notes.append("%s KW DC RATED" % round(dc_rated/1000.0, 2)) #BUG: This doesn't work for unbalanced 3 phase if system.phase == 1: a_ac = round(ac_kva_rated/i.ac_voltage, 1) else: a_ac = round(ac_kva_rated/i.ac_voltage/3**.5, 1) notes.append("System AC Output Current: %s A" % a_ac) notes.append("Nominal AC Voltage: %s V" % i.ac_voltage) notes.append("") notes.append("Minimum Temperature: %s C" % mintemp) notes.append("2 Percent Max Temperature: %s C" % twopercent_temp) notes.append("Weather Source: %s %s" % (name, usaf)) notes.append("") d_inverters, d_panels = system.describe() a_max = 0 for i in system.shape: module_name = i.array.dump()['panel'] if d_panels.has_key(module_name): module = modules.Module(module_name) notes.append("PV Module Ratings @ STC") notes.append("Module Make: %s" % module.make) notes.append("Module Model: %s" % module.model) notes.append("Quantity: %s" % d_panels[module_name]) notes.append("Max Power-Point Current (Imp): %s A" % module.i_mpp) notes.append("Max Power-Point Voltage (Vmp): %s V" % module.v_mpp) notes.append("Open-Circuit Voltage (Voc): %s V" % module.v_oc) notes.append("Short-Circuit Current (Isc): %s A" % module.i_sc) notes.append("Maximum Power (Pmax): %s W" % round(module.p_max, 1)) notes.append("") d_panels.pop(module_name) if d_inverters.has_key(i.model): notes.append("Inverter Make: %s" % i.make) notes.append("Inverter Model: %s" % i.model) notes.append("Quantity: %s" % d_inverters[i.model]) notes.append("Max Power: %s KW" % round(i.p_aco/1000.0, 1)) #this is hack... This should be calculated based upon power cores if hasattr(i, 'current'): notes.append("Max AC Current: %s A" % round(i.current, 1)) elif i.ac_voltage == 480: notes.append("Max AC Current: %s A" % \ round(i.p_aco*1.0/i.ac_voltage/3**.5, 1)) else: notes.append("Max AC Current: %s A" % \ round(i.p_aco*1.0/i.ac_voltage, 1)) #greater than 1 in parallel if i.array.mcount() > 1: notes.append("DC Operating Current: %s A" % \ round(i.array.i_mpp(), 1)) notes.append("DC Short Circuit Current: %s A" % \ round(i.array.i_sc(), 1)) #greater than 1 in series if i.array.mcount() > 1: notes.append("DC Operating Voltage: %s V" % \ round(i.array.v_dc(), 1)) notes.append("System Max DC Voltage: %s V" % \ round(i.array.v_max(mintemp), 1)) if i.array.v_max(mintemp) > 600: logger.warning("WARNING: Array exceeds 600V DC") notes.append("Pnom Ratio: %s" % \ round((i.array.p_max/i.p_aco), 2)) if (i.array.v_dc(twopercent_temp) * .9) < i.mppt_low: logger.warning("WARNING: " \ "Array IV Knee drops out of Inverter range") if (i.array.p_max/i.p_aco) < 1.1: logger.warning("WARNING: Array potentially undersized") notes.append("") d_inverters.pop(i.model) if i.array.v_max(mintemp) > a_max: a_max = i.array.v_max(mintemp) notes.append("Array Azimuth: %s Degrees" % system.azimuth) notes.append("Array Tilt: %s Degrees" % system.tilt) sols_9 = system.solstice(9) sols_15 = system.solstice(15) notes.append("December 21 9:00 AM Sun Azimuth: %s Degrees" % \ (round(degrees(sols_9[1]), 1))) notes.append("December 21 9:00 AM Sun Altitude: %s Degrees" % \ (round(degrees(sols_9[0]), 1))) notes.append("December 21 3:00 PM Sun Azimuth: %s Degrees" % \ (round(degrees(sols_15[1]), 1))) notes.append("December 21 3:00 PM Sun Altitude: %s Degrees" % \ (round(degrees(sols_9[0]), 1))) if 'geomag' in sys.modules: notes.append("Magnetic declination: %s Degrees" % \ round(geomag.declination(dlat=system.place[0], \ dlon=system.place[1]))) notes.append("Minimum Row space ratio: %s" % \ round(system.min_row_space(1.0), 2)) if __name__ == '__main__': print "\n".join(notes) else: logger.info("Plant Details:\n" + "\n".join(notes)) print "" print "Minimum Bundle" min_c = vd.vd(a_ac, 5, verbose=False) try: ee.assemble(min_c, a_ac, conduit='STEEL') if run > 0: print "Long Run" min_c = vd.vd(a_ac, run, v=i.ac_voltage, t_amb=15, pf=.95, \ material='AL', verbose=False) ee.assemble(min_c, a_ac, conduit='PVC') except: print "Warning: Multiple sets of conductors" return notes
def getMagneticDeclination(geometry, feature, parent): geom_pt = geometry.asPoint() return geomag.declination(geom_pt.y(), geom_pt.x())