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()
