def getPlanetsForDatetimeAndTimezone(dt, locTuple): """Returns a string with the planet longitude position for the given datetime and timezone. """ locName = locTuple[0] locLongitude = locTuple[1] locLatitude = locTuple[2] locElevation = locTuple[3] # Set the Location (required). Ephemeris.setGeographicPosition(locLongitude, locLatitude, locElevation) longitudeType = "tropical" fieldName = "longitude" rv = "For datetime: " + Ephemeris.datetimeToDayStr(dt) + \ ", location: " + locName + endl for planetName in geocentricPlanetNames: pi = Ephemeris.getPlanetaryInfo(planetName, dt) longitude = pi.geocentric[longitudeType][fieldName] # Format differently for lunation phase of G.MoSu. if planetName == "MoSu": rv += " {: <14}".format("G." + planetName + ": ") + \ "{:>.3f}".format(longitude) + \ " Phase (of max 30): {:.2f}".format(longitude / 12.0) + \ endl else: rv += " {: <14}".format("G." + planetName + ": ") + \ "{:>.3f}".format(longitude) + \ endl rv += endl for planetName in heliocentricPlanetNames: pi = Ephemeris.getPlanetaryInfo(planetName, dt) rv += " {: <14}".format("H." + planetName + ": ") + \ "{:>.3f}".format(pi.heliocentric[longitudeType][fieldName]) + \ endl return rv
def getFieldValue(dt, planetParams, fieldName): """Creates the PlanetaryInfo object for the given planetParamsList and returns the value of the field desired. """ log.debug("planetParams passed in is: {}".\ format(planetParams)) t = planetParams planetName = t[0] centricityType = t[1] longitudeType = t[2] pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Planet {} has geo sid longitude: {}".\ format(planetName, pi.geocentric["sidereal"]["longitude"])) fieldValue = None if centricityType.lower() == "geocentric": fieldValue = pi.geocentric[longitudeType][fieldName] elif centricityType.lower() == "topocentric": fieldValue = pi.topocentric[longitudeType][fieldName] elif centricityType.lower() == "heliocentric": fieldValue = pi.heliocentric[longitudeType][fieldName] else: log.error("Unknown centricity type: {}".\ format(centricityType)) fieldValue = None return fieldValue
def getFieldValue(dt, planetParams, fieldName): """Creates the PlanetaryInfo object for the given planetParamsList and returns the value of the field desired. """ log.debug("planetParams passed in is: {}".\ format(planetParams)) t = planetParams planetName = t[0] centricityType = t[1] longitudeType = t[2] pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Planet {} has geo sid longitude: {}".\ format(planetName, pi.geocentric["sidereal"]["longitude"])) fieldValue = None if centricityType.lower() == "geocentric": fieldValue = pi.geocentric[longitudeType][fieldName] elif centricityType.lower() == "topocentric": fieldValue = pi.topocentric[longitudeType][fieldName] elif centricityType.lower() == "heliocentric": fieldValue = pi.heliocentric[longitudeType][fieldName] else: log.error("Unknown centricity type: {}".\ format(centricityType)) fieldValue = None return fieldValue
def getFieldValue(dt, planetParamsList, fieldName): """Creates the PlanetaryInfo object for the given planetParamsList and returns the value of the field desired. """ log.debug("planetParamsList passed in is: {}".\ format(planetParamsList)) unAveragedFieldValues = [] for t in planetParamsList: planetName = t[0] centricityType = t[1] longitudeType = t[2] pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Planet {} has geo sid longitude: {}".\ format(planetName, pi.geocentric["sidereal"]["longitude"])) fieldValue = None if centricityType.lower() == "geocentric": fieldValue = pi.geocentric[longitudeType][fieldName] elif centricityType.lower() == "topocentric": fieldValue = pi.topocentric[longitudeType][fieldName] elif centricityType.lower() == "heliocentric": fieldValue = pi.heliocentric[longitudeType][fieldName] else: log.error("Unknown centricity type: {}".\ format(centricityType)) fieldValue = None unAveragedFieldValues.append(fieldValue) log.debug("unAveragedFieldValues is: {}".\ format(unAveragedFieldValues)) # Average the field values. total = 0.0 for v in unAveragedFieldValues: total += v averagedFieldValue = total / len(unAveragedFieldValues) log.debug("averagedFieldValue is: {}".\ format(averagedFieldValue)) return averagedFieldValue
def getFieldValue(dt, planetParamsList, fieldName): """Creates the PlanetaryInfo object for the given planetParamsList and returns the value of the field desired. """ log.debug("planetParamsList passed in is: {}".\ format(planetParamsList)) unAveragedFieldValues = [] for t in planetParamsList: planetName = t[0] centricityType = t[1] longitudeType = t[2] pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Planet {} has geo sid longitude: {}".\ format(planetName, pi.geocentric["sidereal"]["longitude"])) fieldValue = None if centricityType.lower() == "geocentric": fieldValue = pi.geocentric[longitudeType][fieldName] elif centricityType.lower() == "topocentric": fieldValue = pi.topocentric[longitudeType][fieldName] elif centricityType.lower() == "heliocentric": fieldValue = pi.heliocentric[longitudeType][fieldName] else: log.error("Unknown centricity type: {}".\ format(centricityType)) fieldValue = None unAveragedFieldValues.append(fieldValue) log.debug("unAveragedFieldValues is: {}".\ format(unAveragedFieldValues)) # Average the field values. total = 0.0 for v in unAveragedFieldValues: total += v averagedFieldValue = total / len(unAveragedFieldValues) log.debug("averagedFieldValue is: {}".\ format(averagedFieldValue)) return averagedFieldValue
def getGeocentricPlanetDirectRetrogradeInfo(planetName): """ Returns a list of tuples, each tuple containing: (planetName, julianDay, datetime, "R" or "D", geoTropLongitudeOfPlanet, geoSidLongitudeOfPlanet) """ # Return value. rv = [] prevDt = None currDt = copy.deepcopy(startDt) prevTropLongitudeSpeed = None currTropLongitudeSpeed = None currTropLongitude = None currSidLongitude = None while currDt <= endDt: dt = currDt pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Just obtained planetaryInfo for planet '{}', timestamp: {}".\ format(planetName, Ephemeris.datetimeToStr(dt))) # Get the geocentric longitude and geocentric longitude speed. tropLongitudeSpeed = pi.geocentric['tropical']['longitude_speed'] tropLongitude = pi.geocentric['tropical']['longitude'] sidLongitude = pi.geocentric['sidereal']['longitude'] # Store new current planet values. currTropLongitudeSpeed = tropLongitudeSpeed currTropLongitude = tropLongitude currSidLongitude = sidLongitude log.debug("prevTropLongitudeSpeed={}, currTropLongitudeSpeed={}".\ format(prevTropLongitudeSpeed, currTropLongitudeSpeed)) # We need two data points to proceed. if prevTropLongitudeSpeed != None and \ currTropLongitudeSpeed != None and \ prevDt != None: # Check to see if we passed over 0 degrees. if prevTropLongitudeSpeed < 0.0 and currTropLongitudeSpeed >= 0.0: # Crossed over from negative to positive! log.debug("Crossed over from negative to positive!") # This is the upper-bound of the error timedelta. t1 = prevDt t2 = currDt currErrorTd = t2 - t1 # Refine the timestamp until it is less than the # desired threshold. while currErrorTd > maxErrorTd: log.debug("Refining between {} and {}".\ format(Ephemeris.datetimeToStr(t1), Ephemeris.datetimeToStr(t2))) # Check the timestamp between. diffTd = t2 - t1 halfDiffTd = \ datetime.\ timedelta(days=(diffTd.days / 2.0), seconds=(diffTd.seconds / 2.0), microseconds=(diffTd.microseconds / 2.0)) testDt = t1 + halfDiffTd pi = Ephemeris.getPlanetaryInfo(planetName, testDt) testTropLongitudeSpeed = \ pi.geocentric['tropical']['longitude_speed'] testTropLongitude = pi.geocentric['tropical']['longitude'] testSidLongitude = pi.geocentric['sidereal']['longitude'] if testTropLongitudeSpeed >= 0.0: t2 = testDt # Update the curr values as the later boundary. currDt = t2 currTropLongitudeSpeed = testTropLongitudeSpeed currTropLongitude = testTropLongitude currSidLongitude = testSidLongitude else: t1 = testDt currErrorTd = t2 - t1 # Broke out of while loop, meaning we have a timestamp # within our threshold. # Create a tuple to add to our list. tup = (planetName, Ephemeris.datetimeToJulianDay(currDt), currDt, directStr, currTropLongitude, currSidLongitude) # Append to the list. rv.append(tup) elif prevTropLongitudeSpeed > 0.0 and currTropLongitudeSpeed <= 0.0: # Crossed over from positive to negative! log.debug("Crossed over from positive to negative!") # This is the upper-bound of the error timedelta. t1 = prevDt t2 = currDt currErrorTd = t2 - t1 # Refine the timestamp until it is less than the # desired threshold. while currErrorTd > maxErrorTd: log.debug("Refining between {} and {}".\ format(Ephemeris.datetimeToStr(t1), Ephemeris.datetimeToStr(t2))) # Check the timestamp between. diffTd = t2 - t1 halfDiffTd = \ datetime.\ timedelta(days=(diffTd.days / 2.0), seconds=(diffTd.seconds / 2.0), microseconds=(diffTd.microseconds / 2.0)) testDt = t1 + halfDiffTd pi = Ephemeris.getPlanetaryInfo(planetName, testDt) testTropLongitudeSpeed = \ pi.geocentric['tropical']['longitude_speed'] testTropLongitude = pi.geocentric['tropical']['longitude'] testSidLongitude = pi.geocentric['sidereal']['longitude'] if testTropLongitudeSpeed <= 0.0: t2 = testDt # Update the curr values as the later boundary. currDt = t2 currTropLongitudeSpeed = testTropLongitudeSpeed currTropLongitude = testTropLongitude currSidLongitude = testSidLongitude else: t1 = testDt currErrorTd = t2 - t1 # Broke out of while loop, meaning we have a timestamp # within our threshold. # Create a tuple to add to our list. tup = (planetName, Ephemeris.datetimeToJulianDay(currDt), currDt, retrogradeStr, currTropLongitude, currSidLongitude) # Append to the list. rv.append(tup) # Increment currDt timestamp. prevDt = currDt currDt = currDt + stepSizeTd # Move the previous currTropLongitudeSpeed to prevTropLongitudeSpeed. prevTropLongitudeSpeed = currTropLongitudeSpeed currTropLongitudeSpeed = None currTropLongitude = None currSidLongitude = None log.debug("prevTropLongitudeSpeed={}, currTropLongitudeSpeed={}".\ format(prevTropLongitudeSpeed, currTropLongitudeSpeed)) return rv
currDt = startDt prevDt = None while currDt < endDt: # See if this is a new month. if prevDt == None or prevDt.month != currDt.month: log.info("Processing: {} {}".\ format(Util.monthNumberToAbbrev(currDt.month), currDt.year)) # Add the text for a new table. text += getTableHeaderText(currDt) planetaryInfosDict = {} for planetName in planetNames: pi = Ephemeris.getPlanetaryInfo(planetName, currDt) planetaryInfosDict[planetName] = pi dateStr = formatToDateStr(currDt) # Add text for a row in the table. text += convertPlanetaryInfosToLine(dateStr, planetaryInfosDict) # Prepare currDt for the next iteration. prevDt = currDt currDt = copy.deepcopy(currDt) + datetime.timedelta(days=1) currDt = currDt.replace(hour=hourOfDay, minute=minuteOfHour) if prevDt.month != currDt.month: # Month passed. Close the table. text += getTableFooterText()
# - planetName1TropicalLongitude_ZodiacSignFormat # - planetName2TropicalLongitude_ZodiacSignFormat # - planetName1TropicalLongitudeLongitudeSpeed # - planetName2TropicalLongitudeLongitudeSpeed # - planetName1SiderealLongitude_Degrees # - planetName2SiderealLongitude_Degrees # - planetName1SiderealLongitude_ZodiacSignFormat # - planetName2SiderealLongitude_ZodiacSignFormat # - planetName1SiderealLongitudeLongitudeSpeed # - planetName2SiderealLongitudeLongitudeSpeed resultList = [] # Create a tuple for each timestamp that was found # that was a conjunction. for dt in conjunctionTimestamps: pi1 = Ephemeris.getPlanetaryInfo(planetName1, dt) pi2 = Ephemeris.getPlanetaryInfo(planetName2, dt) tup = (comboPlanetName, Ephemeris.datetimeToJulianDay(dt), dt, desiredAspectDegree, pi1.heliocentric["tropical"]["longitude"], pi2.heliocentric["tropical"]["longitude"], pi1.heliocentric["tropical"]["longitude_speed"], pi2.heliocentric["tropical"]["longitude_speed"], pi1.heliocentric["sidereal"]["longitude"], pi2.heliocentric["sidereal"]["longitude"], pi1.heliocentric["sidereal"]["longitude_speed"], pi2.heliocentric["sidereal"]["longitude_speed"])
def getLongitudeDiffBetweenDatetimes(planetName, centricityType, dt1, loc1Tuple, dt2, loc2Tuple): startTimestamp = dt1 endTimestamp = dt2 loc1Name = loc1Tuple[0] loc1Longitude = loc1Tuple[1] loc1Latitude = loc1Tuple[2] loc1Elevation = loc1Tuple[3] loc2Name = loc2Tuple[0] loc2Longitude = loc2Tuple[1] loc2Latitude = loc2Tuple[2] loc2Elevation = loc2Tuple[3] # maxErrorTd - datetime.timedelta object holding the maximum # time difference between the exact planetary # timestamp for the phenomena, and the one # calculated. This would define the accuracy of # the calculations. # maxErrorTd = datetime.timedelta(seconds=4) # Size of a circle, in degrees. # # Here we define our own value instead of using the value in # AstrologyUtils.degreesInCircle because it is possible we may # want to test different sizes of a 'circle'. circleSizeInDegrees = 360.0 # All references to longitude_speed need to # be from tropical zodiac measurements! If I use # sidereal zodiac measurements for getting the # longitude_speed, then the measurements from the # Swiss Ephemeris do not yield the correct values. # I use the following variable in these locations. zodiacTypeForLongitudeSpeed = "tropical" tropicalZodiacFlag = True # Text to set in the text item. text = "" # Total number of degrees elapsed. totalDegrees = 0 Ephemeris.setGeographicPosition(loc1Longitude, loc1Latitude, loc1Elevation) # List of PlanetaryInfo objects for this particular # planet, sorted by timestamp. planetData = [] # Step size to use in populating the data list with # PlanetaryInfos. # # The step size should cause the planet to move less # than 120 degrees in all cases, and idealy much less # than this, that way we can easily narrow down when # the planet passes the 0 degree or 360 degree # threshold, and also so it is easier to narrow down # when retrograde periods happen. If the step size is # too large, it is possible that we would miss a whole # time window of retrograde movement, so discretion # has to be used in determining what to use for this value. # # Here we will set it to 1 day for the default case, # but if the planet name is a house cusp then shrink # the step size so we will get the correct resolution. # Also, if the planet name is an outer planet with a # large period, we can increase the step size slightly # to improve performance. stepSizeTd = datetime.timedelta(days=1) if Ephemeris.isHouseCuspPlanetName(planetName) or \ Ephemeris.isAscmcPlanetName(planetName): stepSizeTd = datetime.timedelta(hours=1) elif planetName == "Jupiter" or \ planetName == "Saturn" or \ planetName == "Neptune" or \ planetName == "Uranus" or \ planetName == "Pluto": stepSizeTd = datetime.timedelta(days=5) log.debug("Stepping through from {} to {} ...".\ format(Ephemeris.datetimeToStr(startTimestamp), Ephemeris.datetimeToStr(endTimestamp))) # Current datetime as we step through all the # timestamps between the start and end timestamp. currDt = copy.deepcopy(startTimestamp) # Step through the timestamps, calculating the planet positions. while currDt < endTimestamp: p = Ephemeris.getPlanetaryInfo(planetName, currDt) planetData.append(p) # Increment step size. currDt += stepSizeTd # We must also append the planet calculation for the end timestamp. Ephemeris.setGeographicPosition(loc2Longitude, loc2Latitude, loc2Elevation) p = Ephemeris.getPlanetaryInfo(planetName, endTimestamp) planetData.append(p) # Geocentric measurement. if centricityType == "geocentric": # Get the PlanetaryInfos for the timestamps of the # planet at the moment right after the # longitude_speed polarity changes. additionalPlanetaryInfos = [] prevLongitudeSpeed = None for i in range(len(planetData)): currLongitudeSpeed = \ planetData[i].geocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'] if prevLongitudeSpeed != None and \ ((prevLongitudeSpeed < 0 and currLongitudeSpeed >= 0) or \ (prevLongitudeSpeed >= 0 and currLongitudeSpeed < 0)): # Polarity changed. # Try to narrow down the exact moment in # time when this occured. t1 = planetData[i-1].dt t2 = planetData[i].dt currErrorTd = t2 - t1 while currErrorTd > maxErrorTd: if log.isEnabledFor(logging.DEBUG) == True: log.debug("Refining between {} and {}".\ format(Ephemeris.datetimeToStr(t1), Ephemeris.datetimeToStr(t2))) # Check the timestamp between. diffTd = t2 - t1 halfDiffTd = \ datetime.\ timedelta(days=(diffTd.days / 2.0), seconds=(diffTd.seconds / 2.0), microseconds=(diffTd.\ microseconds / 2.0)) testDt = t1 + halfDiffTd p = Ephemeris.getPlanetaryInfo(planetName, testDt) testLongitudeSpeed = \ p.geocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'] if ((prevLongitudeSpeed < 0 and \ testLongitudeSpeed >= 0) or \ (prevLongitudeSpeed >= 0 and \ testLongitudeSpeed < 0)): # Polarity change at the test timestamp. t2 = testDt else: # No polarity change yet. t1 = testDt # Update the currErrorTd. currErrorTd = t2 - t1 log.debug("Broke out of loop to find " + \ "velocity polarity change. " + \ "currErrorTd is: {}, ".\ format(currErrorTd)) # Timestamp at t2 is now within the amount # of the time error threshold ('maxErrorTd') # following the polarity change. # Append this value to the list. p = Ephemeris.getPlanetaryInfo(planetName, t2) additionalPlanetaryInfos.append(p) t1pi = planetData[i-1] t2pi = Ephemeris.getPlanetaryInfo(planetName, t2) if log.isEnabledFor(logging.DEBUG) == True: log.debug("t1 == {}, ".\ format(Ephemeris.datetimeToStr(t1pi.dt)) + \ "longitude(tropical) == {}, ".\ format(t1pi.geocentric['tropical']['longitude']) + \ "longitude(sidereal) == {}, ".\ format(t1pi.geocentric['sidereal']['longitude']) + \ "longitude_speed == {}, ".\ format(t1pi.geocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'])) log.debug("t2 == {}, ".\ format(Ephemeris.datetimeToStr(t2pi.dt)) + \ "longitude(tropical) == {}, ".\ format(t2pi.geocentric['tropical']['longitude']) + \ "longitude(sidereal) == {}, ".\ format(t2pi.geocentric['sidereal']['longitude']) + \ "longitude_speed == {}, ".\ format(t2pi.geocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'])) # There is no need to update # currLongitudeSpeed here, because the # longitude_speed for 'p' should be the # same polarity. # Update prevLongitudeSpeed. prevLongitudeSpeed = currLongitudeSpeed # Sort all the extra PlanetaryInfo objects by timestamp. additionalPlanetaryInfos = \ sorted(additionalPlanetaryInfos, key=lambda c: c.dt) # Insert PlanetaryInfos from # 'additionalPlanetaryInfos' into 'planetData' at # the timestamp-ordered location. currLoc = 0 for i in range(len(additionalPlanetaryInfos)): pi = additionalPlanetaryInfos[i] insertedFlag = False while currLoc < len(planetData): if pi.dt < planetData[currLoc].dt: planetData.insert(currLoc, pi) insertedFlag = True currLoc += 1 break else: currLoc += 1 if insertedFlag == False: # PlanetaryInfo 'pi' has a timestamp that # is later than the last PlanetaryInfo in # 'planetData', so just append it. planetData.append(pi) # Increment currLoc so that the rest of # the PlanetaryInfos in # 'additionalPlanetaryInfos' can be # appended without doing anymore timestamp tests. currLoc += 1 # Do summations to determine the measurements. showGeocentricRetroAsNegativeTextFlag = True if showGeocentricRetroAsNegativeTextFlag == True: if tropicalZodiacFlag == True: totalDegrees = 0 zodiacType = "tropical" for i in range(len(planetData)): if i != 0: prevPi = planetData[i-1] currPi = planetData[i] if prevPi.geocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'] >= 0: # Direct motion. # Elapsed amount for this segment should be positive. # Find the amount of longitude elasped. longitudeElapsed = \ currPi.geocentric[zodiacType]['longitude'] - \ prevPi.geocentric[zodiacType]['longitude'] # See if there was a crossing of the # 0 degree point or the 360 degree point. # If so, make the necessary adjustments # so that the longitude elapsed is # correct. longitudeElapsed = \ Util.toNormalizedAngle(longitudeElapsed) totalDegrees += longitudeElapsed else: # Retrograde motion. # Elapsed amount for this segment should be negative. # Find the amount of longitude elasped. longitudeElapsed = \ currPi.geocentric[zodiacType]['longitude'] - \ prevPi.geocentric[zodiacType]['longitude'] # See if there was a crossing of the # 0 degree point or the 360 degree point. # If so, make the necessary adjustments # so that the longitude elapsed is # correct. if longitudeElapsed > 0: longitudeElapsed -= 360 totalDegrees += longitudeElapsed # Line of text. We append measurements to # this line of text depending on what # measurements are enabled. line = "G T {} moves ".format(planetName) numCircles = totalDegrees / circleSizeInDegrees numBiblicalCircles = \ totalDegrees / AstrologyUtils.degreesInBiblicalCircle line += "{:.2f} deg ".format(totalDegrees) # Append last part of the line. line += "(r as -)" text += line + os.linesep if centricityType == "heliocentric": if tropicalZodiacFlag == True: totalDegrees = 0 zodiacType = "tropical" for i in range(len(planetData)): if i != 0: prevPi = planetData[i-1] currPi = planetData[i] if prevPi.heliocentric[zodiacTypeForLongitudeSpeed]['longitude_speed'] >= 0: # Direct motion. # Elapsed amount for this segment should be positive. # Find the amount of longitude elasped. longitudeElapsed = \ currPi.heliocentric[zodiacType]['longitude'] - \ prevPi.heliocentric[zodiacType]['longitude'] # See if there was a crossing of the # 0 degree point or the 360 degree point. # If so, make the necessary adjustments # so that the longitude elapsed is # correct. longitudeElapsed = \ Util.toNormalizedAngle(longitudeElapsed) totalDegrees += longitudeElapsed else: # Retrograde motion. # Elapsed amount for this segment should be negative. # Find the amount of longitude elasped. longitudeElapsed = \ currPi.heliocentric[zodiacType]['longitude'] - \ prevPi.heliocentric[zodiacType]['longitude'] # See if there was a crossing of the # 0 degree point or the 360 degree point. # If so, make the necessary adjustments # so that the longitude elapsed is # correct. if longitudeElapsed > 0: longitudeElapsed -= 360 totalDegrees += longitudeElapsed # Line of text. We append measurements to # this line of text depending on what # measurements are enabled. line = "H T {} moves ".format(planetName) numCircles = totalDegrees / circleSizeInDegrees numBiblicalCircles = \ totalDegrees / AstrologyUtils.degreesInBiblicalCircle line += "{:.2f} deg ".format(totalDegrees) text += line + os.linesep text = text.rstrip() return totalDegrees
def getGeocentricPlanetDirectRetrogradeInfo(planetName): """ Returns a list of tuples, each tuple containing: (planetName, julianDay, datetime, "R" or "D", geoTropLongitudeOfPlanet, geoSidLongitudeOfPlanet) """ # Return value. rv = [] prevDt = None currDt = copy.deepcopy(startDt) prevTropLongitudeSpeed = None currTropLongitudeSpeed = None currTropLongitude = None currSidLongitude = None while currDt <= endDt: dt = currDt pi = Ephemeris.getPlanetaryInfo(planetName, dt) log.debug("Just obtained planetaryInfo for planet '{}', timestamp: {}".\ format(planetName, Ephemeris.datetimeToStr(dt))) # Get the geocentric longitude and geocentric longitude speed. tropLongitudeSpeed = pi.geocentric['tropical']['longitude_speed'] tropLongitude = pi.geocentric['tropical']['longitude'] sidLongitude = pi.geocentric['sidereal']['longitude'] # Store new current planet values. currTropLongitudeSpeed = tropLongitudeSpeed currTropLongitude = tropLongitude currSidLongitude = sidLongitude log.debug("prevTropLongitudeSpeed={}, currTropLongitudeSpeed={}".\ format(prevTropLongitudeSpeed, currTropLongitudeSpeed)) # We need two data points to proceed. if prevTropLongitudeSpeed != None and \ currTropLongitudeSpeed != None and \ prevDt != None: # Check to see if we passed over 0 degrees. if prevTropLongitudeSpeed < 0.0 and currTropLongitudeSpeed >= 0.0: # Crossed over from negative to positive! log.debug("Crossed over from negative to positive!") # This is the upper-bound of the error timedelta. t1 = prevDt t2 = currDt currErrorTd = t2 - t1 # Refine the timestamp until it is less than the # desired threshold. while currErrorTd > maxErrorTd: log.debug("Refining between {} and {}".\ format(Ephemeris.datetimeToStr(t1), Ephemeris.datetimeToStr(t2))) # Check the timestamp between. diffTd = t2 - t1 halfDiffTd = \ datetime.\ timedelta(days=(diffTd.days / 2.0), seconds=(diffTd.seconds / 2.0), microseconds=(diffTd.microseconds / 2.0)) testDt = t1 + halfDiffTd pi = Ephemeris.getPlanetaryInfo(planetName, testDt) testTropLongitudeSpeed = \ pi.geocentric['tropical']['longitude_speed'] testTropLongitude = pi.geocentric['tropical']['longitude'] testSidLongitude = pi.geocentric['sidereal']['longitude'] if testTropLongitudeSpeed >= 0.0: t2 = testDt # Update the curr values as the later boundary. currDt = t2 currTropLongitudeSpeed = testTropLongitudeSpeed currTropLongitude = testTropLongitude currSidLongitude = testSidLongitude else: t1 = testDt currErrorTd = t2 - t1 # Broke out of while loop, meaning we have a timestamp # within our threshold. # Create a tuple to add to our list. tup = (planetName, Ephemeris.datetimeToJulianDay(currDt), currDt, directStr, currTropLongitude, currSidLongitude) # Append to the list. rv.append(tup) elif prevTropLongitudeSpeed > 0.0 and currTropLongitudeSpeed <= 0.0: # Crossed over from positive to negative! log.debug("Crossed over from positive to negative!") # This is the upper-bound of the error timedelta. t1 = prevDt t2 = currDt currErrorTd = t2 - t1 # Refine the timestamp until it is less than the # desired threshold. while currErrorTd > maxErrorTd: log.debug("Refining between {} and {}".\ format(Ephemeris.datetimeToStr(t1), Ephemeris.datetimeToStr(t2))) # Check the timestamp between. diffTd = t2 - t1 halfDiffTd = \ datetime.\ timedelta(days=(diffTd.days / 2.0), seconds=(diffTd.seconds / 2.0), microseconds=(diffTd.microseconds / 2.0)) testDt = t1 + halfDiffTd pi = Ephemeris.getPlanetaryInfo(planetName, testDt) testTropLongitudeSpeed = \ pi.geocentric['tropical']['longitude_speed'] testTropLongitude = pi.geocentric['tropical']['longitude'] testSidLongitude = pi.geocentric['sidereal']['longitude'] if testTropLongitudeSpeed <= 0.0: t2 = testDt # Update the curr values as the later boundary. currDt = t2 currTropLongitudeSpeed = testTropLongitudeSpeed currTropLongitude = testTropLongitude currSidLongitude = testSidLongitude else: t1 = testDt currErrorTd = t2 - t1 # Broke out of while loop, meaning we have a timestamp # within our threshold. # Create a tuple to add to our list. tup = (planetName, Ephemeris.datetimeToJulianDay(currDt), currDt, retrogradeStr, currTropLongitude, currSidLongitude) # Append to the list. rv.append(tup) # Increment currDt timestamp. prevDt = currDt currDt = currDt + stepSizeTd # Move the previous currTropLongitudeSpeed to prevTropLongitudeSpeed. prevTropLongitudeSpeed = currTropLongitudeSpeed currTropLongitudeSpeed = None currTropLongitude = None currSidLongitude = None log.debug("prevTropLongitudeSpeed={}, currTropLongitudeSpeed={}".\ format(prevTropLongitudeSpeed, currTropLongitudeSpeed)) return rv