ComplexZmanimCalendar (Zmanim API 1.3.0beta-Dec-18-2011)

java.lang.Object
- net.sourceforge.zmanim.AstronomicalCalendar
- - net.sourceforge.zmanim.ZmanimCalendar
  - - net.sourceforge.zmanim.ComplexZmanimCalendar

All Implemented Interfaces:

Cloneable
```
public class ComplexZmanimCalendar
extends ZmanimCalendar
```
This class extends ZmanimCalendar and provides many more zmanim than available in the ZmanimCalendar. The basis for most zmanim in this class are from the sefer Yisroel Vehazmanim by Rabbi Yisroel Dovid Harfenes.
As an example of the number of different zmanim made available by this class, there are methods to return 12 different calculations for alos (dawn) available in this class. The real power of this API is the ease in calculating zmanim that are not part of the API. The methods for doing zmanim calculations not present in this class or it's superclass the ZmanimCalendar are contained in the AstronomicalCalendar , the base class of the calendars in our API since they are generic methods for calculating time based on degrees or time before or after sunrise and sunset and are of interest for calculation beyond zmanim calculations. Here are some examples:
First create the Calendar for the location you would like to calculate:
```
 String locationName = "Lakewood, NJ";
 double latitude = 40.0828; // Lakewood, NJ
 double longitude = -74.2094; // Lakewood, NJ
 double elevation = 0;
 // the String parameter in getTimeZone() has to be a valid timezone listed in
 // TimeZone.getAvailableIDs()
 TimeZone timeZone = TimeZone.getTimeZone("America/New_York");
 GeoLocation location = new GeoLocation(locationName, latitude, longitude, elevation, timeZone);
 ComplexZmanimCalendar czc = new ComplexZmanimCalendar(location);
 // Optionally set the date or it will default to today's date
 czc.getCalendar().set(Calendar.MONTH, Calendar.FEBRUARY);
 czc.getCalendar().set(Calendar.DAY_OF_MONTH, 8);
 
```
Note: For locations such as Israel where the beginning and end of daylight savings time can fluctuate from year to year create a SimpleTimeZone with the known start and end of DST.
To get alos calculated as 14° below the horizon (as calculated in the calendars published in Montreal), add AstronomicalCalendar.ASTRONOMICAL_ZENITH (90) to the 14° offset to get the desired time:
```
 Date alos14 = czc.getSunriseOffsetByDegrees(AstronomicalCalendar.ASTRONOMICAL_ZENITH + 14);
 
```
To get mincha gedola calculated based on the MGA using a shaah zmanis based on the day starting 16.1° below the horizon (and ending 16.1° after sunset) the following calculation can be used:
```
 Date minchaGedola = czc.getTimeOffset(czc.getAlos16point1Degrees(), czc.getShaahZmanis16Point1Degrees() * 6.5);
 
```
A little more complex example would be calculating plag hamincha based on a shaah zmanis that was not present in this class. While a drop more complex it is still rather easy. For example if you wanted to calculate plag based on the day starting 12° before sunrise and ending 12° after sunset as calculated in the calendars in Manchester, England (there is nothing that would prevent your calculating the day using sunrise and sunset offsets that are not identical degrees, but this would lead to chatzos being a time other than the solar transit (solar midday)). The steps involved would be to first calculate the shaah zmanis and then use that time in milliseconds to calculate 10.75 hours after sunrise starting at 12° before sunset
```
 long shaahZmanis = czc.getTemporalHour(czc.getSunriseOffsetByDegrees(AstronomicalCalendar.ASTRONOMICAL_ZENITH + 12),
                                                czc.getSunsetOffsetByDegrees(AstronomicalCalendar.ASTRONOMICAL_ZENITH + 12));
 Date plag = getTimeOffset(czc.getSunriseOffsetByDegrees(AstronomicalCalendar.ASTRONOMICAL_ZENITH + 12), 
                                        shaahZmanis * 10.75);
 
```
Disclaimer:
While I did my best to get accurate results please do not rely on these zmanim for halacha lemaaseh
Version:

1.2

Author:

© Eliyahu Hershfeld 2004 - 2011

Field Summary

Fields
Modifier and Type	Field and Description
`protected static double`	`ZENITH_10_POINT_2` The zenith of 10.2° below `geometric zenith` (90°).
`protected static double`	`ZENITH_11_DEGREES` The zenith of 11° below `geometric zenith` (90°).
`protected static double`	`ZENITH_11_POINT_5` The zenith of 11.5° below `geometric zenith` (90°).
`protected static double`	`ZENITH_13_POINT_24` The zenith of 13.24° below `geometric zenith` (90°).
`protected static double`	`ZENITH_19_POINT_8` The zenith of 19.8° below `geometric zenith` (90°).
`protected static double`	`ZENITH_26_DEGREES` The zenith of 26° below `geometric zenith` (90°).
`protected static double`	`ZENITH_3_POINT_65` The zenith of 3.65° below `geometric zenith` (90°).
`protected static double`	`ZENITH_3_POINT_7` The zenith of 3.7° below `geometric zenith` (90°).
`protected static double`	`ZENITH_4_POINT_37` The zenith of 4.37° below `geometric zenith` (90°).
`protected static double`	`ZENITH_4_POINT_61` The zenith of 4.61° below `geometric zenith` (90°).
`protected static double`	`ZENITH_4_POINT_8`
`protected static double`	`ZENITH_5_POINT_88`
`protected static double`	`ZENITH_5_POINT_95` The zenith of 5.95° below `geometric zenith` (90°).
`protected static double`	`ZENITH_7_POINT_083` The zenith of 7.083° below `geometric zenith` (90°).

Fields inherited from class net.sourceforge.zmanim.ZmanimCalendar
ZENITH_16_POINT_1, ZENITH_8_POINT_5

Fields inherited from class net.sourceforge.zmanim.AstronomicalCalendar
ASTRONOMICAL_ZENITH, CIVIL_ZENITH, GEOMETRIC_ZENITH, HOUR_MILLIS, MINUTE_MILLIS, NAUTICAL_ZENITH

Constructor Summary

Constructors
Constructor and Description
`ComplexZmanimCalendar()` Default constructor will set a default `GeoLocation.GeoLocation()`, a default `AstronomicalCalculator` and default the calendar to the current date.
`ComplexZmanimCalendar(GeoLocation location)`

Method Summary

