def get_stellarium_nakshatra_boundaries(self): equatorial_boundary_coordinates_with_ra = self.get_equatorial_boundary_coordinates( ) ecliptic_north_pole = swe.cotrans(lon=20, lat=90, dist=9999999, obliquity=23.437404) ecliptic_north_pole_with_ra = ( custom_transliteration.longitudeToRightAscension( ecliptic_north_pole[0]), ecliptic_north_pole[1]) # logging.debug(ecliptic_north_pole_with_ra) ecliptic_south_pole = swe.cotrans(lon=20, lat=-90, dist=9999999, obliquity=23.437404) ecliptic_south_pole_with_ra = ( custom_transliteration.longitudeToRightAscension( ecliptic_south_pole[0]), ecliptic_south_pole[1]) # logging.debug(ecliptic_south_pole_with_ra) for index, (boundary_ra, boundary_declination ) in enumerate(equatorial_boundary_coordinates_with_ra): print( '3 %(north_pole_ra)f %(north_pole_dec)f %(boundary_ra)f %(boundary_declination)f %(south_pole_ra)f %(south_pole_dec)f 2 N%(sector_id_1)02d N%(sector_id_2)02d' % dict(north_pole_ra=ecliptic_north_pole_with_ra[0], north_pole_dec=ecliptic_north_pole_with_ra[1], boundary_ra=boundary_ra, boundary_declination=boundary_declination, south_pole_ra=ecliptic_south_pole_with_ra[0], south_pole_dec=ecliptic_south_pole_with_ra[1], sector_id_1=(index % 27 + 1), sector_id_2=((index + 1) % 27 + 1)))
def calcProfPos(self, prof): hcs = [self.cusps[0]] for i in range(1, Houses.HOUSE_NUM+1): hcs.append(util.normalize(self.cusps[i]+prof.offs)) #to tuple (which is a read-only list) self.cusps = tuple(hcs) self.ascmc = (util.normalize(self.ascmc[Houses.ASC]+prof.offs), util.normalize(self.ascmc[Houses.MC]+prof.offs), self.ascmc[Houses.ARMC], self.ascmc[Houses.VERTEX], self.ascmc[Houses.EQUASC], self.ascmc[Houses.COASC], self.ascmc[Houses.COASC2], self.ascmc[Houses.POLARASC]) ascra, ascdecl, dist = swisseph.cotrans(self.ascmc[Houses.ASC], 0.0, 1.0, -self.obl) mcra, mcdecl, dist = swisseph.cotrans(self.ascmc[Houses.MC], 0.0, 1.0, -self.obl) self.ascmc2 = ((self.ascmc[Houses.ASC], 0.0, ascra, ascdecl), (self.ascmc[Houses.MC], 0.0, mcra, mcdecl))
def __init__(self, tjd_ut, flag, names, obl): self.data = [] i = 0 for k in names: self.data.append(['', '', 0.0, 0.0, 0.0, 0.0]) dat = swisseph.fixstar_ut(',' + k, tjd_ut, flag) nam = k nomnam = '' DELIMITER = ',' if nam.find(DELIMITER) != -1: snam = nam.split(DELIMITER) nam = snam[0].strip() nomnam = snam[1].strip() self.data[i][FixStars.NAME] = nam self.data[i][FixStars.NOMNAME] = nam self.data[i][FixStars.LON] = dat[0] self.data[i][FixStars.LAT] = dat[1] ra, decl, dist = swisseph.cotrans(dat[0], dat[1], 1.0, -obl) self.data[i][FixStars.RA] = ra self.data[i][FixStars.DECL] = decl i += 1 self.sort()
def __init__(self, tjd_ut, pId, flag, lat = None, ascmc2 = None, raequasc = None, ecl = None, equ = None, nolat = False, obl = 0.0): self.pId = pId self.speculums = None if (ecl == None): self.data = swisseph.calc_ut(tjd_ut, pId, flag) self.dataEqu = swisseph.calc_ut(tjd_ut, pId, flag+astrology.SEFLG_EQUATORIAL) # data[0] : longitude # data[1] : latitude # data[2] : distance # data[3] : speed in long # data[4] : speed in lat # data[5] : speed in dist # if rflag < 0: # print 'Error: %s' % serr self.name = swisseph.get_planet_name(pId) else: self.data = tuple(ecl) self.dataEqu = tuple(equ) self.name = 'DescNode' if nolat: self.data = (self.data[Planet.LONG], 0.0, self.data[Planet.DIST], self.data[Planet.SPLON], self.data[Planet.SPLAT], self.data[Planet.SPDIST]) ra, decl, dist = swisseph.cotrans(self.data[Planet.LONG], 0.0, 1.0, -obl) self.dataEqu = (ra, decl, self.dataEqu[Planet.DISTEQU], self.dataEqu[Planet.SPRAEQU], self.dataEqu[Planet.SPDECLEQU], self.dataEqu[Planet.SPDISTEQU]) if lat != None: #placspec.py and regiospec should be used instead, remove these! self.speculums = [] self.computePlacidianSpeculum(lat, ascmc2) self.computeRegiomontanSpeculum(lat, ascmc2, raequasc)
def ecliptic_to_equatorial(longitude, latitude): coordinates = swe.cotrans(lon=longitude, lat=latitude, dist=9999999, obliquity=23.437404) # swe.cotrans returns the right ascension longitude in degrees, rather than hours. return (longitude_to_right_ascension(coordinates[0]), coordinates[1])
def __init__(self, ascmc2, pls, obl, placelat): ramc = ascmc2[houses.Houses.MC][houses.Houses.RA] aoasc = ramc + 90.0 if aoasc >= 360.0: aoasc -= 360.0 ramoon = pls.planets[astrology.SE_MOON].dataEqu[planets.Planet.RAEQU] rasun = pls.planets[astrology.SE_SUN].dataEqu[planets.Planet.RAEQU] adsun = 0.0 self.mLoFvalid = False val = math.tan(math.radians(placelat)) * math.tan( math.radians( pls.planets[astrology.SE_SUN].dataEqu[planets.Planet.DECLEQU])) if math.fabs(val) <= 1.0: adsun = math.degrees(math.asin(val)) self.mLoFvalid = True aosun = rasun - adsun if aosun < 0.0: aosun += 360.0 raMLoF = aoasc + ramoon - aosun raMLoF = util.normalize(raMLoF) declMLoF = pls.planets[astrology.SE_MOON].dataEqu[ planets.Planet.DECLEQU] lonMLoF, latMLoF, dist = swisseph.cotrans(raMLoF, declMLoF, 1.0, obl) self.mfortune = (lonMLoF, latMLoF, raMLoF, declMLoF) self.speculum = placspec.PlacidianSpeculum(placelat, ascmc2, lonMLoF, latMLoF, raMLoF, declMLoF) self.valid = self.mLoFvalid and self.speculum.valid
def get_equatorial_boundary_coordinates(self): """Get equatorial coordinates for the points where the ecliptic nakShatra boundary longitude intersects the ecliptic.""" equatorial_boundary_coordinates = [swe.cotrans(lon=longitude, lat=0, dist=9999999, obliquity=23.437404) for longitude in self.right_boundaries] # swe.cotrans returns the right ascension longitude in degrees, rather than hours. equatorial_boundary_coordinates_with_ra = [ (custom_transliteration.longitudeToRightAscension(longitude), declination) for (longitude, declination, distance) in equatorial_boundary_coordinates] return equatorial_boundary_coordinates_with_ra
def calcFullAstronomicalProc(self, da, oblN, raN, declN, placelat, ascmc2, raequasc): # print '**** %s ****' % pl.name ksi = raN+da ksi = util.normalize(ksi) # print 'ksi=%f' % ksi # print 'declN=%f' % declN roblN = math.radians(oblN) rksi = math.radians(ksi) rdeclN = math.radians(declN) longSZ = 0.0 if ksi == 90.0: longSZ = 90.0 elif ksi == 270.0: longSZ = 270.0 else: # print 'obl=%f' % oblN Fd = 0.0 if math.cos(rksi) != 0.0: Fd = math.degrees(math.atan((math.cos(roblN)*math.sin(rksi)+math.sin(roblN)*math.tan(rdeclN))/math.cos(rksi))) # print 'rFd=%f' % math.radians(Fd) if ksi >= 0.0 and ksi < 90.0: longSZ = Fd # print 'First ksi' elif ksi > 90.0 and ksi < 270.0: longSZ = Fd+180.0 # print 'Second ksi' elif ksi > 270.0 and ksi < 360.0: longSZ = Fd+360.0 # print 'Third ksi' if longSZ <= 0.0: # print 'longSz<=0' longSZ = Fd+360.0 longSZ = util.normalize(longSZ)## # print 'longSz=%f' % longSZ roblN = math.radians(oblN) rksi = math.radians(ksi) rdeclN = math.radians(declN) latSZ = math.degrees(math.asin(math.sin(rdeclN)*math.cos(roblN)-math.cos(rdeclN)*math.sin(rksi)*math.sin(roblN))) raSZ, declSZ, distSZ = swisseph.cotrans(longSZ, latSZ, 1.0, -oblN) self.data = (longSZ, latSZ, self.data[Planet.DIST], self.data[Planet.SPLON], self.data[Planet.SPLAT], self.data[Planet.SPDIST]) self.dataEqu = (raSZ, declSZ, self.dataEqu[Planet.DISTEQU], self.dataEqu[Planet.SPRAEQU], self.dataEqu[Planet.SPDECLEQU], self.dataEqu[Planet.SPDISTEQU]) self.speculums = [] self.computePlacidianSpeculum(placelat, ascmc2) self.computeRegiomontanSpeculum(placelat, ascmc2, raequasc)
def __init__(self, tjd_ut, flag, geolat, geolon, hsys, obl, ayanopt, ayan): if hsys in Houses.hsystems: self.hsys = hsys else: self.hsys = hsystems[0] self.obl = obl self.cusps, self.ascmc = swisseph.houses_ex(tjd_ut, geolat, geolon, bytes(self.hsys, 'utf-8'), flag) ################## if ayanopt != 0 and self.hsys == 'W': del self.cusps cusps = [0.0] sign = int(util.normalize(self.ascmc[Houses.ASC]-ayan))/30 cusps.append(sign*30.0) for i in range(2, Houses.HOUSE_NUM+1): hc = util.normalize(cusps[i-1]+30.0) cusps.append(hc) #to tuple (which is a read-only list) self.cusps = tuple(cusps) ################## ascra, ascdecl, dist = swisseph.cotrans(self.ascmc[Houses.ASC], 0.0, 1.0, -obl) mcra, mcdecl, dist = swisseph.cotrans(self.ascmc[Houses.MC], 0.0, 1.0, -obl) self.ascmc2 = ((self.ascmc[Houses.ASC], 0.0, ascra, ascdecl), (self.ascmc[Houses.MC], 0.0, mcra, mcdecl)) #zdAsc=90.0, zdMC=0.0 #poleAsc=lat, poleMC=0.0 qasc = math.degrees(math.asin(math.tan(math.radians(ascdecl))*math.tan(math.radians(geolat)))) self.regioMPAsc = ascra-qasc self.regioMPMC = mcra self.cuspstmp = [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]] for i in range(Houses.HOUSE_NUM): self.cuspstmp[i][0], self.cuspstmp[i][1], dist = swisseph.cotrans(self.cusps[i], 0.0, dist, -obl) self.cusps2 = ((self.cuspstmp[0][0], self.cuspstmp[0][1]), (self.cuspstmp[1][0], self.cuspstmp[1][1]), (self.cuspstmp[2][0], self.cuspstmp[2][1]), (self.cuspstmp[3][0], self.cuspstmp[3][1]), (self.cuspstmp[4][0], self.cuspstmp[4][1]), (self.cuspstmp[5][0], self.cuspstmp[5][1]), (self.cuspstmp[6][0], self.cuspstmp[6][1]), (self.cuspstmp[7][0], self.cuspstmp[7][1]), (self.cuspstmp[8][0], self.cuspstmp[8][1]), (self.cuspstmp[9][0], self.cuspstmp[9][1]), (self.cuspstmp[10][0], self.cuspstmp[10][1]), (self.cuspstmp[11][0], self.cuspstmp[11][1]))
def calcMundaneWithoutSM(self, da, obl, placelat, ascmc2, raequasc): ra = self.dataEqu[Planet.RAEQU] decl = self.dataEqu[Planet.DECLEQU] da *= -1 ra += da ra = util.normalize(ra) lon, lat, dist = swisseph.cotrans(ra, decl, 1.0, obl) self.data = (lon, lat, self.data[Planet.DIST], self.data[Planet.SPLON], self.data[Planet.SPLAT], self.data[Planet.SPDIST]) self.dataEqu = (ra, decl, self.dataEqu[Planet.DISTEQU], self.dataEqu[Planet.SPRAEQU], self.dataEqu[Planet.SPDECLEQU], self.dataEqu[Planet.SPDISTEQU]) self.speculums = [] self.computePlacidianSpeculum(placelat, ascmc2) self.computeRegiomontanSpeculum(placelat, ascmc2, raequasc)
def calcFullAstronomicalProc(self, fort, da, oblN): #, raN, declN): raN = fort.fortune[Fortune.RA] declN = fort.fortune[Fortune.DECL] ksi = raN + da ksi = util.normalize(ksi) roblN = math.radians(oblN) rksi = math.radians(ksi) rdeclN = math.radians(declN) longSZ = 0.0 if ksi == 90.0: longSZ = 90.0 elif ksi == 270.0: longSZ = 270.0 else: Fd = 0.0 if math.cos(rksi) != 0.0: Fd = math.degrees( math.atan( (math.cos(roblN) * math.sin(rksi) + math.sin(roblN) * math.tan(rdeclN)) / math.cos(rksi))) if ksi >= 0.0 and ksi < 90.0: longSZ = Fd elif ksi > 90.0 and ksi < 270.0: longSZ = Fd + 180.0 elif ksi > 270.0 and ksi < 360.0: longSZ = Fd + 360.0 if longSZ <= 0.0: longSZ = Fd + 360.0 latSZ = math.degrees( math.asin( math.sin(rdeclN) * math.cos(roblN) - math.cos(rdeclN) * math.sin(rksi) * math.sin(roblN))) raSZ, declSZ, distSZ = swisseph.cotrans(longSZ, latSZ, 1.0, -oblN) self.fortune = [longSZ, latSZ, raSZ, declSZ]
def __init__(self, pls, ascmc, lof, obl, ayanopt, ayan): self.obl = obl self.plantiscia = [] self.plcontraant = [] self.pldodecatemoria = [] self.lofant = None self.lofcontraant = None self.lofdodec = None self.ascmcant = [] self.ascmccontraant = [] self.ascmcdodec = [] self.ayanopt = ayanopt self.ayan = ayan plcants = [] for i in range(planets.Planets.PLANETS_NUM): ant, cant = self.calc(pls[i].data[planets.Planet.LONG]) dodec = self.calcDodecatemoria(pls[i].data[planets.Planet.LONG]) lat = pls[i].data[planets.Planet.LAT] plcants.append((cant, lat)) #self.pldodecatemoria.append((dodec, lat)) # raant, declant = util.getRaDecl(ant, lat, self.obl) raant, declant, dist = swisseph.cotrans(ant, lat, 1.0, -obl) self.plantiscia.append( Antiscion(Antiscion.ANTISCION, i, ant, lat, raant, declant)) self.pldodecatemoria.append( Antiscion(Antiscion.DODECATEMORIA, i, dodec, lat, raant, declant)) for i in range(planets.Planets.PLANETS_NUM): # raant, declant = util.getRaDecl(plcants[i][0], plcants[i][1], self.obl) raant, declant, dist = swisseph.cotrans(plcants[i][0], plcants[i][1], 1.0, -obl) self.plcontraant.append( Antiscion(Antiscion.CONTRAANT, i, plcants[i][0], plcants[i][1], raant, declant)) ant, cant = self.calc(lof[fortune.Fortune.LON]) dodec = self.calcDodecatemoria(lof[fortune.Fortune.LON]) # lat = lof[fortune.Fortune.LAT] #=0.0 raant, declant, dist = swisseph.cotrans(ant, 0.0, 1.0, -self.obl) self.lofant = Antiscion(Antiscion.ANTISCION, Antiscion.LOF, ant, 0.0, raant, declant) raant, declant, dist = swisseph.cotrans(cant, 0.0, 1.0, -self.obl) self.lofcontraant = Antiscion(Antiscion.CONTRAANT, Antiscion.LOF, cant, 0.0, raant, declant) #Afegeixo LOF raant, declant, dist = swisseph.cotrans(cant, 0.0, 1.0, -self.obl) self.lofdodec = Antiscion(Antiscion.DODECATEMORIA, Antiscion.LOF, dodec, 0.0, raant, declant) antasc, cantasc = self.calc(ascmc[houses.Houses.ASC]) raantasc, declantasc, dist = swisseph.cotrans(antasc, 0.0, 1.0, -self.obl) self.ascmcant.append( Antiscion(Antiscion.ANTISCION, Antiscion.ASC, antasc, 0.0, raantasc, declantasc)) antmc, cantmc = self.calc(ascmc[houses.Houses.MC]) raantmc, declantmc, dist = swisseph.cotrans(antmc, 0.0, 1.0, -self.obl) self.ascmcant.append( Antiscion(Antiscion.ANTISCION, Antiscion.MC, antmc, 0.0, raantmc, declantmc)) raantasc, declantasc, dist = swisseph.cotrans(cantasc, 0.0, 1.0, -self.obl) self.ascmccontraant.append( Antiscion(Antiscion.CONTRAANT, Antiscion.ASC, cantasc, 0.0, raantasc, declantasc)) raantmc, declantmc, dist = swisseph.cotrans(cantmc, 0.0, 1.0, -self.obl) self.ascmccontraant.append( Antiscion(Antiscion.CONTRAANT, Antiscion.MC, cantmc, 0.0, raantmc, declantmc)) dodecasc = self.calcDodecatemoria(ascmc[houses.Houses.ASC]) raantasc, declantasc, dist = swisseph.cotrans(dodecasc, 0.0, 1.0, -self.obl) self.ascmcdodec.append( Antiscion(Antiscion.DODECATEMORIA, Antiscion.ASC, dodecasc, 0.0, raantasc, declantasc)) dodecmc = self.calcDodecatemoria(ascmc[houses.Houses.MC]) raantmc, declantmc, dist = swisseph.cotrans(antmc, 0.0, 1.0, -self.obl) self.ascmcdodec.append( Antiscion(Antiscion.DODECATEMORIA, Antiscion.MC, dodecmc, 0.0, raantmc, declantmc))
def __init__(self, typ, ascmc2, raequasc, pls, obl, placelat, abovehorizon): self.fortune = [0.0, 0.0, 0.0, 0.0] self.abovehorizon = abovehorizon if typ == chart.Chart.LFMOONSUN: diff = pls.planets[astrology.SE_MOON].data[ planets.Planet.LONG] - pls.planets[astrology.SE_SUN].data[ planets.Planet.LONG] if diff < 0.0: diff += 360.0 self.fortune[Fortune.LON] = ascmc2[houses.Houses.ASC][ houses.Houses.LON] + diff if self.fortune[Fortune.LON] > 360.0: self.fortune[Fortune.LON] -= 360.0 elif typ == chart.Chart.LFDSUNMOON: diff = 0.0 if abovehorizon: diff = pls.planets[astrology.SE_SUN].data[ planets.Planet.LONG] - pls.planets[astrology.SE_MOON].data[ planets.Planet.LONG] else: diff = pls.planets[astrology.SE_MOON].data[ planets.Planet.LONG] - pls.planets[astrology.SE_SUN].data[ planets.Planet.LONG] if diff < 0.0: diff += 360.0 self.fortune[Fortune.LON] = ascmc2[houses.Houses.ASC][ houses.Houses.LON] + diff if self.fortune[Fortune.LON] > 360.0: self.fortune[Fortune.LON] -= 360.0 elif typ == chart.Chart.LFDMOONSUN: diff = 0.0 if abovehorizon: diff = pls.planets[astrology.SE_MOON].data[ planets.Planet.LONG] - pls.planets[astrology.SE_SUN].data[ planets.Planet.LONG] else: diff = pls.planets[astrology.SE_SUN].data[ planets.Planet.LONG] - pls.planets[astrology.SE_MOON].data[ planets.Planet.LONG] if diff < 0.0: diff += 360.0 self.fortune[Fortune.LON] = ascmc2[houses.Houses.ASC][ houses.Houses.LON] + diff if self.fortune[Fortune.LON] > 360.0: self.fortune[Fortune.LON] -= 360.0 self.fortune[Fortune.RA], self.fortune[ Fortune.DECL], distprom = swisseph.cotrans( self.fortune[Fortune.LON], 0.0, 1.0, -obl) self.speculum = placspec.PlacidianSpeculum(placelat, ascmc2, self.fortune[Fortune.LON], self.fortune[Fortune.LAT], self.fortune[Fortune.RA], self.fortune[Fortune.DECL]) self.speculum2 = regiospec.RegiomontanianSpeculum( placelat, ascmc2, raequasc, self.fortune[Fortune.LON], self.fortune[Fortune.LAT], self.fortune[Fortune.RA], self.fortune[Fortune.DECL])
def __init__(self, chrt): self.time = chrt.time self.lon = chrt.planets.planets[astrology.SE_MOON].data[ planets.Planet.LONG] self.flags = astrology.SEFLG_SPEED + astrology.SEFLG_SWIEPH #for topical almutens self.lons = [] if not chrt.time.bc: lonsun = chrt.planets.planets[astrology.SE_SUN].data[ planets.Planet.LONG] lonmoon = chrt.planets.planets[astrology.SE_MOON].data[ planets.Planet.LONG] d, m, s = util.decToDeg(lonsun) lonsun = d + m / 60.0 + s / 3600.0 d, m, s = util.decToDeg(lonmoon) lonmoon = d + m / 60.0 + s / 3600.0 diff = lonmoon - lonsun self.newmoon, self.ready = self.isNewMoon(diff) if not self.ready: ok, self.time, self.ready = self.getDateHour( self.time, chrt.place, self.newmoon) if not self.ready: ok, self.time, self.ready = self.getDateMinute( self.time, chrt.place, self.newmoon) if not self.ready: ok, self.time, self.ready = self.getDateSecond( self.time, chrt.place, self.newmoon) hses = houses.Houses(self.time.jd, 0, chrt.place.lat, chrt.place.lon, chrt.options.hsys, chrt.obl[0], chrt.options.ayanamsha, chrt.ayanamsha) moon = planets.Planet(self.time.jd, astrology.SE_MOON, self.flags, chrt.place.lat, hses.ascmc2) if self.newmoon: self.lon = moon.data[planets.Planet.LONG] else: if chrt.options.syzmoon == options.Options.MOON: self.lon = moon.data[planets.Planet.LONG] elif chrt.options.syzmoon == options.Options.ABOVEHOR: if moon.abovehorizon: self.lon = moon.data[planets.Planet.LONG] else: sun = planets.Planet(self.time.jd, astrology.SE_SUN, self.flags) self.lon = sun.data[planets.Planet.LONG] else: moon = planets.Planet(self.time.jd, astrology.SE_MOON, self.flags, chrt.place.lat, chrt.houses.ascmc2) if moon.abovehorizon: self.lon = moon.data[planets.Planet.LONG] else: sun = planets.Planet(self.time.jd, astrology.SE_SUN, self.flags) self.lon = sun.data[planets.Planet.LONG] ra, decl, dist = swisseph.cotrans(self.lon, 0.0, 1.0, -chrt.obl[0]) self.speculum = [self.lon, 0.0, ra, decl] #the other syzygy (i.e. if the syzygy was conjunction then calculate the opposition and vice versa) self.lon2 = chrt.planets.planets[astrology.SE_MOON].data[ planets.Planet.LONG] if not chrt.time.bc: self.time2 = self.time ok, self.time2, self.ready2 = self.getDateHour( self.time2, chrt.place, not self.newmoon) if not self.ready2: ok, self.time2, self.ready2 = self.getDateMinute( self.time2, chrt.place, not self.newmoon) if not self.ready2: ok, self.time2, self.ready2 = self.getDateSecond( self.time2, chrt.place, not self.newmoon) hses2 = houses.Houses(self.time2.jd, 0, chrt.place.lat, chrt.place.lon, chrt.options.hsys, chrt.obl[0], chrt.options.ayanamsha, chrt.ayanamsha) moon2 = planets.Planet(self.time2.jd, astrology.SE_MOON, self.flags, chrt.place.lat, hses2.ascmc2) if not self.newmoon: self.lon2 = moon2.data[planets.Planet.LONG] else: if chrt.options.syzmoon == options.Options.MOON: self.lon2 = moon2.data[planets.Planet.LONG] elif chrt.options.syzmoon == options.Options.ABOVEHOR: if moon2.abovehorizon: self.lon2 = moon2.data[planets.Planet.LONG] else: sun2 = planets.Planet(self.time2.jd, astrology.SE_SUN, self.flags) self.lon2 = sun2.data[planets.Planet.LONG] else: moon2 = planets.Planet(self.time2.jd, astrology.SE_MOON, self.flags, chrt.place.lat, chrt.houses.ascmc2) if moon2.abovehorizon: self.lon2 = moon2.data[planets.Planet.LONG] else: sun2 = planets.Planet(self.time2.jd, astrology.SE_SUN, self.flags) self.lon2 = sun2.data[planets.Planet.LONG] ra2, decl2, dist2 = swisseph.cotrans(self.lon2, 0.0, 1.0, -chrt.obl[0]) self.speculum2 = [self.lon2, 0.0, ra2, decl2] #for topical almutens self.lons.append(self.lon) #Default if self.newmoon: #Conjunction self.lons.append(self.lon) else: self.lons.append(self.lon2) #Moon in chart of Syzygy hses = houses.Houses(self.time.jd, 0, chrt.place.lat, chrt.place.lon, chrt.options.hsys, chrt.obl[0], chrt.options.ayanamsha, chrt.ayanamsha) moonSyz = planets.Planet(self.time.jd, astrology.SE_MOON, self.flags, chrt.place.lat, hses.ascmc2) hses2 = houses.Houses(self.time2.jd, 0, chrt.place.lat, chrt.place.lon, chrt.options.hsys, chrt.obl[0], chrt.options.ayanamsha, chrt.ayanamsha) moonSyz2 = planets.Planet(self.time2.jd, astrology.SE_MOON, self.flags, chrt.place.lat, hses2.ascmc2) if not self.newmoon: #Opposition if moonSyz.abovehorizon: self.lons.append(moonSyz.data[planets.Planet.LONG]) else: sun = planets.Planet(self.time.jd, astrology.SE_SUN, self.flags) self.lons.append(sun.data[planets.Planet.LONG]) else: if moonSyz2.abovehorizon: self.lons.append(moonSyz2.data[planets.Planet.LONG]) else: sun2 = planets.Planet(self.time2.jd, astrology.SE_SUN, self.flags) self.lons.append(sun2.data[planets.Planet.LONG]) if not self.newmoon: #OppositionRadix moon = planets.Planet(self.time.jd, astrology.SE_MOON, self.flags, chrt.place.lat, chrt.houses.ascmc2) if moon.abovehorizon: self.lons.append(moon.data[planets.Planet.LONG]) else: sun = planets.Planet(self.time.jd, astrology.SE_SUN, self.flags) self.lons.append(sun.data[planets.Planet.LONG]) else: moon = planets.Planet(self.time2.jd, astrology.SE_MOON, self.flags, chrt.place.lat, chrt.houses.ascmc2) if moon.abovehorizon: self.lons.append(moon.data[planets.Planet.LONG]) else: sun = planets.Planet(self.time.jd, astrology.SE_SUN, self.flags) self.lons.append(sun.data[planets.Planet.LONG]) if not self.newmoon: #Opposition Moon self.lons.append(moonSyz.data[planets.Planet.LONG]) else: self.lons.append(moonSyz2.data[planets.Planet.LONG])
def create(self): hflag = 0 fsflag = 0 pflag = astrology.SEFLG_SWIEPH+astrology.SEFLG_SPEED astflag = astrology.SEFLG_SWIEPH self.ayanamsha = 0.0 if self.options.ayanamsha != 0: swisseph.set_sid_mode(self.options.ayanamsha-1, 0, 0) self.ayanamsha = swisseph.get_ayanamsa_ut(self.time.jd) if self.options.topocentric: pflag += astrology.SEFLG_TOPOCTR self.houses = houses.Houses( self.time.jd, hflag, self.place.lat, self.place.lon, self.options.hsys, self.obl[0], self.options.ayanamsha, self.ayanamsha) self.raequasc, declequasc, dist = swisseph.cotrans( self.houses.ascmc[houses.Houses.EQUASC], 0.0, 1.0, -self.obl[0]) self.planets = planets.Planets( self.time.jd, self.options.meannode, pflag, self.place.lat, self.houses.ascmc2, self.raequasc, self.nolat, self.obl[0]) self.abovehorizonwithorb = self.isAboveHorizonWithOrb() abovehor = self.planets.planets[astrology.SE_SUN].abovehorizon if self.options.usedaynightorb: abovehor = self.abovehorizonwithorb self.fortune = fortune.Fortune( self.options.lotoffortune, self.houses.ascmc2, self.raequasc, self.planets, self.obl[0], self.place.lat, abovehor) # ########################################### # Roberto change V 7.3.0 self.firdaria = None # ########################################### self.munfortune = None self.parts = None self.fixstars = None self.midpoints = None self.riseset = None self.zodpars = None self.antiscia = None self.antzodpars = None self.cpd = None self.cpd2 = None self.syzygy = None self.almutens = None mdsun = self.planets.planets[astrology.SE_SUN].speculums[0][planets.Planet.MD] sasun = self.planets.planets[astrology.SE_SUN].speculums[0][planets.Planet.SA] if self.full: # ########################################### # Roberto change V 7.3.0 self.firdaria = firdaria.Firdaria( self.time.origyear, self.time.origmonth, self.time.origday, self.options, self.abovehorizonwithorb) # ########################################### self.munfortune = munfortune.MundaneFortune( self.houses.ascmc2, self.planets, self.obl[0], self.place.lat) self.syzygy = syzygy.Syzygy(self) self.parts = arabicparts.ArabicParts( self.options.arabicparts, self.houses.ascmc, self.planets, self.houses, self.houses.cusps, self.fortune, self.syzygy, self.options) self.fixstars = fixstars.FixStars( self.time.jd, fsflag, self.options.fixstars, self.obl[0]) self.midpoints = midpoints.MidPoints(self.planets) self.riseset = riseset.RiseSet( self.time.jd, self.time.cal, self.place.lon, self.place.lat, self.place.altitude, self.planets) self.zodpars = zodpars.ZodPars(self.planets, self.obl[0]) self.antiscia = antiscia.Antiscia( self.planets.planets, self.houses.ascmc, self.fortune.fortune, self.obl[0], self.options.ayanamsha, self.ayanamsha) self.antzodpars = antzodpars.AntZodPars( self.antiscia.plantiscia, self.antiscia.plcontraant, self.obl[0]) self.almutens = almutens.Almutens(self) if self.options.pdcustomer: self.cpd = customerpd.CustomerPD( self.options.pdcustomerlon[0], self.options.pdcustomerlon[1], self.options.pdcustomerlon[2], self.options.pdcustomerlat[0], self.options.pdcustomerlat[1], self.options.pdcustomerlat[2], self.options.pdcustomersouthern, self.place.lat, self.houses.ascmc2, self.obl[0], self.raequasc) if self.options.pdcustomer2: self.cpd2 = customerpd.CustomerPD( self.options.pdcustomer2lon[0], self.options.pdcustomer2lon[1], self.options.pdcustomer2lon[2], self.options.pdcustomer2lat[0], self.options.pdcustomer2lat[1], self.options.pdcustomer2lat[2], self.options.pdcustomer2southern, self.place.lat, self.houses.ascmc2, self.obl[0], self.raequasc) swisseph.close() self.calcAspMatrix() if self.fixstars is not None: self.calcFixStarAspMatrix()