Files
sorsfonalak/legacy/src/astrochart/client/util/AstrologyUtil.java
T

547 lines
27 KiB
Java
Raw Normal View History

package astrochart.client.util;
import java.util.Date;
import com.google.gwt.i18n.client.NumberFormat;
import astrochart.shared.EquinocticalShaddowLengths;
import astrochart.shared.enums.ZodiacSign;
import astrochart.shared.wrappers.AscendentAndOffset;
import astrochart.shared.wrappers.BodyPosition;
import astrochart.shared.wrappers.RiseAndSet;
public class AstrologyUtil {
public static final double EARTH_INCLINATION_J2000 = 23.4392911D; // in degrees
public static final double EARTH_INCLINATION_J1950 = 23.4457889D; // in degrees
public static final double EARTH_AXIS_TILT = 23.45D; // TODO change to EARTH_AXIS_TILT_PRECISE
public static final double EARTH_AXIS_TILT_PRECISE = 23.439D; // TODO use EARTH_INCLINATION_J2000
public static final double EARTH_AXIS_TILT_DAILY_CHANGE = 0.0000004D;
public static final double PERIHELION_TO_VENERAL_EQUINOX_DEGREES = 102.9372D;
public static final double LONG_ABERRATION = 0.9856474D;
public static final double ANGLE_TO_SUN_FROM_PERIHELION = 357.528D; // TODO change to ANGLE_TO_SUN_FROM_PERIHELION_PRECISE
public static final double ANGLE_TO_SUN_FROM_PERIHELION_PRECISE = 357.5291D;
public static final double SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION = 0.9856003D; // TODO change to SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION_PRECISE
public static final double SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION_PRECISE = 0.98560028D;
public static final double SOLAR_ELEVATION_AT_SUNRISE_AND_SUNSET = -0.83D;
public static final double EARTHS_SOLAR_TRANSIT_DATE = 0.0009D;
public static final double EARTHS_SOLAR_TRANSIT_ECCENTRICAL_VARIATION = 0.0053D;
public static final double EARTHS_SOLAR_TRANSIT_ECLIPTIC_OBLIQUITY_VARIATION = 0.0069D;
public static final double EARTH_ECCENTRICITY = 0.0167D;
public static final double SAEMUNDSON_REFRACTION_CONSTANT_1 = 1.02D;
public static final double SAEMUNDSON_REFRACTION_CONSTANT_2 = 10.3D;
public static final double SAEMUNDSON_REFRACTION_CONSTANT_3 = 5.11D;
public static final double EQUATION_OF_CENTER_CONSTANT_1 = 1.9148D;
public static final double EQUATION_OF_CENTER_CONSTANT_2 = 0.0200D;
public static final double EQUATION_OF_CENTER_CONSTANT_3 = 0.0003D;
private final EquinocticalShaddowLengths esl = new EquinocticalShaddowLengths();
private final DateTimeUtil dateTimeUtil = new DateTimeUtil();
private double meanSolarAnomaly = 0D;
private double equationOfCenter = 0D;
private double solarEclipticalLongitude = 0D;
private double solarNoonTransit = 0D;
public final double getMeanSolarNoonAnomaly() {
return meanSolarAnomaly;
}
public final double getEquationOfCenter() {
return equationOfCenter;
}
public final double getSolarEclipticalLongitude() {
return solarEclipticalLongitude;
}
public final double getSolarNoonTransit() {
return solarNoonTransit;
}
/**
* Asserts the ascendent for the provided local SiderealTime at latitude
* @param localSiderealTimeDeg Local siderealTime in degrees
* @param latitude of the location
* @return
*/
@Deprecated
public final ZodiacSign getTropicalAscendent(final double localSiderealTimeDeg, final double localLatitude) {
double ascendentDegrees = Math.atan(
(Math.cos(localSiderealTimeDeg) * -1)
/ (
(Math.sin(localSiderealTimeDeg) * Math.cos(EARTH_INCLINATION_J2000))
+ (Math.tan(localLatitude) * Math.sin(EARTH_INCLINATION_J2000))
));
if (ascendentDegrees < 0D || Math.cos(localSiderealTimeDeg) < 0D) {
ascendentDegrees = ascendentDegrees + (Constants.DEGREES_IN_CIRCLE / 2);
}
return ZodiacSign.getSignAtDegree(ascendentDegrees);
}
public final long calculateRashimanaSeconds(final ZodiacSign sign, final double latitude) {
final int roundedLat = Double.valueOf(latitude).intValue();
final int charakhandas = esl.calculateCharakhandas(sign, roundedLat);
final long asus = getAsus(sign, charakhandas);
return dateTimeUtil.convertAsusToSiderealSeconds(asus);
}
private long getAsus(final ZodiacSign sign, final int charakhandas) {
if (sign.hasLongAscension()) {
return sign.getRashimanaGroup().getEquatorialAsus() + charakhandas;
} else {
return sign.getRashimanaGroup().getEquatorialAsus() - charakhandas;
}
}
public final double calculateEclipticLongitude(final double julianDayNumber) {
return Constants.MEAN_LONGITUDE_OF_THE_SUN + (LONG_ABERRATION * julianDayNumber);
}
public final double calculateMeanAnomaly(final double julianDayNumber) {
return ANGLE_TO_SUN_FROM_PERIHELION + (SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION * julianDayNumber);
}
public final double calculateJulianCycle(final double julianDay, final double longitudeWest) {
final double cycle = julianDay - DateTimeUtil.J_CONSTANT - (longitudeWest / Constants.DEGREES_IN_CIRCLE);
return cycle + Constants.HALF_JULIAN_DAY;
}
public final double calculateAccurateJulianCycle(final double julianDay, final double longitude) {
return Math.round((julianDay - Constants.JULIAN_DAY_AT_01_01_2000 - EARTHS_SOLAR_TRANSIT_DATE) - (longitude / Constants.DEGREES_IN_CIRCLE));
}
/**
* calculates the solar meanpoint as ecliptic coordinate
* with a numeric eccentricity of ~0.0167
* @param eclipticLongitude
* @param meanAnormaly
* @return
*/
public final double calculateEclipticalLength(final double eclipticLongitude, final double meanAnormaly) {
final double el = Math.toRadians(eclipticLongitude % Constants.DEGREES_IN_CIRCLE);
final double ma = Math.toRadians(meanAnormaly % Constants.DEGREES_IN_CIRCLE);
final double result = el
+ ((2 * EARTH_ECCENTRICITY * Math.sin(ma))
+ ((5.0D / 4.0D) * Math.pow(EARTH_ECCENTRICITY, 2) * Math.sin(2 * EARTH_ECCENTRICITY))
);
return Math.toDegrees(result);
}
public final double calculateEclipticInclination(final double julianDayNumber) {
return EARTH_AXIS_TILT_PRECISE - (EARTH_AXIS_TILT_DAILY_CHANGE * julianDayNumber);
}
/**
* http://de.wikipedia.org/wiki/Sonnenstand#.C3.84quatorialkoordinaten_der_Sonne
* @param eclipticInclination
* @param eclipticalLength
* @return
*/
public final double calculateRightAscension(final double eclipticInclination, final double eclipticalLength) {
final double eclipticInclinationRadians = Math.toRadians(eclipticInclination);
final double eclipticalLengthRadians = Math.toRadians(eclipticalLength);
final double argument = (Math.cos(eclipticInclinationRadians) * Math.sin(eclipticalLengthRadians)) / Math.cos(eclipticalLengthRadians);
final double atan = Math.atan(argument);
final double result = Math.toDegrees(atan);
return clampResult(result);
}
private double clampResult(final double result) {
if (result < 0.0D) {
return result + (Constants.DEGREES_IN_CIRCLE / 2);
} else {
return result;
}
}
public final double calculateDeclination(final double eclipticInclination, final double eclipticalLength) {
final double result = Math.asin(Math.sin(Math.toRadians(eclipticInclination)) * Math.sin(Math.toRadians(eclipticalLength)));
return Math.toDegrees(result);
}
public final double calculateVeneralEquinoxDegrees(final double starTimeDegrees, final double longitude) {
return (starTimeDegrees + longitude) % Constants.DEGREES_IN_CIRCLE;
}
public final double calculateHourAngle(final double localJulianDeg, final double rightAscension) {
return localJulianDeg - rightAscension;
}
public final double calculateAzimuth(final double hourAngle, final double latitude, final double declination) {
final double divisor =
(Math.cos(Math.toRadians(hourAngle)) * Math.sin(Math.toRadians(latitude)))
- (Math.tan(Math.toRadians(declination)) * Math.cos(Math.toRadians(latitude)));
final double azimuthAtan = Math.atan(Math.sin(Math.toRadians(hourAngle)) / divisor);
final double azimuth = Math.toDegrees(azimuthAtan);
return clampAzimuth(azimuth, divisor);
}
private double clampAzimuth(final double azimuth, final double divisor) {
if (divisor < 0D) {
return azimuth + (Constants.DEGREES_IN_CIRCLE / 2);
} else {
return azimuth;
}
}
public final double calculateAzimuthNorth(final double hourAngle, final double latitude, final double declination) {
return calculateAzimuth(hourAngle, latitude, declination) + (Constants.DEGREES_IN_CIRCLE / 2);
}
public final double calculateHeightAngle(final double hourAngle, final double latitude, final double declination) {
final double heightAngle =
Math.asin((Math.cos(Math.toRadians(declination))
* Math.cos(Math.toRadians(hourAngle))
* Math.cos(Math.toRadians(latitude)))
+ (Math.sin(Math.toRadians(declination))
* Math.sin(Math.toRadians(latitude))));
return Math.toDegrees(heightAngle);
}
/**
* Calculates the mean refraction for an object at the provided angle at 1010 mbar and 10� C.
* http://de.wikipedia.org/wiki/Sonnenstand#Korrektur_der_H.C3.B6he_wegen_Refraktion
* @param heightAngle
* @return
*/
private double calculateRefraction(final double heightAngle) {
final double term = heightAngle + (SAEMUNDSON_REFRACTION_CONSTANT_2 / (heightAngle + SAEMUNDSON_REFRACTION_CONSTANT_3));
final double termRadians = Math.toRadians(term);
return SAEMUNDSON_REFRACTION_CONSTANT_1 / Math.tan(termRadians);
}
public final double calculateRefractionDegrees(final double heightAngle) {
return heightAngle + (calculateRefraction(heightAngle) / Constants.MINUTES_PER_DEGREE);
}
/**
* http://de.wikipedia.org/wiki/Sonnenstand
*/
public final BodyPosition calculateSunPosition(final Date date, final double latitude, final double longitude) {
final double julianDay = dateTimeUtil.getJdTimeDate(date);
final double n = dateTimeUtil.calculateJulianDayNumberFromJd(julianDay);
final double l = calculateEclipticLongitude(n);
final double g = calculateMeanAnomaly(n);
final double lambda = calculateEclipticalLength(l, g); //solar ecliptic coordinate
final double epsilon = calculateEclipticInclination(n); //ecliptic inclination
final double rightAscension = calculateRightAscension(epsilon, lambda);
final double declination = calculateDeclination(epsilon, lambda); //equatorical declination
final double jdo = dateTimeUtil.getJulianDayNumberTimeDropped(date);
final double t = dateTimeUtil.getJulianCenturiesSinceJ2000(jdo); //julian centuries since J2000.0
final double decimalHours = dateTimeUtil.getDecimalHours(date);
final double starTimeHours = dateTimeUtil.calculateStarTimeHours(t, decimalHours);
final double starTimeDegrees = dateTimeUtil.convertHoursToDegree(starTimeHours);
final double localJulianDeg = calculateVeneralEquinoxDegrees(starTimeDegrees, longitude); //veneral equinox degrees
final double hourAngle = calculateHourAngle(localJulianDeg, rightAscension);
final double azimuth = calculateAzimuth(hourAngle, latitude, declination);
final double heightAngle = calculateHeightAngle(hourAngle, latitude, declination);
final double refHeight = calculateRefractionDegrees(heightAngle);
return new BodyPosition(azimuth, refHeight);
}
public final double calculateApproxSolarNoon(final double julianCycle, final double longitude) {
return Constants.JULIAN_DAY_AT_01_01_2000 + EARTHS_SOLAR_TRANSIT_DATE + (longitude / Constants.DEGREES_IN_CIRCLE) + julianCycle;
}
public final double calculateAccurateMeanAnomaly(final double solarNoonApprox) {
return (ANGLE_TO_SUN_FROM_PERIHELION_PRECISE
+ (SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION_PRECISE
* (solarNoonApprox - Constants.JULIAN_DAY_AT_01_01_2000)))
% Constants.DEGREES_IN_CIRCLE;
}
/**
* http://en.wikipedia.org/wiki/Sunrise_equation#Equation_of_Center
* @param meanSolarAnomaly
* @return
*/
public final double calculateEquationOfCenter(final double meanSolarAnomaly) {
return (EQUATION_OF_CENTER_CONSTANT_1 * Math.sin(Math.toRadians(meanSolarAnomaly)))
+ (EQUATION_OF_CENTER_CONSTANT_2 * Math.sin(2D * Math.toRadians(meanSolarAnomaly)))
+ (EQUATION_OF_CENTER_CONSTANT_3 * Math.sin(3D * Math.toRadians(meanSolarAnomaly)));
}
public final double calculateSolarEclipticLongitude(final double meanSolarAnomaly, final double equationOfCenter) {
return (meanSolarAnomaly + PERIHELION_TO_VENERAL_EQUINOX_DEGREES + equationOfCenter + (Constants.DEGREES_IN_CIRCLE / 2)) % Constants.DEGREES_IN_CIRCLE;
}
public final double calculateSolarNoonTransit(final double solarNoonApprox, final double meanSolarAnomaly, final double solarEclipticalLongitude) {
return solarNoonApprox
+ (EARTHS_SOLAR_TRANSIT_ECCENTRICAL_VARIATION * Math.sin(Math.toRadians(meanSolarAnomaly)))
- (EARTHS_SOLAR_TRANSIT_ECLIPTIC_OBLIQUITY_VARIATION * Math.sin(Math.toRadians(2D * solarEclipticalLongitude)));
}
public final double calculateSolarDeclination(final double solarEclipticalLongitude) {
final double result = Math.asin(
Math.sin(Math.toRadians(solarEclipticalLongitude))
* Math.sin(Math.toRadians(EARTH_AXIS_TILT))
);
return Math.toDegrees(result);
}
public final double calculateAccurateMeanAnomalyRecursive(final double solarNoonApprox, final double oldMeanSolarAnomaly, final double solarNoonTransit) {
final double meanSolarAnomaly = calculateAccurateMeanAnomaly(solarNoonTransit);
if (oldMeanSolarAnomaly != meanSolarAnomaly) {
final double equationOfCenter = calculateEquationOfCenter(meanSolarAnomaly);
final double solarEclipticalLongitude = calculateSolarEclipticLongitude(meanSolarAnomaly, equationOfCenter);
final double newSolarNoonTransit = calculateSolarNoonTransit(solarNoonApprox, meanSolarAnomaly, solarEclipticalLongitude);
return calculateAccurateMeanAnomalyRecursive(solarNoonApprox, meanSolarAnomaly, newSolarNoonTransit);
} else {
this.meanSolarAnomaly = meanSolarAnomaly;
this.equationOfCenter = calculateEquationOfCenter(meanSolarAnomaly);
this.solarEclipticalLongitude = calculateSolarEclipticLongitude(meanSolarAnomaly, equationOfCenter);
this.solarNoonTransit = calculateSolarNoonTransit(solarNoonApprox, meanSolarAnomaly, solarEclipticalLongitude);
return meanSolarAnomaly;
}
}
public final double calculateExactHourAngle(final double latitude, final double solarDeclination) {
final double result =
Math.acos(
(Math.sin(Math.toRadians(SOLAR_ELEVATION_AT_SUNRISE_AND_SUNSET))
- (Math.sin(Math.toRadians(latitude))
* Math.sin(Math.toRadians(solarDeclination))))
/ (Math.cos(Math.toRadians(latitude))
* Math.cos(Math.toRadians(solarDeclination)))
);
return Math.toDegrees(result);
}
public final double calculateSolarNoonSecondApprox(final double hourAngle, final double longitude, final double julianCycle) {
return Constants.JULIAN_DAY_AT_01_01_2000 + EARTHS_SOLAR_TRANSIT_DATE + ((hourAngle + longitude) / Constants.DEGREES_IN_CIRCLE) + julianCycle;
}
public final double calculateSunset(final double solarNoonSecondApprox, final double meanSolarAnomaly, final double solarEclipticalLongitude) {
return solarNoonSecondApprox
+ (EARTHS_SOLAR_TRANSIT_ECCENTRICAL_VARIATION * Math.sin(Math.toRadians(meanSolarAnomaly)))
- (EARTHS_SOLAR_TRANSIT_ECLIPTIC_OBLIQUITY_VARIATION * Math.sin(Math.toRadians(2D * solarEclipticalLongitude)));
}
public final double calculateSunrise(final double sunset, final double solarNoonTransit) {
return solarNoonTransit - (sunset - solarNoonTransit);
}
/**
* http://users.electromagnetic.net/bu/astro/sunrise-set.php
* http://www.jgiesen.de/astro/astroJS/sunriseJS/index.htm
* @param julianDay
* @param latitude
* @param longitude
* @return
*/
public final RiseAndSet calculateSunRiseAndSet(final Date date, final double latitude, final double longitude) {
final double julianDate = dateTimeUtil.calculateJulianDate(date);
final double julianCycle = calculateAccurateJulianCycle(julianDate, longitude);
final double solarNoonApprox = calculateApproxSolarNoon(julianCycle, longitude);
final double meanSolarAnomaly = calculateAccurateMeanAnomaly(solarNoonApprox);
this.equationOfCenter = calculateEquationOfCenter(meanSolarAnomaly);
this.solarEclipticalLongitude = calculateSolarEclipticLongitude(meanSolarAnomaly, equationOfCenter);
this.solarNoonTransit = calculateSolarNoonTransit(solarNoonApprox, meanSolarAnomaly, solarEclipticalLongitude);
final double accurateMeanSolarAnomaly = calculateAccurateMeanAnomalyRecursive(solarNoonApprox, meanSolarAnomaly, solarNoonTransit);
final double solarDeclination = calculateSolarDeclination(solarEclipticalLongitude);
final double hourAngle = calculateExactHourAngle(latitude, solarDeclination);
final double solarNoonSecondApprox = calculateSolarNoonSecondApprox(hourAngle, longitude, julianCycle);
final double sunset = calculateSunset(solarNoonSecondApprox, accurateMeanSolarAnomaly, getSolarEclipticalLongitude());
final double sunrise = calculateSunrise(sunset, getSolarNoonTransit());
final Date sunriseDate = dateTimeUtil.convertJdToDate(sunrise);
final Date sunsetDate = dateTimeUtil.convertJdToDate(sunset);
final RiseAndSet result = new RiseAndSet(sunriseDate, sunsetDate);
return result;
}
/**
* http://en.wikipedia.org/wiki/Sunrise_equation
* @param julianDay
* @param latitude
* @param longitude
* @return
*/
@Deprecated
public final double calculateSunrise(final double julianDay, final double latitude, final double longitude) {
//FIXME
final double currentJulianCycle = calculateJulianCycle(julianDay, longitude);
final double approximateSolarNoon = DateTimeUtil.J_CONSTANT + (longitude / Constants.DEGREES_IN_CIRCLE) + currentJulianCycle;
final double solarMeanAnomaly = (ANGLE_TO_SUN_FROM_PERIHELION_PRECISE
+ (SOLAR_MEAN_DAILY_ANOMALISTIC_MOTION_PRECISE * (approximateSolarNoon - Constants.JULIAN_DAY_AT_01_01_2000)))
% Constants.DEGREES_IN_CIRCLE;
final double equationOfCenter =
(EQUATION_OF_CENTER_CONSTANT_1 * Math.sin(solarMeanAnomaly))
+ (EQUATION_OF_CENTER_CONSTANT_2 * Math.sin(2.0D * solarMeanAnomaly))
+ (EQUATION_OF_CENTER_CONSTANT_3 * Math.sin(3.0D * solarMeanAnomaly));
final double eclipticLongitude = (solarMeanAnomaly + PERIHELION_TO_VENERAL_EQUINOX_DEGREES + equationOfCenter + (Constants.DEGREES_IN_CIRCLE / 2))
% Constants.DEGREES_IN_CIRCLE;
final double solarTransit =
approximateSolarNoon
+ (EARTHS_SOLAR_TRANSIT_ECCENTRICAL_VARIATION * Math.sin(solarMeanAnomaly))
- (EARTHS_SOLAR_TRANSIT_ECLIPTIC_OBLIQUITY_VARIATION * Math.sin(2.0D * eclipticLongitude)); //hour angle for solar noon
final double sunDeclination = Math.asin(Math.sin(eclipticLongitude) * Math.sin(EARTH_AXIS_TILT));
final double hourAngle =
Math.acos(
(Math.sin(SOLAR_ELEVATION_AT_SUNRISE_AND_SUNSET) - (Math.sin(latitude) * Math.sin(sunDeclination)))
/ (Math.cos(latitude) * Math.cos(sunDeclination))
);
final double sunSet = DateTimeUtil.J_CONSTANT + ((hourAngle + longitude) / Constants.DEGREES_IN_CIRCLE) + currentJulianCycle
+ (EARTHS_SOLAR_TRANSIT_ECCENTRICAL_VARIATION * Math.sin(solarMeanAnomaly))
- (EARTHS_SOLAR_TRANSIT_ECLIPTIC_OBLIQUITY_VARIATION * Math.sin(2D * eclipticLongitude));
final double sunRise = solarTransit - (sunSet - solarTransit);
return sunRise;
}
/**
* http://de.wikipedia.org/wiki/Aszendent_%28Astrologie%29#Berechnung_des_Aszendenten
* @param localSiderealDegrees
* @param latitude
* @return
*/
public final double calculateEclipticLongitudeJ2000Tangens(final double localSiderealDegrees, final double latitude) {
final double tanLambda =
(Math.cos(Math.toRadians(localSiderealDegrees)) * -1)
/ ((Math.sin(Math.toRadians(localSiderealDegrees))
* Math.cos(Math.toRadians(EARTH_INCLINATION_J2000)))
+ (Math.tan(Math.toRadians(latitude))
* Math.sin(Math.toRadians(EARTH_INCLINATION_J2000))));
return tanLambda;
}
public final boolean returnDescendent(final double localSiderealDegrees) {
return ((Constants.DEGREES_IN_CIRCLE / 4) < localSiderealDegrees && localSiderealDegrees < ((Constants.DEGREES_IN_CIRCLE / 4) * 3));
}
public final double getFirstHorizontEclipticSection(final double eclipticLongitudeTan) {
final double eclipticLongitude = Math.atan(eclipticLongitudeTan);
final double eclipticLongitudeDeg = Math.toDegrees(eclipticLongitude);
final double firstS1 = (eclipticLongitudeDeg + (Constants.DEGREES_IN_CIRCLE / 2)) % Constants.DEGREES_IN_CIRCLE;
return clampS1(firstS1);
}
private double clampS1(final double firstS1) {
if (firstS1 >= (Constants.DEGREES_IN_CIRCLE / 2)) {
return firstS1 - (Constants.DEGREES_IN_CIRCLE / 2);
} else {
return firstS1;
}
}
public final double getSecondHorizontEclipticSection(final double eclipticLongitudeTan) {
return getFirstHorizontEclipticSection(eclipticLongitudeTan) + (Constants.DEGREES_IN_CIRCLE / 2);
}
public final ZodiacSign returnSign(final double s1, final double s2, final boolean returnDescendent) {
if (returnDescendent) {
return ZodiacSign.getSignAtDegree(s2);
} else {
return ZodiacSign.getSignAtDegree(s1);
}
}
public final double returnPosition(final double s1, final double s2, final boolean returnDescendent) {
if (returnDescendent) {
return s2 - returnSign(s1, s2, returnDescendent).getEclipticLongitude();
} else {
return s1 - returnSign(s1, s2, returnDescendent).getEclipticLongitude();
}
}
public final AscendentAndOffset determineAscendent(final Date utcDate, final double longitude, final double latitude) {
final double jd = dateTimeUtil.getJdTimeDate(utcDate);
final double siderealDegrees = dateTimeUtil.getSiderealDegrees(jd);
final double localSiderealDegrees = dateTimeUtil.getLocalSiderealDegrees(siderealDegrees, longitude);
final double eclipticLongitudeTan = calculateEclipticLongitudeJ2000Tangens(localSiderealDegrees, latitude);
final double s1 = getFirstHorizontEclipticSection(eclipticLongitudeTan);
final double s2 = getSecondHorizontEclipticSection(eclipticLongitudeTan);
final boolean returnDescendent = returnDescendent(localSiderealDegrees);
final ZodiacSign sign = returnSign(s1, s2, returnDescendent);
final double position = returnPosition(s1, s2, returnDescendent);
// final double midheaven = calculateMidheaven(localSiderealDegrees);
// final double midheaven = calculateMc(localSiderealDegrees);
final double midheaven = 0.0D; //FIXME
final AscendentAndOffset asc = new AscendentAndOffset(sign, position, midheaven);
return asc;
}
/**
* http://www.sismoloc.info/mc_east_and_ac_north.html
* ARMC = ascensio recta medii coeli = right ascension of the local meridian
* @return
*/
@Deprecated
public final double calculateMidheaven(final double armcDegree) {
return Math.toDegrees(
Math.atan(
Math.cos(Math.toRadians(EARTH_INCLINATION_J2000))
* (1D / Math.tan(Math.toRadians(armcDegree))) //=cot
) * -1D
) + ((Constants.DEGREES_IN_CIRCLE / 4) * 3);
}
/**
* http://groups.google.com/group/alt.astrology.moderated/browse_thread/thread/5cf05d6fe8eabb52/17e0c6282d8c7dce?lnk=raot
* @return
*/
@Deprecated
public final double calculateMc(final double ramc) {
return Math.toDegrees(Math.atan(
Math.tan(Math.toRadians(ramc))
/ Math.cos(Math.toRadians(EARTH_INCLINATION_J2000))
)) + ((Constants.DEGREES_IN_CIRCLE / 4) * 3);
}
@Deprecated
public final double calculateObliqueAscension(final double ascendentLongitude, final double longitude) {
final double rightAscension =
Math.toDegrees(Math.atan(
Math.cos(Math.toRadians(EARTH_INCLINATION_J2000))
* Math.tan(Math.toRadians(ascendentLongitude))
));
final double d =
Math.toDegrees(Math.asin(
Math.sin(Math.toRadians(EARTH_INCLINATION_J2000))
* Math.sin(Math.toRadians(ascendentLongitude))
));
System.out.println("rightAscension: " + rightAscension);
final double obliqueAscension =
rightAscension
- Math.toDegrees(Math.asin(
Math.tan(Math.toRadians(d))
* Math.tan(Math.toRadians(longitude))
));
return obliqueAscension;
}
/**
* Converts the provided degrees from decimal to a String with degrees, minutes and seconds.
* @param inDegrees decimal
* @return converted String
*/
public final String convertDegrees(final double inDegrees) {
final int degrees;
if (inDegrees >= 0) {
degrees = Double.valueOf(Math.floor(inDegrees)).intValue();
} else {
degrees = Double.valueOf(Math.ceil(inDegrees)).intValue();
}
final double decimalPlaces = Math.abs(inDegrees - degrees);
final double exactMinutes = decimalPlaces * Constants.MINUTES_PER_DEGREE;
final int minutes = Double.valueOf(Math.floor(exactMinutes)).intValue();
final double second = Double.valueOf((exactMinutes - Math.floor(exactMinutes)) * Constants.SECONDS_PER_MINUTE);
final String secondString = NumberFormat.getFormat("0.0").format(second);
return "" + degrees + Constants.DEGREE_SIGN + minutes + Constants.MINUTE_SIGN + secondString + Constants.SECOND_SIGN;
}
}