/*****************************************************
**
** GenericNakshatraDasaExpert --- getKPLordRecursive
**
******************************************************/
void GenericNakshatraDasaExpert::getKPLordRecursive( int &lord_index, double &elapsed, double &total_len )
{
int count = 0;
const int max_loop = 10; // maximum number of antardasas in cycle
double antar_len; // in years
if ( elapsed >= total_len ) printf( "ERROR GenericNakshatraDasaExpert::getKPLordRecursive: elapsed time too big, %f total was %f\n", elapsed, total_len );
assert ( elapsed < total_len );
antar_len = getDasaDuration( lord_index ) * total_len;
antar_len /= getParamayus();
//printf( "Elapsed 1 %f antar_len %f total_len %f dur1 %d dur2 %d\n", elapsed, antar_len, total_len, getDasaDuration( lord_index ), getDasaDuration( lord_index ) );
// count so many antardasas that elapsed time is more than antarlen
while (( elapsed > antar_len ) && ( count++ < max_loop ))
{
lord_index++;
if ( lord_index >= getNbLords() ) lord_index -= getNbLords();
elapsed -= antar_len;
antar_len = getDasaDuration( lord_index ) * total_len;
antar_len /= getParamayus();
//printf( "Elapsed 2 %f antar_len %f\n", elapsed, antar_len );
}
if ( count >= max_loop ) printf( "ERROR GenericNakshatraDasaExpert::getKPLordRecursive: count %d max_loop %d\n", count, max_loop );
assert( count < max_loop );
total_len = antar_len;
}
/*****************************************************
**
** GenericNakshatraDasaExpert --- getFirstLevel
**
******************************************************/
vector<Dasa*> GenericNakshatraDasaExpert::getFirstLevel()
{
vector<Dasa*> ret, tret;
double nportion;
int total_length = 0;
Nakshatra nak;
nportion = getPortion( nak );
int pindex = getDasaIndex4Nakshatra( nak );
int pl = getDasaLordByIndex( pindex );
double start_jd = horoscope->getJD() - nportion * getDasaDuration( pindex ) * getYearLength( true );
double end_jd = start_jd + getParamayus() * getYearLength( true );
while ( total_length < 100 )
{
Dasa d( dasaId, pl, start_jd, end_jd, (Dasa*)NULL );
d.setLevel( -1 );
tret = getNextLevel( &d );
for ( unsigned j = 0; j < tret.size(); j++ )
{
tret[j]->setParent( (Dasa*)NULL );
ret.push_back( tret[j] );
}
tret.clear();
total_length += getParamayus();
start_jd = end_jd;
end_jd += getParamayus() * getYearLength( true );
}
return ret;
}
/*****************************************************
**
** GenericNakshatraDasaExpert --- getSolarDasa
**
******************************************************/
vector<Dasa*> GenericNakshatraDasaExpert::getSolarDasa( const Horoscope *solarchart, const int &year )
{
vector<Dasa*> ret;
int currentdasa;
double start_jd, end_jd;
// lenght of generic dasas is in days. Solar Dasa shifts from e.g. 120 y to 365.25 days
//const double duration_factor = 365.25 / (double)getParamayus();
const double duration_factor = getYearLength( true ) / (double)getParamayus();
const int birthnaks = getNakshatra27( horoscope->getVedicLongitude( OMOON ));
const int numyears = year - getYearForJD( horoscope->getJD());
int basedasa = ( birthnaks + numyears - 2 ) % 9;
if ( basedasa < 0 ) basedasa += 9;
assert( basedasa >= 0 && basedasa < 9 );
start_jd = solarchart->getJD();
for( int i = 0; i < 9; i++ )
{
currentdasa = ( basedasa + i ) % 9;
//printf( "DASA %d basedasa %d numyears %d\n", currentdasa, basedasa, numyears );
end_jd = start_jd + duration_factor * getDasaDuration( currentdasa );
ret.push_back( new Dasa( dasaId, getDasaLordByIndex( currentdasa ), start_jd, end_jd, (Dasa*)NULL ));
start_jd = end_jd;
}
return ret;
}
/*****************************************************
**
** GenericNakshatraDasaExpert --- getKPLords
**
******************************************************/
KpData GenericNakshatraDasaExpert::getKPLords( const double &len )
{
KpData kp;
// 0...27 - ASWINI = 0 etc
Nakshatra nak = getNakshatra27( len );
// index of the first lord for that Nakshatra in the sequence of lords, e.g. Vimsottari has Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury, Ketu, Venus
int lord_index = getDasaIndex4Nakshatra( nak );
// elapsed portion in the Nakshatra (0...1)
double nakshatraPortion = getNakshatraLongitude27( len ) / NAKSHATRA_LEN;
// elapsed time in years
double elapsed = nakshatraPortion * getDasaDuration( lord_index );
// total length in years (e.g. 120 for Vimsottari)
double total_len = getParamayus();
//printf( "START ------ CAll 1 KP len %f lord_index %d, portion %f elapsed %f total_len %f\n", len, lord_index, nakshatraPortion, elapsed, total_len );
getKPLordRecursive( lord_index, elapsed, total_len );
kp.lord = getDasaLordByIndex( lord_index );
//printf( "CAll 2 KP len %f lord_index %d KPLORD %d, elapsed %f total_len %f\n", len, lord_index, kp.lord, elapsed, total_len );
getKPLordRecursive( lord_index, elapsed, total_len );
kp.sublord = getDasaLordByIndex( lord_index );
//printf( "CAll 3 KP len %f lord_index %d KPLORD %d, elapsed %f total_len %f\n\n", len, lord_index, kp.sublord, elapsed, total_len );
getKPLordRecursive( lord_index, elapsed, total_len );
kp.subsublord = getDasaLordByIndex( lord_index );
//printf( "FINISHED ------ CAll 4 KP len %f lord_index %d KPLORD %d, elapsed %f total_len %f\n\n", len, lord_index, kp.subsublord, elapsed, total_len );
return kp;
}
/*****************************************************
**
** VimsottariBaseDasaExpert --- getMahaDasaLength
**
******************************************************/
int VimsottariBaseDasaExpert::getMahaDasaLength( const int &dasa )
{
//assert( dasa >= 0 && dasa < 9 );
for( int i = 0; i < 9; i++ )
{
if (getDasaLordByIndex( i ) == dasa )
{
return getDasaDuration( i );
}
}
assert( 0 );
return -1;
}
/*****************************************************
**
** GenericNakshatraDasaExpert --- getKPEventList
**
******************************************************/
vector<KPEvent> GenericNakshatraDasaExpert::getKPEventList( const double &startlen, const double &endlen,
const double &startjd )
{
vector<KPEvent> events;
Nakshatra currentnak;
int currentlord, i, j, antarlord, antardasatime;
double dasastartlen, antarstartlen, dist;
bool append;
Nakshatra startnak = getNakshatra27( startlen );
for ( i = 0; i < 32; i++ )
{
currentnak = (Nakshatra)(((int)startnak + i ) % 27 );
currentlord = getDasaIndex4Nakshatra( currentnak );
dasastartlen = red_deg( ( startnak + i ) * 13.33333333 );
antarstartlen = dasastartlen;
for ( j = 0; j < getNbLords(); j++ )
{
append = true;
antarlord = ( currentlord + j ) % getNbLords();
antardasatime = getDasaDuration( antarlord ); // years
if ( i == 0 ) // cut off at the beginning (antardasas before starting point)
{
dist = antarstartlen - startlen;
if ( dist < -300 ) dist += 360; // correct if 360-deg shift
if ( dist < 0 ) append = false;
}
if ( i >= 28 ) // cut off at the end (if event belongs to next time interval)
{
dist = antarstartlen - endlen;
if ( dist > 300 ) dist -= 360;
if ( dist < -300 ) dist += 360;
if ( dist > 0 ) append = false; // could also be return ?
}
if ( append )
events.push_back( KPEvent( getDasaLordByIndex( currentlord ), getDasaLordByIndex( antarlord ),
antarstartlen + .0000001, startjd + i + (double)j/getNbLords(), i ));
antarstartlen += 13.333333333 * (double)antardasatime / getParamayus();
}
}
return events;
}
/*****************************************************
**
** GenericNakshatraDasaExpert --- getNextLevel
**
******************************************************/
vector<Dasa*> GenericNakshatraDasaExpert::getNextLevel( Dasa *dasa )
{
assert( dasa );
vector<Dasa*> ret;
Dasa *parent;
double start_jd = dasa->getStartJD();
double end_jd = dasa->getEndJD();
double dasa_len = end_jd - start_jd;
double antar_len = 0;
int lord = -1;
for ( int i = 0; i < getNbLords(); i++ )
{
if ( getDasaLordByIndex( i ) == dasa->getDasaLord() )
{
lord = i;
break;
}
}
assert( lord != -1 );
parent = dasa;
//printf( "GenericNakshatraDasaExpert::getNextLevel level %d parent %ld dasa %ld\n", dasa->getLevel(), (long)parent, (long)dasa );
for ( int i = 0; i < getNbLords(); i++ )
{
antar_len = ( dasa_len * getDasaDuration( lord )) / getParamayus();
end_jd = start_jd + antar_len;
ret.push_back( new Dasa( dasaId, getDasaLordByIndex( lord ), start_jd, end_jd, parent ));
lord = ( lord + 1 ) % getNbLords();
start_jd = end_jd;
}
return ret;
}
/*****************************************************
**
** DasaExpert --- writeMore
**
******************************************************/
void DasaExpert::writeMore( Writer *writer, const Horoscope *horoscope, const int varga, const bool show_header )
{
Formatter *formatter = Formatter::get();
double startjd;
unsigned int i;
wxString s, s1, lord;
VargaExpert vexpert;
if ( show_header )
{
s.Printf( wxT( "%s %s" ), getName(), _( "Dasa" ) );
writer->writeHeader1( s );
}
vector<Dasa*> v = getFirstLevel( horoscope, varga );
vector<Dasa*> w;
for( i = 0; i < v.size(); i++ )
{
if ( isRasiDasaExpert() ) lord = writer->getSignName( v[i]->getDasaLord(), TLARGE );
else lord = writer->getObjectName(v[i]->getDasaLord(), TLARGE, true );
s.Printf( wxT( "%d. %s %s" ), i+1, _( "Mahadasa" ), (const wxChar*)lord );
writer->writeHeader2( s );
if ( ! v[i]->getExtraText().IsEmpty())
{
writer->writeLine( v[i]->getExtraText() );
}
startjd = Max( v[i]->getStartJD(), horoscope->getJD() );
s.Printf( wxT( "%s: %s" ), _( "Start Date" ), (const wxChar*)formatter->getDateStringFromJD( startjd ) );
writer->writeLine( s );
s.Printf( wxT( "%s: %s" ), _( "End Date" ), (const wxChar*)formatter->getDateStringFromJD( v[i]->getEndJD() ) );
writer->writeLine( s );
getDasaDuration( s1, v[i]->getEndJD() - v[i]->getStartJD() );
s.Printf( wxT( "%s: %s" ), _( "Duration" ), (const wxChar*)s1 );
writer->writeLine( s );
w = getNextLevel( v[i] );
if ( w.size() == 0 ) continue;
writer->writeHeader3( _( "Antardasas" ) );
// Get the number of lines
int lines = 1;
for( unsigned int j = 0; j < w.size(); j++ )
{
if ( w[j]->getEndJD() >= horoscope->getJD()) lines++;
}
Table table( 4, lines );
table.setHeader( 0, _( "Lord" ));
table.setHeader( 1, _( "Start Date" ));
table.setHeader( 2, _( "Final Date" ));
table.setHeader( 3, _( "Duration" ));
int line = 1;
for( unsigned int j = 0; j < w.size(); j++ )
{
if ( w[j]->getEndJD() >= horoscope->getJD())
{
if ( isRasiDasaExpert() ) lord = writer->getSignName(w[j]->getDasaLord(), TLARGE );
else lord = writer->getObjectName(w[j]->getDasaLord(), TLARGE, true );
table.setEntry( 0, line, lord );
startjd = Max( w[j]->getStartJD(), horoscope->getJD() );
table.setEntry( 1, line, formatter->getDateStringFromJD( startjd ) );
table.setEntry( 2, line, formatter->getDateStringFromJD( w[j]->getEndJD() ) );
getDasaDuration( s, w[j]->getEndJD() - w[j]->getStartJD() );
table.setEntry( 3, line, s );
line++;
}
delete w[j];
}
writer->writeTable( table );
}
for( i = 0; i < v.size(); i++ ) delete v[i];
}
