// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Implementation of the TAstronomicalCalendar class.

// 

//

// System includes

#include <e32base.h>

#include <e32math.h>

// User includes

#include "calconv.h"

#include "calconvAstronomicalCal.h"

// Constants

const TReal KCoeff19th[] =

	{

	-0.00002,

	0.000297,

	0.025184,

	-0.181133,

	0.553040,

	-0.861938,

	0.677066,

	-0.212591,

	};

const TReal KCoeff18th[] =

	{

	-0.000009,

	0.003844,

	0.083563,

	0.865736,

	4.867575,

	15.845535,

	31.332267,

	38.291999,

	28.316289,

	11.636204,

	2.043794,

	};

const TInt KCoeffs[] =

	{

	403406,

	195207,

	119433,

	112392,

	3891,

	2819,

	1721,

	0,

	660,

	350,

	334,

	314,

	268,

	242,

	234,

	158,

	132,

	129,

	114,

	99,

	93,

	86,

	78,

	72,

	68,

	64,

	46,

	38,

	37,

	32,

	29,

	28,

	27,

	27,

	25,

	24,

	21,

	21,

	20,

	18,

	17,

	14,

	13,

	13,

	13,

	12,

	10,

	10,

	10,

	10,

	};

const TReal KMulti[] =

	{

	4.721964,

	5.937458,

	1.115589,

	5.781616,

	5.5474,

	1.512,

	4.1897,

	1.163,

	5.415,

	4.315,

	4.553,

	5.198,

	5.989,

	2.911,

	1.423,

	0.061,

	2.317,

	3.193,

	2.828,

	0.52,

	4.65,

	4.35,

	2.75,

	4.5,

	3.23,

	1.22,

	0.14,

	3.44,

	4.37,

	1.14,

	2.84,

	5.96,

	5.09,

	1.72,

	2.56,

	1.92,

	0.09,

	5.98,

	4.03,

	4.47,

	0.79,

	4.24,

	2.01,

	2.65,

	4.98,

	0.93,

	2.21,

	3.59,

	1.5,

	2.55,

	};

const TReal KAdd[] =

	{

	0.01621043,

	628.30348067,

	628.30821524,

	628.29634302,

	1256.605691,

	1256.60984,

	628.324766,

	0.00813,

	1256.5931,

	575.3385,

	-0.33931,

	7771.37715,

	786.04191,

	0.05412,

	393.02098,

	-0.34861,

	1150.67698,

	157.74337,

	52.9667,

	588.4927,

	52.9611,

	-39.807,

	522.3769,

	550.7647,

	2.6108,

	157.7385,

	1884.9103,

	-77.5655,

	2.6489,

	1179.0627,

	550.7575,

	-79.6139,

	1884.8981,

	21.3219,

	1097.7103,

	548.6856,

	254.4393,

	-557.3143,

	606.9774,

	21.3279,

	1097.7163,

	-77.5282,

	1884.9191,

	2.0781,

	294.2463,

	-0.0799,

	469.4114,

	-0.6829,

	214.6325,

	1572.084,

	};

const TReal KMuArray[] =

	{

	-0.40720,

	0.17241,

	0.01608,

	0.01039,

	0.00739,

	-0.00514,

	0.00208,

	-0.00111,

	-0.00057,

	0.00056,

	-0.00042,

	0.00042,

	0.00038,

	-0.00024,

	-0.00007,

	0.00004,

	0.00004,

	0.00003,

	0.00003,

	-0.00003,

	0.00003,

	-0.00002,

	-0.00002,

	0.00002,

	};

const TInt8 KOmegaArray[] =

	{

	0,

	1,

	0,

	0,

	1,

	1,

	2,

	0,

	0,

	1,

	0,

	1,

	1,

	1,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	};

const TInt8 KXiArray[] =

	{

	0,

	1,

	0,

	0,

	-1,

	1,

	2,

	0,

	0,

	1,

	0,

	1,

	1,

	-1,

	2,

	0,

	3,

	1,

	0,

	1,

	-1,

	-1,

	1,

	0,

	};

const TInt8 KGammaArray[] =

	{

	1,

	0,

	2,

	0,

	1,

	1,

	0,

	1,

	1,

	2,

	3,

	0,

	0,

	2,

	1,

	2,

	0,

	1,

	2,

	1,

	1,

	1,

	3,

	4,

	};

const TInt8 KZetaArray[] =

	{

	0,

	0,

	0,

	2,

	0,

	0,

	0,

	-2,

	2,

	0,

	0,

	2,

	-2,

	0,

	0,

	-2,

	0,

	-2,

	2,

	2,

	2,

	-2,

	0,

	0,

	};