Methods
Modifier and Type	Method and Description
`Date`	`getAlos120()` Method to return alos (dawn) calculated using 120 minutes before `sea level sunrise` (no adjustment for elevation is made) based on the time to walk the distance of 5 Mil( Ula) at 24 minutes a Mil.
`Date`	`getAlos120Zmanis()` Method to return alos (dawn) calculated using 120 minutes zmaniyos( GRA and the Baal Hatanya) or 1/6th of the day before sea level sunrise.
`Date`	`getAlos16Point1Degrees()` Method to return alos (dawn) calculated when the sun is `16.1°` below the eastern geometric horizon before sunrise.
`Date`	`getAlos18Degrees()` A method to return alos (dawn) calculated when the sun is `18°` below the eastern geometric horizon before sunrise.
`Date`	`getAlos19Point8Degrees()` Method to return alos (dawn) calculated when the sun is `19.8°` below the eastern geometric horizon before sunrise.
`Date`	`getAlos26Degrees()` A method to return alos (dawn) calculated when the sun is `26°` below the eastern geometric horizon before sunrise.
`Date`	`getAlos60()` Method to return alos (dawn) calculated as 60 minutes before `sea level sunrise`.
`Date`	`getAlos72Zmanis()` Method to return alos (dawn) calculated using 72 minutes zmaniyos( GRA and the Baal Hatanya) or 1/10th of the day before sea level sunrise.
`Date`	`getAlos90()` Method to return alos (dawn) calculated using 90 minutes before `sea level sunrise` based on the time to walk the distance of 4 Mil at 22.5 minutes a Mil.
`Date`	`getAlos90Zmanis()` Method to return alos (dawn) calculated using 90 minutes zmaniyos( GRA and the Baal Hatanya) or 1/8th of the day before sea level sunrise.
`Date`	`getAlos96()` Method to return alos (dawn) calculated using 96 minutes before `sea level sunrise` based on the time to walk the distance of 4 Mil at 24 minutes a Mil.
`Date`	`getAlos96Zmanis()` Method to return alos (dawn) calculated using 96 minutes zmaniyos( GRA and the Baal Hatanya) or 1/8th of the day before sea level sunrise.
`double`	`getAteretTorahSunsetOffset()` Returns the offset in minutes after sunset used to calculate sunset for the Ateret Torah zmanim.
`Date`	`getBainHasmashosRT13Point24Degrees()` Method to return Bain Hashmasho of Rabainu Tam calculated when the sun is `13.24°` below the western `geometric horizon` (90°) after sunset.
`Date`	`getBainHasmashosRT13Point5MinutesBefore7Point083Degrees()` This method returns the time of bain hashmashos based on the calculation of 13.5 minutes (3/4 of an 18 minute Mil before shkiah calculated as `7.083°`.
`Date`	`getBainHasmashosRT2Stars()` This method returns bain hashmashos of Rabainu Tam calculated according to the opinion of the Divray Yosef (see Yisrael Vehazmanim) calculated 5/18th (27.77%) of the time between alos (calculated as 19.8° before sunrise) and sunrise.
`Date`	`getBainHasmashosRT58Point5Minutes()` This method returns Bain Hashmashos of Rabainu Tam* calculated as a 58.5 minute offset after sunset.*
`Date`	`getFixedLocalChatzos()` A method that returns the local time for fixed chatzos.
`Date`	`getMinchaGedola16Point1Degrees()` This method returns the time of mincha gedola according to the Magen Avraham with the day starting and ending 16.1° below the horizon.
`Date`	`getMinchaGedola30Minutes()` This method returns mincha gedola calculated as 30 minutes after `chatzos` and not 1/2 of a `shaah zmanis` after `chatzos` as calculated by `ZmanimCalendar.getMinchaGedola()`.
`Date`	`getMinchaGedola72Minutes()` This method returns the time of mincha gedola according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset.
`Date`	`getMinchaGedolaAteretTorah()` This method returns the time of mincha gedola based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts `1/10th of the day` before sunrise and is usually calculated as ending `40 minutes after sunset` (configurable to any offset via `setAteretTorahSunsetOffset(double)`).
`Date`	`getMinchaGedolaGreaterThan30()` This is a conveniance methd that returns the later of `ZmanimCalendar.getMinchaGedola()` and `getMinchaGedola30Minutes()`.
`Date`	`getMinchaKetana16Point1Degrees()` This method returns the time of mincha ketana according to the Magen Avraham with the day starting and ending 16.1° below the horizon.
`Date`	`getMinchaKetana72Minutes()` This method returns the time of mincha ketana according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset.
`Date`	`getMinchaKetanaAteretTorah()` This method returns the time of mincha ketana based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts `1/10th of the day` before sunrise and is usually calculated as ending `40 minutes after sunset` (configurable to any offset via `setAteretTorahSunsetOffset(double)`).
`Date`	`getMisheyakir10Point2Degrees()` This method returns misheyakir based on the position of the sun when it is `10.2°` below `geometric zenith` (90°).
`Date`	`getMisheyakir11Degrees()` This method returns misheyakir based on the position of the sun when it is `11°` below `geometric zenith` (90°).
`Date`	`getMisheyakir11Point5Degrees()` This method returns misheyakir based on the position of the sun when it is `11.5°` below `geometric zenith` (90°).
`Date`	`getPlagAlos16Point1ToTzaisGeonim7Point083Degrees()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 16.1°` and ends at `tzais`. 10.75 shaos zmaniyos are calculated based on this day and added to `alos` to reach this time.
`Date`	`getPlagAlosToSunset()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 16.1°` and ends at `sunset`. 10.75 shaos zmaniyos are calculated based on this day and added to `alos` to reach this time.
`Date`	`getPlagHamincha120Minutes()` This method returns the time of plag hamincha according to the Magen Avraham with the day starting 120 minutes before sunrise and ending 120 minutes after sunset.
`Date`	`getPlagHamincha120MinutesZmanis()` This method returns the time of plag hamincha based on sunrise being 120 minutes zmaniyos( GRA and the Baal Hatanya) or 1/6th of the day before sea level sunrise.
`Date`	`getPlagHamincha16Point1Degrees()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 16.1°` and ends at `tzais 16.1°`.
`Date`	`getPlagHamincha18Degrees()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 18°` and ends at `tzais 18°` .
`Date`	`getPlagHamincha19Point8Degrees()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 19.8°` and ends at `tzais 19.8°`.
`Date`	`getPlagHamincha26Degrees()` This method returns the time of plag hamincha based on the opinion that the day starts at `alos 26°` and ends at `tzais 26°` .
`Date`	`getPlagHamincha60Minutes()` This method returns the time of plag hamincha according to the Magen Avraham with the day starting 60 minutes before sunrise and ending 60 minutes after sunset.
`Date`	`getPlagHamincha72Minutes()` This method returns the time of plag hamincha according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset.
`Date`	`getPlagHamincha72MinutesZmanis()` This method returns the time of plag hamincha.
`Date`	`getPlagHamincha90Minutes()` This method returns the time of plag hamincha according to the Magen Avraham with the day starting 90 minutes before sunrise and ending 90 minutes after sunset.
`Date`	`getPlagHamincha90MinutesZmanis()` This method returns the time of plag hamincha.
`Date`	`getPlagHamincha96Minutes()` This method returns the time of plag hamincha according to the Magen Avraham with the day starting 96 minutes before sunrise and ending 96 minutes after sunset.
`Date`	`getPlagHamincha96MinutesZmanis()` This method returns the time of plag hamincha.
`Date`	`getPlagHaminchaAteretTorah()` This method returns the time of plag hamincha based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts `1/10th of the day` before sunrise and is usually calculated as ending `40 minutes after sunset` (configurable to any offset via `setAteretTorahSunsetOffset(double)`).
`long`	`getShaahZmanis120Minutes()` Method to return a shaah zmanis (temporal hour) calculated using a dip of 120 minutes.
`long`	`getShaahZmanis120MinutesZmanis()` Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being `120` minutes zmaniyos before `sunrise`.
`long`	`getShaahZmanis16Point1Degrees()` Method to return a shaah zmanis (temporal hour) calculated using a dip of 16.1°.
`long`	`getShaahZmanis18Degrees()` Method to return a shaah zmanis (temporal hour) calculated using a 18° dip.
`long`	`getShaahZmanis19Point8Degrees()` Method to return a shaah zmanis (temporal hour) calculated using a 19.8° dip.
`long`	`getShaahZmanis26Degrees()` Method to return a shaah zmanis (temporal hour) calculated using a dip of 26°.
`long`	`getShaahZmanis60Minutes()` Method to return a shaah zmanis (solar hour) according to the opinion of the MGA.
`long`	`getShaahZmanis72Minutes()` Method to return a shaah zmanis (solar hour) according to the opinion of the MGA.
`long`	`getShaahZmanis72MinutesZmanis()` Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being `72` minutes zmaniyos before `sunrise`.
`long`	`getShaahZmanis90Minutes()` Method to return a shaah zmanis (temporal hour) calculated using a dip of 90 minutes.
`long`	`getShaahZmanis90MinutesZmanis()` Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being `90` minutes zmaniyos before `sunrise`.
`long`	`getShaahZmanis96Minutes()` Method to return a shaah zmanis (temporal hour) calculated using a dip of 96 minutes.
`long`	`getShaahZmanis96MinutesZmanis()` Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being `96` minutes zmaniyos before `sunrise`.
`long`	`getShaahZmanisAteretTorah()` Method to return a shaah zmanis (temporal hour) according to the opinion of the Chacham Yosef Harari-Raful of Yeshivat Ateret Torah calculated with alos being 1/10th of sunrise to sunset day, or `72` minutes zmaniyos of such a day before `sunrise`, and tzais is usually calculated as `40 minutes` (configurable to any offset via `setAteretTorahSunsetOffset(double)`) after `sunset`.
`Date`	`getSofZmanAchilasChametzGRA()` This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the GRA and the Baal Hatanya.
`Date`	`getSofZmanAchilasChametzMGA16Point1Degrees()` This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the MGA based on alos being `16.1°` before `sunrise`.
`Date`	`getSofZmanAchilasChametzMGA72Minutes()` This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the MGA based on alos being `72` minutes before `sunrise`.
`Date`	`getSofZmanBiurChametzGRA()` This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the GRA and the Baal Hatanya.
`Date`	`getSofZmanBiurChametzMGA16Point1Degrees()` This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the MGA based on alos being `16.1°` before `sunrise`.
`Date`	`getSofZmanBiurChametzMGA72Minutes()` This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the MGA based on alos being `72` minutes before `sunrise`.
`Date`	`getSofZmanKidushLevana15Days()` Returns the latest time of Kiddush Levana calculated as 15 days after the molad.
`Date`	`getSofZmanKidushLevana15Days(Date alos, Date tzais)` Returns the latest time of Kiddush Levana calculated as 15 days after the molad.
`Date`	`getSofZmanKidushLevanaBetweenMoldos()` Returns the latest time of Kiddush Levana according to the Maharil's opinion that it is calculated as halfway between molad and molad.
`Date`	`getSofZmanKidushLevanaBetweenMoldos(Date alos, Date tzais)` Returns the latest time of Kiddush Levana according to the Maharil's opinion that it is calculated as halfway between molad and molad.
`Date`	`getSofZmanShma3HoursBeforeChatzos()` This method returns the latest zman krias shema (time to recite Shema in the morning) calculated as 3 hours (regular and not zmaniyos) before `ZmanimCalendar.getChatzos()`.
`Date`	`getSofZmanShmaAlos16Point1ToSunset()` This method returns the latest zman krias shema (time to recite Shema in the morning) based on the opinion that the day starts at `alos 16.1°` and ends at `sea level sunset`. 3 shaos zmaniyos are calculated based on this day and added to `alos`to reach this time.
`Date`	`getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees()` This method returns the latest zman krias shema (time to recite Shema in the morning) based on the opinion that the day starts at `alos 16.1°` and ends at `tzais 7.083°`. 3 shaos zmaniyos are calculated based on this day and added to `alos` to reach this time.
`Date`	`getSofZmanShmaAteretTorah()` This method returns the latest zman krias shema (time to recite Shema in the morning) based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts `1/10th of the day` before sunrise and is usually calculated as ending `40 minutes after sunset` (configurable to any offset via `setAteretTorahSunsetOffset(double)`).
`Date`	`getSofZmanShmaFixedLocal()` A method that returns the latest zman krias shema (time to recite Shema in the morning) calculated as 3 hours before `getFixedLocalChatzos()`.
`Date`	`getSofZmanShmaKolEliyahu()` From the GRA in Kol Eliyahu on Berachos #173 that states that zman krias shema is calculated as half the time from `sea level sunrise` to `fixed local chatzos`.
`Date`	`getSofZmanShmaMGA120Minutes()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `120` minutes or 1/6th of the day before `sunrise`.
`Date`	`getSofZmanShmaMGA16Point1Degrees()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `16.1°` before `sunrise`.
`Date`	`getSofZmanShmaMGA19Point8Degrees()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `19.8°` before `sunrise`.
`Date`	`getSofZmanShmaMGA72Minutes()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `72` minutes before `sunrise`.
`Date`	`getSofZmanShmaMGA72MinutesZmanis()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `72` minutes zmaniyos , or 1/10th of the day before `sunrise`.
`Date`	`getSofZmanShmaMGA90Minutes()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `90` minutes before `sunrise`.
`Date`	`getSofZmanShmaMGA90MinutesZmanis()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `90` minutes zmaniyos before `sunrise`.
`Date`	`getSofZmanShmaMGA96Minutes()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `96` minutes before `sunrise`.
`Date`	`getSofZmanShmaMGA96MinutesZmanis()` This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being `96` minutes zmaniyos before `sunrise`.
`Date`	`getSofZmanTfila2HoursBeforeChatzos()` This method returns the latest zman tfila (time to recite the morning prayers) calculated as 2 hours before `ZmanimCalendar.getChatzos()`.
`Date`	`getSofZmanTfilaFixedLocal()` This method returns the latest zman tfila (time to recite the morning prayers) calculated as 2 hours before `getFixedLocalChatzos()`.
`Date`	`getSofZmanTfilahAteretTorah()` This method returns the latest zman tfila (time to recite the morning prayers) based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts `1/10th of the day` before sunrise and is usually calculated as ending `40 minutes after sunset` (configurable to any offset via `setAteretTorahSunsetOffset(double)`).
`Date`	`getSofZmanTfilaMGA120Minutes()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `120` minutes before `sunrise` .
`Date`	`getSofZmanTfilaMGA16Point1Degrees()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `16.1°` before `sunrise`.
`Date`	`getSofZmanTfilaMGA19Point8Degrees()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `19.8°` before `sunrise`.
`Date`	`getSofZmanTfilaMGA72Minutes()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `72` minutes before `sunrise`.
`Date`	`getSofZmanTfilaMGA72MinutesZmanis()` This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being `72` minutes zmaniyos before `sunrise`.
`Date`	`getSofZmanTfilaMGA90Minutes()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `90` minutes before `sunrise`.
`Date`	`getSofZmanTfilaMGA90MinutesZmanis()` This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being `90` minutes zmaniyos before `sunrise`.
`Date`	`getSofZmanTfilaMGA96Minutes()` This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being `96` minutes before `sunrise`.
`Date`	`getSofZmanTfilaMGA96MinutesZmanis()` This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being `96` minutes zmaniyos before `sunrise`.
`Date`	`getSolarMidnight()` A method that returns "solar" midnight, or the time when the sun is at its nadir.
`Date`	`getTchilasZmanKidushLevana3Days()`
`Date`	`getTchilasZmanKidushLevana3Days(Date alos, Date tzais)`
`Date`	`getTchilasZmanKidushLevana7Days()`
`Date`	`getTchilasZmanKidushLevana7Days(Date alos, Date tzais)`
`Date`	`getTzais120()` This method returns tzais (nightfall) based on the opinion of the Magen Avraham that the time to walk the distance of a Mil according to the Rambam's opinion is 2/5 of an hour (24 minutes) for a total of 120 minutes based on the opinion of Ula who calculated tzais as 5 Mil after sea level shkiah (sunset).
`Date`	`getTzais120Zmanis()` Method to return tzais (dusk) calculated using 120 minutes zmaniyos (GRA and the Baal Hatanya) after `sea level sunset`.
`Date`	`getTzais16Point1Degrees()` For information on how this is calculated see the comments on `getAlos16Point1Degrees()`
`Date`	`getTzais18Degrees()` For information on how this is calculated see the comments on `getAlos18Degrees()`
`Date`	`getTzais19Point8Degrees()` For information on how this is calculated see the comments on `getAlos19Point8Degrees()`
`Date`	`getTzais26Degrees()` For information on how this is calculated see the comments on `getAlos26Degrees()`
`Date`	`getTzais60()` This method returns the tzais (nightfall) based on the opinion of the Chavas Yair and Divray Malkiel that the time to walk the distance of a Mil is 15 minutes for a total of 60 minutes for 4 Mil after `sea level sunset`.
`Date`	`getTzais72Zmanis()` Method to return tzais (dusk) calculated as 72 minutes zmaniyos, or 1/10th of the day after `sea level sunset`.
`Date`	`getTzais90()` Method to return tzais (dusk) calculated as 90 minutes after sea level sunset.
`Date`	`getTzais90Zmanis()` Method to return tzais (dusk) calculated using 90 minutes zmaniyos (GRA and the Baal Hatanya) after `sea level sunset`.
`Date`	`getTzais96()` A method to return tzais (dusk) calculated as 96 minutes after sea level sunset.
`Date`	`getTzais96Zmanis()` Method to return tzais (dusk) calculated using 96 minutes zmaniyos (GRA and the Baal Hatanya) after `sea level sunset`.
`Date`	`getTzaisAteretTorah()` This method returns tzais usually calculated as 40 minutes (configurable to any offset via `setAteretTorahSunsetOffset(double)`) after sunset.
`Date`	`getTzaisGeonim3Point65Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on an 18 minute Mil, or 13.5 minutes.
`Date`	`getTzaisGeonim4Point37Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil, based on a 22.5 minute Mil, or 16 7/8 minutes.
`Date`	`getTzaisGeonim4Point61Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on a 24 minute Mil, or 18 minutes.
`Date`	`getTzaisGeonim4Point8Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on the sun's position at `4.8°` below the western horizon.
`Date`	`getTzaisGeonim5Point88Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a 24 minute Mil, ( Baal Hatanya) based on a Mil being 24 minutes, and is calculated as 18 + 2 + 4 for a total of 24 minutes (FIXME: additional documentation details needed).
`Date`	`getTzaisGeonim5Point95Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at `5.95°` below the western horizon.
`Date`	`getTzaisGeonim7Point083Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at `7.083°` below the western horizon.
`Date`	`getTzaisGeonim8Point5Degrees()` This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at `8.5°` below the western horizon.
`void`	`setAteretTorahSunsetOffset(double ateretTorahSunsetOffset)` Allows setting the offset in minutes after sunset for the Ateret Torah zmanim.

Methods inherited from class net.sourceforge.zmanim.ZmanimCalendar
getAlos72, getAlosHashachar, getCandleLighting, getCandleLightingOffset, getChatzos, getMinchaGedola, getMinchaKetana, getPlagHamincha, getShaahZmanisGra, getShaahZmanisMGA, getSofZmanShmaGRA, getSofZmanShmaMGA, getSofZmanTfilaGRA, getSofZmanTfilaMGA, getTzais, getTzais72, setCandleLightingOffset

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ZENITH_3_POINT_7
```
protected static final double ZENITH_3_POINT_7
```
    The zenith of 3.7° below geometric zenith (90°). This calculation is used for calculating tzais (nightfall) based on the opinion of the Geonim that tzais is the time it takes to walk 3/4 of a Mil at 18 minutes a Mil, or 13.5 minutes after sunset. The sun is 3.7° below geometric zenith at this time in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes. TODO AT see #getTzaisGeonim3Point7Degrees()
    
    See Also:
    Constant Field Values
  - ZENITH_5_POINT_95
```
protected static final double ZENITH_5_POINT_95
```
    The zenith of 5.95° below geometric zenith (90°). This calculation is used for calculating tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 24 minutes after sunset in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes, which calculates to 5.95° below geometric zenith.
    
    See Also:
    getTzaisGeonim5Point95Degrees(), Constant Field Values
  - ZENITH_7_POINT_083
```
protected static final double ZENITH_7_POINT_083
```
    The zenith of 7.083° below geometric zenith (90°). This is often referred to as 7°5' or 7° and 5 minutes. This calculation is used for calculating alos (dawn) and tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 30 minutes after sunset in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes, which calculates to 7.0833333° below geometric zenith. This is time some opinions consider dark enough for 3 stars to be visible. This is the opinion of the Sh"Ut Melamed Leho'il, Sh"Ut Binyan Tziyon, Tenuvas Sadeh and very close to the time of the Mekor Chesed on the Sefer chasidim.
    
    See Also:
    getTzaisGeonim7Point083Degrees(), getBainHasmashosRT13Point5MinutesBefore7Point083Degrees(), Constant Field Values
  - ZENITH_10_POINT_2
```
protected static final double ZENITH_10_POINT_2
```
    The zenith of 10.2° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 45 minutes before sunrise in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 10.2° below geometric zenith.
    
    See Also:
    getMisheyakir10Point2Degrees(), Constant Field Values
  - ZENITH_11_DEGREES
```
protected static final double ZENITH_11_DEGREES
```
    The zenith of 11° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 48 minutes before sunrise in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 11° below geometric zenith
    
    See Also:
    getMisheyakir11Degrees(), Constant Field Values
  - ZENITH_11_POINT_5
```
protected static final double ZENITH_11_POINT_5
```
    The zenith of 11.5° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 52 minutes before sunrise in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 11.5° below geometric zenith
    
    See Also:
    getMisheyakir11Point5Degrees(), Constant Field Values
  - ZENITH_13_POINT_24
```
protected static final double ZENITH_13_POINT_24
```
    The zenith of 13.24° below geometric zenith (90°). This calculation is used for calculating Rabainu Tam's bain hashmashos according to some opinions.
    
    NOTE: See comments on getBainHasmashosRT13Point24Degrees() for additional details about the degrees.
    
    See Also:
    getBainHasmashosRT13Point24Degrees(), Constant Field Values
  - ZENITH_19_POINT_8
```
protected static final double ZENITH_19_POINT_8
```
    The zenith of 19.8° below geometric zenith (90°). This calculation is used for calculating alos (dawn) and tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 90 minutes after sunset in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 19.8° below geometric zenith
    
    See Also:
    getTzais19Point8Degrees(), getAlos19Point8Degrees(), getAlos90(), getTzais90(), Constant Field Values
  - ZENITH_26_DEGREES
```
protected static final double ZENITH_26_DEGREES
```
    The zenith of 26° below geometric zenith (90°). This calculation is used for calculating alos (dawn) and tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 120 minutes after sunset in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 26° below geometric zenith
    
    See Also:
    getAlos26Degrees(), getTzais26Degrees(), getAlos120(), getTzais120(), Constant Field Values
  - ZENITH_4_POINT_37
```
protected static final double ZENITH_4_POINT_37
```
    The zenith of 4.37° below geometric zenith (90°). This calculation is used for calculating tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 16 7/8 minutes after sunset (3/4 of a 22.5 minute Mil) in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 4.37° below geometric zenith
    
    See Also:
    getTzaisGeonim4Point37Degrees(), Constant Field Values
  - ZENITH_4_POINT_61
```
protected static final double ZENITH_4_POINT_61
```
    The zenith of 4.61° below geometric zenith (90°). This calculation is used for calculating tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 18 minutes after sunset (3/4 of a 24 minute Mil) in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 4.61° below geometric zenith
    
    See Also:
    getTzaisGeonim4Point61Degrees(), Constant Field Values
  - ZENITH_4_POINT_8
```
protected static final double ZENITH_4_POINT_8
```
    See Also:
    Constant Field Values
  - ZENITH_3_POINT_65
```
protected static final double ZENITH_3_POINT_65
```
    The zenith of 3.65° below geometric zenith (90°). This calculation is used for calculating tzais (nightfall) according to some opinions. This calculation is based on the position of the sun 13.5 minutes after sunset (3/4 of an 18 minute Mil) in Jerusalem on March 16, about 4 days before the equinox, the day that a solar hour is 60 minutes which calculates to 3.65° below geometric zenith
    
    See Also:
    getTzaisGeonim3Point65Degrees(), Constant Field Values
  - ZENITH_5_POINT_88
```
protected static final double ZENITH_5_POINT_88
```
    See Also:
    Constant Field Values
- Constructor Detail
  - ComplexZmanimCalendar
```
public ComplexZmanimCalendar(GeoLocation location)
```
  - ComplexZmanimCalendar
```
public ComplexZmanimCalendar()
```
    Default constructor will set a default GeoLocation.GeoLocation(), a default AstronomicalCalculator and default the calendar to the current date.
    
    See Also:
    AstronomicalCalendar.AstronomicalCalendar()
- Method Detail
  - getShaahZmanis19Point8Degrees
```
public long getShaahZmanis19Point8Degrees()
```
    Method to return a shaah zmanis (temporal hour) calculated using a 19.8° dip. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is when the sun is 19.8° below the eastern geometric horizon before sunrise. Dusk for this is when the sun is 19.8° below the western geometric horizon after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis18Degrees
```
public long getShaahZmanis18Degrees()
```
    Method to return a shaah zmanis (temporal hour) calculated using a 18° dip. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is when the sun is 18° below the eastern geometric horizon before sunrise. Dusk for this is when the sun is 18° below the western geometric horizon after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis26Degrees
```
public long getShaahZmanis26Degrees()
```
    Method to return a shaah zmanis (temporal hour) calculated using a dip of 26°. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is when the sun is 26° below the eastern geometric horizon before sunrise. Dusk for this is when the sun is 26° below the western geometric horizon after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis16Point1Degrees
```
public long getShaahZmanis16Point1Degrees()
```
    Method to return a shaah zmanis (temporal hour) calculated using a dip of 16.1°. This calculation divides the day based on the opinion that the day runs from dawn to dusk. Dawn for this calculation is when the sun is 16.1° below the eastern geometric horizon before sunrise and dusk is when the sun is 16.1° below the western geometric horizon after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos16Point1Degrees(), getTzais16Point1Degrees(), getSofZmanShmaMGA16Point1Degrees(), getSofZmanTfilaMGA16Point1Degrees(), getMinchaGedola16Point1Degrees(), getMinchaKetana16Point1Degrees(), getPlagHamincha16Point1Degrees()
  - getShaahZmanis60Minutes
```
public long getShaahZmanis60Minutes()
```
    Method to return a shaah zmanis (solar hour) according to the opinion of the MGA. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 60 minutes before sunrise and dusk is 60 minutes after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. Alternate mothods of calculating a shaah zmanis are available in the subclass ComplexZmanimCalendar
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis72Minutes
```
public long getShaahZmanis72Minutes()
```
    Method to return a shaah zmanis (solar hour) according to the opinion of the MGA. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 72 minutes before sunrise and dusk is 72 minutes after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. Alternate mothods of calculating a shaah zmanis are available in the subclass ComplexZmanimCalendar
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis72MinutesZmanis
```
public long getShaahZmanis72MinutesZmanis()
```
    Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being 72 minutes zmaniyos before sunrise. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 72 minutes zmaniyos before sunrise and dusk is 72 minutes zmaniyos after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. This is identical to 1/10th of the day from sunrise to sunset.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos72Zmanis(), getTzais72Zmanis()
  - getShaahZmanis90Minutes
```
public long getShaahZmanis90Minutes()
```
    Method to return a shaah zmanis (temporal hour) calculated using a dip of 90 minutes. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 90 minutes before sunrise and dusk is 90 minutes after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis90MinutesZmanis
```
public long getShaahZmanis90MinutesZmanis()
```
    Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being 90 minutes zmaniyos before sunrise. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 90 minutes zmaniyos before sunrise and dusk is 90 minutes zmaniyos after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. This is identical to 1/8th of the day from sunrise to sunset.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos90Zmanis(), getTzais90Zmanis()
  - getShaahZmanis96MinutesZmanis
```
public long getShaahZmanis96MinutesZmanis()
```
    Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being 96 minutes zmaniyos before sunrise. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 96 minutes zmaniyos before sunrise and dusk is 96 minutes zmaniyos after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. This is identical to 1/7.5th of the day from sunrise to sunset.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos96Zmanis(), getTzais96Zmanis()
  - getShaahZmanisAteretTorah
```
public long getShaahZmanisAteretTorah()
```
    Method to return a shaah zmanis (temporal hour) according to the opinion of the Chacham Yosef Harari-Raful of Yeshivat Ateret Torah calculated with alos being 1/10th of sunrise to sunset day, or 72 minutes zmaniyos of such a day before sunrise, and tzais is usually calculated as 40 minutes (configurable to any offset via setAteretTorahSunsetOffset(double)) after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. Note that with this system, chatzos (mid-day) will not be the point that the sun is halfway across the sky.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos72Zmanis(), getTzaisAteretTorah(), getAteretTorahSunsetOffset(), setAteretTorahSunsetOffset(double)
  - getShaahZmanis96Minutes
```
public long getShaahZmanis96Minutes()
```
    Method to return a shaah zmanis (temporal hour) calculated using a dip of 96 minutes. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 96 minutes before sunrise and dusk is 96 minutes after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis120Minutes
```
public long getShaahZmanis120Minutes()
```
    Method to return a shaah zmanis (temporal hour) calculated using a dip of 120 minutes. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 120 minutes before sunrise and dusk is 120 minutes after sunset. This day is split into 12 equal parts with each part being a shaah zmanis.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getShaahZmanis120MinutesZmanis
```
public long getShaahZmanis120MinutesZmanis()
```
    Method to return a shaah zmanis (temporal hour) according to the opinion of the MGA based on alos being 120 minutes zmaniyos before sunrise. This calculation divides the day based on the opinion of the MGA that the day runs from dawn to dusk. Dawn for this calculation is 120 minutes zmaniyos before sunrise and dusk is 120 minutes zmaniyos after sunset. This day is split into 12 equal parts with each part being a shaah zmanis. This is identical to 1/6th of the day from sunrise to sunset.
    
    Returns:
    the long millisecond length of a shaah zmanis. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a Long.MIN_VALUE will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos120Zmanis(), getTzais120Zmanis()
  - getPlagHamincha120MinutesZmanis
```
public Date getPlagHamincha120MinutesZmanis()
```
    This method returns the time of plag hamincha based on sunrise being 120 minutes zmaniyos( GRA and the Baal Hatanya) or 1/6th of the day before sea level sunrise. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 * getShaahZmanis120MinutesZmanis() after dawn.
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis120MinutesZmanis()
  - getPlagHamincha120Minutes
```
public Date getPlagHamincha120Minutes()
```
    This method returns the time of plag hamincha according to the Magen Avraham with the day starting 120 minutes before sunrise and ending 120 minutes after sunset. This is calculated as 10.75 hours after dawn 120 minutes. The formula used is:
    10.75 getShaahZmanis120Minutes() after getAlos120().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis120Minutes()
  - getAlos60
```
public Date getAlos60()
```
    Method to return alos (dawn) calculated as 60 minutes before sea level sunrise. This is the time to walk the distance of 4 Mil at 15 minutes a Mil (the opinion of the Chavas Yair. See the Divray Malkiel). Time based offset calculations for alos are based on the opinion of most Rishonim who stated that the time of the Neshef (time between dawn and sunrise) does not vary by the time of year or location but purely depends on the time it takes to walk the distance of 4 Mil.
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getAlos72Zmanis
```
public Date getAlos72Zmanis()
```
    Method to return alos (dawn) calculated using 72 minutes zmaniyos( GRA and the Baal Hatanya) or 1/10th of the day before sea level sunrise. This is based on an 18 minute Mil so the time for 4 Mil is 72 minutes which is 1/10th of a day (12 * 60 = 720) based on the day starting at sea level sunrise and ending at sea level sunset. The actual alculation is AstronomicalCalendar.getSeaLevelSunrise()- ( ZmanimCalendar.getShaahZmanisGra() * 1.2). This calculation is used in the calendars published by Hisachdus Harabanim D'Artzos Habris Ve'Canada
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getShaahZmanisGra()
  - getAlos96
```
public Date getAlos96()
```
    Method to return alos (dawn) calculated using 96 minutes before sea level sunrise based on the time to walk the distance of 4 Mil at 24 minutes a Mil. Time based offset calculations for alos are based on the opinion of most Rishonim who stated that the time of the Neshef (time between dawn and sunrise) does not vary by the time of year or location but purely depends on the time it takes to walk the distance of 4 Mil.
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getAlos90Zmanis
```
public Date getAlos90Zmanis()
```
    Method to return alos (dawn) calculated using 90 minutes zmaniyos( GRA and the Baal Hatanya) or 1/8th of the day before sea level sunrise. This is based on a 22.5 minute Mil so the time for 4 Mil is 90 minutes which is 1/8th of a day (12 * 60) / 8 = 90 based on the day starting at sunrise and ending at sunset. The actual calculation is AstronomicalCalendar.getSunrise() - ( ZmanimCalendar.getShaahZmanisGra() * 1.5).
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getShaahZmanisGra()
  - getAlos96Zmanis
```
public Date getAlos96Zmanis()
```
    Method to return alos (dawn) calculated using 96 minutes zmaniyos( GRA and the Baal Hatanya) or 1/8th of the day before sea level sunrise. This is based on a 24 minute Mil so the time for 4 Mil is 96 minutes which is 1/7.5th of a day (12 * 60) / 7.5 = 96 based on the day starting at sunrise and ending at sunset. The actual calculation is AstronomicalCalendar.getSunrise() - ( ZmanimCalendar.getShaahZmanisGra() * 1.6).
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getShaahZmanisGra()
  - getAlos90
```
public Date getAlos90()
```
    Method to return alos (dawn) calculated using 90 minutes before sea level sunrise based on the time to walk the distance of 4 Mil at 22.5 minutes a Mil. Time based offset calculations for alos are based on the opinion of most Rishonim who stated that the time of the Neshef (time between dawn and sunrise) does not vary by the time of year or location but purely depends on the time it takes to walk the distance of 4 Mil.
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getAlos120
```
public Date getAlos120()
```
    Method to return alos (dawn) calculated using 120 minutes before sea level sunrise (no adjustment for elevation is made) based on the time to walk the distance of 5 Mil( Ula) at 24 minutes a Mil. Time based offset calculations for alos are based on the opinion of most Rishonim who stated that the time of the Neshef (time between dawn and sunrise) does not vary by the time of year or location but purely depends on the time it takes to walk the distance of 5 Mil(Ula).
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getAlos120Zmanis
```
public Date getAlos120Zmanis()
```
    Method to return alos (dawn) calculated using 120 minutes zmaniyos( GRA and the Baal Hatanya) or 1/6th of the day before sea level sunrise. This is based on a 24 minute Mil so the time for 5 Mil is 120 minutes which is 1/6th of a day (12 * 60) / 6 = 120 based on the day starting at sunrise and ending at sunset. The actual calculation is AstronomicalCalendar.getSunrise() - ( ZmanimCalendar.getShaahZmanisGra() * 2).
    
    Returns:
    the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getShaahZmanisGra()
  - getAlos26Degrees
```
public Date getAlos26Degrees()
```
    A method to return alos (dawn) calculated when the sun is 26° below the eastern geometric horizon before sunrise. This calculation is based on the same calculation of 120 minutes but uses a degree based calculation instead of 120 exact minutes. This calculation is based on the position of the sun 120 minutes before sunrise in Jerusalem during the equinox which calculates to 26° below geometric zenith.
    
    Returns:
    the Date representing alos. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_26_DEGREES, getAlos120(), getTzais120()
  - getAlos18Degrees
```
public Date getAlos18Degrees()
```
    A method to return alos (dawn) calculated when the sun is 18° below the eastern geometric horizon before sunrise.
    
    Returns:
    the Date representing alos. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    AstronomicalCalendar.ASTRONOMICAL_ZENITH
  - getAlos19Point8Degrees
```
public Date getAlos19Point8Degrees()
```
    Method to return alos (dawn) calculated when the sun is 19.8° below the eastern geometric horizon before sunrise. This calculation is based on the same calculation of 90 minutes but uses a degree based calculation instead of 90 exact minutes. This calculation is based on the position of the sun 90 minutes before sunrise in Jerusalem during the equinox which calculates to 19.8° below geometric zenith
    
    Returns:
    the Date representing alos. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_19_POINT_8, getAlos90()
  - getAlos16Point1Degrees
```
public Date getAlos16Point1Degrees()
```
    Method to return alos (dawn) calculated when the sun is 16.1° below the eastern geometric horizon before sunrise. This calculation is based on the same calculation of 72 minutes but uses a degree based calculation instead of 72 exact minutes. This calculation is based on the position of the sun 72 minutes before sunrise in Jerusalem during the equinox which calculates to 16.1° below geometric zenith.
    
    Returns:
    the Date representing alos. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.ZENITH_16_POINT_1, ZmanimCalendar.getAlos72()
  - getMisheyakir11Point5Degrees
```
public Date getMisheyakir11Point5Degrees()
```
    This method returns misheyakir based on the position of the sun when it is 11.5° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 52 minutes before sunrise in Jerusalem during the equinox which calculates to 11.5° below geometric zenith
    
    Returns:
    the Date of misheyakir. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_11_POINT_5
  - getMisheyakir11Degrees
```
public Date getMisheyakir11Degrees()
```
    This method returns misheyakir based on the position of the sun when it is 11° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 48 minutes before sunrise in Jerusalem during the equinox which calculates to 11° below geometric zenith
    
    Returns:
    If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_11_DEGREES
  - getMisheyakir10Point2Degrees
```
public Date getMisheyakir10Point2Degrees()
```
    This method returns misheyakir based on the position of the sun when it is 10.2° below geometric zenith (90°). This calculation is used for calculating misheyakir according to some opinions. This calculation is based on the position of the sun 45 minutes before sunrise in Jerusalem during the equinox which calculates to 10.2° below geometric zenith
    
    Returns:
    the Date of the latest misheyakir. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_10_POINT_2
  - getSofZmanShmaMGA19Point8Degrees
```
public Date getSofZmanShmaMGA19Point8Degrees()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 19.8° before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 19.8° below sunrise or sunset. This returns the time of 3 * getShaahZmanis19Point8Degrees() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis19Point8Degrees(), getAlos19Point8Degrees()
  - getSofZmanShmaMGA16Point1Degrees
```
public Date getSofZmanShmaMGA16Point1Degrees()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 16.1° before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 16.1° below sunrise or sunset. This returns the time of 3 * getShaahZmanis16Point1Degrees() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees(), getAlos16Point1Degrees()
  - getSofZmanShmaMGA72Minutes
```
public Date getSofZmanShmaMGA72Minutes()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 72 minutes before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes before sunrise to nightfall of 72 minutes after sunset. This returns the time of 3 * getShaahZmanis72Minutes() after dawn. This class returns an identical time to ZmanimCalendar.getSofZmanShmaMGA() and is repeated here for clarity.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis72Minutes(), ZmanimCalendar.getAlos72(), ZmanimCalendar.getSofZmanShmaMGA()
  - getSofZmanShmaMGA72MinutesZmanis
```
public Date getSofZmanShmaMGA72MinutesZmanis()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 72 minutes zmaniyos , or 1/10th of the day before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes zmaniyos, or 1/10th of the day before sea level sunrise to nightfall of 72 minutes zmaniyos after sea level sunset. This returns the time of 3 * getShaahZmanis72MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis72MinutesZmanis(), getAlos72Zmanis()
  - getSofZmanShmaMGA90Minutes
```
public Date getSofZmanShmaMGA90Minutes()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 90 minutes before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 90 minutes before sunrise to nightfall of 90 minutes after sunset. This returns the time of 3 * getShaahZmanis90Minutes() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90Minutes(), getAlos90()
  - getSofZmanShmaMGA90MinutesZmanis
```
public Date getSofZmanShmaMGA90MinutesZmanis()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 90 minutes zmaniyos before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 90 minutes zmaniyos before sunrise to nightfall of 90 minutes zmaniyos after sunset. This returns the time of 3 * getShaahZmanis90MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90MinutesZmanis(), getAlos90Zmanis()
  - getSofZmanShmaMGA96Minutes
```
public Date getSofZmanShmaMGA96Minutes()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 96 minutes before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 96 minutes before sunrise to nightfall of 96 minutes after sunset. This returns the time of 3 * getShaahZmanis96Minutes() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis96Minutes(), getAlos96()
  - getSofZmanShmaMGA96MinutesZmanis
```
public Date getSofZmanShmaMGA96MinutesZmanis()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 96 minutes zmaniyos before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 96 minutes zmaniyos before sunrise to nightfall of 96 minutes zmaniyos after sunset. This returns the time of 3 * getShaahZmanis96MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis96MinutesZmanis(), getAlos96Zmanis()
  - getSofZmanShma3HoursBeforeChatzos
```
public Date getSofZmanShma3HoursBeforeChatzos()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) calculated as 3 hours (regular and not zmaniyos) before ZmanimCalendar.getChatzos(). This is the opinion of the Shach in the Nekudas Hakesef (Yora Deah 184), Shevus Yaakov, Chasan Sofer and others. This returns the time of 3 hours before ZmanimCalendar.getChatzos().
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getChatzos(), getSofZmanTfila2HoursBeforeChatzos()
  - getSofZmanShmaMGA120Minutes
```
public Date getSofZmanShmaMGA120Minutes()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) according to the opinion of the MGA based on alos being 120 minutes or 1/6th of the day before sunrise. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 120 minutes before sunrise to nightfall of 120 minutes after sunset. This returns the time of 3 * getShaahZmanis120Minutes() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis120Minutes(), getAlos120()
  - getSofZmanShmaAlos16Point1ToSunset
