public void CopyFrom(GCConfigRatedEvents srcConf)
{
List <ParameterDescriptor> target = this.ParameterDescriptions;
List <ParameterDescriptor> source = srcConf.ParameterDescriptions;
for (int index = 0; index < target.Count; index++)
{
ParameterDescriptor a = target[index];
ParameterDescriptor b = source[index];
if (a.Array != null)
{
for (int i = a.Min; i < a.Max; i++)
{
a.Array[i].Rating = b.Array[i].Rating;
a.Array[i].Note = b.Array[i].Note;
a.Array[i].Margins = b.Array[i].CloneMargins();
}
}
else if (a.Array2 != null)
{
for (int i = a.Min; i < a.Max; i++)
{
for (int j = a.Min2; j < a.Max2; j++)
{
a.Array2[i, j].Rating = b.Array2[i, j].Rating;
a.Array2[i, j].Note = b.Array2[i, j].Note;
a.Array2[i, j].Margins = b.Array2[i, j].CloneMargins();
}
}
}
}
}
public static int DeleteConfiguration(GCConfigRatedEvents gCConfigRatedEvents)
{
int i = Configurations.IndexOf(gCConfigRatedEvents);
if (i >= 0 && i < Configurations.Count)
{
Configurations.RemoveAt(i);
}
return(i);
}
public static void RefreshListFromDirectory(string folder)
{
Configurations.Clear();
directoryPath = folder;
foreach (string file in Directory.EnumerateFiles(folder))
{
if (file.EndsWith(".recn"))
{
GCConfigRatedEvents gc = new GCConfigRatedEvents();
gc.Load(Path.Combine(folder, file));
Configurations.Add(gc);
}
}
if (Configurations.Count < 1)
{
Configurations.Add(DefaultConfiguration);
DefaultConfiguration.Save(Path.Combine(folder, "Default.recn"));
}
}
/// <summary>
/// - save to disk
/// - add to configurations
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public static GCConfigRatedEvents CreateConfiguration(string title)
{
GCConfigRatedEvents ne = new GCConfigRatedEvents();
ne.Title = title;
bool notFound = true;
int i = 0;
string file = "";
string fileName = null;
while (notFound)
{
file = string.Format("ratev{0:000}", i++);
fileName = Path.Combine(directoryPath, file);
notFound = ExistsFile(fileName);
}
ne.Save(fileName);
Configurations.Add(ne);
return(ne);
}
public void CompleteCalculation(GCLocation loc, GregorianDateTime vcStart, GregorianDateTime vcEnd, GCConfigRatedEvents rec)
{
// calculate raw events
CalculateEvents(loc, vcStart, vcEnd, rec);
// sort them
Sort();
foreach (GCRatedMoment tde in p_ratings)
{
Debugger.Log(0, "", " DE: " + tde.ToString() + "\n");
}
// create rated time intervals
CreateRatedList(rec);
}
/// <summary>
/// Creating list of intervals based on single moments
/// </summary>
/// <param name="rec"></param>
public void CreateRatedList(GCConfigRatedEvents rec)
{
StringBuilder sb = new StringBuilder();
List <string> nt = new List <string>();
Intervals.Clear();
Dictionary <string, GCRatedMoment> notes = new Dictionary <string, GCRatedMoment>();
GCRatedMoment lastRec = null;
double lastMoment = -1;
double thisMoment = 0;
foreach (GCRatedMoment rm in p_ratings)
{
thisMoment = rm.JulianDay.GetJulianComplete();
if (lastMoment < 0)
{
lastMoment = thisMoment;
lastRec = rm;
}
// test if this period is acceptable
if ((rec.useMinPeriodLength && rec.minPeriodLength < (thisMoment - lastMoment) * 1440.0) ||
!rec.useMinPeriodLength)
{
GCRatedInterval gi = new GCRatedInterval();
gi.startTime = lastRec.JulianDay;
gi.endTime = rm.JulianDay;
nt.Clear();
sb.Clear();
foreach (string k in notes.Keys)
{
GCRatedMoment b = notes[k];
if (b.Rating < 0.0)
{
gi.ratingNeg += b.Rating;
}
else if (b.Rating > 0.0)
{
gi.ratingPos += b.Rating;
}
if (b.Note != null && b.Note.Length > 0)
{
nt.Add(b.Note);
}
if (Math.Abs(b.Rating) > 0.001)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(b.Title);
}
}
// last test for acceptance limit
if (!rec.useAcceptLimit || (gi.ratingPos + gi.ratingNeg > rec.acceptLimit))
{
if (sb.Length > 0)
{
if (nt.Count > 0)
{
gi.Notes = nt.ToArray <string>();
}
gi.Title = sb.ToString();
Intervals.Add(gi);
}
}
}
if (rm.Key != null)
{
notes[rm.Key] = rm;
}
lastMoment = thisMoment;
lastRec = rm;
}
// calculate percentage
double max = rec.GetMaximum();
foreach (GCRatedInterval interval in Intervals)
{
interval.ResultRatio = Convert.ToInt32((interval.ratingPos + interval.ratingNeg) * 100.0 / max);
interval.ResultRatio = Math.Max(interval.ResultRatio, -100);
}
// sorting
GCRatedInterval.IntervalComparer ic = new GCRatedInterval.IntervalComparer();
Intervals.Sort(ic);
}
private void CalculateKalam(GregorianDateTime vcAdd, double sunRise, double sunSet, int kalaType, GCConfigRatedEvents rec)
{
double r1, r2;
GCSunData.CalculateKala(sunRise, sunSet, vcAdd.dayOfWeek, out r1, out r2, kalaType);
if (r1 > 0 && r2 > 0)
{
vcAdd.shour = r1;
//AddEvent(vcAdd, CoreEventType.CCTYPE_KALA_START, kalaType, ndst);
AddRating(vcAdd, rec.rateKalas[kalaType], rec.rateKalas[KalaType.KT_NONE]);
vcAdd.shour = r2;
//AddEvent(vcAdd, CoreEventType.CCTYPE_KALA_END, kalaType, ndst);
AddRating(vcAdd, rec.rateKalas[KalaType.KT_NONE], rec.rateKalas[kalaType]);
}
}
private void CalculateMoonTimes(GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCEarthData earth, GCConfigRatedEvents rec)
{
GregorianDateTime vcNext = new GregorianDateTime();
vcAdd.SubtractDays(2);
while (vcAdd.IsBeforeThis(vcEnd))
{
vcNext.Set(GCMoonData.GetNextRise(earth, vcAdd, true));
vcNext.AddHours(earth.TimeZone.GetBiasMinutesForDay(vcNext) / 60.0);
//AddEvent(vcNext, CoreEventType.CCTYPE_M_RISE, 0, ndst);
AddRating(vcNext, rec.rateMoonTime[0], rec.rateMoonTime[1]);
vcNext.Set(GCMoonData.GetNextRise(earth, vcNext, false));
vcNext.AddHours(earth.TimeZone.GetBiasMinutesForDay(vcNext) / 60.0);
//AddEvent(vcNext, CoreEventType.CCTYPE_M_SET, 0, ndst);
AddRating(vcNext, rec.rateMoonTime[1], rec.rateMoonTime[0]);
vcNext.shour += 0.05;
vcNext.NormalizeValues();
vcAdd.Set(vcNext);
}
}
private void CalculatePlanetHouse(int bodyId, GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCConfigRatedEvents rec)
{
int nData;
double JD, JDE;
GCEarthData earth = loc.GetEarthData();
JD = vcAdd.GetJulian() - 0.5 - loc.OffsetUtcHours / 24.0;
JDE = vcEnd.GetJulian() + 0.5 - loc.OffsetUtcHours / 24.0;
// initial rasi at the start date 00:00
nData = GCMath.IntFloor(GetPlanetHouse(GCVSOPAstronomy.GetPlanetLongitude(bodyId, JD), JD, earth));
AddRating(JD, loc, rec.rateGrahaHouse[bodyId, nData], rec.rateGrahaHouse[bodyId, Prev(nData, 12)]);
while ((JD = FindNextHouseChange(JD, JDE, bodyId, earth, out nData)) < JDE)
{
AddRating(JD, loc, rec.rateGrahaHouse[bodyId, nData], rec.rateGrahaHouse[bodyId, Prev(nData, 12)]);
JD += 1.0 / 24.0;
}
}
private void CalculatePlanetRasi(int bodyId, GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCConfigRatedEvents rec)
{
int nData;
double JD, JDE;
JD = vcAdd.GetJulian() - 0.5 - loc.OffsetUtcHours / 24.0;
JDE = vcEnd.GetJulian() + 0.5 - loc.OffsetUtcHours / 24.0;
nData = GCMath.IntFloor(GCMath.putIn360(GCVSOPAstronomy.GetPlanetLongitude(bodyId, JD) - GCAyanamsha.GetAyanamsa(JD)) / 30.0);
// initial rasi at the start date 00:00
AddRating(JD, loc, rec.rateGrahaRasi[bodyId, nData], rec.rateGrahaRasi[bodyId, Prev(nData, 12)]);
while ((JD = FindNextRasiChange(JD, JDE, bodyId, out nData)) < JDE)
{
AddRating(JD, loc, rec.rateGrahaRasi[bodyId, nData], rec.rateGrahaRasi[bodyId, Prev(nData, 12)]);
JD += 1.0;
}
}
private void CalculateMoonRasi(GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCEarthData earth, GCConfigRatedEvents rec)
{
CalculatePlanetRasi(1, loc, vcEnd, vcAdd, rec);
}
private void CalculateSunRasi(GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCConfigRatedEvents rec)
{
int nData;
GregorianDateTime vcNext = new GregorianDateTime();
int ndst;
GCEarthData earth = loc.GetEarthData();
vcAdd.SubtractDays(30);
while (vcAdd.IsBeforeThis(vcEnd))
{
vcNext.Set(GCSankranti.GetNextSankranti(vcAdd, earth, out nData));
if (vcNext.GetDayInteger() < vcEnd.GetDayInteger())
{
vcNext.InitWeekDay();
vcNext.AddHours(loc.TimeZone.GetBiasMinutesForDay(vcNext) / 60.0);
//AddEvent(vcNext, CoreEventType.CCTYPE_SANK, nData, ndst);
AddRating(vcNext, rec.rateGrahaRasi[0, nData], rec.rateGrahaRasi[0, Prev(nData, 12)]);
}
else
{
break;
}
vcAdd.Set(vcNext);
vcAdd.NextDay();
}
}
private int CalculateYoga(GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCEarthData earth, GCConfigRatedEvents rec)
{
int nData = 0;
GregorianDateTime vcNext = new GregorianDateTime();
int ndst;
vcAdd.SubtractDays(1);
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = GCYoga.GetNextYogaStart(earth, vcAdd, out vcNext);
if (vcNext.GetDayInteger() < vcEnd.GetDayInteger())
{
vcNext.InitWeekDay();
vcNext.AddHours(loc.TimeZone.GetBiasMinutesForDay(vcNext) / 60.0);
//AddEvent(vcNext, CoreEventType.CCTYPE_YOGA, nData, ndst);
AddRating(vcNext, rec.rateYoga[nData], rec.rateYoga[Prev(nData, 27)]);
}
else
{
break;
}
vcAdd.Set(vcNext);
vcAdd.shour += 0.2;
if (vcAdd.shour >= 1.0)
{
vcAdd.shour -= 1.0;
vcAdd.NextDay();
}
}
return(nData);
}
private int CalculateNaksatras(GCLocation loc, GregorianDateTime vcEnd, GregorianDateTime vcAdd, GCEarthData earth, GCConfigRatedEvents rec)
{
int nData = 0;
GregorianDateTime vcNext;
int ndst;
bool prevNaksatraValid = false;
GregorianDateTime prevNaksatra = new GregorianDateTime();
vcAdd.SubtractDays(1);
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = GCNaksatra.GetNextNaksatra(earth, vcAdd, out vcNext);
if (vcNext.GetDayInteger() < vcEnd.GetDayInteger())
{
vcNext.InitWeekDay();
vcNext.AddHours(loc.TimeZone.GetBiasMinutesForDay(vcNext) / 60.0);
//AddEvent(vcNext, CoreEventType.CCTYPE_NAKS, nData, ndst);
AddRating(vcNext, rec.rateNaksatra[nData], rec.rateNaksatra[Prev(nData, 27)]);
if (prevNaksatraValid)
{
double padaLength = (vcNext.GetJulianComplete() - prevNaksatra.GetJulianComplete()) / 4.0;
for (int j = 0; j < 4; j++)
{
//AddEvent(prevNaksatra, CoreEventType.CCTYPE_NAKS_PADA1 + j, nData, ndst);
int prevPada = (nData * 4 + j + 107) % 108;
AddRating(vcNext, rec.rateNaksatraPada[nData, j], rec.rateNaksatraPada[prevPada / 4, prevPada % 4]);
prevNaksatra.shour += padaLength;
prevNaksatra.NormalizeValues();
}
}
prevNaksatra.Set(vcNext);
prevNaksatraValid = true;
}
else
{
break;
}
vcAdd.Set(vcNext);
vcAdd.shour += 0.2;
if (vcAdd.shour >= 1.0)
{
vcAdd.shour -= 1.0;
vcAdd.NextDay();
}
}
return(nData);
}
private void CalculateEvents(GCLocation loc, GregorianDateTime vcStart, GregorianDateTime vcEnd, GCConfigRatedEvents rec)
{
GregorianDateTime vc = new GregorianDateTime(vcStart);
double biasHours = 0;
ShowAboveOnly = rec.useAcceptLimit;
ShowLongerThan = rec.useMinPeriodLength;
RatingsAboveOnly = rec.acceptLimit;
MinIntervalLength = rec.minPeriodLength;
//bool hasAscendent = rec.RequiredGrahaRasi(9);
bool hasRahuKalam = rec.rateKalas[KalaType.KT_RAHU_KALAM].Usable;
bool hasYamaghanti = rec.rateKalas[KalaType.KT_YAMA_GHANTI].Usable;
bool hasGulikalam = rec.rateKalas[KalaType.KT_GULI_KALAM].Usable;
bool hasAbhijit = rec.rateKalas[KalaType.KT_ABHIJIT].Usable;
bool hasMuhurta = rec.RequiredMuhurta();
p_events.Clear();
EarthLocation = new GCLocation(loc);
DateStart = new GregorianDateTime(vcStart);
DateEnd = new GregorianDateTime(vcEnd);
bool hasPreviousSunset = false;
GregorianDateTime previousSunset = new GregorianDateTime();
GregorianDateTime vcAdd = new GregorianDateTime(vcStart);
GregorianDateTime vcNext = new GregorianDateTime();
GCEarthData earth = loc.GetEarthData();
vcAdd.InitWeekDay();
GCHourTime sunRise, sunSet;
double muhurtaLength = 48.0 / 1440.0;
GregorianDateTime muhurtaDate = new GregorianDateTime();
while (vcAdd.IsBeforeThis(vcEnd))
{
biasHours = loc.TimeZone.GetBiasMinutesForDay(vcAdd) / 60.0;
sunRise = GCSunData.CalcSunrise(vcAdd, earth);
sunSet = GCSunData.CalcSunset(vcAdd, earth);
sunRise.AddMinutes(biasHours * 60);
sunSet.AddMinutes(biasHours * 60);
vcAdd.shour = sunRise.TotalDays;
vcAdd.InitWeekDay();
//AddEvent(vcAdd, CoreEventType.CCTYPE_S_RISE, 0, ndst);
AddRating(vcAdd, rec.rateDayHours[0], rec.rateDayHours[3]);
AddRating(vcAdd, rec.rateDay[0], rec.rateDayHours[1]);
//AddEvent(vcAdd, CoreEventType.CCTYPE_DAY_OF_WEEK, vcAdd.dayOfWeek, ndst);
AddRating(vcAdd, rec.weekday[vcAdd.dayOfWeek], rec.weekday[Prev(vcAdd.dayOfWeek, 7)]);
if (hasPreviousSunset)
{
previousSunset.shour += (vcAdd.shour + 1.0 - previousSunset.shour) / 2;
previousSunset.NormalizeValues();
//AddEvent(previousSunset, CoreEventType.CCTYPE_S_MIDNIGHT, 0, ndst);
AddRating(previousSunset, rec.rateDayHours[3], rec.rateDayHours[2]);
}
if (hasMuhurta)
{
muhurtaDate.Set(vcAdd);
muhurtaDate.shour -= 2 * muhurtaLength;
muhurtaDate.NormalizeValues();
for (int j = 0; j < 30; j++)
{
//AddEvent(muhurtaDate, CoreEventType.CCTYPE_DAY_MUHURTA, (j + 28) % 30, ndst);
int mi = (j + 28) % 30;
AddRating(muhurtaDate, rec.rateMuhurta[mi], rec.rateMuhurta[Prev(mi, 30)]);
}
}
vcAdd.shour = (sunRise.TotalDays + sunSet.TotalDays) / 2;
//AddEvent(vcAdd, CoreEventType.CCTYPE_S_NOON, 0, ndst);
AddRating(vcAdd, rec.rateDayHours[1], rec.rateDayHours[0]);
vcAdd.shour = sunSet.TotalDays;
//AddEvent(vcAdd, CoreEventType.CCTYPE_S_SET, 0, ndst);
AddRating(vcAdd, rec.rateDayHours[2], rec.rateDayHours[1]);
AddRating(vcAdd, rec.rateDay[1], rec.rateDayHours[0]);
previousSunset.Set(vcAdd);
hasPreviousSunset = true;
if (hasRahuKalam)
{
CalculateKalam(vcAdd, sunRise.TotalDays, sunSet.TotalDays, KalaType.KT_RAHU_KALAM, rec);
}
if (hasYamaghanti)
{
CalculateKalam(vcAdd, sunRise.TotalDays, sunSet.TotalDays, KalaType.KT_YAMA_GHANTI, rec);
}
if (hasGulikalam)
{
CalculateKalam(vcAdd, sunRise.TotalDays, sunSet.TotalDays, KalaType.KT_GULI_KALAM, rec);
}
if (hasAbhijit)
{
CalculateKalam(vcAdd, sunRise.TotalDays, sunSet.TotalDays, KalaType.KT_ABHIJIT, rec);
}
vcAdd.NextDay();
}
if (rec.RequiredGrahaRasi(9))
{
GCAscendant asc = new GCAscendant();
asc.Earth = EarthLocation.GetEarthData();
asc.CurrentDateTime = new GregorianDateTime(vc);
while (asc.GetNextAscendantBefore(vcEnd))
{
AddRating(asc.CurrentDateTime.TimeWithOffset(biasHours), rec.rateGrahaRasi[9, asc.CurrentSign], rec.rateGrahaRasi[9, Prev(asc.CurrentSign, 12)]);
asc.CurrentDateTime.AddHours(0.5);
}
}
if (rec.RequiredTithi())
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculateTithis(loc, vcEnd, vcAdd, earth, rec);
}
if (rec.RequiredNaksatra())
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculateNaksatras(loc, vcEnd, vcAdd, earth, rec);
}
if (rec.RequiredYoga())
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculateYoga(loc, vcEnd, vcAdd, earth, rec);
}
for (int i = 0; i < 9; i++)
{
if (rec.RequiredGrahaRasi(i))
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculatePlanetRasi(i, loc, vcEnd, vcAdd, rec);
//CalculateSunRasi(loc, vcEnd, vcAdd, rec);
}
if (rec.RequiredGrahaHouse(i))
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculatePlanetHouse(i, loc, vcEnd, vcAdd, rec);
//CalculateSunRasi(loc, vcEnd, vcAdd, rec);
}
}
/*if (rec.RequiredGrahaRasi(1))
* {
* vcAdd.Set(vc);
* vcAdd.shour = 0.0;
* CalculateMoonRasi(loc, vcEnd, vcAdd, earth, rec);
*
* }*/
if (rec.RequiredMoonTimes())
{
vcAdd.Set(vc);
vcAdd.shour = 0.0;
CalculateMoonTimes(vcEnd, vcAdd, earth, rec);
}
IComparer <GCRatedMoment> C = new GCRatedMoment.ComparerClass();
p_ratings.Sort(C);
}