const TReal KIotaArray[] =

	{

	299.77,

	251.88,

	251.83,

	349.42,

	84.66,

	141.74,

	207.14,

	154.84,

	34.52,

	207.19,

	291.34,

	161.72,

	239.56,

	331.55,

	};

const TReal KChiArray[] =

	{

	0.107408,

	0.016321,

	26.641886,

	36.412478,

	18.206239,

	53.303771,

	2.453732,

	7.306860,

	27.261239,

	0.121824,

	1.844379,

	24.198154,

	25.513099,

	3.592518,

	};

const TReal KNuArray[] =

	{

	-0.009173,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	0,

	};

const TReal KLamdaArray[] =

	{

	0.000325,

	0.000165,

	0.000164,

	0.000126,

	0.00011,

	0.000062,

	0.00006,

	0.000056,

	0.000047,

	0.000042,

	0.00004,

	0.000037,

	0.000035,

	0.000023,

	};

const TInt  KInitOne				= 1;

const TInt KHoursInDay				= 24;

const TInt KMinsInHour				= 60;

const TInt KSecsInMin				= 60;

const TInt KDaysInGregHundredYears	= 36525;

const TReal KMeanDaysInGregYear		= 365.25;

const TInt  KSquared				= 2;

const TInt  KCubed					= 3;

const TInt  KQuad					= 4;

const TInt K360Degrees				= 360;

const TReal KDegreesToRadians		= 0.017453292519943296; //(KPi/180);

const TInt  KNumElementsCoeff19th	= 8;

const TInt  KNumElementsCoeff18th	= 11;

const TInt  KNoOfPeriodicTerms		= 50;

const TInt  KMaxCorrectionValues	= 24;

const TReal KMonthsInTropicalYear	= 12.3685;

const TInt  KMaxAdditionalValues	= 14;

//

// Construction/Destruction

//

//------------------------------------------------------

// Class:       TAstronomicalCalendar

// Function:    TAstronomicalCalendar

// Arguments:   None

//

// Comments:    Constructor

//

// Return:      None

//------------------------------------------------------

TAstronomicalCalendar::TAstronomicalCalendar()

	{

	}

//------------------------------------------------------

// Class:       TAstronomicalCalendar

// Function:    UniversalFromLocal

// Arguments:   TReal , TInt 

//

// Comments:    Universal time is used for time keeping purposes.

//				It is given as a fraction on a solar day

//

// Return:      Universal time

//------------------------------------------------------

TReal TAstronomicalCalendar::UniversalFromLocal(const TReal& aTime,const TReal& aZone) const

	{

	return (aTime - (aZone / (KHoursInDay * KMinsInHour)));

	}

//------------------------------------------------------

// Class:       TAstronomicalCalendar

// Function:    LocalFromUniversal

// Arguments:   TReal , TInt 

//

// Comments:    Universal time is used for time keeping purposes.

//				It is given as a fraction on a solar day

//

// Return:      Local time

//------------------------------------------------------

TReal TAstronomicalCalendar::LocalFromUniversal(const TReal& aTime, const TReal& aZone) const

	{

	return (aTime + (aZone / (KHoursInDay * KMinsInHour)));

	}

//------------------------------------------------------

// Class:       TAstronomicalCalendarL

// Function:    EphemerisCorrection

// Arguments:   TReal 

//

// Comments:    Astronomical calculations are performed using

//				Ephemeris time that is not affected by nutation

//				and aberation. 

//

// Return:      Correction value

//------------------------------------------------------

void TAstronomicalCalendar::EphemerisCorrection(const TReal aJulianDay, TReal& aCorrection) const

	{

	TGregorianCalendar greg(aJulianDay);

	TArithmeticalDate gregDate;

	TInt year;

	TReal theta;

	TReal x;

	aCorrection = 0;

	// get the value for the year

	greg.GetDate(gregDate);

	year = gregDate.iYear;

	// get theta value

	PopulateTheta(theta,year);

	// get x value

	EphemerisCorrPopX(year, x);

	// perform ephemeris correction

	if((year >= 1988) && (year <= 2019))

		{

		aCorrection = ((year - 1933) / (KHoursInDay * KMinsInHour * KSecsInMin));

		}

	else if((year >= 1900) && (year <= 1987))

		{

		GetPoly(KCoeff19th,theta,KNumElementsCoeff19th,aCorrection);