```
public Date getSofZmanShmaAlos16Point1ToSunset()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) based on the opinion that the day starts at alos 16.1° and ends at sea level sunset. 3 shaos zmaniyos are calculated based on this day and added to alosto reach this time. This time is 3 shaos zmaniyos (solar hours) after dawn based on the opinion that the day is calculated from a alos 16.1° to sea level sunset.
    Note: Based on this calculation chatzos will not be at midday.
    
    Returns:
    the Date of the latest zman krias shema based on this day. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos16Point1Degrees(), AstronomicalCalendar.getSeaLevelSunset()
  - getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees
```
public Date getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees()
```
    This method returns the latest zman krias shema (time to recite Shema in the morning) based on the opinion that the day starts at alos 16.1° and ends at tzais 7.083°. 3 shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 3 shaos zmaniyos (temporal hours) after alos 16.1° based on the opinion that the day is calculated from a alos 16.1° to tzais 7.083°.
    Note: Based on this calculation chatzos will not be at midday.
    
    Returns:
    the Date of the latest zman krias shema based on this calculation. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos16Point1Degrees(), getTzaisGeonim7Point083Degrees()
  - getSofZmanShmaKolEliyahu
```
public Date getSofZmanShmaKolEliyahu()
```
    From the GRA in Kol Eliyahu on Berachos #173 that states that zman krias shema is calculated as half the time from sea level sunrise to fixed local chatzos. The GRA himself seems to contradict this when he stated that zman krias shema is 1/4 of the day from sunrise to sunset. See Sarah Lamoed #25 in Yisroel Vehazmanim Vol III page 1016.
    
    Returns:
    the Date of the latest zman krias shema based on this calculation. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getFixedLocalChatzos()
  - getSofZmanTfilaMGA19Point8Degrees
```
public Date getSofZmanTfilaMGA19Point8Degrees()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 19.8° before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 19.8° below sunrise or sunset. This returns the time of 4 * getShaahZmanis19Point8Degrees() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis19Point8Degrees(), getAlos19Point8Degrees()
  - getSofZmanTfilaMGA16Point1Degrees
