def writeFirstDayXml(xml, loc, vc):
vcStart = GCGregorianDate(
date=GetFirstDayOfYear(loc.GetEarthData(), vcStart.year))
vcStart.InitWeekDay()
# write
xml.write("<xml>\n")
xml.write("\t<request name=\"FirstDay\" version=\"")
xml.write(GCStrings.getString(130))
xml.write("\">\n")
xml.write("\t\t<arg name=\"longitude\" val=\"")
xml.write(str(loc.m_fLongitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"latitude\" val=\"")
xml.write(str(loc.m_fLatitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"year\" val=\"")
xml.write(str(vcStart.year))
xml.write("\" />\n")
xml.write("\t</request>\n")
xml.write("\t<result name=\"FirstDay_of_GaurabdaYear\">\n")
xml.write("\t\t<firstday date=\"")
xml.write(str(vcStart))
xml.write("\" dayweekid = \"")
xml.write(str(vcStart.dayOfWeek))
xml.write("\" dayweek=\"")
xml.write(GCStrings.getString(vcStart.dayOfWeek))
xml.write("\" />\n")
xml.write("\t</result>\n")
xml.write("</xml>\n")
return 0
def __init__(self):
# date
self.date = GCGregorianDate()
# moon times
self.moonrise = GCTime()
self.moonset = GCTime()
# astronomical data from astro-sub-layer
self.astrodata = GCDayData()
self.nCaturmasya = 0
self.hasDST = 0
self.nFeasting = FeastType.FEAST_NULL
# data for vaisnava calculations
self.dayEvents = []
self.festivals = ''
self.nFastType = FastType.FAST_NULL
self.nMhdType = MahadvadasiType.EV_NULL
self.ekadasi_vrata_name = ''
self.ekadasi_parana = False
self.eparana_time1 = 0.0
self.eparana_time2 = 0.0
self.eparana_type1 = 0
self.eparana_type2 = 0
self.sankranti_zodiac = -1
#double sankranti_time
self.sankranti_day = GCGregorianDate()
def GetNaksatraTimeRange(self, earth, fromTime, toTime):
start = GCGregorianDate(date=self.date)
start.shour = self.astrodata.sun.sunrise_deg / 360 + earth.tzone / 24.0
GCNaksatra.GetNextNaksatra(earth, start, toTime)
GCNaksatra.GetPrevNaksatra(earth, start, fromTime)
return True
def __init__(self):
self.m_vcStart = GCGregorianDate()
self.m_vcEnd = GCGregorianDate()
self.m_options = 0
self.m_location = GCLocation()
self.p_events = []
self.b_sorted = True
def unittests():
GCUT.info('gc tithi')
e = GCEarthData.EARTHDATA()
e.longitude_deg = 27.0
e.latitude_deg = 45.0
e.tzone = 1.0
vc = Today()
vc2 = GCGregorianDate()
vc3 = GCGregorianDate(date=vc)
vc3.NextDay()
if False:
import io
s = io.StringIO()
clr = GCLocation.GCLocation()
writeXml(s, clr, vc)
GCUT.msg(s.getvalue())
s.seek(0)
writeGaurabdaTithiXml(s, clr, GCGaurabdaDate(2, 1, 512),
GCGaurabdaDate(20, 1, 514))
GCUT.msg('writeGaurabdaTithiXml')
GCUT.msg(s.getvalue())
s = io.StringIO()
writeGaurabdaNextTithiXml(s, clr, vc, GCGaurabdaDate(2, 1, 512))
GCUT.msg('writeGaurabdaNextTithiXml')
GCUT.msg(s.getvalue())
print(GetTithiTimes(e, vc, 0.25))
def GetTithiTimeRange(self, earth, fromTime, toTime):
start = GCGregorianDate(date=self.date)
start.shour = self.astrodata.sun.sunrise_deg / 360 + earth.tzone / 24.0
GCTithi.GetNextTithiStart(earth, start, toTime)
GCTithi.GetPrevTithiStart(earth, start, fromTime)
return True
def __init__(self):
self.m_location = GCLocation()
self.eventTime = GCGregorianDate()
self.details = GCDayData()
self.b_adhika = False
self.celeb_gy = [0] * TRESULT_APP_CELEBS
self.celeb_date = [
GCGregorianDate() for i in range(TRESULT_APP_CELEBS)
]
def GetNextSankranti(startDate):
zodiac = 0
step = 1.0
count = 0
prevday = GCGregorianDate()
d = GCGregorianDate(date=startDate)
prev = GCMath.putIn360(
GCSunData.GetSunLongitude(d) - GCAyanamsha.GetAyanamsa(d.GetJulian()))
prev_rasi = int(floor(prev / 30.0))
while count < 20:
prevday.Set(d)
d.shour += step
d.NormalizeHours()
ld = GCMath.putIn360(
GCSunData.GetSunLongitude(d) -
GCAyanamsha.GetAyanamsa(d.GetJulian()))
new_rasi = int(floor(ld / 30.0))
if prev_rasi != new_rasi:
zodiac = new_rasi
step *= 0.5
d.Set(prevday)
count += 1
continue
return d, zodiac
def unittests():
GCUT.info('sankranti')
vc = Today()
vc2 = GCGregorianDate()
vc3 = GCGregorianDate(date=vc)
vc3.AddDays(100)
n = GetSankMethodName(GetSankrantiType())
GCUT.msg('Sankranti Type: {}'.format(n))
import io
s = io.StringIO()
clr = GCLocation()
writeXml(s, clr, vc, vc3)
GCUT.msg(s.getvalue())
def writeHtml(self, stream):
stream.write("<html>\n<head>\n<title>Core Events</title>\n\n")
stream.write(
"<style>\n<!--\nbody {\n font-family:Verdana;\n font-size:11pt;\n}\n\ntd.hed {\n font-size:11pt;\n font-weight:bold;\n"
)
stream.write(
" background:#aaaaaa;\n color:white;\n text-align:center;\n vertical-align:center;\n padding-left:15pt;\n padding-right:15pt;\n"
)
stream.write(
" padding-top:5pt;\n padding-bottom:5pt;\n}\n-->\n</style>\n")
stream.write("</head>\n")
stream.write("<body>\n\n")
stream.write(
"<h1 align=center>Events</h1>\n<p align=center>From {} to {}.</p>\n\n"
.format(self.m_vcStart, self.m_vcEnd))
stream.write("<p align=center>{}</p>\n".format(
self.m_location.m_strFullName))
prevd = GCGregorianDate()
prevd.day = 0
prevd.month = 0
prevd.year = 0
prevt = -1
stream.write("<table align=center><tr>\n")
last_header = ''
new_header = ''
for dnr in self.p_events:
if self.b_sorted:
new_header = " {} - {} ".format(
dnr.Time, GCStrings.GetDayOfWeek(dnr.Time.dayOfWeek))
else:
new_header = self.header_text[dnr.nType]
if last_header != new_header:
stream.write(
f"<td class=\"hed\" colspan=2>{new_header}</td></tr>\n<tr>\n"
)
last_header = new_header
stream.write("<td>{}</td><td>{}</td></tr><tr>\n".format(
dnr.EventText(), dnr.Time.time_str()))
stream.write("</tr></table>\n")
stream.write(
"<hr align=center width=\"50%%\">\n<p align=center>Generated by {}</p>"
.format(GCStrings.getString(130)))
stream.write("</body>\n</html>\n")
return 1
def unittests():
GCUT.info('core events results')
loc = GCLocation(
data={
'latitude': 48.150002,
'longitude': 17.116667,
'tzid': 321,
'name': 'Bratislava, Slovakia'
})
earth = loc.GetEarthData()
today = Today()
future = GCGregorianDate(date=today, addDays=100)
tc = TCoreEvents()
print('start calculate', datetime.datetime.now())
tc.CalculateEvents(loc, today, future)
print('end calculate', datetime.datetime.now())
with open('test/events.xml', 'wt') as wf:
tc.formatXml(wf)
with open('test/events.txt', 'wt') as wf:
tc.formatText(wf)
with open('test/events.rtf', 'wt') as wf:
tc.formatRtf(wf)
with open('test/events.html', 'wt') as wf:
tc.writeHtml(wf)
def formatRtf(self, stream):
sb = GCStringBuilder(stream)
sb.Format = SBTF_RTF
sb.fontSizeH1 = GCLayoutData.textSizeH1
sb.fontSizeH2 = GCLayoutData.textSizeH2
sb.fontSizeText = GCLayoutData.textSizeText
sb.fontSizeNote = GCLayoutData.textSizeNote
sb.AppendDocumentHeader()
sb.AppendHeader1("Events")
stream.write("\\par from {} to {}.\\par\r\n\\par\r\n".format(
self.m_vcStart, self.m_vcEnd))
stream.write("{}\\par\r\n\\par\r\n".format(
self.m_location.m_strFullName))
prevd = GCGregorianDate()
prevd.day = 0
prevd.month = 0
prevd.year = 0
prevt = -1
last_header = ''
for dnr in self.p_events:
new_header = ''
if self.b_sorted:
new_header = " {} - {} ".format(
dnr.Time, GCStrings.GetDayOfWeek(dnr.Time.dayOfWeek))
else:
new_header = header_text[dnr.nType]
if last_header != new_header:
sb.AppendLine()
sb.AppendHeader2(new_header)
sb.AppendLine()
last_header = new_header
stream.write("\\par {} {} {}".format(
dnr.Time.time_str(), GCStrings.GetDSTSignature(dnr.nDst),
dnr.EventText()))
sb.AppendLine()
sb.AppendNote()
sb.AppendDocumentTail()
return 1
def unittests():
GCUT.info('conjunctions')
b = IsConjunction(10, 11, 12, 20)
GCUT.val(b, True, 'is conjunction')
e = GCEarthData.EARTHDATA()
e.longitude_deg = 27.0
e.latitude_deg = 45.0
e.tzone = 1.0
vc = Today()
vc2 = GCGregorianDate(date=vc)
vc3 = GCGregorianDate(date=vc)
l = GetPrevConjunction(vc2, e)
GCUT.msg('Conjunction on: {}'.format(repr(vc2)))
vc2.Set(vc)
l = GetNextConjunctionEx(vc2, vc3, True, e)
GCUT.msg('Conjunction on: {}'.format(repr(vc3)))
def unittests():
GCUT.info('yoga')
e = GCEarthData.EARTHDATA()
e.longitude_deg = 27.0
e.latitude_deg = 45.0
e.tzone = 1.0
vc = Today()
vc2 = GCGregorianDate()
GetNextYogaStart(e, vc, vc2)
print('Next yoga:', repr(vc2))
def CalculateMasaList(self, loc, year, count):
day = GCDayData()
earth = loc.GetEarthData()
self.startYear = year
self.countYears = count
self.start = GCGregorianDate(date=GetFirstDayOfYear(earth, year))
self.end = GCGregorianDate(date=GetFirstDayOfYear(earth, year + count))
self.location = GCLocation()
self.location.Set(loc)
i = 0
prev_masa = -1
prev_paksa = -1
prev_gyear = -1
current = 0
d = GCGregorianDate(date=self.start)
while d.IsBeforeThis(self.end):
day.DayCalc(d, earth)
if prev_paksa != day.nPaksa:
day.nMasa = day.MasaCalc(d, earth)
if prev_masa != day.nMasa:
if len(self.arr) > 0:
self.arr[-1]['end'] = GCGregorianDate(date=d,
addDays=-1)
prev_masa = day.nMasa
self.arr.append({
'masa':
day.nMasa,
'masaName':
GCStrings.GetMasaName(day.nMasa),
'year':
day.nGaurabdaYear,
'start':
GCGregorianDate(date=d)
})
prev_paksa = day.nPaksa
d.NextDay()
self.arr[-1]['end'] = GCGregorianDate(date=d, addDays=-1)
return len(self.arr)
def formatText(self, stream):
sb = GCStringBuilder(stream)
sb.Format = SBTF_TEXT
stream.write("Events from {} to {}.\r\n\r\n".format(
self.m_vcStart, self.m_vcEnd))
stream.write("{}\r\n\r\n".format(self.m_location.m_strFullName))
prevd = GCGregorianDate()
prevd.day = 0
prevd.month = 0
prevd.year = 0
prevt = -1
last_header = ''
for dnr in self.p_events:
new_header = ''
if self.b_sorted:
new_header = " {} - {} ".format(
dnr.Time, GCStrings.GetDayOfWeek(dnr.Time.dayOfWeek))
else:
new_header = header_text[dnr.nType]
if last_header != new_header:
sb.AppendLine()
sb.AppendHeader3(new_header)
sb.AppendLine()
last_header = new_header
stream.write(" {} {} {}".format(
dnr.Time.time_str(), GCStrings.GetDSTSignature(dnr.nDst),
dnr.EventText()))
sb.AppendLine()
sb.AppendLine()
sb.AppendNote()
return 1
def GetPrevConjunctionEx(test_date, found, this_conj, earth, forward=False):
phi = 12.0
dir = 1.0 if forward else -1.0
if this_conj:
test_date.shour += 0.2 * dir
test_date.NormalizeHours()
jday = test_date.GetJulianComplete()
moon = GCMoonData.MOONDATA()
d = GCGregorianDate(date=test_date)
xd = GCGregorianDate()
scan_step = 1.0
prev_tit = 0
new_tit = -1
moon.Calculate(jday, earth)
sunl = GCSunData.GetSunLongitude(d)
l1 = GCMath.putIn180(moon.longitude_deg - sunl)
prev_tit = int(math.floor(l1 / phi))
counter = 0
while counter < 20:
xj = jday
xd.Set(d)
jday += scan_step * dir
d.shour += scan_step * dir
d.NormalizeHours()
moon.Calculate(jday, earth)
sunl = GCSunData.GetSunLongitude(d)
l2 = GCMath.putIn180(moon.longitude_deg - sunl)
new_tit = int(math.floor(l2 / phi))
if forward:
is_change = prev_tit < 0 and new_tit >= 0
else:
is_change = prev_tit >= 0 and new_tit < 0
if is_change:
jday = xj
d.Set(xd)
scan_step *= 0.5
counter += 1
else:
l1 = l2
prev_tit = new_tit
found.Set(d)
return sunl
def GetTithiTimes(ed, vc, sunRise):
d1 = GCGregorianDate()
d2 = GCGregorianDate()
vc.shour = sunRise
GetPrevTithiStart(ed, vc, d1)
GetNextTithiStart(ed, vc, d2)
titBeg = d1.shour + d1.GetJulian() - vc.GetJulian()
titEnd = d2.shour + d2.GetJulian() - vc.GetJulian()
return titEnd - titBeg, titBeg, titEnd
def formatXml(self, stream):
d = self.details
vc = GCGregorianDate(date=self.eventTime)
m_earth = self.m_location.GetEarthData()
loc = self.m_location
bDuringAdhika = False
stream.write('''<xml>
<request name="AppDay" version="{}">
<arg name="longitude" value="{}" />
<arg name="latitude" value="{}" />
<arg name="timezone" value="{}" />
<arg name="year" value="{}" />
<arg name="month" value="{}" />
<arg name="day" value="{}" />
<arg name="hour" value="{}" />
<arg name="minute" value="{}" />
</request>'''.format(GCStrings.getString(130), loc.m_fLongitude,
loc.m_fLatitude, loc.m_fTimezone, self.eventTime.year,
self.eventTime.month, self.eventTime.day,
self.eventTime.GetHour(),
self.eventTime.GetMinuteRound()))
npada = int(floor(d.nNaksatraElapse / 25.0)) + 1
if (npada > 4): npada = 4
is_adhika = "yes" if bDuringAdhika else "no"
stream.write(
"\t<result name=\"AppDay\" >\n\t\t<tithi name=\"{}\" elapse=\"%f\" />\n\t\t<naksatra name=\"{}\" elapse=\"%f\" pada=\"{}\"/>\n\t\t<paksa name=\"{}\" />\n\t\t<masa name=\"{}\" adhikamasa=\"{}\"/>\n\t\t<gaurabda value=\"{}\" />\n"
.format(GCStrings.GetTithiName(d.nTithi), d.nTithiElapse,
GCStrings.GetNaksatraName(d.nNaksatra), d.nNaksatraElapse,
npada, GCStrings.GetPaksaName(d.nPaksa),
GCStrings.GetMasaName(d.nMasa), is_adhika,
d.nGaurabdaYear))
stream.write("\t\t<celebrations>\n")
for i in range(TRESULT_APP_CELEBS):
stream.write(
"\t\t\t<celebration gaurabda=\"{}\" day=\"{}\" month=\"{}\" monthabr=\"{}\" year=\"{}\" />\n"
.format(
self.celeb_gy[i], self.celeb_date[i].day,
self.celeb_date[i].month,
GCStrings.GetMonthAbreviation(self.celeb_date[i].month),
self.celeb_date[i].year))
stream.write("\t\t</celebrations>\n\t</result>\n</xml>\n")
def unittests():
GCUT.info('calendar')
e = EARTHDATA()
e.longitude_deg = 27.0
e.latitude_deg = 45.0
e.tzone = 1.0
vc = Today()
a = GetGaurabdaYear(vc, e)
GCUT.msg('Gaurabda year:' + str(a))
va = GCGaurabdaDate()
Gregorian2Gaurabda(vc, va, e)
GCUT.msg('Vatime: ' + str(va))
va.prevMasa()
va.tithi = 0
vc2 = GCGregorianDate()
Gaurabda2Gregorian(va, vc2, e)
GCUT.msg('vctime2:' + str(vc2) + ' --> ' + str(va))
def GetNextYogaStart(ed, startDate, nextDate):
phi = 40.0 / 3.0
jday = startDate.GetJulianComplete()
moon = MOONDATA()
d = GCGregorianDate(date=startDate)
xd = GCGregorianDate()
scan_step = 0.5
prev_tit = 0
new_tit = -1
ayanamsha = GCAyanamsha.GetAyanamsa(jday)
moon.Calculate(jday, ed)
sunl = GetSunLongitude(d)
l1 = GCMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsha)
prev_tit = int(floor(l1 / phi))
counter = 0
while counter < 20:
xj = jday
xd.Set(d)
jday += scan_step
d.shour += scan_step
d.NormalizeHours()
moon.Calculate(jday, ed)
sunl = GetSunLongitude(d)
l2 = GCMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsha)
new_tit = int(floor(l2 / phi))
if prev_tit != new_tit:
jday = xj
d.Set(xd)
scan_step *= 0.5
counter += 1
continue
else:
l1 = l2
nextDate.Set(d)
return new_tit
def GetNextTithiStart(ed, startDate, nextDate, forward=True):
phi = 12.0
jday = startDate.GetJulianComplete()
moon = MOONDATA()
d = GCGregorianDate(date=startDate)
xd = GCGregorianDate()
dir = 1.0 if forward else -1.0
scan_step = 0.5 * dir
prev_tit = 0
new_tit = -1
moon.Calculate(jday, ed)
sunl = GetSunLongitude(d)
l1 = GCMath.putIn360(moon.longitude_deg - sunl - 180.0)
prev_tit = int(floor(l1 / phi))
counter = 0
while counter < 20:
xj = jday
xd.Set(d)
jday += scan_step
d.shour += scan_step
d.NormalizeHours()
moon.Calculate(jday, ed)
sunl = GetSunLongitude(d)
l2 = GCMath.putIn360(moon.longitude_deg - sunl - 180.0)
new_tit = int(floor(l2 / phi))
if prev_tit != new_tit:
jday = xj
d.Set(xd)
scan_step *= 0.5
counter += 1
continue
else:
l1 = l2
nextDate.Set(d)
return new_tit
def GetFirstDayOfYear(earth, nYear):
a = [2, 15, 3, 1, 3, 15, 4, 1, 4, 15]
d = GCGregorianDate()
day = GCDayData()
if nYear >= 1950 and nYear < 2058:
tmp = gGaurBeg[(nYear - 1950) * 26 + 22]
d.month = (tmp & 0x3e0) >> 5
d.day = (tmp & 0x1f)
d.year = nYear
d.NextDay()
a[0] = d.month
a[1] = d.day
for i in range(0, 10, 2):
d.year = nYear
d.month = a[i]
d.day = a[i + 1]
day.DayCalc(d, earth)
masa = day.MasaCalc(d, earth)
gy = day.nGaurabdaYear
if masa == 11: # visnu masa
while True:
# shifts date
step = max(int(day.nTithi / 2), 1)
for j in range(step):
d.PreviousDay()
# try new time
day.DayCalc(d, earth)
if day.nTithi >= 28: break
d.NextDay()
d.tzone = earth.tzone
d.shour = day.sun.sunrise_deg / 360.0
return d
d.year = -1
d.month = -1
d.day = -1
d.tzone = earth.tzone
d.shour = day.sun.sunrise_deg / 360.0
return d
def MasaCalc(self, date, earth):
PREV_MONTHS = 6
L = [0] * 8
C = [GCGregorianDate() for i in range(8)]
R = [0] * 8
ksaya_from = -1
ksaya_to = -1
date.shour = self.sun.sunrise_deg / 360.0 + earth.tzone / 24.0
# STEP 1: calculate position of the sun and moon
# it is done by previous call of DayCalc
# and results are in argument GCDayData day
# *DayCalc(date, earth, day, moon, sun);*
L[1] = GCConjunction.GetNextConjunctionEx(date, C[1], False, earth)
L[0] = GCConjunction.GetNextConjunctionEx(C[1], C[0], True, earth)
# on Pratipat (nTithi == 15) we need to look for previous conjunction
# but this conjunction can occur on this date before sunrise
# so we need to include this very date into looking for conjunction
# on other days we cannot include it
# and exclude it from looking for next because otherwise that will cause
# incorrect detection of Purusottama adhika masa
L[2] = GCConjunction.GetPrevConjunctionEx(date, C[2], False, earth)
for n in range(3, PREV_MONTHS):
L[n] = GCConjunction.GetPrevConjunctionEx(C[n - 1], C[n], True,
earth)
for n in range(0, PREV_MONTHS):
R[n] = GCRasi.GetRasi(L[n],
GCAyanamsha.GetAyanamsa(C[n].GetJulian()))
# TRACE("TEST Date: %d %d %d\n", date.day, date.month, date.year)
# TRACE("FOUND CONJ Date: %d %d %d rasi: %d\n", C[1].day, C[1].month, C[1].year, R[1])
# TRACE("FOUND CONJ Date: %d %d %d rasi: %d\n", C[2].day, C[2].month, C[2].year, R[2])
# TRACE("FOUND CONJ Date: %d %d %d rasi: %d\n", C[3].day, C[3].month, C[3].year, R[3])
# TRACE("FOUND CONJ Date: %d %d %d rasi: %d\n", C[4].day, C[4].month, C[4].year, R[4])
# TRACE("---\n")
# look for ksaya month
ksaya_from = -1
for n in range(PREV_MONTHS - 2, 0, -1):
if (R[n + 1] + 2) % 12 == R[n]:
ksaya_from = n
break
if ksaya_from >= 0:
for n in range(ksaya_from, 0, -1):
if R[n] == R[n - 1]:
ksaya_to = n
break
if ksaya_to >= 0:
pass
# adhika masa found
# now correct succession of rasis
else:
# adhika masa not found
# there will be some break in masa queue
ksaya_to = 0
current_rasi = R[ksaya_from + 1] + 1
for n in range(ksaya_from, ksaya_to - 1, -1):
R[n] = current_rasi
current_rasi = (current_rasi + 1) % 12
# STEP 3: test for adhika masa
# test for adhika masa
if R[1] == R[2]:
# it is adhika masa
masa = 12
rasi = R[1]
else:
# STEP 2. select nearest Conjunction
if self.nPaksa == 0:
masa = R[1]
elif self.nPaksa == 1:
masa = R[2]
rasi = masa
# calculation of Gaurabda year
self.nGaurabdaYear = date.year - 1486
if (rasi > 7) and (rasi < 11): # Visnu
if date.month < 6:
self.nGaurabdaYear -= 1
self.nMasa = masa
return masa
def CalcTithiDate(nGYear, nMasa, nPaksa, nTithi, earth):
i = 0
gy = 0
d = GCGregorianDate()
dtemp = GCGregorianDate()
day = GCDayData()
tithi = 0
counter = 0
tmp = 0
if nGYear >= 464 and nGYear < 572:
tmp = gGaurBeg[(nGYear - 464) * 26 + nMasa * 2 + nPaksa]
d.month = (tmp & 0x3e0) >> 5
d.day = (tmp & 0x1f)
d.year = (tmp & 0xfffc00) >> 10
d.tzone = earth.tzone
d.NextDay()
day.DayCalc(d, earth)
day.nMasa = day.MasaCalc(d, earth)
gy = day.nGaurabdaYear
else:
#d = GetFirstDayOfYear(earth, nGYear + 1486)
d.day = 15
d.month = 2 + nMasa
d.year = nGYear + 1486
if d.month > 12:
d.month -= 12
d.year += 1
d.shour = 0.5
d.tzone = earth.tzone
i = 0
while True:
d.AddDays(13)
day.DayCalc(d, earth)
day.nMasa = day.MasaCalc(d, earth)
gy = day.nGaurabdaYear
i += 1
if i >= 30: break
if (day.nPaksa == nPaksa) and (day.nMasa == nMasa): break
if i >= 30:
d.year = d.month = d.day = -1
return d
# we found masa and paksa
# now we have to find tithi
tithi = nTithi + nPaksa * 15
if day.nTithi == tithi:
# loc1
# find tithi juncts in this day and according to that times,
# look in previous or next day for end and start of this tithi
d.PreviousDay()
day.DayCalc(d, earth)
if (day.nTithi > tithi) and (day.nPaksa != nPaksa):
d.NextDay()
return d
if day.nTithi < tithi:
# do increment of date until nTithi == tithi
# but if nTithi > tithi
# then do decrement of date
counter = 0
while counter < 16:
d.NextDay()
day.DayCalc(d, earth)
if day.nTithi == tithi:
return d
if (day.nTithi < tithi) and (day.nPaksa != nPaksa):
return d
if day.nTithi > tithi:
return d
counter += 1
# somewhere is error
d.year = d.month = d.day = 0
return d
else:
# do decrement of date until nTithi <= tithi
counter = 0
while counter < 16:
d.PreviousDay()
day.DayCalc(d, earth)
if day.nTithi == tithi:
return d
if (day.nTithi > tithi) and (day.nPaksa != nPaksa):
d.NextDay()
return d
if day.nTithi < tithi:
d.NextDay()
return d
counter += 1
# somewhere is error
d.year = d.month = d.day = 0
return d
# now we know the type of day-accurancy
# nType = 0 means, that we dont found a day
# nType = 1 means, we find day, when tithi was present at sunrise
# nType = 2 means, we found day, when tithi started after sunrise
# but ended before next sunrise
#
return d
def GetPrevConjunction(date, earth, forward=False):
prevSun = 0.0
prevMoon = 0.0
prevDiff = 0.0
nowSun = 0.0
nowMoon = 0.0
nowDiff = 0.0
dir = 1.0 if forward else -1.0
moon = GCMoonData.MOONDATA()
d = GCGregorianDate(date=date)
d.shour = 0.5
d.tzone = 0.0
jd = d.GetJulian()
# set initial data for input day
# NOTE: for grenwich
moon.Calculate(jd, earth)
prevSun = GCSunData.GetSunLongitude(d)
prevMoon = moon.longitude_deg
prevDiff = GCMath.putIn180(prevSun - prevMoon)
for bCont in range(32):
if forward:
d.NextDay()
else:
d.PreviousDay()
jd += dir
moon.Calculate(jd, earth)
nowSun = GCSunData.GetSunLongitude(d)
nowMoon = moon.longitude_deg
nowDiff = GCMath.putIn180(nowSun - nowMoon)
if IsConjunction(nowMoon, nowSun, prevSun, prevMoon):
# now it calculates actual time and zodiac of conjunction
if prevDiff == nowDiff: return 0
x = math.fabs(nowDiff) / math.fabs(prevDiff - nowDiff)
if x < 0.5:
if forward: d.PreviousDay()
d.shour = x + 0.5
else:
if not forward: d.NextDay()
d.shour = x - 0.5
date.Set(d)
prevSun = GCMath.putIn360(prevSun)
nowSun = GCMath.putIn360(nowSun)
if math.fabs(prevSun - nowSun) > 10.0:
return GCMath.putIn180(nowSun) + (GCMath.putIn180(prevSun) -
GCMath.putIn180(nowSun)) * x
else:
return nowSun + (prevSun - nowSun) * x
prevSun = nowSun
prevMoon = nowMoon
prevDiff = nowDiff
return 1000.0
def writeXml(xml, loc, vc):
date = GCGregorianDate()
xml.write("<xml>\n")
xml.write("\t<request name=\"Tithi\" version=\"")
xml.write(GCStrings.getString(130))
xml.write("\">\n")
xml.write("\t\t<arg name=\"longitude\" val=\"")
xml.write(str(loc.m_fLongitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"latitude\" val=\"")
xml.write(str(loc.m_fLatitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"timezone\" val=\"")
xml.write(str(loc.m_fTimezone))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"startdate\" val=\"")
xml.write(str(vc))
xml.write("\" />\n")
xml.write("\t</request>\n")
xml.write("\t<result name=\"Tithi\">\n")
d1 = GCGregorianDate()
d2 = GCGregorianDate()
dn = GCGregorianDate()
dt = GCTime()
earth = loc.GetEarthData()
day = GCDayData()
day.DayCalc(vc, earth)
d = GCGregorianDate(date=vc)
d.tzone = loc.m_fTimezone
d.shour = day.sun.sunrise_deg / 360.0 + loc.m_fTimezone / 24.0
GCTithi.GetPrevTithiStart(earth, d, d1)
GCTithi.GetNextTithiStart(earth, d, d2)
dt.SetDegTime(d1.shour * 360)
# start tithi at t[0]
xml.write("\t\t<tithi\n\t\t\tid=\"")
xml.write(str(day.nTithi))
xml.write("\"\n")
xml.write("\t\t\tname=\"")
xml.write(GCStrings.GetTithiName(day.nTithi))
xml.write("\"\n")
xml.write("\t\t\tstartdate=\"")
xml.write(str(d1))
xml.write("\"\n")
xml.write("\t\t\tstarttime=\"")
xml.write(repr(dt))
xml.write("\"\n")
dt.SetDegTime(d2.shour * 360)
xml.write("\t\t\tenddate=\"")
xml.write(str(d2))
xml.write("\"\n")
xml.write("\t\t\tendtime=\"")
xml.write(repr(dt))
xml.write("\"\n />")
xml.write("\t</result>\n")
xml.write("</xml>\n")
return 1
def writeXml(xml, loc, vcStart, vcEnd):
dt = GCTime()
zodiac = 0
d = GCGregorianDate(date=vcStart)
xml.write("<xml>\n")
xml.write("\t<request name=\"Sankranti\" version=\"")
xml.write(GCStrings.getString(130))
xml.write("\">\n")
xml.write("\t\t<arg name=\"longitude\" val=\"")
xml.write(str(loc.m_fLongitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"latitude\" val=\"")
xml.write(str(loc.m_fLatitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"timezone\" val=\"")
xml.write(str(loc.m_fTimezone))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"location\" val=\"")
xml.write(loc.m_strName)
xml.write("\" />\n")
xml.write("\t\t<arg name=\"startdate\" val=\"")
xml.write(repr(vcStart))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"enddate\" val=\"")
xml.write(repr(vcEnd))
xml.write("\" />\n")
xml.write("\t</request>\n")
xml.write("\t<result name=\"SankrantiList\">\n")
while d.IsBeforeThis(vcEnd):
nextDate, zodiac = GetNextSankranti(d)
d.Set(nextDate)
d.InitWeekDay()
xml.write("\t\t<sank date=\"")
xml.write(str(d))
xml.write("\" ")
xml.write("dayweekid=\"")
xml.write(str(d.dayOfWeek))
xml.write("\" dayweek=\"")
xml.write(GCStrings.getString(d.dayOfWeek))
xml.write("\" ")
dt.SetDegTime(360 * d.shour)
xml.write(" time=\"")
xml.write(repr(dt))
xml.write("\" >\n")
xml.write("\t\t\t<zodiac sans=\"")
xml.write(GCStrings.GetSankrantiName(zodiac))
xml.write("\" eng=\"")
xml.write(GCStrings.GetSankrantiNameEn(zodiac))
xml.write("\" id=\"")
xml.write(str(zodiac))
xml.write("\" />\n")
xml.write("\t\t</sank>\n")
d.NextDay()
d.NextDay()
xml.write("\t</result>\n")
xml.write("</xml>")
return 1
def writeGaurabdaTithiXml(xml, loc, vaStart, vaEnd):
gyearA = vaStart.gyear
gyearB = vaEnd.gyear
gmasa = vaStart.masa
gpaksa = 1 if vaStart.tithi >= 15 else 0
gtithi = vaStart.tithi % 15
if gyearB < gyearA:
gyearB = gyearA
xml.write("<xml>\n")
xml.write("\t<request name=\"Tithi\" version=\"")
xml.write(GCStrings.getString(130))
xml.write("\">\n")
xml.write("\t\t<arg name=\"longitude\" val=\"")
xml.write(str(loc.m_fLongitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"latitude\" val=\"")
xml.write(str(loc.m_fLatitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"timezone\" val=\"")
xml.write(str(loc.m_fTimezone))
xml.write("\" />\n")
if gyearA > 1500:
xml.write("\t\t<arg name=\"year-start\" val=\"")
xml.write(str(gyearA))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"year-end\" val=\"")
xml.write(str(gyearB))
xml.write("\" />\n")
else:
xml.write("\t\t<arg name=\"gaurabdayear-start\" val=\"")
xml.write(str(gyearA))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"gaurabdayear-end\" val=\"")
xml.write(str(gyearB))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"masa\" val=\"")
xml.write(str(gmasa))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"paksa\" val=\"")
xml.write(str(gpaksa))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"tithi\" val=\"")
xml.write(str(gtithi))
xml.write("\" />\n")
xml.write("\t</request>\n")
xml.write("\t<result name=\"Tithi\">\n")
earth = loc.GetEarthData()
vcs = GCGregorianDate()
vce = GCGregorianDate()
today = GCGregorianDate()
sun = SUNDATA()
day = GCDayData()
A = B = 0
if gyearA > 1500:
A = gyearA - 1487
B = gyearB - 1485
else:
A = gyearA
B = gyearB
for A in range(A, B + 1):
vcs.Set(GCTithi.CalcTithiEnd(A, gmasa, gpaksa, gtithi, earth, vce))
if gyearA > 1500:
if (vcs.year < gyearA) or (vcs.year > gyearB):
continue
oTithi = gpaksa * 15 + gtithi
oMasa = gmasa
oPaksa = gpaksa
oYear = 0
xml.write("\t<celebration\n")
xml.write("\t\trtithi=\"")
xml.write(GCStrings.GetTithiName(oTithi))
xml.write("\"\n")
xml.write("\t\trmasa=\"")
xml.write(GCStrings.GetMasaName(oMasa))
xml.write("\"\n")
xml.write("\t\trpaksa=\"")
xml.write('Gaura' if oPaksa else "Krsna")
xml.write("\"\n")
# test ci je ksaya
today.Set(vcs)
today.shour = 0.5
sun.SunCalc(today, earth)
sunrise = (sun.sunrise_deg + loc.m_fTimezone * 15.0) / 360
if sunrise < vcs.shour:
today.Set(vce)
sun.SunCalc(today, earth)
sunrise = (sun.sunrise_deg + loc.m_fTimezone * 15.0) / 360
if sunrise < vce.shour:
# normal type
vcs.NextDay()
xml.write("\t\ttype=\"normal\"\n")
else:
# ksaya
vcs.NextDay()
day.DayCalc(vcs, earth)
oTithi = day.nTithi
oPaksa = day.nPaksa
oMasa = day.MasaCalc(vcs, earth)
oYear = day.nGaurabdaYear
xml.write("\t\ttype=\"ksaya\"\n")
else:
# normal, alebo prvy den vriddhi
today.Set(vce)
sun.SunCalc(today, earth)
if (sun.sunrise_deg + loc.m_fTimezone * 15.0) / 360 < vce.shour:
# first day of vriddhi type
xml.write("\t\ttype=\"vriddhi\"\n")
else:
# normal
xml.write("\t\ttype=\"normal\"\n")
xml.write("\t\tdate=\"")
xml.write(str(vcs))
xml.write("\"\n")
xml.write("\t\totithi=\"")
xml.write(GCStrings.GetTithiName(oTithi))
xml.write("\"\n")
xml.write("\t\tomasa=\"")
xml.write(GCStrings.GetMasaName(oMasa))
xml.write("\"\n")
xml.write("\t\topaksa=\"")
xml.write('Gaura' if oPaksa else 'Krsna')
xml.write("\"\n")
xml.write("\t/>\n")
xml.write("\t</result>\n")
xml.write("</xml>\n")
return 1
def writeGaurabdaNextTithiXml(xml, loc, vcStart, vaStart):
gmasa = vaStart.masa
gpaksa = 1 if vaStart.tithi >= 15 else 0
gtithi = vaStart.tithi % 15
xml.write("<xml>\n")
xml.write("\t<request name=\"Tithi\" version=\"")
xml.write(GCStrings.getString(130))
xml.write("\">\n")
xml.write("\t\t<arg name=\"longitude\" val=\"")
xml.write(str(loc.m_fLongitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"latitude\" val=\"")
xml.write(str(loc.m_fLatitude))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"timezone\" val=\"")
xml.write(str(loc.m_fTimezone))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"start date\" val=\"")
xml.write(str(vcStart))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"masa\" val=\"")
xml.write(str(gmasa))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"paksa\" val=\"")
xml.write(str(gpaksa))
xml.write("\" />\n")
xml.write("\t\t<arg name=\"tithi\" val=\"")
xml.write(str(gtithi))
xml.write("\" />\n")
xml.write("\t</request>\n")
xml.write("\t<result name=\"Tithi\">\n")
earth = loc.GetEarthData()
vcs = GCGregorianDate()
vce = GCGregorianDate()
sun = SUNDATA()
A = 0
day = GCDayData()
today = GCGregorianDate(date=vcStart)
today.PreviousDay()
vcStart.SubtractDays(15)
for A in range(0, 4):
vcs.Set(
GCTithi.CalcTithiEndEx(vcStart, 0, gmasa, gpaksa, gtithi, earth,
vce))
if not vcs.IsBeforeThis(today):
oTithi = gpaksa * 15 + gtithi
oMasa = gmasa
oPaksa = gpaksa
oYear = 0
xml.write("\t<celebration\n")
xml.write("\t\trtithi=\"")
xml.write(GCStrings.GetTithiName(oTithi))
xml.write("\"\n")
xml.write("\t\trmasa=\"")
xml.write(GCStrings.GetMasaName(oMasa))
xml.write("\"\n")
xml.write("\t\trpaksa=\"")
xml.write("Gaura" if oPaksa else "Krsna")
xml.write("\"\n")
# test ci je ksaya
today.Set(vcs)
today.shour = 0.5
sun.SunCalc(today, earth)
sunrise = (sun.sunrise_deg + loc.m_fTimezone * 15.0) / 360
if sunrise < vcs.shour:
today.Set(vce)
sun.SunCalc(today, earth)
sunrise = (sun.sunrise_deg + loc.m_fTimezone * 15.0) / 360
if sunrise < vce.shour:
# normal type
vcs.NextDay()
xml.write("\t\ttype=\"normal\"\n")
else:
# ksaya
vcs.NextDay()
day.DayCalc(vcs, earth)
oTithi = day.nTithi
oPaksa = day.nPaksa
oMasa = day.MasaCalc(vcs, earth)
oYear = day.nGaurabdaYear
xml.write("\t\ttype=\"ksaya\"\n")
else:
# normal, alebo prvy den vriddhi
today.Set(vce)
sun.SunCalc(today, earth)
if (sun.sunrise_deg +
loc.m_fTimezone * 15.0) / 360 < vce.shour:
# first day of vriddhi type
xml.write("\t\ttype=\"vriddhi\"\n")
else:
# normal
xml.write("\t\ttype=\"normal\"\n")
xml.write("\t\tdate=\"")
xml.write(str(vcs))
xml.write("\"\n")
xml.write("\t\totithi=\"")
xml.write(GCStrings.GetTithiName(oTithi))
xml.write("\"\n")
xml.write("\t\tomasa=\"")
xml.write(GCStrings.GetMasaName(oMasa))
xml.write("\"\n")
xml.write("\t\topaksa=\"")
xml.write("Gaura" if oPaksa else "Krsna")
xml.write("\"\n")
xml.write("\t/>\n")
break
else:
vcStart.Set(vcs)
vcs.NextDay()
xml.write("\t</result>\n")
xml.write("</xml>\n")
return 1