```
public Date getSofZmanTfilaMGA16Point1Degrees()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 16.1° before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 16.1° below sunrise or sunset. This returns the time of 4 * getShaahZmanis16Point1Degrees() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees(), getAlos16Point1Degrees()
  - getSofZmanTfilaMGA72Minutes
```
public Date getSofZmanTfilaMGA72Minutes()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 72 minutes before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes before sunrise to nightfall of 72 minutes after sunset. This returns the time of 4 * getShaahZmanis72Minutes() after dawn. This class returns an identical time to ZmanimCalendar.getSofZmanTfilaMGA() and is repeated here for clarity.
    
    Returns:
    the Date of the latest zman tfila. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis72Minutes(), ZmanimCalendar.getAlos72(), ZmanimCalendar.getSofZmanShmaMGA()
  - getSofZmanTfilaMGA72MinutesZmanis
```
public Date getSofZmanTfilaMGA72MinutesZmanis()
```
    This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being 72 minutes zmaniyos before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes zmaniyos before sunrise to nightfall of 72 minutes zmaniyos after sunset. This returns the time of 4 * getShaahZmanis72MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis72MinutesZmanis(), getAlos72Zmanis()
  - getSofZmanTfilaMGA90Minutes
```
public Date getSofZmanTfilaMGA90Minutes()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 90 minutes before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 90 minutes before sunrise to nightfall of 90 minutes after sunset. This returns the time of 4 * getShaahZmanis90Minutes() after dawn.
    
    Returns:
    the Date of the latest zman tfila. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90Minutes(), getAlos90()
  - getSofZmanTfilaMGA90MinutesZmanis
```
public Date getSofZmanTfilaMGA90MinutesZmanis()
```
    This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being 90 minutes zmaniyos before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 90 minutes zmaniyos before sunrise to nightfall of 90 minutes zmaniyos after sunset. This returns the time of 4 * getShaahZmanis90MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90MinutesZmanis(), getAlos90Zmanis()
  - getSofZmanTfilaMGA96Minutes
```
public Date getSofZmanTfilaMGA96Minutes()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 96 minutes before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 96 minutes before sunrise to nightfall of 96 minutes after sunset. This returns the time of 4 * getShaahZmanis96Minutes() after dawn.
    
    Returns:
    the Date of the latest zman tfila. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis96Minutes(), getAlos96()
  - getSofZmanTfilaMGA96MinutesZmanis
```
public Date getSofZmanTfilaMGA96MinutesZmanis()
```
    This method returns the latest zman tfila (time to the morning prayers) according to the opinion of the MGA based on alos being 96 minutes zmaniyos before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 96 minutes zmaniyos before sunrise to nightfall of 96 minutes zmaniyos after sunset. This returns the time of 4 * getShaahZmanis96MinutesZmanis() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90MinutesZmanis(), getAlos90Zmanis()
  - getSofZmanTfilaMGA120Minutes
```
public Date getSofZmanTfilaMGA120Minutes()
```
    This method returns the latest zman tfila (time to recite the morning prayers) according to the opinion of the MGA based on alos being 120 minutes before sunrise . This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 120 minutes before sunrise to nightfall of 120 minutes after sunset. This returns the time of 4 * getShaahZmanis120Minutes() after dawn.
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis120Minutes(), getAlos120()
  - getSofZmanTfila2HoursBeforeChatzos
```
public Date getSofZmanTfila2HoursBeforeChatzos()
```
    This method returns the latest zman tfila (time to recite the morning prayers) calculated as 2 hours before ZmanimCalendar.getChatzos(). This is based on the opinions that calculate sof zman krias shema as getSofZmanShma3HoursBeforeChatzos(). This returns the time of 2 hours before ZmanimCalendar.getChatzos().
    
    Returns:
    the Date of the latest zman krias shema. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getChatzos(), getSofZmanShma3HoursBeforeChatzos()
  - getMinchaGedola30Minutes
```
public Date getMinchaGedola30Minutes()
```
    This method returns mincha gedola calculated as 30 minutes after chatzos and not 1/2 of a shaah zmanis after chatzos as calculated by ZmanimCalendar.getMinchaGedola(). Some use this time to delay the start of mincha in the winter when 1/2 of a shaah zmanis is less than 30 minutes. See getMinchaGedolaGreaterThan30()for a conveniance method that returns the later of the 2 calculations. One should not use this time to start mincha before the standard mincha gedola. See Shulchan Aruch Orach Chayim Siman Raish Lamed Gimel seif alef and the Shaar Hatziyon seif katan ches.
    
    Returns:
    the Date of 30 mintes after chatzos. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getMinchaGedola(), getMinchaGedolaGreaterThan30()
  - getMinchaGedola72Minutes
```
public Date getMinchaGedola72Minutes()
```
    This method returns the time of mincha gedola according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset. This is the earliest time to pray mincha. For more information on this see the documentation on mincha gedola. This is calculated as 6.5 solar hours after alos. The calculation used is 6.5 * getShaahZmanis72Minutes() after alos.
    
    Returns:
    the Date of the time of mincha gedola. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZmanimCalendar.getAlos72(), ZmanimCalendar.getMinchaGedola(), ZmanimCalendar.getMinchaKetana(), ZmanimCalendar.getMinchaGedola()
  - getMinchaGedola16Point1Degrees
```
public Date getMinchaGedola16Point1Degrees()
```
    This method returns the time of mincha gedola according to the Magen Avraham with the day starting and ending 16.1° below the horizon. This is the earliest time to pray mincha. For more information on this see the documentation on mincha gedola. This is calculated as 6.5 solar hours after alos. The calculation used is 6.5 * getShaahZmanis16Point1Degrees() after alos.
    
    Returns:
    the Date of the time of mincha gedola. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees(), ZmanimCalendar.getMinchaGedola(), ZmanimCalendar.getMinchaKetana()
  - getMinchaGedolaGreaterThan30
```
public Date getMinchaGedolaGreaterThan30()
```
    This is a conveniance methd that returns the later of ZmanimCalendar.getMinchaGedola() and getMinchaGedola30Minutes(). In the winter when a shaah zmanis is less than 30 minutes getMinchaGedola30Minutes() will be returned, otherwise ZmanimCalendar.getMinchaGedola() will be returned.
    
    Returns:
    the Date of the later of ZmanimCalendar.getMinchaGedola() and getMinchaGedola30Minutes(). If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getMinchaKetana16Point1Degrees
```
public Date getMinchaKetana16Point1Degrees()
```
    This method returns the time of mincha ketana according to the Magen Avraham with the day starting and ending 16.1° below the horizon. This is the perfered earliest time to pray mincha according to the opinion of the Rambam and others. For more information on this see the documentation on mincha gedola. This is calculated as 9.5 solar hours after alos. The calculation used is 9.5 * getShaahZmanis16Point1Degrees() after alos.
    
    Returns:
    the Date of the time of mincha ketana. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees(), ZmanimCalendar.getMinchaGedola(), ZmanimCalendar.getMinchaKetana()
  - getMinchaKetana72Minutes
```
public Date getMinchaKetana72Minutes()
```
    This method returns the time of mincha ketana according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset. This is the perfered earliest time to pray mincha according to the opinion of the Rambam and others. For more information on this see the documentation on mincha gedola. This is calculated as 9.5 getShaahZmanis72Minutes() after alos. The calculation used is 9.5 * getShaahZmanis72Minutes() after alos.
    
    Returns:
    the Date of the time of mincha ketana. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees(), ZmanimCalendar.getMinchaGedola(), ZmanimCalendar.getMinchaKetana()
  - getPlagHamincha60Minutes
```
public Date getPlagHamincha60Minutes()
```
    This method returns the time of plag hamincha according to the Magen Avraham with the day starting 60 minutes before sunrise and ending 60 minutes after sunset. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 getShaahZmanis60Minutes() after getAlos60().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis60Minutes()
  - getPlagHamincha72Minutes
```
public Date getPlagHamincha72Minutes()
```
    This method returns the time of plag hamincha according to the Magen Avraham with the day starting 72 minutes before sunrise and ending 72 minutes after sunset. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 getShaahZmanis72Minutes() after ZmanimCalendar.getAlos72().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis72Minutes()
  - getPlagHamincha90Minutes
```
public Date getPlagHamincha90Minutes()
```
    This method returns the time of plag hamincha according to the Magen Avraham with the day starting 90 minutes before sunrise and ending 90 minutes after sunset. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 getShaahZmanis90Minutes() after getAlos90().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis90Minutes()
  - getPlagHamincha96Minutes
```
public Date getPlagHamincha96Minutes()
```
    This method returns the time of plag hamincha according to the Magen Avraham with the day starting 96 minutes before sunrise and ending 96 minutes after sunset. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 getShaahZmanis96Minutes() after getAlos96().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis96Minutes()
  - getPlagHamincha96MinutesZmanis
```
public Date getPlagHamincha96MinutesZmanis()
```
    This method returns the time of plag hamincha. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 * getShaahZmanis96MinutesZmanis() after dawn.
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getPlagHamincha90MinutesZmanis
```
public Date getPlagHamincha90MinutesZmanis()
```
    This method returns the time of plag hamincha. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 * getShaahZmanis90MinutesZmanis() after dawn.
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getPlagHamincha72MinutesZmanis
```
public Date getPlagHamincha72MinutesZmanis()
```
    This method returns the time of plag hamincha. This is calculated as 10.75 hours after dawn. The formula used is:
    10.75 * getShaahZmanis72MinutesZmanis() after dawn.
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  - getPlagHamincha16Point1Degrees
```
public Date getPlagHamincha16Point1Degrees()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 16.1° and ends at tzais 16.1°. This is calculated as 10.75 hours zmaniyos after dawn. The formula is
    10.75 * getShaahZmanis16Point1Degrees() after getAlos16Point1Degrees().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis16Point1Degrees()
  - getPlagHamincha19Point8Degrees
```
public Date getPlagHamincha19Point8Degrees()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 19.8° and ends at tzais 19.8°. This is calculated as 10.75 hours zmaniyos after dawn. The formula is
    10.75 * getShaahZmanis19Point8Degrees() after getAlos19Point8Degrees().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis19Point8Degrees()
  - getPlagHamincha26Degrees
```
public Date getPlagHamincha26Degrees()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 26° and ends at tzais 26° . This is calculated as 10.75 hours zmaniyos after dawn. The formula is
    10.75 * getShaahZmanis26Degrees() after getAlos26Degrees().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis26Degrees()
  - getPlagHamincha18Degrees
```
public Date getPlagHamincha18Degrees()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 18° and ends at tzais 18° . This is calculated as 10.75 hours zmaniyos after dawn. The formula is
    10.75 * getShaahZmanis18Degrees() after getAlos18Degrees().
    
    Returns:
    the Date of the time of plag hamincha. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getShaahZmanis18Degrees()
  - getPlagAlosToSunset
```
public Date getPlagAlosToSunset()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 16.1° and ends at sunset. 10.75 shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 10.75 shaos zmaniyos (temporal hours) after dawn based on the opinion that the day is calculated from a dawn of 16.1 degrees before sunrise to sea level sunset. This returns the time of 10.75 * the calculated shaah zmanis after dawn.
    
    Returns:
    the Date of the plag. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos16Point1Degrees(), AstronomicalCalendar.getSeaLevelSunset()
  - getPlagAlos16Point1ToTzaisGeonim7Point083Degrees
```
public Date getPlagAlos16Point1ToTzaisGeonim7Point083Degrees()
```
    This method returns the time of plag hamincha based on the opinion that the day starts at alos 16.1° and ends at tzais. 10.75 shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 10.75 shaos zmaniyos (temporal hours) after dawn based on the opinion that the day is calculated from a dawn of 16.1 degrees before sunrise to tzais . This returns the time of 10.75 * the calculated shaah zmanis after dawn.
    
    Returns:
    the Date of the plag. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    getAlos16Point1Degrees(), getTzaisGeonim7Point083Degrees()
  - getBainHasmashosRT13Point24Degrees
```
public Date getBainHasmashosRT13Point24Degrees()
```
    Method to return Bain Hashmasho of Rabainu Tam calculated when the sun is 13.24° below the western geometric horizon (90°) after sunset. This calculation is based on the same calculation of Bain Hasmashos Rabainu Tam 58.5 minutes but uses a degree based calculation instead of 58.5 exact minutes. This calculation is based on the position of the sun 58.5 minutes after sunset in Jerusalem during the equinox which calculates to 13.24° below geometric zenith.
    
    NOTE: As per Yisroel Vehazmanim Vol III page 1028 No 50, a dip of slightly less than 13° should be used. Calculations show that the proper dip to be 13.2456° (truncated to 13.24 that provides about 1.5 second earlier (lechumra) time) below the horizon at that time. This makes a difference of 1 minute and 10 seconds in Jerusalem during the Equinox, and 1 minute 29 seconds during the solstice as compared to the proper 13.24°. For NY during the solstice, the difference is 1 minute 56 seconds.
    
    Returns:
    the Date of the sun being 13.24° below geometric zenith (90°). If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
    See Also:
    ZENITH_13_POINT_24, getBainHasmashosRT58Point5Minutes()
  - getBainHasmashosRT58Point5Minutes
```
public Date getBainHasmashosRT58Point5Minutes()
```
    This method returns Bain Hashmashos of Rabainu Tam calculated as a 58.5 minute offset after sunset. Bain hashmashos is 3/4 of a Mil before tzais or 3 1/4 Mil after sunset. With a Mil calculated as 18 minutes, 3.25 * 18 = 58.5 minutes.
    
    Returns:
    the Date of 58.5 minutes after sunset. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  getBainHasmashosRT13Point5MinutesBefore7Point083Degrees
  
  public Date getBainHasmashosRT13Point5MinutesBefore7Point083Degrees()
  
  This method returns the time of bain hashmashos based on the calculation of 13.5 minutes (3/4 of an 18 minute Mil before shkiah calculated as 7.083°.
  
  Returns:
  the Date of the bain hashmashos of Rabainu Tam in this calculation. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getTzaisGeonim7Point083Degrees()
  
  getBainHasmashosRT2Stars
  
  public Date getBainHasmashosRT2Stars()
  
  This method returns bain hashmashos of Rabainu Tam calculated according to the opinion of the Divray Yosef (see Yisrael Vehazmanim) calculated 5/18th (27.77%) of the time between alos (calculated as 19.8° before sunrise) and sunrise. This is added to sunset to arrive at the time for bain hashmashos of Rabainu Tam).
  
  Returns:
  the Date of bain hashmashos of Rabainu Tam for this calculation. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  
  getTzaisGeonim5Point95Degrees
  
  public Date getTzaisGeonim5Point95Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at 5.95° below the western horizon.
  
  Returns:
  the Date representing the time when the sun is 5.95° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_5_POINT_95
  
  getTzaisGeonim3Point65Degrees
  
  public Date getTzaisGeonim3Point65Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on an 18 minute Mil, or 13.5 minutes. It is the sun's position at 3.65° below the western horizon. This is a very early zman and should not be relied on without Rabbinical guidance.
  
  Returns:
  the Date representing the time when the sun is 3.65° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_3_POINT_65
  
  getTzaisGeonim4Point61Degrees
  
  public Date getTzaisGeonim4Point61Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on a 24 minute Mil, or 18 minutes. It is the sun's position at 4.61° below the western horizon. This is a very early zman and should not be relied on without Rabbinical guidance.
  
  Returns:
  the Date representing the time when the sun is 4.61° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_4_POINT_61
  
  getTzaisGeonim4Point37Degrees
  
  public Date getTzaisGeonim4Point37Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil, based on a 22.5 minute Mil, or 16 7/8 minutes. It is the sun's position at 4.37° below the western horizon. This is a very early zman and should not be relied on without Rabbinical guidance.
  
  Returns:
  the Date representing the time when the sun is 4.37° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_4_POINT_37
  
  getTzaisGeonim5Point88Degrees
  
  public Date getTzaisGeonim5Point88Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a 24 minute Mil, ( Baal Hatanya) based on a Mil being 24 minutes, and is calculated as 18 + 2 + 4 for a total of 24 minutes (FIXME: additional documentation details needed). It is the sun's position at 5.88° below the western horizon. This is a very early zman and should not be relied on without Rabbinical guidance.
  
  Returns:
  the Date representing the time when the sun is 5.88° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_5_POINT_88
  
  getTzaisGeonim4Point8Degrees
  
  public Date getTzaisGeonim4Point8Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated as 3/4 of a Mil based on the sun's position at 4.8° below the western horizon. This is based on Rabbi Leo Levi's calculations. FIXME: additional documentation needed. This is the This is a very early zman and should not be relied on without Rabbinical guidance.
  
  Returns:
  the Date representing the time when the sun is 4.8° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_4_POINT_8
  
  getTzaisGeonim7Point083Degrees
  
  public Date getTzaisGeonim7Point083Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at 7.083° below the western horizon.
  
  Returns:
  the Date representing the time when the sun is 7.083° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZENITH_7_POINT_083
  
  getTzaisGeonim8Point5Degrees
  
  public Date getTzaisGeonim8Point5Degrees()
  
  This method returns the tzais (nightfall) based on the opinion of the Geonim calculated at the sun's position at 8.5° below the western horizon.
  
  Returns:
  the Date representing the time when the sun is 8.5° below sea level. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.ZENITH_8_POINT_5
  
  getTzais60
  
  public Date getTzais60()
  
  This method returns the tzais (nightfall) based on the opinion of the Chavas Yair and Divray Malkiel that the time to walk the distance of a Mil is 15 minutes for a total of 60 minutes for 4 Mil after sea level sunset.
  
  Returns:
  the Date representing 60 minutes after sea level sunset. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos60()
  
  getTzaisAteretTorah
  
  public Date getTzaisAteretTorah()
  
  This method returns tzais usually calculated as 40 minutes (configurable to any offset via setAteretTorahSunsetOffset(double)) after sunset. Please note that Chacham Yosef Harari-Raful of Yeshivat Ateret Torah who uses this time, does so only for calculating various other zmanai hayom such as Sof Zman Krias Shema and Plag Hamincha. His calendars do not publish a zman for Tzais. It should also be noted that Chacham Harari-Raful provided a 25 minute zman for Israel. This API uses 40 minutes year round in any place on the globe by default. This offset can be changed by calling setAteretTorahSunsetOffset(double).
  
  Returns:
  the Date representing 40 minutes (configurable via setAteretTorahSunsetOffset(double)) after sea level sunset. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAteretTorahSunsetOffset(), setAteretTorahSunsetOffset(double)
  
  getAteretTorahSunsetOffset
  
  public double getAteretTorahSunsetOffset()
  
  Returns the offset in minutes after sunset used to calculate sunset for the Ateret Torah zmanim. The defaullt value is 40 minutes. This affects most zmanim, since almost all zmanim use sunbset as part of their calculation.
  
  Returns:
  the number of minutes after sunset for Tzait.
  See Also:
  setAteretTorahSunsetOffset(double)
  
  setAteretTorahSunsetOffset
  
  public void setAteretTorahSunsetOffset(double ateretTorahSunsetOffset)
  
  Allows setting the offset in minutes after sunset for the Ateret Torah zmanim. The default if unset is 40 minutes. Chacham Yosef Harari-Raful of Yeshivat Ateret Torah uses 40 minutes globally with the exception of Israel where a 25 minute offset is used. This 40 minute (or any other) offset can be overridden by this methd. This offset impacts all Ateret Torah zmanim.
  
  Parameters:
  ateretTorahSunsetOffset - the number of minutes after sunset to use as an offset for the Ateret Torah tzais
  See Also:
  getAteretTorahSunsetOffset()
  
  getSofZmanShmaAteretTorah
  
  public Date getSofZmanShmaAteretTorah()
  
  This method returns the latest zman krias shema (time to recite Shema in the morning) based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts 1/10th of the day before sunrise and is usually calculated as ending 40 minutes after sunset (configurable to any offset via setAteretTorahSunsetOffset(double)). shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 3 shaos zmaniyos (temporal hours) after alos 72 zmaniyos.
  Note: Based on this calculation chatzos will not be at midday.
  
  Returns:
  the Date of the latest zman krias shema based on this calculation. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis(), getTzaisAteretTorah(), getAteretTorahSunsetOffset(), setAteretTorahSunsetOffset(double), getShaahZmanisAteretTorah()
  
  getSofZmanTfilahAteretTorah
  
  public Date getSofZmanTfilahAteretTorah()
  
  This method returns the latest zman tfila (time to recite the morning prayers) based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts 1/10th of the day before sunrise and is usually calculated as ending 40 minutes after sunset (configurable to any offset via setAteretTorahSunsetOffset(double)). shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 4 * shaos zmaniyos (temporal hours) after alos 72 zmaniyos.
  Note: Based on this calculation chatzos will not be at midday.
  
  Returns:
  the Date of the latest zman krias shema based on this calculation. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis(), getTzaisAteretTorah(), getShaahZmanisAteretTorah(), setAteretTorahSunsetOffset(double)
  
  getMinchaGedolaAteretTorah
  
  public Date getMinchaGedolaAteretTorah()
  
  This method returns the time of mincha gedola based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts 1/10th of the day before sunrise and is usually calculated as ending 40 minutes after sunset (configurable to any offset via setAteretTorahSunsetOffset(double)). This is the perfered earliest time to pray mincha according to the opinion of the Rambam and others. For more information on this see the documentation on mincha gedola. This is calculated as 6.5 solar hours after alos. The calculation used is 6.5 * getShaahZmanisAteretTorah() after alos.
  
  Returns:
  the Date of the time of mincha gedola. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis(), getTzaisAteretTorah(), getShaahZmanisAteretTorah(), ZmanimCalendar.getMinchaGedola(), getMinchaKetanaAteretTorah(), ZmanimCalendar.getMinchaGedola(), getAteretTorahSunsetOffset(), setAteretTorahSunsetOffset(double)
  
  getMinchaKetanaAteretTorah
  
  public Date getMinchaKetanaAteretTorah()
  
  This method returns the time of mincha ketana based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts 1/10th of the day before sunrise and is usually calculated as ending 40 minutes after sunset (configurable to any offset via setAteretTorahSunsetOffset(double)). This is the perfered earliest time to pray mincha according to the opinion of the Rambam and others. For more information on this see the documentation on mincha gedola. This is calculated as 9.5 solar hours after alos. The calculation used is 9.5 * getShaahZmanisAteretTorah() after alos.
  
  Returns:
  the Date of the time of mincha ketana. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis(), getTzaisAteretTorah(), getShaahZmanisAteretTorah(), getAteretTorahSunsetOffset(), setAteretTorahSunsetOffset(double), ZmanimCalendar.getMinchaGedola(), ZmanimCalendar.getMinchaKetana()
  
  getPlagHaminchaAteretTorah
  
  public Date getPlagHaminchaAteretTorah()
  
  This method returns the time of plag hamincha based on the calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that the day starts 1/10th of the day before sunrise and is usually calculated as ending 40 minutes after sunset (configurable to any offset via setAteretTorahSunsetOffset(double)). shaos zmaniyos are calculated based on this day and added to alos to reach this time. This time is 10.75 shaos zmaniyos (temporal hours) after dawn.
  
  Returns:
  the Date of the plag. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis(), getTzaisAteretTorah(), getShaahZmanisAteretTorah(), setAteretTorahSunsetOffset(double), getAteretTorahSunsetOffset()
  
  getTzais72Zmanis
  
  public Date getTzais72Zmanis()
  
  Method to return tzais (dusk) calculated as 72 minutes zmaniyos, or 1/10th of the day after sea level sunset.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos72Zmanis()
  
  getTzais90Zmanis
  
  public Date getTzais90Zmanis()
  
  Method to return tzais (dusk) calculated using 90 minutes zmaniyos (GRA and the Baal Hatanya) after sea level sunset.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos90Zmanis()
  
  getTzais96Zmanis
  
  public Date getTzais96Zmanis()
  
  Method to return tzais (dusk) calculated using 96 minutes zmaniyos (GRA and the Baal Hatanya) after sea level sunset.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos96Zmanis()
  
  getTzais90
  
  public Date getTzais90()
  
  Method to return tzais (dusk) calculated as 90 minutes after sea level sunset. This method returns tzais (nightfall) based on the opinion of the Magen Avraham that the time to walk the distance of a Mil according to the Rambam's opinion is 18 minutes for a total of 90 minutes based on the opinion of Ula who calculated tzais as 5 Mil after sea level shkiah (sunset). A similar calculation getTzais19Point8Degrees()uses solar position calculations based on this time.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getTzais19Point8Degrees(), getAlos90()
  
  getTzais120
  
  public Date getTzais120()
  
  This method returns tzais (nightfall) based on the opinion of the Magen Avraham that the time to walk the distance of a Mil according to the Rambam's opinion is 2/5 of an hour (24 minutes) for a total of 120 minutes based on the opinion of Ula who calculated tzais as 5 Mil after sea level shkiah (sunset). A similar calculation getTzais26Degrees() uses temporal calculations based on this time.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getTzais26Degrees(), getAlos120()
  
  getTzais120Zmanis
  
  public Date getTzais120Zmanis()
  
  Method to return tzais (dusk) calculated using 120 minutes zmaniyos (GRA and the Baal Hatanya) after sea level sunset.
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos120Zmanis()
  
  getTzais16Point1Degrees
  
  public Date getTzais16Point1Degrees()
  
  For information on how this is calculated see the comments on getAlos16Point1Degrees()
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.getTzais72(), for more information on this calculation.
  
  getTzais26Degrees
  
  public Date getTzais26Degrees()
  
  For information on how this is calculated see the comments on getAlos26Degrees()
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getTzais120(), getAlos26Degrees()
  
  getTzais18Degrees
  
  public Date getTzais18Degrees()
  
  For information on how this is calculated see the comments on getAlos18Degrees()
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos18Degrees()
  
  getTzais19Point8Degrees
  
  public Date getTzais19Point8Degrees()
  
  For information on how this is calculated see the comments on getAlos19Point8Degrees()
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getTzais90(), getAlos19Point8Degrees()
  
  getTzais96
  
  public Date getTzais96()
  
  A method to return tzais (dusk) calculated as 96 minutes after sea level sunset. For information on how this is calculated see the comments on getAlos96().
  
  Returns:
  the Date representing the time. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getAlos96()
  
  getFixedLocalChatzos
  
  public Date getFixedLocalChatzos()
  
  A method that returns the local time for fixed chatzos. This time is noon and midnight adjusted from standard time to account for the local latitude. The 360° of the globe divided by 24 calculates to 15° per hour with 4 minutes per degree, so at a longitude of 0 , 15, 30 etc... Chatzos in 12:00 noon. Lakewood, N.J., whose longitude is -74.2094, is 0.7906 away from the closest multiple of 15 at -75°. This is multiplied by 4 to yield 3 minutes and 10 seconds for a chatzos of 11:56:50. This method is not tied to the theoretical 15° timezones, but will adjust to the actual timezone and Daylight saving time.
  
  Returns:
  the Date representing the local chatzos
  See Also:
  GeoLocation.getLocalMeanTimeOffset()
  
  getSofZmanShmaFixedLocal
  
  public Date getSofZmanShmaFixedLocal()
  
  A method that returns the latest zman krias shema (time to recite Shema in the morning) calculated as 3 hours before getFixedLocalChatzos().
  
  Returns:
  the Date of the latest zman krias shema calculated as 3 hours before getFixedLocalChatzos()..
  See Also:
  getFixedLocalChatzos(), getSofZmanTfilaFixedLocal()
  
  getSofZmanTfilaFixedLocal
  
  public Date getSofZmanTfilaFixedLocal()
  
  This method returns the latest zman tfila (time to recite the morning prayers) calculated as 2 hours before getFixedLocalChatzos().
  
  Returns:
  the Date of the latest zman tfila.
  See Also:
  getFixedLocalChatzos(), getSofZmanShmaFixedLocal()
  
  getSofZmanKidushLevanaBetweenMoldos
  
  public Date getSofZmanKidushLevanaBetweenMoldos(Date alos, Date tzais)
  
  Returns the latest time of Kiddush Levana according to the Maharil's opinion that it is calculated as halfway between molad and molad. This adds half the 29 days, 12 hours and 793 chalakim time between molad and molad (14 days, 18 hours, 22 minutes and 666 milliseconds) to the month's molad. If the time of sof zman Kiddush Levana occurs during the day (between the alos and tzais passed in as parameters), it returns the alos passed in.
  
  Parameters:
  alos -
  tzais -
  
  Returns:
  the Date representing the moment halfway between molad and molad. If the time occurs between alos and tzais, alos will be returned
  See Also:
  getSofZmanKidushLevanaBetweenMoldos(), getSofZmanKidushLevana15Days(Date, Date)
  
  getSofZmanKidushLevanaBetweenMoldos
  
  public Date getSofZmanKidushLevanaBetweenMoldos()
  
  Returns the latest time of Kiddush Levana according to the Maharil's opinion that it is calculated as halfway between molad and molad. This adds half the 29 days, 12 hours and 793 chalakim time between molad and molad (14 days, 18 hours, 22 minutes and 666 milliseconds) to the month's molad. If the time of sof zman Kiddush Levana occurs during the day (between Alos and tzais) it return the alos prior to the calculated sof zman Kiddush Levana.
  
  Returns:
  the Date representing the moment halfway between molad and molad. If the time occurs between alos and tzais, alos will be returned
  See Also:
  getSofZmanKidushLevanaBetweenMoldos(Date, Date), getSofZmanKidushLevana15Days()
  
  getSofZmanKidushLevana15Days
  
  public Date getSofZmanKidushLevana15Days(Date alos, Date tzais)
  
  Returns the latest time of Kiddush Levana calculated as 15 days after the molad. This is the opinion brought down in the Shulchan Aruch (Orach Chaim 426). It should be noted that some opinions hold that the Rema who brings down the opinion of the Maharil's of calculating half way between molad and mold is of the opinion that Mechaber agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject, See Rabbi Dovid Heber's very detailed writeup in Siman Daled (chapter 4) of Shaarei Zmanim. If the time of sof zman Kiddush Levana occurs during the day (between the alos and tzais passed in as parameters), it returns the alos passed in.
  
  Parameters:
  alos -
  tzais -
  
  Returns:
  the Date representing the moment 15 days after the molad. If the time occurs between alos and tzais, alos will be returned
  See Also:
  getSofZmanKidushLevanaBetweenMoldos(Date, Date)
  
  getSofZmanKidushLevana15Days
  
  public Date getSofZmanKidushLevana15Days()
  
  Returns the latest time of Kiddush Levana calculated as 15 days after the molad. This is the opinion brought down in the Shulchan Aruch (Orach Chaim 426). It should be noted that some opinions hold that the Rema who brings down the opinion of the Maharil's of calculating half way between molad and mold is of the opinion that Mechaber agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject, See Rabbi Dovid Heber's very detailed writeup in Siman Daled (chapter 4) of Shaarei Zmanim. If the time of sof zman Kiddush Levana occurs during the day (between Alos and tzais) it return the alos prior to the calculated sof zman Kiddush Levana.
  
  Returns:
  the Date representing the moment 15 days after the molad. If the time occurs between alos and tzais, alos will be returned
  See Also:
  getSofZmanKidushLevana15Days(Date, Date), getSofZmanKidushLevanaBetweenMoldos()
  
  getTchilasZmanKidushLevana3Days
  
  public Date getTchilasZmanKidushLevana3Days(Date alos, Date tzais)
  
  getTchilasZmanKidushLevana3Days
  
  public Date getTchilasZmanKidushLevana3Days()
  
  getTchilasZmanKidushLevana7Days
  
  public Date getTchilasZmanKidushLevana7Days(Date alos, Date tzais)
  
  getTchilasZmanKidushLevana7Days
  
  public Date getTchilasZmanKidushLevana7Days()
  
  getSofZmanAchilasChametzGRA
  
  public Date getSofZmanAchilasChametzGRA()
  
  This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the GRA and the Baal Hatanya. This time is identical to the Sof zman tefilah GRA. This time is 4 hours into the day based on the opinion of the GRA and the Baal Hatanya that the day is calculated from sunrise to sunset. This returns the time 4 * ZmanimCalendar.getShaahZmanisGra() after sea level sunrise.
  
  Returns:
  the Date one is allowed eating chametz on Erev Pesach. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.getShaahZmanisGra(), ZmanimCalendar.getSofZmanTfilaGRA()
  
  getSofZmanAchilasChametzMGA72Minutes
  
  public Date getSofZmanAchilasChametzMGA72Minutes()
  
  This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the MGA based on alos being 72 minutes before sunrise. This time is identical to the Sof zman tefilah MGA 72 minutes. This time is 4 shaos zmaniyos (temporal hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes before sunrise to nightfall of 72 minutes after sunset. This returns the time of 4 * ZmanimCalendar.getShaahZmanisMGA() after dawn.
  
  Returns:
  the Date of the latest time of eating chametz. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set), a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.getShaahZmanisMGA(), ZmanimCalendar.getAlos72(), getSofZmanTfilaMGA72Minutes()
  
  getSofZmanAchilasChametzMGA16Point1Degrees
  
  public Date getSofZmanAchilasChametzMGA16Point1Degrees()
  
  This method returns the latest time one is allowed eating chametz on Erev Pesach according to the opinion of the MGA based on alos being 16.1° before sunrise. This time is 4 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 16.1° below sunrise or sunset. This returns the time of 4 getShaahZmanis16Point1Degrees() after dawn.
  
  Returns:
  the Date of the latest time of eating chametz. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getShaahZmanis16Point1Degrees(), getAlos16Point1Degrees(), getSofZmanTfilaMGA16Point1Degrees()
  
  getSofZmanBiurChametzGRA
  
  public Date getSofZmanBiurChametzGRA()
  
  This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the GRA and the Baal Hatanya. This time is 5 hours into the day based on the opinion of the GRA and the Baal Hatanya that the day is calculated from sunrise to sunset. This returns the time 5 * ZmanimCalendar.getShaahZmanisGra() after sea level sunrise.
  
  Returns:
  the Date of the latest time for burning chametz on Erev Pesach. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.getShaahZmanisGra()
  
  getSofZmanBiurChametzMGA72Minutes
  
  public Date getSofZmanBiurChametzMGA72Minutes()
  
  This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the MGA based on alos being 72 minutes before sunrise. This time is 5 shaos zmaniyos (temporal hours) after dawn based on the opinion of the MGA that the day is calculated from a dawn of 72 minutes before sunrise to nightfall of 72 minutes after sunset. This returns the time of 5 * ZmanimCalendar.getShaahZmanisMGA() after dawn.
  
  Returns:
  the Date of the latest time for burning chametz on Erev Pesach. If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set), a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  ZmanimCalendar.getShaahZmanisMGA(), ZmanimCalendar.getAlos72()
  
  getSofZmanBiurChametzMGA16Point1Degrees
  
  public Date getSofZmanBiurChametzMGA16Point1Degrees()
  
  This method returns the latest time for burning chametz on Erev Pesach according to the opinion of the MGA based on alos being 16.1° before sunrise. This time is 5 shaos zmaniyos (solar hours) after dawn based on the opinion of the MGA that the day is calculated from dawn to nightfall with both being 16.1° below sunrise or sunset. This returns the time of 5 getShaahZmanis16Point1Degrees() after dawn.
  
  Returns:
  the Date of the latest time for burning chametz on Erev Pesach. If the calculation can't be computed such as northern and southern locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach low enough below the horizon for this calculation, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.
  See Also:
  getShaahZmanis16Point1Degrees(), getAlos16Point1Degrees()
  
  getSolarMidnight
  
  public Date getSolarMidnight()
  
  A method that returns "solar" midnight, or the time when the sun is at its nadir.
  
  Note: this method is experimental and might be removed.
  
  Returns:
  the Date of Solar Midnight (chatzos layla). If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the AstronomicalCalendar documentation.

Class ComplexZmanimCalendar

Disclaimer:

Field Summary

Fields inherited from class net.sourceforge.zmanim.ZmanimCalendar

Fields inherited from class net.sourceforge.zmanim.AstronomicalCalendar

Constructor Summary

Method Summary

Methods inherited from class net.sourceforge.zmanim.ZmanimCalendar

Methods inherited from class net.sourceforge.zmanim.AstronomicalCalendar

Methods inherited from class java.lang.Object

Field Detail

ZENITH_3_POINT_7

ZENITH_5_POINT_95

ZENITH_7_POINT_083

ZENITH_10_POINT_2

ZENITH_11_DEGREES

ZENITH_11_POINT_5

ZENITH_13_POINT_24

ZENITH_19_POINT_8

ZENITH_26_DEGREES

ZENITH_4_POINT_37

ZENITH_4_POINT_61

ZENITH_4_POINT_8

ZENITH_3_POINT_65

ZENITH_5_POINT_88

Constructor Detail

ComplexZmanimCalendar

ComplexZmanimCalendar

Method Detail

getShaahZmanis19Point8Degrees

getShaahZmanis18Degrees

getShaahZmanis26Degrees

getShaahZmanis16Point1Degrees

getShaahZmanis60Minutes

getShaahZmanis72Minutes

getShaahZmanis72MinutesZmanis

getShaahZmanis90Minutes

getShaahZmanis90MinutesZmanis

getShaahZmanis96MinutesZmanis

getShaahZmanisAteretTorah

getShaahZmanis96Minutes

getShaahZmanis120Minutes

getShaahZmanis120MinutesZmanis

getPlagHamincha120MinutesZmanis

getPlagHamincha120Minutes

getAlos60

getAlos72Zmanis

getAlos96

getAlos90Zmanis

getAlos96Zmanis

getAlos90

getAlos120

getAlos120Zmanis

getAlos26Degrees

getAlos18Degrees

getAlos19Point8Degrees

getAlos16Point1Degrees

getMisheyakir11Point5Degrees

getMisheyakir11Degrees

getMisheyakir10Point2Degrees

getSofZmanShmaMGA19Point8Degrees

getSofZmanShmaMGA16Point1Degrees

getSofZmanShmaMGA72Minutes

getSofZmanShmaMGA72MinutesZmanis

getSofZmanShmaMGA90Minutes

getSofZmanShmaMGA90MinutesZmanis

getSofZmanShmaMGA96Minutes

getSofZmanShmaMGA96MinutesZmanis

getSofZmanShma3HoursBeforeChatzos

getSofZmanShmaMGA120Minutes

getSofZmanShmaAlos16Point1ToSunset

getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees

getSofZmanShmaKolEliyahu

getSofZmanTfilaMGA19Point8Degrees

getSofZmanTfilaMGA16Point1Degrees

getSofZmanTfilaMGA72Minutes

getSofZmanTfilaMGA72MinutesZmanis

getSofZmanTfilaMGA90Minutes

getSofZmanTfilaMGA90MinutesZmanis

getSofZmanTfilaMGA96Minutes