001    /*
002     * Zmanim Java API
003     * Copyright (C) 2004-2011 Eliyahu Hershfeld
004     *
005     * This program is free software; you can redistribute it and/or modify it under the terms of the
006     * GNU General Public License as published by the Free Software Foundation; either version 2 of the
007     * License, or (at your option) any later version.
008     *
009     * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
010     * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
011     * General Public License for more details.
012     *
013     * You should have received a copy of the GNU General Public License along with this program; if
014     * not, write to the Free Software Foundation, Inc. 59 Temple Place - Suite 330, Boston, MA
015     * 02111-1307, USA or connect to: http://www.fsf.org/copyleft/gpl.html
016     */
017    package net.sourceforge.zmanim;
018    
019    import java.util.Date;
020    
021    import net.sourceforge.zmanim.util.AstronomicalCalculator;
022    import net.sourceforge.zmanim.util.GeoLocation;
023    
024    /**
025     * This class extends ZmanimCalendar and provides many more zmanim than
026     * available in the ZmanimCalendar. The basis for most zmanim in this class are
027     * from the <em>sefer</em> <b>Yisroel Vehazmanim</b> by <b>Rabbi Yisroel Dovid
028     * Harfenes</b>. <br />
029     * For an example of the number of different <em>zmanim</em> made available by
030     * this class, there are methods to return 12 different calculations for
031     * <em>alos</em> (dawn) available in this class. The real power of this API is
032     * the ease in calculating <em>zmanim</em> that are not part of the API. The
033     * methods for doing <em>zmanim</em> calculations not present in this or it's
034     * superclass the {@link ZmanimCalendar} are contained in the
035     * {@link AstronomicalCalendar}, the base class of the calendars in our API
036     * since they are generic methods for calculating time based on degrees or time
037     * before or after {@link #getSunrise sunrise} and {@link #getSunset sunset} and
038     * are of interest for calculation beyond <em>zmanim</em> calculations. Here are
039     * some examples: <br />
040     * First create the Calendar for the location you would like to calculate:
041     * 
042     * <pre>
043     * String locationName = &quot;Lakewood, NJ&quot;;
044     * double latitude = 40.0828; // Lakewood, NJ
045     * double longitude = -74.2094; // Lakewood, NJ
046     * double elevation = 0;
047     * // the String parameter in getTimeZone() has to be a valid timezone listed in
048     * // {@link java.util.TimeZone#getAvailableIDs()}
049     * TimeZone timeZone = TimeZone.getTimeZone(&quot;America/New_York&quot;);
050     * GeoLocation location = new GeoLocation(locationName, latitude, longitude,
051     *              elevation, timeZone);
052     * ComplexZmanimCalendar czc = new ComplexZmanimCalendar(location);
053     * </pre>
054     * 
055     * Note: For locations such as Israel where the beginning and end of daylight
056     * savings time can fluctuate from year to year create a
057     * {@link java.util.SimpleTimeZone} with the known start and end of DST. <br />
058     * To get alos calculated as 14&deg; below the horizon (as calculated in the
059     * calendars published in Montreal) use:
060     * 
061     * <pre>
062     * Date alos14 = czc.getSunriseOffsetByDegrees(14);
063     * </pre>
064     * 
065     * To get <em>mincha gedola</em> calculated based on the MGA using a <em>shaah
066     * zmanis</em> based on the day starting 16.1&deg; below the horizon (and ending
067     * 16.1&deg; after sunset the following calculation can be used:
068     * 
069     * <pre>
070     * Date minchaGedola = czc.getTimeOffset(czc.getAlos16point1Degrees(),
071     *              czc.getShaahZmanis16Point1Degrees() * 6.5);
072     * </pre>
073     * 
074     * A little more complex example would be calculating <em>plag hamincha</em>
075     * based on a shaah zmanis that was not present in this class. While a drop more
076     * complex it is still rather easy. For example if you wanted to calculate
077     * <em>plag</em> based on the day starting 12&deg; before sunrise and ending
078     * 12&deg; after sunset as calculated in the calendars in Manchester, England
079     * (there is nothing that would prevent your calculating the day using sunrise
080     * and sunset offsets that are not identical degrees, but this would lead to
081     * chatzos being a time other than the {@link #getSunTransit() solar transit}
082     * (solar midday)). The steps involved would be to first calculate the
083     * <em>shaah zmanis</em> and than use that time in milliseconds to calculate
084     * 10.75 hours after sunrise starting at 12&deg; before sunset
085     * 
086     * <pre>
087     * long shaahZmanis = czc.getTemporalHour(czc.getSunriseOffsetByDegrees(12),
088     *              czc.getSunsetOffsetByDegrees(12));
089     * Date plag = getTimeOffset(czc.getSunriseOffsetByDegrees(12),
090     *              shaahZmanis * 10.75);
091     * </pre>
092     * 
093     * <h2>Disclaimer:</h2> While I did my best to get accurate results please do
094     * not rely on these zmanim for <em>halacha lemaaseh</em>
095     * 
096     * @author &copy; Eliyahu Hershfeld 2004 - 2011
097     * @version 1.2
098     */
099    public class ComplexZmanimCalendar extends ZmanimCalendar {
100            private static final long serialVersionUID = 1;
101    
102            /**
103             * The zenith of 3.7&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
104             * (90&deg;). This calculation is used for calculating <em>tzais</em>
105             * (nightfall) according to some opinions. This calculation is based on the
106             * opinion of the Geonim that <em>tzais</em> is the time it takes to walk
107             * 3/4 of a Mil at 18 minutes a Mil, or 13.5 minutes after sunset. The sun
108             * is 3.7&deg below {@link #GEOMETRIC_ZENITH geometric zenith} at this time
109             * in Jerusalem on March 16, about 4 days before the equinox, the day that a
110             * solar hour is one hour.
111             * 
112             * TODO AT see #getTzaisGeonim3Point7Degrees()
113             */
114            protected static final double ZENITH_3_POINT_7 = GEOMETRIC_ZENITH + 3.7;
115    
116            /**
117             * The zenith of 5.95&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
118             * (90&deg;). This calculation is used for calculating <em>tzais</em>
119             * (nightfall) according to some opinions. This calculation is based on the
120             * position of the sun 24 minutes after sunset in Jerusalem on March 16,
121             * about 4 days before the equinox, the day that a solar hour is one hour,
122             * which calculates to 5.95&deg; below {@link #GEOMETRIC_ZENITH geometric
123             * zenith}
124             * 
125             * @see #getTzaisGeonim5Point95Degrees()
126             */
127            protected static final double ZENITH_5_POINT_95 = GEOMETRIC_ZENITH + 5.95;
128    
129            /**
130             * The zenith of 7.083&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
131             * (90&deg;). This is often referred to as 7&deg;5' or 7&deg; and 5 minutes.
132             * This calculation is used for calculating <em>alos</em> (dawn) and
133             * <em>tzais</em> (nightfall) according to some opinions. This calculation
134             * is based on the position of the sun 30 minutes after sunset in Jerusalem
135             * on March 16, about 4 days before the equinox, the day that a solar hour
136             * is one hour, which calculates to 7.0833333&deg; below
137             * {@link #GEOMETRIC_ZENITH geometric zenith}. This is time some opinions
138             * consider dark enough for 3 stars to be visible. This is the opinion of
139             * the Shu"t Melamed Leho'il, Shu"t Binyan Tziyon, Tenuvas Sadeh and very
140             * close to the time of the Mekor Chesed on the Sefer chasidim.
141             * 
142             * @see #getTzaisGeonim7Point083Degrees()
143             * @see #getBainHasmashosRT13Point5MinutesBefore7Point083Degrees()
144             */
145            protected static final double ZENITH_7_POINT_083 = GEOMETRIC_ZENITH + 7
146                            + (5 / 60);
147    
148            /**
149             * The zenith of 10.2&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
150             * (90&deg;). This calculation is used for calculating <em>misheyakir</em>
151             * according to some opinions. This calculation is based on the position of
152             * the sun 45 minutes before {@link #getSunrise sunrise} in Jerusalem on
153             * March 16, about 4 days before the equinox, the day that a solar hour is
154             * one hour which calculates to 10.2&deg; below {@link #GEOMETRIC_ZENITH
155             * geometric zenith}
156             * 
157             * @see #getMisheyakir10Point2Degrees()
158             */
159            protected static final double ZENITH_10_POINT_2 = GEOMETRIC_ZENITH + 10.2;
160    
161            /**
162             * The zenith of 11&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
163             * (90&deg;). This calculation is used for calculating <em>misheyakir</em>
164             * according to some opinions. This calculation is based on the position of
165             * the sun 48 minutes before {@link #getSunrise sunrise} in Jerusalem on
166             * March 16, about 4 days before the equinox, the day that a solar hour is
167             * one hour which calculates to 11&deg; below {@link #GEOMETRIC_ZENITH
168             * geometric zenith}
169             * 
170             * @see #getMisheyakir11Degrees()
171             */
172            protected static final double ZENITH_11_DEGREES = GEOMETRIC_ZENITH + 11;
173    
174            /**
175             * The zenith of 11.5&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
176             * (90&deg;). This calculation is used for calculating <em>misheyakir</em>
177             * according to some opinions. This calculation is based on the position of
178             * the sun 52 minutes before {@link #getSunrise sunrise} in Jerusalem on
179             * March 16, about 4 days before the equinox, the day that a solar hour is
180             * one hour which calculates to 11.5&deg; below {@link #GEOMETRIC_ZENITH
181             * geometric zenith}
182             * 
183             * @see #getMisheyakir11Point5Degrees()
184             */
185            protected static final double ZENITH_11_POINT_5 = GEOMETRIC_ZENITH + 11.5;
186    
187            /**
188             * The zenith of 13&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
189             * (90&deg;). This calculation is used for calculating
190             * <em>Rabainu Tam's bain hashmashos</em> according to some opinions. <br/>
191             * <br/>
192             * <b>FIXME:</b> See comments on {@link #getBainHasmashosRT13Degrees}. This
193             * should be changed to 13.2477 after confirmation.
194             * 
195             * @see #getBainHasmashosRT13Degrees
196             * 
197             */
198            protected static final double ZENITH_13_DEGREES = GEOMETRIC_ZENITH + 13;
199    
200            /**
201             * The zenith of 19.8&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
202             * (90&deg;). This calculation is used for calculating <em>alos</em> (dawn)
203             * and <em>tzais</em> (nightfall) according to some opinions. This
204             * calculation is based on the position of the sun 90 minutes after sunset
205             * in Jerusalem on March 16, about 4 days before the equinox, the day that a
206             * solar hour is one hour which calculates to 19.8&deg; below
207             * {@link #GEOMETRIC_ZENITH geometric zenith}
208             * 
209             * @see #getTzais19Point8Degrees()
210             * @see #getAlos19Point8Degrees()
211             * @see #getAlos90()
212             * @see #getTzais90()
213             */
214            protected static final double ZENITH_19_POINT_8 = GEOMETRIC_ZENITH + 19.8;
215    
216            /**
217             * The zenith of 26&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
218             * (90&deg;). This calculation is used for calculating <em>alos</em> (dawn)
219             * and <em>tzais</em> (nightfall) according to some opinions. This
220             * calculation is based on the position of the sun {@link #getAlos120() 120
221             * minutes} after sunset in Jerusalem on March 16, about 4 days before the
222             * equinox, the day that a solar hour is one hour which calculates to
223             * 26&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
224             * 
225             * @see #getAlos26Degrees()
226             * @see #getTzais26Degrees()
227             * @see #getAlos120()
228             * @see #getTzais120()
229             */
230            protected static final double ZENITH_26_DEGREES = GEOMETRIC_ZENITH + 26.0;
231    
232            /**
233             * Experimental and may not make the final 1.3 cut
234             */
235    
236            /**
237             * The zenith of 4.37&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
238             * (90&deg;). This calculation is used for calculating <em>tzais</em>
239             * (nightfall) according to some opinions. This calculation is based on the
240             * position of the sun {@link #getTzaisGeonim4Point37Degrees() 16 7/8
241             * minutes} after sunset (3/4 of a 22.5 minute Mil) in Jerusalem on March
242             * 16, about 4 days before the equinox, the day that a solar hour is one
243             * hour which calculates to 4.37&deg; below {@link #GEOMETRIC_ZENITH
244             * geometric zenith}
245             * 
246             * @see #getTzaisGeonim4Point37Degrees()
247             */
248            protected static final double ZENITH_4_POINT_37 = GEOMETRIC_ZENITH + 4.37;
249    
250            /**
251             * The zenith of 4.61&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
252             * (90&deg;). This calculation is used for calculating <em>tzais</em>
253             * (nightfall) according to some opinions. This calculation is based on the
254             * position of the sun {@link #getTzaisGeonim4Point37Degrees() 18 minutes}
255             * after sunset (3/4 of a 24 minute Mil) in Jerusalem on March 16, about 4
256             * days before the equinox, the day that a solar hour is one hour which
257             * calculates to 4.61&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
258             * 
259             * @see #getTzaisGeonim4Point61Degrees()
260             */
261            protected static final double ZENITH_4_POINT_61 = GEOMETRIC_ZENITH + 4.61;
262    
263            protected static final double ZENITH_4_POINT_8 = GEOMETRIC_ZENITH + 4.8;
264    
265            /**
266             * The zenith of 3.65&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
267             * (90&deg;). This calculation is used for calculating <em>tzais</em>
268             * (nightfall) according to some opinions. This calculation is based on the
269             * position of the sun {@link #getTzaisGeonim3Point65Degrees() 13.5 minutes}
270             * after sunset (3/4 of an 18 minute Mil) in Jerusalem on March 16, about 4
271             * days before the equinox, the day that a solar hour is one hour which
272             * calculates to 3.65&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
273             * 
274             * @see #getTzaisGeonim3Point65Degrees()
275             */
276            protected static final double ZENITH_3_POINT_65 = GEOMETRIC_ZENITH + 3.65;
277    
278            protected static final double ZENITH_5_POINT_88 = GEOMETRIC_ZENITH + 5.88;
279    
280            private double ateretTorahSunsetOffset = 40;
281    
282            public ComplexZmanimCalendar(GeoLocation location) {
283                    super(location);
284            }
285    
286            /**
287             * Default constructor will set a default {@link GeoLocation#GeoLocation()},
288             * a default {@link AstronomicalCalculator#getDefault()
289             * AstronomicalCalculator} and default the calendar to the current date.
290             * 
291             * @see AstronomicalCalendar#AstronomicalCalendar()
292             */
293            public ComplexZmanimCalendar() {
294                    super();
295            }
296    
297            /**
298             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
299             * a 19.8&deg; dip. This calculation divides the day based on the opinion of
300             * the MGA that the day runs from dawn to dusk. Dawn for this calculation is
301             * when the sun is 19.8&deg; below the eastern geometric horizon before
302             * sunrise. Dusk for this is when the sun is 19.8&deg; below the western
303             * geometric horizon after sunset. This day is split into 12 equal parts
304             * with each part being a <em>shaah zmanis</em>.
305             * 
306             * @return the <code>long</code> millisecond length of a
307             *         <em>shaah zmanis</em>. If the calculation can't be computed such
308             *         as northern and southern locations even south of the Arctic
309             *         Circle and north of the Antarctic Circle where the sun may not
310             *         reach low enough below the horizon for this calculation, a
311             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
312             *         on top of the {@link AstronomicalCalendar} documentation.
313             */
314            public long getShaahZmanis19Point8Degrees() {
315                    return getTemporalHour(getAlos19Point8Degrees(),
316                                    getTzais19Point8Degrees());
317            }
318    
319            /**
320             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
321             * a 18&deg; dip. This calculation divides the day based on the opinion of
322             * the MGA that the day runs from dawn to dusk. Dawn for this calculation is
323             * when the sun is 18&deg; below the eastern geometric horizon before
324             * sunrise. Dusk for this is when the sun is 18&deg; below the western
325             * geometric horizon after sunset. This day is split into 12 equal parts
326             * with each part being a <em>shaah zmanis</em>.
327             * 
328             * @return the <code>long</code> millisecond length of a
329             *         <em>shaah zmanis</em>. If the calculation can't be computed such
330             *         as northern and southern locations even south of the Arctic
331             *         Circle and north of the Antarctic Circle where the sun may not
332             *         reach low enough below the horizon for this calculation, a
333             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
334             *         on top of the {@link AstronomicalCalendar} documentation.
335             */
336            public long getShaahZmanis18Degrees() {
337                    return getTemporalHour(getAlos18Degrees(), getTzais18Degrees());
338            }
339    
340            /**
341             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
342             * a dip of 26&deg;. This calculation divides the day based on the opinion
343             * of the MGA that the day runs from dawn to dusk. Dawn for this calculation
344             * is when the sun is {@link #getAlos26Degrees() 26&deg;} below the eastern
345             * geometric horizon before sunrise. Dusk for this is when the sun is
346             * {@link #getTzais26Degrees() 26&deg;} below the western geometric horizon
347             * after sunset. This day is split into 12 equal parts with each part being
348             * a <em>shaah zmanis</em>.
349             * 
350             * @return the <code>long</code> millisecond length of a
351             *         <em>shaah zmanis</em>. If the calculation can't be computed such
352             *         as northern and southern locations even south of the Arctic
353             *         Circle and north of the Antarctic Circle where the sun may not
354             *         reach low enough below the horizon for this calculation, a
355             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
356             *         on top of the {@link AstronomicalCalendar} documentation.
357             */
358            public long getShaahZmanis26Degrees() {
359                    return getTemporalHour(getAlos26Degrees(), getTzais26Degrees());
360            }
361    
362            /**
363             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
364             * a dip of 16.1&deg;. This calculation divides the day based on the opinion
365             * that the day runs from dawn to dusk. Dawn for this calculation is when
366             * the sun is 16.1&deg; below the eastern geometric horizon before sunrise
367             * and dusk is when the sun is 16.1&deg; below the western geometric horizon
368             * after sunset. This day is split into 12 equal parts with each part being
369             * a <em>shaah zmanis</em>.
370             * 
371             * @return the <code>long</code> millisecond length of a
372             *         <em>shaah zmanis</em>. If the calculation can't be computed such
373             *         as northern and southern locations even south of the Arctic
374             *         Circle and north of the Antarctic Circle where the sun may not
375             *         reach low enough below the horizon for this calculation, a
376             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
377             *         on top of the {@link AstronomicalCalendar} documentation.
378             * @see #getAlos16Point1Degrees()
379             * @see #getTzais16Point1Degrees()
380             * @see #getSofZmanShmaMGA16Point1Degrees()
381             * @see #getSofZmanTfilaMGA16Point1Degrees()
382             * @see #getMinchaGedola16Point1Degrees()
383             * @see #getMinchaKetana16Point1Degrees()
384             * @see #getPlagHamincha16Point1Degrees()
385             */
386    
387            public long getShaahZmanis16Point1Degrees() {
388                    return getTemporalHour(getAlos16Point1Degrees(),
389                                    getTzais16Point1Degrees());
390            }
391    
392            /**
393             * Method to return a <em>shaah zmanis</em> (solar hour) according to the
394             * opinion of the MGA. This calculation divides the day based on the opinion
395             * of the <em>MGA</em> that the day runs from dawn to dusk. Dawn for this
396             * calculation is 60 minutes before sunrise and dusk is 60 minutes after
397             * sunset. This day is split into 12 equal parts with each part being a
398             * <em>shaah zmanis</em>. Alternate mothods of calculating a
399             * <em>shaah zmanis</em> are available in the subclass
400             * {@link ComplexZmanimCalendar}
401             * 
402             * @return the <code>long</code> millisecond length of a
403             *         <em>shaah zmanis</em>. If the calculation can't be computed such
404             *         as in the Arctic Circle where there is at least one day a year
405             *         where the sun does not rise, and one where it does not set, a
406             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
407             *         on top of the {@link AstronomicalCalendar} documentation.
408             */
409            public long getShaahZmanis60Minutes() {
410                    return getTemporalHour(getAlos60(), getTzais60());
411            }
412    
413            /**
414             * Method to return a <em>shaah zmanis</em> (solar hour) according to the
415             * opinion of the MGA. This calculation divides the day based on the opinion
416             * of the <em>MGA</em> that the day runs from dawn to dusk. Dawn for this
417             * calculation is 72 minutes before sunrise and dusk is 72 minutes after
418             * sunset. This day is split into 12 equal parts with each part being a
419             * <em>shaah zmanis</em>. Alternate mothods of calculating a
420             * <em>shaah zmanis</em> are available in the subclass
421             * {@link ComplexZmanimCalendar}
422             * 
423             * @return the <code>long</code> millisecond length of a
424             *         <em>shaah zmanis</em>. If the calculation can't be computed such
425             *         as in the Arctic Circle where there is at least one day a year
426             *         where the sun does not rise, and one where it does not set, a
427             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
428             *         on top of the {@link AstronomicalCalendar} documentation.
429             */
430            public long getShaahZmanis72Minutes() {
431                    return getShaahZmanisMGA();
432            }
433    
434            /**
435             * Method to return a <em>shaah zmanis</em> (temporal hour) according to the
436             * opinion of the MGA based on <em>alos</em> being
437             * {@link #getAlos72Zmanis() 72} minutes <em>zmaniyos</em> before
438             * {@link #getSunrise() sunrise}. This calculation divides the day based on
439             * the opinion of the <em>MGA</em> that the day runs from dawn to dusk. Dawn
440             * for this calculation is 72 minutes <em>zmaniyos</em> before sunrise and
441             * dusk is 72 minutes <em>zmaniyos</em> after sunset. This day is split into
442             * 12 equal parts with each part being a <em>shaah zmanis</em>. This is
443             * identical to 1/10th of the day from {@link #getSunrise() sunrise} to
444             * {@link #getSunset() sunset}.
445             * 
446             * @return the <code>long</code> millisecond length of a
447             *         <em>shaah zmanis</em>. If the calculation can't be computed such
448             *         as in the Arctic Circle where there is at least one day a year
449             *         where the sun does not rise, and one where it does not set, a
450             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
451             *         on top of the {@link AstronomicalCalendar} documentation.
452             * @see #getAlos72Zmanis()
453             * @see #getTzais72Zmanis()
454             */
455            public long getShaahZmanis72MinutesZmanis() {
456                    return getTemporalHour(getAlos72Zmanis(), getTzais72Zmanis());
457            }
458    
459            /**
460             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
461             * a dip of 90 minutes. This calculation divides the day based on the
462             * opinion of the MGA that the day runs from dawn to dusk. Dawn for this
463             * calculation is 90 minutes before sunrise and dusk is 90 minutes after
464             * sunset. This day is split into 12 equal parts with each part being a
465             * <em>shaah zmanis</em>.
466             * 
467             * @return the <code>long</code> millisecond length of a
468             *         <em>shaah zmanis</em>. If the calculation can't be computed such
469             *         as in the Arctic Circle where there is at least one day a year
470             *         where the sun does not rise, and one where it does not set, a
471             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
472             *         on top of the {@link AstronomicalCalendar} documentation.
473             */
474            public long getShaahZmanis90Minutes() {
475                    return getTemporalHour(getAlos90(), getTzais90());
476            }
477    
478            /**
479             * Method to return a <em>shaah zmanis</em> (temporal hour) according to the
480             * opinion of the MGA based on <em>alos</em> being
481             * {@link #getAlos90Zmanis() 90} minutes <em>zmaniyos</em> before
482             * {@link #getSunrise() sunrise}. This calculation divides the day based on
483             * the opinion of the <em>MGA</em> that the day runs from dawn to dusk. Dawn
484             * for this calculation is 90 minutes <em>zmaniyos</em> before sunrise and
485             * dusk is 90 minutes <em>zmaniyos</em> after sunset. This day is split into
486             * 12 equal parts with each part being a <em>shaah zmanis</em>. This is
487             * identical to 1/8th of the day from {@link #getSunrise() sunrise} to
488             * {@link #getSunset() sunset}.
489             * 
490             * @return the <code>long</code> millisecond length of a
491             *         <em>shaah zmanis</em>. If the calculation can't be computed such
492             *         as in the Arctic Circle where there is at least one day a year
493             *         where the sun does not rise, and one where it does not set, a
494             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
495             *         on top of the {@link AstronomicalCalendar} documentation.
496             * @see #getAlos90Zmanis()
497             * @see #getTzais90Zmanis()
498             */
499            public long getShaahZmanis90MinutesZmanis() {
500                    return getTemporalHour(getAlos90Zmanis(), getTzais90Zmanis());
501            }
502    
503            /**
504             * Method to return a <em>shaah zmanis</em> (temporal hour) according to the
505             * opinion of the MGA based on <em>alos</em> being
506             * {@link #getAlos96Zmanis() 96} minutes <em>zmaniyos</em> before
507             * {@link #getSunrise() sunrise}. This calculation divides the day based on
508             * the opinion of the <em>MGA</em> that the day runs from dawn to dusk. Dawn
509             * for this calculation is 96 minutes <em>zmaniyos</em> before sunrise and
510             * dusk is 96 minutes <em>zmaniyos</em> after sunset. This day is split into
511             * 12 equal parts with each part being a <em>shaah zmanis</em>. This is
512             * identical to 1/7.5th of the day from {@link #getSunrise() sunrise} to
513             * {@link #getSunset() sunset}.
514             * 
515             * @return the <code>long</code> millisecond length of a
516             *         <em>shaah zmanis</em>. If the calculation can't be computed such
517             *         as in the Arctic Circle where there is at least one day a year
518             *         where the sun does not rise, and one where it does not set, a
519             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
520             *         on top of the {@link AstronomicalCalendar} documentation.
521             * @see #getAlos96Zmanis()
522             * @see #getTzais96Zmanis()
523             */
524            public long getShaahZmanis96MinutesZmanis() {
525                    return getTemporalHour(getAlos96Zmanis(), getTzais96Zmanis());
526            }
527    
528            /**
529             * Method to return a <em>shaah zmanis</em> (temporal hour) according to the
530             * opinion of the Chacham Yosef Harari-Raful of Yeshivat Ateret Torah
531             * calculated with <em>alos</em> being 1/10th of sunrise to sunset day, or
532             * {@link #getAlos72Zmanis() 72} minutes <em>zmaniyos</em> of such a day
533             * before {@link #getSunrise() sunrise}, and tzais is usually calculated as
534             * {@link #getTzaisAteretTorah() 40 minutes} after {@link #getSunset()
535             * sunset}. This day is split into 12 equal parts with each part being a
536             * <em>shaah zmanis</em>. Note that with this system, chatzos (mid-day) will
537             * not be the point that the sun is {@link #getSunTransit() halfway across
538             * the sky}.
539             * 
540             * @return the <code>long</code> millisecond length of a
541             *         <em>shaah zmanis</em>. If the calculation can't be computed such
542             *         as in the Arctic Circle where there is at least one day a year
543             *         where the sun does not rise, and one where it does not set, a
544             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
545             *         on top of the {@link AstronomicalCalendar} documentation.
546             * @see #getAlos72Zmanis()
547             * @see #getTzaisAteretTorah()
548             * @see #getAteretTorahSunsetOffset()
549             * @see #setAteretTorahSunsetOffset(double)
550             */
551            public long getShaahZmanisAteretTorah() {
552                    return getTemporalHour(getAlos72Zmanis(), getTzaisAteretTorah());
553            }
554    
555            /**
556             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
557             * a dip of 96 minutes. This calculation divides the day based on the
558             * opinion of the MGA that the day runs from dawn to dusk. Dawn for this
559             * calculation is 96 minutes before sunrise and dusk is 96 minutes after
560             * sunset. This day is split into 12 equal parts with each part being a
561             * <em>shaah zmanis</em>.
562             * 
563             * @return the <code>long</code> millisecond length of a
564             *         <em>shaah zmanis</em>. If the calculation can't be computed such
565             *         as in the Arctic Circle where there is at least one day a year
566             *         where the sun does not rise, and one where it does not set, a
567             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
568             *         on top of the {@link AstronomicalCalendar} documentation.
569             */
570            public long getShaahZmanis96Minutes() {
571                    return getTemporalHour(getAlos96(), getTzais96());
572            }
573    
574            /**
575             * Method to return a <em>shaah zmanis</em> (temporal hour) calculated using
576             * a dip of 120 minutes. This calculation divides the day based on the
577             * opinion of the MGA that the day runs from dawn to dusk. Dawn for this
578             * calculation is 120 minutes before sunrise and dusk is 120 minutes after
579             * sunset. This day is split into 12 equal parts with each part being a
580             * <em>shaah zmanis</em>.
581             * 
582             * @return the <code>long</code> millisecond length of a
583             *         <em>shaah zmanis</em>. If the calculation can't be computed such
584             *         as in the Arctic Circle where there is at least one day a year
585             *         where the sun does not rise, and one where it does not set, a
586             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
587             *         on top of the {@link AstronomicalCalendar} documentation.
588             */
589            public long getShaahZmanis120Minutes() {
590                    return getTemporalHour(getAlos120(), getTzais120());
591            }
592    
593            /**
594             * Method to return a <em>shaah zmanis</em> (temporal hour) according to the
595             * opinion of the MGA based on <em>alos</em> being
596             * {@link #getAlos120Zmanis() 120} minutes <em>zmaniyos</em> before
597             * {@link #getSunrise() sunrise}. This calculation divides the day based on
598             * the opinion of the <em>MGA</em> that the day runs from dawn to dusk. Dawn
599             * for this calculation is 120 minutes <em>zmaniyos</em> before sunrise and
600             * dusk is 120 minutes <em>zmaniyos</em> after sunset. This day is split
601             * into 12 equal parts with each part being a <em>shaah zmanis</em>. This is
602             * identical to 1/6th of the day from {@link #getSunrise() sunrise} to
603             * {@link #getSunset() sunset}.
604             * 
605             * @return the <code>long</code> millisecond length of a
606             *         <em>shaah zmanis</em>. If the calculation can't be computed such
607             *         as in the Arctic Circle where there is at least one day a year
608             *         where the sun does not rise, and one where it does not set, a
609             *         {@link Long#MIN_VALUE} will be returned. See detailed explanation
610             *         on top of the {@link AstronomicalCalendar} documentation.
611             * @see #getAlos120Zmanis()
612             * @see #getTzais120Zmanis()
613             */
614            public long getShaahZmanis120MinutesZmanis() {
615                    return getTemporalHour(getAlos120Zmanis(), getTzais120Zmanis());
616            }
617    
618            /**
619             * This method returns the time of <em>plag hamincha</em>. This is
620             * calculated as 10.75 hours after {@link #getAlos120Zmanis() dawn}. The
621             * formula used is:<br/>
622             * 10.75 * {@link #getShaahZmanis120MinutesZmanis()} after
623             * {@link #getAlos120Zmanis() dawn}.
624             * 
625             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
626             *         the calculation can't be computed such as in the Arctic Circle
627             *         where there is at least one day a year where the sun does not
628             *         rise, and one where it does not set, a null will be returned. See
629             *         detailed explanation on top of the {@link AstronomicalCalendar}
630             *         documentation.
631             */
632            public Date getPlagHamincha120MinutesZmanis() {
633                    return getTimeOffset(getAlos120Zmanis(),
634                                    getShaahZmanis120MinutesZmanis() * 10.75);
635            }
636    
637            /**
638             * This method returns the time of <em>plag hamincha</em>. This is
639             * calculated as 10.75 hours after {@link #getAlos120() dawn}. The formula
640             * used is:<br/>
641             * 10.75 {@link #getShaahZmanis120Minutes()} after {@link #getAlos120()}.
642             * 
643             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
644             *         the calculation can't be computed such as in the Arctic Circle
645             *         where there is at least one day a year where the sun does not
646             *         rise, and one where it does not set, a null will be returned. See
647             *         detailed explanation on top of the {@link AstronomicalCalendar}
648             *         documentation.
649             */
650            public Date getPlagHamincha120Minutes() {
651                    return getTimeOffset(getAlos120(), getShaahZmanis120Minutes() * 10.75);
652            }
653    
654            /**
655             * Method to return <em>alos</em> (dawn) calculated using 60 minutes before
656             * {@link #getSeaLevelSunrise() sea level sunrise} on the time to walk the
657             * distance of 4 <em>Mil</em> at 15 minutes a <em>Mil</em> (the opinion of
658             * the Chavas Yair. See the Divray Malkiel). This is based on the opinion of
659             * most <em>Rishonim</em> who stated that the time of the <em>Neshef</em>
660             * (time between dawn and sunrise) does not vary by the time of year or
661             * location but purely depends on the time it takes to walk the distance of
662             * 4 <em>Mil</em>.
663             * 
664             * @return the <code>Date</code> representing the time. If the calculation
665             *         can't be computed such as in the Arctic Circle where there is at
666             *         least one day a year where the sun does not rise, and one where
667             *         it does not set, a null will be returned. See detailed
668             *         explanation on top of the {@link AstronomicalCalendar}
669             *         documentation.
670             */
671            public Date getAlos60() {
672                    return getTimeOffset(getSeaLevelSunrise(), -60 * MINUTE_MILLIS);
673            }
674    
675            /**
676             * Method to return <em>alos</em> (dawn) calculated using 72 minutes
677             * <em>zmaniyos</em>( <em>GR"A</em> and the <em>Baal Hatanya</em>) or 1/10th
678             * of the day before sea level sunrise. This is based on an 18 minute
679             * <em>Mil</em> so the time for 4 <em>Mil</em> is 72 minutes which is 1/10th
680             * of a day (12 * 60 = 720) based on the day starting at
681             * {@link #getSeaLevelSunrise() sea level sunrise} and ending at
682             * {@link #getSeaLevelSunset() sea level sunset}. The actual alculation is
683             * {@link #getSeaLevelSunrise()}- ( {@link #getShaahZmanisGra()} * 1.2).
684             * This calculation is used in the calendars published by
685             * <em>Hisachdus Harabanim D'Artzos Habris Ve'Kanada</em>
686             * 
687             * @return the <code>Date</code> representing the time. If the calculation
688             *         can't be computed such as in the Arctic Circle where there is at
689             *         least one day a year where the sun does not rise, and one where
690             *         it does not set, a null will be returned. See detailed
691             *         explanation on top of the {@link AstronomicalCalendar}
692             *         documentation.
693             * @see #getShaahZmanisGra()
694             */
695            public Date getAlos72Zmanis() {
696                    long shaahZmanis = getShaahZmanisGra();
697                    if (shaahZmanis == Long.MIN_VALUE) {
698                            return null;
699                    }
700                    return getTimeOffset(getSeaLevelSunrise(), (long) (shaahZmanis * -1.2));
701            }
702    
703            /**
704             * Method to return <em>alos</em> (dawn) calculated using 96 minutes before
705             * {@link #getSeaLevelSunrise() sea level sunrise} based on the time to walk
706             * the distance of 4 <em>Mil</em> at 24 minutes a <em>Mil</em>. This is
707             * based on the opinion of most <em>Rishonim</em> who stated that the time
708             * of the <em>Neshef</em> (time between dawn and sunrise) does not vary by
709             * the time of year or location but purely depends on the time it takes to
710             * walk the distance of 4 <em>Mil</em>.
711             * 
712             * @return the <code>Date</code> representing the time. If the calculation
713             *         can't be computed such as in the Arctic Circle where there is at
714             *         least one day a year where the sun does not rise, and one where
715             *         it does not set, a null will be returned. See detailed
716             *         explanation on top of the {@link AstronomicalCalendar}
717             *         documentation.
718             */
719            public Date getAlos96() {
720                    return getTimeOffset(getSeaLevelSunrise(), -96 * MINUTE_MILLIS);
721            }
722    
723            /**
724             * Method to return <em>alos</em> (dawn) calculated using 90 minutes
725             * <em>zmaniyos</em>( <em>GR"A</em> and the <em>Baal Hatanya</em>) or 1/8th
726             * of the day before sea level sunrise. This is based on a 22.5 minute
727             * <em>Mil</em> so the time for 4 <em>Mil</em> is 90 minutes which is 1/8th
728             * of a day (12 * 60 = 720) /8 =90 based on the day starting at
729             * {@link #getSunrise() sunrise} and ending at {@link #getSunset() sunset}.
730             * The actual calculation is {@link #getSunrise()} - (
731             * {@link #getShaahZmanisGra()} * 1.5).
732             * 
733             * @return the <code>Date</code> representing the time. If the calculation
734             *         can't be computed such as in the Arctic Circle where there is at
735             *         least one day a year where the sun does not rise, and one where
736             *         it does not set, a null will be returned. See detailed
737             *         explanation on top of the {@link AstronomicalCalendar}
738             *         documentation.
739             * @see #getShaahZmanisGra()
740             */
741            public Date getAlos90Zmanis() {
742                    long shaahZmanis = getShaahZmanisGra();
743                    if (shaahZmanis == Long.MIN_VALUE) {
744                            return null;
745                    }
746                    return getTimeOffset(getSeaLevelSunrise(), (long) (shaahZmanis * -1.5));
747            }
748    
749            /**
750             * Method to return <em>alos</em> (dawn) calculated using 90 minutes
751             * <em>zmaniyos</em>( <em>GR"A</em> and the <em>Baal Hatanya</em>) or 1/8th
752             * of the day before sea level sunrise. This is based on a 24 minute
753             * <em>Mil</em> so the time for 4 <em>Mil</em> is 90 minutes which is
754             * 1/7.5th of a day (12 * 60 = 720) / 7.5 =96 based on the day starting at
755             * {@link #getSunrise() sunrise} and ending at {@link #getSunset() sunset}.
756             * The actual calculation is {@link #getSunrise()} - (
757             * {@link #getShaahZmanisGra()} * 1.6).
758             * 
759             * @return the <code>Date</code> representing the time. If the calculation
760             *         can't be computed such as in the Arctic Circle where there is at
761             *         least one day a year where the sun does not rise, and one where
762             *         it does not set, a null will be returned. See detailed
763             *         explanation on top of the {@link AstronomicalCalendar}
764             *         documentation.
765             * @see #getShaahZmanisGra()
766             */
767            public Date getAlos96Zmanis() {
768                    long shaahZmanis = getShaahZmanisGra();
769                    if (shaahZmanis == Long.MIN_VALUE) {
770                            return null;
771                    }
772                    return getTimeOffset(getSeaLevelSunrise(), (long) (shaahZmanis * -1.6));
773            }
774    
775            /**
776             * Method to return <em>alos</em> (dawn) calculated using 90 minutes before
777             * {@link #getSeaLevelSunrise() sea level sunrise} on the time to walk the
778             * distance of 4 <em>Mil</em> at 22.5 minutes a <em>Mil</em>. This is based
779             * on the opinion of most <em>Rishonim</em> who stated that the time of the
780             * <em>Neshef</em> (time between dawn and sunrise) does not vary by the time
781             * of year or location but purely depends on the time it takes to walk the
782             * distance of 4 <em>Mil</em>.
783             * 
784             * @return the <code>Date</code> representing the time. If the calculation
785             *         can't be computed such as in the Arctic Circle where there is at
786             *         least one day a year where the sun does not rise, and one where
787             *         it does not set, a null will be returned. See detailed
788             *         explanation on top of the {@link AstronomicalCalendar}
789             *         documentation.
790             */
791            public Date getAlos90() {
792                    return getTimeOffset(getSeaLevelSunrise(), -90 * MINUTE_MILLIS);
793            }
794    
795            /**
796             * Method to return <em>alos</em> (dawn) calculated using 120 minutes before
797             * {@link #getSeaLevelSunrise() sea level sunrise} (no adjustment for
798             * elevation is made) based on the time to walk the distance of 5
799             * <em>Mil</em>( <em>Ula</em>) at 24 minutes a <em>Mil</em>. This is based
800             * on the opinion of most <em>Rishonim</em> who stated that the time of the
801             * <em>Neshef</em> (time between dawn and sunrise) does not vary by the time
802             * of year or location but purely depends on the time it takes to walk the
803             * distance of 5 <em>Mil</em>(<em>Ula</em>).
804             * 
805             * @return the <code>Date</code> representing the time. If the calculation
806             *         can't be computed such as in the Arctic Circle where there is at
807             *         least one day a year where the sun does not rise, and one where
808             *         it does not set, a null will be returned. See detailed
809             *         explanation on top of the {@link AstronomicalCalendar}
810             *         documentation.
811             */
812            public Date getAlos120() {
813                    return getTimeOffset(getSeaLevelSunrise(), -120 * MINUTE_MILLIS);
814            }
815    
816            /**
817             * Method to return <em>alos</em> (dawn) calculated using 120 minutes
818             * <em>zmaniyos</em>( <em>GR"A</em> and the <em>Baal Hatanya</em>) or 1/6th
819             * of the day before sea level sunrise. This is based on a 24 minute
820             * <em>Mil</em> so the time for 5 <em>Mil</em> is 120 minutes which is 1/6th
821             * of a day (12 * 60 = 720) / 6 =120 based on the day starting at
822             * {@link #getSunrise() sunrise} and ending at {@link #getSunset() sunset}.
823             * The actual calculation is {@link #getSunrise()} - (
824             * {@link #getShaahZmanisGra()} * 2).
825             * 
826             * @return the <code>Date</code> representing the time. If the calculation
827             *         can't be computed such as in the Arctic Circle where there is at
828             *         least one day a year where the sun does not rise, and one where
829             *         it does not set, a null will be returned. See detailed
830             *         explanation on top of the {@link AstronomicalCalendar}
831             *         documentation.
832             * @see #getShaahZmanisGra()
833             */
834            public Date getAlos120Zmanis() {
835                    long shaahZmanis = getShaahZmanisGra();
836                    if (shaahZmanis == Long.MIN_VALUE) {
837                            return null;
838                    }
839                    return getTimeOffset(getSeaLevelSunrise(), shaahZmanis * -2);
840            }
841    
842            /**
843             * Method to return <em>alos</em> (dawn) calculated when the sun is
844             * {@link #ZENITH_26_DEGREES 26&deg;} below the eastern geometric horizon
845             * before sunrise. This calculation is based on the same calculation of
846             * {@link #getAlos120() 120 minutes} but uses a degree based calculation
847             * instead of 120 exact minutes. This calculation is based on the position
848             * of the sun 120 minutes before sunrise in Jerusalem in the equinox which
849             * calculates to 26&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}.
850             * 
851             * @return the <code>Date</code> representing <em>alos</em>. If the
852             *         calculation can't be computed such as northern and southern
853             *         locations even south of the Arctic Circle and north of the
854             *         Antarctic Circle where the sun may not reach low enough below the
855             *         horizon for this calculation, a null will be returned. See
856             *         detailed explanation on top of the {@link AstronomicalCalendar}
857             *         documentation.
858             * @see #ZENITH_26_DEGREES
859             * @see #getAlos120()
860             * @see #getTzais120()
861             */
862            public Date getAlos26Degrees() {
863                    return getSunriseOffsetByDegrees(ZENITH_26_DEGREES);
864            }
865    
866            /**
867             * to return <em>alos</em> (dawn) calculated when the sun is
868             * {@link #ASTRONOMICAL_ZENITH 18&deg;} below the eastern geometric horizon
869             * before sunrise.
870             * 
871             * @return the <code>Date</code> representing <em>alos</em>. If the
872             *         calculation can't be computed such as northern and southern
873             *         locations even south of the Arctic Circle and north of the
874             *         Antarctic Circle where the sun may not reach low enough below the
875             *         horizon for this calculation, a null will be returned. See
876             *         detailed explanation on top of the {@link AstronomicalCalendar}
877             *         documentation.
878             * @see #ASTRONOMICAL_ZENITH
879             */
880            public Date getAlos18Degrees() {
881                    return getSunriseOffsetByDegrees(ASTRONOMICAL_ZENITH);
882            }
883    
884            /**
885             * Method to return <em>alos</em> (dawn) calculated when the sun is
886             * {@link #ZENITH_19_POINT_8 19.8&deg;} below the eastern geometric horizon
887             * before sunrise. This calculation is based on the same calculation of
888             * {@link #getAlos90() 90 minutes} but uses a degree based calculation
889             * instead of 90 exact minutes. This calculation is based on the position of
890             * the sun 90 minutes before sunrise in Jerusalem in the equinox which
891             * calculates to 19.8&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
892             * 
893             * @return the <code>Date</code> representing <em>alos</em>. If the
894             *         calculation can't be computed such as northern and southern
895             *         locations even south of the Arctic Circle and north of the
896             *         Antarctic Circle where the sun may not reach low enough below the
897             *         horizon for this calculation, a null will be returned. See
898             *         detailed explanation on top of the {@link AstronomicalCalendar}
899             *         documentation.
900             * @see #ZENITH_19_POINT_8
901             * @see #getAlos90()
902             */
903            public Date getAlos19Point8Degrees() {
904                    return getSunriseOffsetByDegrees(ZENITH_19_POINT_8);
905            }
906    
907            /**
908             * Method to return <em>alos</em> (dawn) calculated when the sun is
909             * {@link #ZENITH_16_POINT_1 16.1&deg;} below the eastern geometric horizon
910             * before sunrise. This calculation is based on the same calculation of
911             * {@link #getAlos72() 72 minutes} but uses a degree based calculation
912             * instead of 72 exact minutes. This calculation is based on the position of
913             * the sun 72 minutes before sunrise in Jerusalem in the equinox which
914             * calculates to 16.1&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}.
915             * 
916             * @return the <code>Date</code> representing <em>alos</em>. If the
917             *         calculation can't be computed such as northern and southern
918             *         locations even south of the Arctic Circle and north of the
919             *         Antarctic Circle where the sun may not reach low enough below the
920             *         horizon for this calculation, a null will be returned. See
921             *         detailed explanation on top of the {@link AstronomicalCalendar}
922             *         documentation.
923             * @see #ZENITH_16_POINT_1
924             * @see #getAlos72()
925             */
926            public Date getAlos16Point1Degrees() {
927                    return getSunriseOffsetByDegrees(ZENITH_16_POINT_1);
928            }
929    
930            /**
931             * This method returns <em>misheyakir</em> based on the position of the sun
932             * when it is {@link #ZENITH_11_DEGREES 11.5&deg;} below
933             * {@link #GEOMETRIC_ZENITH geometric zenith} (90&deg;). This calculation is
934             * used for calculating <em>misheyakir</em> according to some opinions. This
935             * calculation is based on the position of the sun 52 minutes before
936             * {@link #getSunrise sunrise} in Jerusalem in the equinox which calculates
937             * to 11.5&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
938             * 
939             * @return the <code>Date</code> of misheyakir. If the calculation can't be
940             *         computed such as northern and southern locations even south of
941             *         the Arctic Circle and north of the Antarctic Circle where the sun
942             *         may not reach low enough below the horizon for this calculation,
943             *         a null will be returned. See detailed explanation on top of the
944             *         {@link AstronomicalCalendar} documentation.
945             * @see #ZENITH_11_POINT_5
946             */
947            public Date getMisheyakir11Point5Degrees() {
948                    return getSunriseOffsetByDegrees(ZENITH_11_POINT_5);
949            }
950    
951            /**
952             * This method returns <em>misheyakir</em> based on the position of the sun
953             * when it is {@link #ZENITH_11_DEGREES 11&deg;} below
954             * {@link #GEOMETRIC_ZENITH geometric zenith} (90&deg;). This calculation is
955             * used for calculating <em>misheyakir</em> according to some opinions. This
956             * calculation is based on the position of the sun 48 minutes before
957             * {@link #getSunrise sunrise} in Jerusalem in the equinox which calculates
958             * to 11&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
959             * 
960             * @return If the calculation can't be computed such as northern and
961             *         southern locations even south of the Arctic Circle and north of
962             *         the Antarctic Circle where the sun may not reach low enough below
963             *         the horizon for this calculation, a null will be returned. See
964             *         detailed explanation on top of the {@link AstronomicalCalendar}
965             *         documentation.
966             * @see #ZENITH_11_DEGREES
967             */
968            public Date getMisheyakir11Degrees() {
969                    return getSunriseOffsetByDegrees(ZENITH_11_DEGREES);
970            }
971    
972            /**
973             * This method returns <em>misheyakir</em> based on the position of the sun
974             * when it is {@link #ZENITH_10_POINT_2 10.2&deg;} below
975             * {@link #GEOMETRIC_ZENITH geometric zenith} (90&deg;). This calculation is
976             * used for calculating <em>misheyakir</em> according to some opinions. This
977             * calculation is based on the position of the sun 45 minutes before
978             * {@link #getSunrise sunrise} in Jerusalem in the equinox which calculates
979             * to 10.2&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
980             * 
981             * @return the <code>Date</code> of the latest misheyakir. If the
982             *         calculation can't be computed such as northern and southern
983             *         locations even south of the Arctic Circle and north of the
984             *         Antarctic Circle where the sun may not reach low enough below the
985             *         horizon for this calculation, a null will be returned. See
986             *         detailed explanation on top of the {@link AstronomicalCalendar}
987             *         documentation.
988             * @see #ZENITH_10_POINT_2
989             */
990            public Date getMisheyakir10Point2Degrees() {
991                    return getSunriseOffsetByDegrees(ZENITH_10_POINT_2);
992            }
993    
994            /**
995             * This method returns the latest <em>zman krias shema</em> (time to say
996             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
997             * <em>alos</em> being {@link #getAlos19Point8Degrees()() 19.8&deg;} before
998             * {@link #getSunrise() sunrise}. This time is 3
999             * <em>{@link #getShaahZmanis19Point8Degrees() shaos zmaniyos}</em> (solar
1000             * hours) after {@link #getAlos19Point8Degrees() dawn} based on the opinion
1001             * of the <em>MG"A</em> that the day is calculated from dawn to nightfall
1002             * with both being 19.8&deg; below sunrise or sunset. This returns the time
1003             * of 3 {@link #getShaahZmanis19Point8Degrees()} after
1004             * {@link #getAlos19Point8Degrees() dawn}.
1005             * 
1006             * @return the <code>Date</code> of the latest zman shema. If the
1007             *         calculation can't be computed such as northern and southern
1008             *         locations even south of the Arctic Circle and north of the
1009             *         Antarctic Circle where the sun may not reach low enough below the
1010             *         horizon for this calculation, a null will be returned. See
1011             *         detailed explanation on top of the {@link AstronomicalCalendar}
1012             *         documentation.
1013             * @see #getShaahZmanis19Point8Degrees()
1014             * @see #getAlos19Point8Degrees()
1015             */
1016            public Date getSofZmanShmaMGA19Point8Degrees() {
1017                    return getTimeOffset(getAlos19Point8Degrees(),
1018                                    getShaahZmanis19Point8Degrees() * 3);
1019            }
1020    
1021            /**
1022             * This method returns the latest <em>zman krias shema</em> (time to say
1023             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1024             * <em>alos</em> being {@link #getAlos16Point1Degrees()() 16.1&deg;} before
1025             * {@link #getSunrise() sunrise}. This time is 3
1026             * <em>{@link #getShaahZmanis16Point1Degrees() shaos zmaniyos}</em> (solar
1027             * hours) after {@link #getAlos16Point1Degrees() dawn} based on the opinion
1028             * of the <em>MG"A</em> that the day is calculated from dawn to nightfall
1029             * with both being 16.1&deg; below sunrise or sunset. This returns the time
1030             * of 3 {@link #getShaahZmanis16Point1Degrees()} after
1031             * {@link #getAlos16Point1Degrees() dawn}.
1032             * 
1033             * @return the <code>Date</code> of the latest zman shema. If the
1034             *         calculation can't be computed such as northern and southern
1035             *         locations even south of the Arctic Circle and north of the
1036             *         Antarctic Circle where the sun may not reach low enough below the
1037             *         horizon for this calculation, a null will be returned. See
1038             *         detailed explanation on top of the {@link AstronomicalCalendar}
1039             *         documentation.
1040             * @see #getShaahZmanis16Point1Degrees()
1041             * @see #getAlos16Point1Degrees()
1042             */
1043            public Date getSofZmanShmaMGA16Point1Degrees() {
1044                    return getTimeOffset(getAlos16Point1Degrees(),
1045                                    getShaahZmanis16Point1Degrees() * 3);
1046            }
1047    
1048            /**
1049             * This method returns the latest <em>zman krias shema</em> (time to say
1050             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1051             * <em>alos</em> being {@link #getAlos72() 72} minutes before
1052             * {@link #getSunrise() sunrise}. This time is 3
1053             * <em>{@link #getShaahZmanis72Minutes() shaos zmaniyos}</em> (solar hours)
1054             * after {@link #getAlos72() dawn} based on the opinion of the <em>MG"A</em>
1055             * that the day is calculated from a {@link #getAlos72() dawn} of 72 minutes
1056             * before sunrise to {@link #getTzais72() nightfall} of 72 minutes after
1057             * sunset. This returns the time of 3 * {@link #getShaahZmanis72Minutes()}
1058             * after {@link #getAlos72() dawn}. This class returns an identical time to
1059             * {@link #getSofZmanShmaMGA()} and is repeated here for clarity.
1060             * 
1061             * @return the <code>Date</code> of the latest zman shema. If the
1062             *         calculation can't be computed such as in the Arctic Circle where
1063             *         there is at least one day a year where the sun does not rise, and
1064             *         one where it does not set, a null will be returned. See detailed
1065             *         explanation on top of the {@link AstronomicalCalendar}
1066             *         documentation.
1067             * @see #getShaahZmanis72Minutes()
1068             * @see #getAlos72()
1069             * @see #getSofZmanShmaMGA()
1070             */
1071            public Date getSofZmanShmaMGA72Minutes() {
1072                    return getSofZmanShmaMGA();
1073            }
1074    
1075            /**
1076             * This method returns the latest <em>zman krias shema</em> (time to say
1077             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1078             * <em>alos</em> being {@link #getAlos72Zmanis() 72} minutes
1079             * <em>zmaniyos</em>, or 1/10th of the day before {@link #getSunrise()
1080             * sunrise}. This time is 3
1081             * <em>{@link #getShaahZmanis90MinutesZmanis() shaos zmaniyos}</em> (solar
1082             * hours) after {@link #getAlos72Zmanis() dawn} based on the opinion of the
1083             * <em>MG"A</em> that the day is calculated from a
1084             * {@link #getAlos72Zmanis() dawn} of 72 minutes <em>zmaniyos</em>, or
1085             * 1/10th of the day before {@link #getSeaLevelSunrise() sea level sunrise}
1086             * to {@link #getTzais72Zmanis() nightfall} of 72 minutes <em>zmaniyos</em>
1087             * after {@link #getSeaLevelSunset() sea level sunset}. This returns the
1088             * time of 3 * {@link #getShaahZmanis72MinutesZmanis()} after
1089             * {@link #getAlos72Zmanis() dawn}.
1090             * 
1091             * @return the <code>Date</code> of the latest zman shema. If the
1092             *         calculation can't be computed such as in the Arctic Circle where
1093             *         there is at least one day a year where the sun does not rise, and
1094             *         one where it does not set, a null will be returned. See detailed
1095             *         explanation on top of the {@link AstronomicalCalendar}
1096             *         documentation.
1097             * @see #getShaahZmanis72MinutesZmanis()
1098             * @see #getAlos72Zmanis()
1099             */
1100            public Date getSofZmanShmaMGA72MinutesZmanis() {
1101                    return getTimeOffset(getAlos72Zmanis(),
1102                                    getShaahZmanis72MinutesZmanis() * 3);
1103            }
1104    
1105            /**
1106             * This method returns the latest <em>zman krias shema</em> (time to say
1107             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1108             * <em>alos</em> being {@link #getAlos90() 90} minutes before
1109             * {@link #getSunrise() sunrise}. This time is 3
1110             * <em>{@link #getShaahZmanis90Minutes() shaos zmaniyos}</em> (solar hours)
1111             * after {@link #getAlos90() dawn} based on the opinion of the <em>MG"A</em>
1112             * that the day is calculated from a {@link #getAlos90() dawn} of 90 minutes
1113             * before sunrise to {@link #getTzais90() nightfall} of 90 minutes after
1114             * sunset. This returns the time of 3 * {@link #getShaahZmanis90Minutes()}
1115             * after {@link #getAlos90() dawn}.
1116             * 
1117             * @return the <code>Date</code> of the latest zman shema. If the
1118             *         calculation can't be computed such as in the Arctic Circle where
1119             *         there is at least one day a year where the sun does not rise, and
1120             *         one where it does not set, a null will be returned. See detailed
1121             *         explanation on top of the {@link AstronomicalCalendar}
1122             *         documentation.
1123             * @see #getShaahZmanis90Minutes()
1124             * @see #getAlos90()
1125             */
1126            public Date getSofZmanShmaMGA90Minutes() {
1127                    return getTimeOffset(getAlos90(), getShaahZmanis90Minutes() * 3);
1128            }
1129    
1130            /**
1131             * This method returns the latest <em>zman krias shema</em> (time to say
1132             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1133             * <em>alos</em> being {@link #getAlos90Zmanis() 90} minutes
1134             * <em>zmaniyos</em> before {@link #getSunrise() sunrise}. This time is 3
1135             * <em>{@link #getShaahZmanis90MinutesZmanis() shaos zmaniyos}</em> (solar
1136             * hours) after {@link #getAlos90Zmanis() dawn} based on the opinion of the
1137             * <em>MG"A</em> that the day is calculated from a
1138             * {@link #getAlos90Zmanis() dawn} of 90 minutes <em>zmaniyos</em> before
1139             * sunrise to {@link #getTzais90Zmanis() nightfall} of 90 minutes
1140             * <em>zmaniyos</em> after sunset. This returns the time of 3 *
1141             * {@link #getShaahZmanis90MinutesZmanis()} after {@link #getAlos90Zmanis()
1142             * dawn}.
1143             * 
1144             * @return the <code>Date</code> of the latest zman shema. If the
1145             *         calculation can't be computed such as in the Arctic Circle where
1146             *         there is at least one day a year where the sun does not rise, and
1147             *         one where it does not set, a null will be returned. See detailed
1148             *         explanation on top of the {@link AstronomicalCalendar}
1149             *         documentation.
1150             * @see #getShaahZmanis90MinutesZmanis()
1151             * @see #getAlos90Zmanis()
1152             */
1153            public Date getSofZmanShmaMGA90MinutesZmanis() {
1154                    return getTimeOffset(getAlos90Zmanis(),
1155                                    getShaahZmanis90MinutesZmanis() * 3);
1156            }
1157    
1158            /**
1159             * This method returns the latest <em>zman krias shema</em> (time to say
1160             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1161             * <em>alos</em> being {@link #getAlos96() 96} minutes before
1162             * {@link #getSunrise() sunrise}. This time is 3
1163             * <em>{@link #getShaahZmanis96Minutes() shaos zmaniyos}</em> (solar hours)
1164             * after {@link #getAlos96() dawn} based on the opinion of the <em>MG"A</em>
1165             * that the day is calculated from a {@link #getAlos96() dawn} of 96 minutes
1166             * before sunrise to {@link #getTzais96() nightfall} of 96 minutes after
1167             * sunset. This returns the time of 3 * {@link #getShaahZmanis96Minutes()}
1168             * after {@link #getAlos96() dawn}.
1169             * 
1170             * @return the <code>Date</code> of the latest zman shema. If the
1171             *         calculation can't be computed such as in the Arctic Circle where
1172             *         there is at least one day a year where the sun does not rise, and
1173             *         one where it does not set, a null will be returned. See detailed
1174             *         explanation on top of the {@link AstronomicalCalendar}
1175             *         documentation.
1176             * @see #getShaahZmanis96Minutes()
1177             * @see #getAlos96()
1178             */
1179            public Date getSofZmanShmaMGA96Minutes() {
1180                    return getTimeOffset(getAlos96(), getShaahZmanis96Minutes() * 3);
1181            }
1182    
1183            /**
1184             * This method returns the latest <em>zman krias shema</em> (time to say
1185             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1186             * <em>alos</em> being {@link #getAlos90Zmanis() 96} minutes
1187             * <em>zmaniyos</em> before {@link #getSunrise() sunrise}. This time is 3
1188             * <em>{@link #getShaahZmanis96MinutesZmanis() shaos zmaniyos}</em> (solar
1189             * hours) after {@link #getAlos96Zmanis() dawn} based on the opinion of the
1190             * <em>MG"A</em> that the day is calculated from a
1191             * {@link #getAlos96Zmanis() dawn} of 96 minutes <em>zmaniyos</em> before
1192             * sunrise to {@link #getTzais90Zmanis() nightfall} of 96 minutes
1193             * <em>zmaniyos</em> after sunset. This returns the time of 3 *
1194             * {@link #getShaahZmanis96MinutesZmanis()} after {@link #getAlos96Zmanis()
1195             * dawn}.
1196             * 
1197             * @return the <code>Date</code> of the latest zman shema. If the
1198             *         calculation can't be computed such as in the Arctic Circle where
1199             *         there is at least one day a year where the sun does not rise, and
1200             *         one where it does not set, a null will be returned. See detailed
1201             *         explanation on top of the {@link AstronomicalCalendar}
1202             *         documentation.
1203             * @see #getShaahZmanis96MinutesZmanis()
1204             * @see #getAlos96Zmanis()
1205             */
1206            public Date getSofZmanShmaMGA96MinutesZmanis() {
1207                    return getTimeOffset(getAlos96Zmanis(),
1208                                    getShaahZmanis96MinutesZmanis() * 3);
1209            }
1210    
1211            /**
1212             * This method returns the latest <em>zman krias shema</em> (time to say
1213             * Shema in the morning) calculated as 3 hours (regular and not zmaniyos)
1214             * before {@link ZmanimCalendar#getChatzos()}. This is the opinion of the
1215             * <em>Shach</em> in the
1216             * <em>Nekudas Hakesef (Yora Deah 184), Shevus Yaakov, Chasan Sofer</em> and
1217             * others.This returns the time of 3 hours before
1218             * {@link ZmanimCalendar#getChatzos()}.
1219             * 
1220             * @return the <code>Date</code> of the latest zman shema. If the
1221             *         calculation can't be computed such as in the Arctic Circle where
1222             *         there is at least one day a year where the sun does not rise, and
1223             *         one where it does not set, a null will be returned. See detailed
1224             *         explanation on top of the {@link AstronomicalCalendar}
1225             *         documentation.
1226             * @see ZmanimCalendar#getChatzos()
1227             * @see #getSofZmanTfila2HoursBeforeChatzos()
1228             */
1229            public Date getSofZmanShma3HoursBeforeChatzos() {
1230                    return getTimeOffset(getChatzos(), -180 * MINUTE_MILLIS);
1231            }
1232    
1233            /**
1234             * This method returns the latest <em>zman krias shema</em> (time to say
1235             * Shema in the morning) in the opinion of the <em>MG"A</em> based on
1236             * <em>alos</em> being {@link #getAlos120() 120} minutes or 1/6th of the day
1237             * before {@link #getSunrise() sunrise}. This time is 3
1238             * <em>{@link #getShaahZmanis120Minutes() shaos zmaniyos}</em> (solar hours)
1239             * after {@link #getAlos120() dawn} based on the opinion of the
1240             * <em>MG"A</em> that the day is calculated from a {@link #getAlos120()
1241             * dawn} of 120 minutes before sunrise to {@link #getTzais120() nightfall}
1242             * of 120 minutes after sunset. This returns the time of 3 *
1243             * {@link #getShaahZmanis120Minutes()} after {@link #getAlos120() dawn}.
1244             * 
1245             * @return the <code>Date</code> of the latest zman shema. If the
1246             *         calculation can't be computed such as in the Arctic Circle where
1247             *         there is at least one day a year where the sun does not rise, and
1248             *         one where it does not set, a null will be returned. See detailed
1249             *         explanation on top of the {@link AstronomicalCalendar}
1250             *         documentation.
1251             * @see #getShaahZmanis120Minutes()
1252             * @see #getAlos120()
1253             */
1254            public Date getSofZmanShmaMGA120Minutes() {
1255                    return getTimeOffset(getAlos120(), getShaahZmanis120Minutes() * 3);
1256            }
1257    
1258            /**
1259             * This method returns the latest <em>zman krias shema</em> (time to say
1260             * Shema in the morning) based on the opinion that the day starts at
1261             * <em>{@link #getAlos16Point1Degrees() alos 16.1&deg;}</em> and ends at
1262             * {@link #getSeaLevelSunset() sea level sunset}. 3 shaos zmaniyos are
1263             * calculated based on this day and added to
1264             * {@link #getAlos16Point1Degrees() alos}to reach this time. This time is 3
1265             * <em>shaos zmaniyos</em> (solar hours) after
1266             * {@link #getAlos16Point1Degrees() dawn} based on the opinion that the day
1267             * is calculated from a {@link #getAlos16Point1Degrees() alos 16.1&deg;} to
1268             * {@link #getSeaLevelSunset() sea level sunset}.<br />
1269             * <b>Note: </b> Based on this calculation <em>chatzos</em> will not be at
1270             * midday.
1271             * 
1272             * @return the <code>Date</code> of the latest zman shema based on this day.
1273             *         If the calculation can't be computed such as northern and
1274             *         southern locations even south of the Arctic Circle and north of
1275             *         the Antarctic Circle where the sun may not reach low enough below
1276             *         the horizon for this calculation, a null will be returned. See
1277             *         detailed explanation on top of the {@link AstronomicalCalendar}
1278             *         documentation.
1279             * @see #getAlos16Point1Degrees()
1280             * @see #getSeaLevelSunset()
1281             */
1282            public Date getSofZmanShmaAlos16Point1ToSunset() {
1283                    long shaahZmanis = getTemporalHour(getAlos16Point1Degrees(),
1284                                    getSeaLevelSunset());
1285                    return getTimeOffset(getAlos16Point1Degrees(), shaahZmanis * 3);
1286            }
1287    
1288            /**
1289             * This method returns the latest <em>zman krias shema</em> (time to say
1290             * Shema in the morning) based on the opinion that the day starts at
1291             * <em>{@link #getAlos16Point1Degrees() alos 16.1&deg;}</em> and ends at
1292             * {@link #getTzaisGeonim7Point083Degrees() tzais 7.083&deg;}. 3
1293             * <em>shaos zmaniyos</em> are calculated based on this day and added to
1294             * {@link #getAlos16Point1Degrees() alos} to reach this time. This time is 3
1295             * <em>shaos zmaniyos</em> (temporal hours) after
1296             * {@link #getAlos16Point1Degrees() alos 16.1&deg;} based on the opinion
1297             * that the day is calculated from a {@link #getAlos16Point1Degrees() alos
1298             * 16.1&deg;} to
1299             * <em>{@link #getTzaisGeonim7Point083Degrees() tzais 7.083&deg;}</em>.<br />
1300             * <b>Note: </b> Based on this calculation <em>chatzos</em> will not be at
1301             * midday.
1302             * 
1303             * @return the <code>Date</code> of the latest zman shema based on this
1304             *         calculation. If the calculation can't be computed such as
1305             *         northern and southern locations even south of the Arctic Circle
1306             *         and north of the Antarctic Circle where the sun may not reach low
1307             *         enough below the horizon for this calculation, a null will be
1308             *         returned. See detailed explanation on top of the
1309             *         {@link AstronomicalCalendar} documentation.
1310             * @see #getAlos16Point1Degrees()
1311             * @see #getTzaisGeonim7Point083Degrees()
1312             */
1313            public Date getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees() {
1314                    long shaahZmanis = getTemporalHour(getAlos16Point1Degrees(),
1315                                    getTzaisGeonim7Point083Degrees());
1316                    return getTimeOffset(getAlos16Point1Degrees(), shaahZmanis * 3);
1317            }
1318    
1319            /**
1320             * From the GR"A in Kol Eliyahu on Berachos #173 that states that zman krias
1321             * shema is calculated as half the time from {@link #getSeaLevelSunrise()
1322             * sea level sunset} to fixed local chatzos. The GR"A himself seems to
1323             * contradic this when he stated that zman krias shema is 1/4 of the day
1324             * from sunrise to sunset. See Sarah Lamoed #25 in Yisroel Vehazmanim Vol
1325             * III page 1016.
1326             * 
1327             * @return the <code>Date</code> of the latest zman shema based on this
1328             *         calculation. If the calculation can't be computed such as in the
1329             *         Arctic Circle where there is at least one day a year where the
1330             *         sun does not rise, and one where it does not set, a null will be
1331             *         returned. See detailed explanation on top of the
1332             *         {@link AstronomicalCalendar} documentation.
1333             * @see #getFixedLocalChatzos()
1334             */
1335            public Date getSofZmanShmaKolEliyahu() {
1336                    Date chatzos = getFixedLocalChatzos();
1337                    if (chatzos == null || getSunrise() == null) {
1338                            return null;
1339                    }
1340                    long diff = (chatzos.getTime() - getSeaLevelSunrise().getTime()) / 2;
1341                    return getTimeOffset(chatzos, -diff);
1342            }
1343    
1344            /**
1345             * This method returns the latest <em>zman tfila</em> (time to say the
1346             * morning prayers) in the opinion of the <em>MG"A</em> based on
1347             * <em>alos</em> being {@link #getAlos19Point8Degrees()() 19.8&deg;} before
1348             * {@link #getSunrise() sunrise}. This time is 4
1349             * <em>{@link #getShaahZmanis19Point8Degrees() shaos zmaniyos}</em> (solar
1350             * hours) after {@link #getAlos19Point8Degrees() dawn} based on the opinion
1351             * of the <em>MG"A</em> that the day is calculated from dawn to nightfall
1352             * with both being 19.8&deg; below sunrise or sunset. This returns the time
1353             * of 4 {@link #getShaahZmanis19Point8Degrees()} after
1354             * {@link #getAlos19Point8Degrees() dawn}.
1355             * 
1356             * @return the <code>Date</code> of the latest zman shema. If the
1357             *         calculation can't be computed such as northern and southern
1358             *         locations even south of the Arctic Circle and north of the
1359             *         Antarctic Circle where the sun may not reach low enough below the
1360             *         horizon for this calculation, a null will be returned. See
1361             *         detailed explanation on top of the {@link AstronomicalCalendar}
1362             *         documentation.
1363             * 
1364             * @see #getShaahZmanis19Point8Degrees()
1365             * @see #getAlos19Point8Degrees()
1366             */
1367            public Date getSofZmanTfilaMGA19Point8Degrees() {
1368                    return getTimeOffset(getAlos19Point8Degrees(),
1369                                    getShaahZmanis19Point8Degrees() * 4);
1370            }
1371    
1372            /**
1373             * This method returns the latest <em>zman tfila</em> (time to say the
1374             * morning prayers) in the opinion of the <em>MG"A</em> based on
1375             * <em>alos</em> being {@link #getAlos19Point8Degrees()() 16.1&deg;} before
1376             * {@link #getSunrise() sunrise}. This time is 4
1377             * <em>{@link #getShaahZmanis16Point1Degrees() shaos zmaniyos}</em> (solar
1378             * hours) after {@link #getAlos16Point1Degrees() dawn} based on the opinion
1379             * of the <em>MG"A</em> that the day is calculated from dawn to nightfall
1380             * with both being 16.1&deg; below sunrise or sunset. This returns the time
1381             * of 4 {@link #getShaahZmanis16Point1Degrees()} after
1382             * {@link #getAlos16Point1Degrees() dawn}.
1383             * 
1384             * @return the <code>Date</code> of the latest zman shema. If the
1385             *         calculation can't be computed such as northern and southern
1386             *         locations even south of the Arctic Circle and north of the
1387             *         Antarctic Circle where the sun may not reach low enough below the
1388             *         horizon for this calculation, a null will be returned. See
1389             *         detailed explanation on top of the {@link AstronomicalCalendar}
1390             *         documentation.
1391             * 
1392             * @see #getShaahZmanis16Point1Degrees()
1393             * @see #getAlos16Point1Degrees()
1394             */
1395            public Date getSofZmanTfilaMGA16Point1Degrees() {
1396                    return getTimeOffset(getAlos16Point1Degrees(),
1397                                    getShaahZmanis16Point1Degrees() * 4);
1398            }
1399    
1400            /**
1401             * This method returns the latest <em>zman tfila</em> (time to say the
1402             * morning prayers) in the opinion of the <em>MG"A</em> based on
1403             * <em>alos</em> being {@link #getAlos72() 72} minutes before
1404             * {@link #getSunrise() sunrise}. This time is 4
1405             * <em>{@link #getShaahZmanis72Minutes() shaos zmaniyos}</em> (solar hours)
1406             * after {@link #getAlos72() dawn} based on the opinion of the <em>MG"A</em>
1407             * that the day is calculated from a {@link #getAlos72() dawn} of 72 minutes
1408             * before sunrise to {@link #getTzais72() nightfall} of 72 minutes after
1409             * sunset. This returns the time of 4 * {@link #getShaahZmanis72Minutes()}
1410             * after {@link #getAlos72() dawn}. This class returns an identical time to
1411             * {@link #getSofZmanTfilaMGA()} and is repeated here for clarity.
1412             * 
1413             * @return the <code>Date</code> of the latest zman tfila. If the
1414             *         calculation can't be computed such as in the Arctic Circle where
1415             *         there is at least one day a year where the sun does not rise, and
1416             *         one where it does not set, a null will be returned. See detailed
1417             *         explanation on top of the {@link AstronomicalCalendar}
1418             *         documentation.
1419             * @see #getShaahZmanis72Minutes()
1420             * @see #getAlos72()
1421             * @see #getSofZmanShmaMGA()
1422             */
1423            public Date getSofZmanTfilaMGA72Minutes() {
1424                    return getSofZmanTfilaMGA();
1425            }
1426    
1427            /**
1428             * This method returns the latest <em>zman tfila</em> (time to the morning
1429             * prayers) in the opinion of the <em>MG"A</em> based on <em>alos</em> being
1430             * {@link #getAlos72Zmanis() 72} minutes <em>zmaniyos</em> before
1431             * {@link #getSunrise() sunrise}. This time is 4
1432             * <em>{@link #getShaahZmanis72MinutesZmanis() shaos zmaniyos}</em> (solar
1433             * hours) after {@link #getAlos72Zmanis() dawn} based on the opinion of the
1434             * <em>MG"A</em> that the day is calculated from a
1435             * {@link #getAlos72Zmanis() dawn} of 72 minutes <em>zmaniyos</em> before
1436             * sunrise to {@link #getTzais72Zmanis() nightfall} of 72 minutes
1437             * <em>zmaniyos</em> after sunset. This returns the time of 4 *
1438             * {@link #getShaahZmanis72MinutesZmanis()} after {@link #getAlos72Zmanis()
1439             * dawn}.
1440             * 
1441             * @return the <code>Date</code> of the latest zman shema. If the
1442             *         calculation can't be computed such as in the Arctic Circle where
1443             *         there is at least one day a year where the sun does not rise, and
1444             *         one where it does not set, a null will be returned. See detailed
1445             *         explanation on top of the {@link AstronomicalCalendar}
1446             *         documentation.
1447             * @see #getShaahZmanis72MinutesZmanis()
1448             * @see #getAlos72Zmanis()
1449             */
1450            public Date getSofZmanTfilaMGA72MinutesZmanis() {
1451                    return getTimeOffset(getAlos72Zmanis(),
1452                                    getShaahZmanis72MinutesZmanis() * 4);
1453            }
1454    
1455            /**
1456             * This method returns the latest <em>zman tfila</em> (time to say the
1457             * morning prayers) in the opinion of the <em>MG"A</em> based on
1458             * <em>alos</em> being {@link #getAlos90() 90} minutes before
1459             * {@link #getSunrise() sunrise}. This time is 4
1460             * <em>{@link #getShaahZmanis90Minutes() shaos zmaniyos}</em> (solar hours)
1461             * after {@link #getAlos90() dawn} based on the opinion of the <em>MG"A</em>
1462             * that the day is calculated from a {@link #getAlos90() dawn} of 90 minutes
1463             * before sunrise to {@link #getTzais90() nightfall} of 90 minutes after
1464             * sunset. This returns the time of 4 * {@link #getShaahZmanis90Minutes()}
1465             * after {@link #getAlos90() dawn}.
1466             * 
1467             * @return the <code>Date</code> of the latest zman tfila. If the
1468             *         calculation can't be computed such as in the Arctic Circle where
1469             *         there is at least one day a year where the sun does not rise, and
1470             *         one where it does not set, a null will be returned. See detailed
1471             *         explanation on top of the {@link AstronomicalCalendar}
1472             *         documentation.
1473             * @see #getShaahZmanis90Minutes()
1474             * @see #getAlos90()
1475             */
1476            public Date getSofZmanTfilaMGA90Minutes() {
1477                    return getTimeOffset(getAlos90(), getShaahZmanis90Minutes() * 4);
1478            }
1479    
1480            /**
1481             * This method returns the latest <em>zman tfila</em> (time to the morning
1482             * prayers) in the opinion of the <em>MG"A</em> based on <em>alos</em> being
1483             * {@link #getAlos90Zmanis() 90} minutes <em>zmaniyos</em> before
1484             * {@link #getSunrise() sunrise}. This time is 4
1485             * <em>{@link #getShaahZmanis90MinutesZmanis() shaos zmaniyos}</em> (solar
1486             * hours) after {@link #getAlos90Zmanis() dawn} based on the opinion of the
1487             * <em>MG"A</em> that the day is calculated from a
1488             * {@link #getAlos90Zmanis() dawn} of 90 minutes <em>zmaniyos</em> before
1489             * sunrise to {@link #getTzais90Zmanis() nightfall} of 90 minutes
1490             * <em>zmaniyos</em> after sunset. This returns the time of 4 *
1491             * {@link #getShaahZmanis90MinutesZmanis()} after {@link #getAlos90Zmanis()
1492             * dawn}.
1493             * 
1494             * @return the <code>Date</code> of the latest zman shema. If the
1495             *         calculation can't be computed such as in the Arctic Circle where
1496             *         there is at least one day a year where the sun does not rise, and
1497             *         one where it does not set, a null will be returned. See detailed
1498             *         explanation on top of the {@link AstronomicalCalendar}
1499             *         documentation.
1500             * @see #getShaahZmanis90MinutesZmanis()
1501             * @see #getAlos90Zmanis()
1502             */
1503            public Date getSofZmanTfilaMGA90MinutesZmanis() {
1504                    return getTimeOffset(getAlos90Zmanis(),
1505                                    getShaahZmanis90MinutesZmanis() * 4);
1506            }
1507    
1508            /**
1509             * This method returns the latest <em>zman tfila</em> (time to say the
1510             * morning prayers) in the opinion of the <em>MG"A</em> based on
1511             * <em>alos</em> being {@link #getAlos96() 96} minutes before
1512             * {@link #getSunrise() sunrise}. This time is 4
1513             * <em>{@link #getShaahZmanis96Minutes() shaos zmaniyos}</em> (solar hours)
1514             * after {@link #getAlos96() dawn} based on the opinion of the <em>MG"A</em>
1515             * that the day is calculated from a {@link #getAlos96() dawn} of 96 minutes
1516             * before sunrise to {@link #getTzais96() nightfall} of 96 minutes after
1517             * sunset. This returns the time of 4 * {@link #getShaahZmanis96Minutes()}
1518             * after {@link #getAlos96() dawn}.
1519             * 
1520             * @return the <code>Date</code> of the latest zman tfila. If the
1521             *         calculation can't be computed such as in the Arctic Circle where
1522             *         there is at least one day a year where the sun does not rise, and
1523             *         one where it does not set, a null will be returned. See detailed
1524             *         explanation on top of the {@link AstronomicalCalendar}
1525             *         documentation.
1526             * @see #getShaahZmanis96Minutes()
1527             * @see #getAlos96()
1528             */
1529            public Date getSofZmanTfilaMGA96Minutes() {
1530                    return getTimeOffset(getAlos96(), getShaahZmanis96Minutes() * 4);
1531            }
1532    
1533            /**
1534             * This method returns the latest <em>zman tfila</em> (time to the morning
1535             * prayers) in the opinion of the <em>MG"A</em> based on <em>alos</em> being
1536             * {@link #getAlos96Zmanis() 96} minutes <em>zmaniyos</em> before
1537             * {@link #getSunrise() sunrise}. This time is 4
1538             * <em>{@link #getShaahZmanis96MinutesZmanis() shaos zmaniyos}</em> (solar
1539             * hours) after {@link #getAlos96Zmanis() dawn} based on the opinion of the
1540             * <em>MG"A</em> that the day is calculated from a
1541             * {@link #getAlos96Zmanis() dawn} of 96 minutes <em>zmaniyos</em> before
1542             * sunrise to {@link #getTzais96Zmanis() nightfall} of 96 minutes
1543             * <em>zmaniyos</em> after sunset. This returns the time of 4 *
1544             * {@link #getShaahZmanis96MinutesZmanis()} after {@link #getAlos96Zmanis()
1545             * dawn}.
1546             * 
1547             * @return the <code>Date</code> of the latest zman shema. If the
1548             *         calculation can't be computed such as in the Arctic Circle where
1549             *         there is at least one day a year where the sun does not rise, and
1550             *         one where it does not set, a null will be returned. See detailed
1551             *         explanation on top of the {@link AstronomicalCalendar}
1552             *         documentation.
1553             * @see #getShaahZmanis90MinutesZmanis()
1554             * @see #getAlos90Zmanis()
1555             */
1556            public Date getSofZmanTfilaMGA96MinutesZmanis() {
1557                    return getTimeOffset(getAlos96Zmanis(),
1558                                    getShaahZmanis96MinutesZmanis() * 4);
1559            }
1560    
1561            /**
1562             * This method returns the latest <em>zman tfila</em> (time to say the
1563             * morning prayers) in the opinion of the <em>MG"A</em> based on
1564             * <em>alos</em> being {@link #getAlos120() 120} minutes before
1565             * {@link #getSunrise() sunrise}. This time is 4
1566             * <em>{@link #getShaahZmanis120Minutes() shaos zmaniyos}</em> (solar hours)
1567             * after {@link #getAlos120() dawn} based on the opinion of the
1568             * <em>MG"A</em> that the day is calculated from a {@link #getAlos120()
1569             * dawn} of 120 minutes before sunrise to {@link #getTzais120() nightfall}
1570             * of 120 minutes after sunset. This returns the time of 4 *
1571             * {@link #getShaahZmanis120Minutes()} after {@link #getAlos120() dawn}.
1572             * 
1573             * @return the <code>Date</code> of the latest zman shema. If the
1574             *         calculation can't be computed such as in the Arctic Circle where
1575             *         there is at least one day a year where the sun does not rise, and
1576             *         one where it does not set, a null will be returned. See detailed
1577             *         explanation on top of the {@link AstronomicalCalendar}
1578             *         documentation.
1579             * @see #getShaahZmanis120Minutes()
1580             * @see #getAlos120()
1581             */
1582            public Date getSofZmanTfilaMGA120Minutes() {
1583                    return getTimeOffset(getAlos120(), getShaahZmanis120Minutes() * 4);
1584            }
1585    
1586            /**
1587             * This method returns the latest <em>zman tfila</em> (time to say the
1588             * morning prayers) calculated as 2 hours befor
1589             * {@link ZmanimCalendar#getChatzos()}. This is based on the opinions that
1590             * calculate <em>sof zman krias shema</em> as
1591             * {@link #getSofZmanShma3HoursBeforeChatzos()}. This returns the time of 2
1592             * hours before {@link ZmanimCalendar#getChatzos()}.
1593             * 
1594             * @return the <code>Date</code> of the latest zman shema. If the
1595             *         calculation can't be computed such as in the Arctic Circle where
1596             *         there is at least one day a year where the sun does not rise, and
1597             *         one where it does not set, a null will be returned. See detailed
1598             *         explanation on top of the {@link AstronomicalCalendar}
1599             *         documentation.
1600             * @see ZmanimCalendar#getChatzos()
1601             * @see #getSofZmanShma3HoursBeforeChatzos()
1602             */
1603            public Date getSofZmanTfila2HoursBeforeChatzos() {
1604                    return getTimeOffset(getChatzos(), -120 * MINUTE_MILLIS);
1605            }
1606    
1607            /**
1608             * This method returns mincha gedola calculated as 30 minutes after
1609             * <em>{@link #getChatzos() chatzos}</em> and not 1/2 of a
1610             * <em>{@link #getShaahZmanisGra() shaah zmanis}</em> after
1611             * <em>{@link #getChatzos() chatzos}</em> as calculated by
1612             * {@link #getMinchaGedola}. Some use this time to delay the start of mincha
1613             * in the winter when 1/2 of a
1614             * <em>{@link #getShaahZmanisGra() shaah zmanis}</em> is less than 30
1615             * minutes. See {@link #getMinchaGedolaGreaterThan30()}for a conveniance
1616             * method that returns the later of the 2 calculations. One should not use
1617             * this time to start <em>mincha</em> before the standard
1618             * <em>{@link #getMinchaGedola() mincha gedola}</em>. See <em>Shulchan Aruch
1619             * Orach Chayim Siman Raish Lamed Gimel seif alef</em> and the
1620             * <em>Shaar Hatziyon seif katan ches</em>.
1621             * 
1622             * @return the <code>Date</code> of 30 mintes after <em>chatzos</em>. If the
1623             *         calculation can't be computed such as in the Arctic Circle where
1624             *         there is at least one day a year where the sun does not rise, and
1625             *         one where it does not set, a null will be returned. See detailed
1626             *         explanation on top of the {@link AstronomicalCalendar}
1627             *         documentation.
1628             * @see #getMinchaGedola()
1629             * @see #getMinchaGedolaGreaterThan30()
1630             */
1631            public Date getMinchaGedola30Minutes() {
1632                    return getTimeOffset(getChatzos(), MINUTE_MILLIS * 30);
1633            }
1634    
1635            /**
1636             * This method returns the time of <em>mincha gedola</em> according to the
1637             * Magen Avraham with the day starting 72 minutes before sunrise and ending
1638             * 72 minutes after sunset. This is the earliest time to pray
1639             * <em>mincha</em>. For more information on this see the documentation on
1640             * <em>{@link #getMinchaGedola() mincha gedola}</em>. This is calculated as
1641             * 6.5 {@link #getTemporalHour() solar hours} after alos. The calculation
1642             * used is 6.5 * {@link #getShaahZmanis72Minutes()} after
1643             * {@link #getAlos72() alos}.
1644             * 
1645             * @see #getAlos72()()
1646             * @see #getMinchaGedola()
1647             * @see #getMinchaKetana()
1648             * @see ZmanimCalendar#getMinchaGedola()
1649             * @return the <code>Date</code> of the time of mincha gedola. If the
1650             *         calculation can't be computed such as in the Arctic Circle where
1651             *         there is at least one day a year where the sun does not rise, and
1652             *         one where it does not set, a null will be returned. See detailed
1653             *         explanation on top of the {@link AstronomicalCalendar}
1654             *         documentation.
1655             */
1656            public Date getMinchaGedola72Minutes() {
1657                    return getTimeOffset(getAlos72(), getShaahZmanis72Minutes() * 6.5);
1658            }
1659    
1660            /**
1661             * This method returns the time of <em>mincha gedola</em> according to the
1662             * Magen Avraham with the day starting and ending 16.1&deg; below the
1663             * horizon. This is the earliest time to pray <em>mincha</em>. For more
1664             * information on this see the documentation on
1665             * <em>{@link #getMinchaGedola() mincha gedola}</em>. This is calculated as
1666             * 6.5 {@link #getTemporalHour() solar hours} after alos. The calculation
1667             * used is 6.5 * {@link #getShaahZmanis16Point1Degrees()} after
1668             * {@link #getAlos16Point1Degrees() alos}.
1669             * 
1670             * @see #getShaahZmanis16Point1Degrees()
1671             * @see #getMinchaGedola()
1672             * @see #getMinchaKetana()
1673             * @return the <code>Date</code> of the time of mincha gedola. If the
1674             *         calculation can't be computed such as northern and southern
1675             *         locations even south of the Arctic Circle and north of the
1676             *         Antarctic Circle where the sun may not reach low enough below the
1677             *         horizon for this calculation, a null will be returned. See
1678             *         detailed explanation on top of the {@link AstronomicalCalendar}
1679             *         documentation.
1680             */
1681            public Date getMinchaGedola16Point1Degrees() {
1682                    return getTimeOffset(getAlos16Point1Degrees(),
1683                                    getShaahZmanis16Point1Degrees() * 6.5);
1684            }
1685    
1686            /**
1687             * This is a conveniance methd that returns the later of
1688             * {@link #getMinchaGedola()} and {@link #getMinchaGedola30Minutes()}. In
1689             * the winter when a <em>{@link #getShaahZmanisGra() shaah zmanis}</em> is
1690             * less than 30 minutes {@link #getMinchaGedola30Minutes()} will be
1691             * returned, otherwise {@link #getMinchaGedola()} will be returned.
1692             * 
1693             * @return the <code>Date</code> of the later of {@link #getMinchaGedola()}
1694             *         and {@link #getMinchaGedola30Minutes()}. If the calculation can't
1695             *         be computed such as in the Arctic Circle where there is at least
1696             *         one day a year where the sun does not rise, and one where it does
1697             *         not set, a null will be returned. See detailed explanation on top
1698             *         of the {@link AstronomicalCalendar} documentation.
1699             */
1700            public Date getMinchaGedolaGreaterThan30() {
1701                    if (getMinchaGedola30Minutes() == null || getMinchaGedola() == null) {
1702                            return null;
1703                    } else {
1704                            return getMinchaGedola30Minutes().compareTo(getMinchaGedola()) > 0 ? getMinchaGedola30Minutes()
1705                                            : getMinchaGedola();
1706                    }
1707            }
1708    
1709            /**
1710             * This method returns the time of <em>mincha ketana</em> according to the
1711             * Magen Avraham with the day starting and ending 16.1&deg; below the
1712             * horizon. This is the perfered earliest time to pray <em>mincha</em> in
1713             * the opinion of the Ramba"m and others. For more information on this see
1714             * the documentation on <em>{@link #getMinchaGedola() mincha gedola}</em>.
1715             * This is calculated as 9.5 {@link #getTemporalHour() solar hours} after
1716             * alos. The calculation used is 9.5 *
1717             * {@link #getShaahZmanis16Point1Degrees()} after
1718             * {@link #getAlos16Point1Degrees() alos}.
1719             * 
1720             * @see #getShaahZmanis16Point1Degrees()
1721             * @see #getMinchaGedola()
1722             * @see #getMinchaKetana()
1723             * @return the <code>Date</code> of the time of mincha ketana. If the
1724             *         calculation can't be computed such as northern and southern
1725             *         locations even south of the Arctic Circle and north of the
1726             *         Antarctic Circle where the sun may not reach low enough below the
1727             *         horizon for this calculation, a null will be returned. See
1728             *         detailed explanation on top of the {@link AstronomicalCalendar}
1729             *         documentation.
1730             */
1731            public Date getMinchaKetana16Point1Degrees() {
1732                    return getTimeOffset(getAlos16Point1Degrees(),
1733                                    getShaahZmanis16Point1Degrees() * 9.5);
1734            }
1735    
1736            /**
1737             * This method returns the time of <em>mincha ketana</em> according to the
1738             * Magen Avraham with the day starting 72 minutes before sunrise and ending
1739             * 72 minutes after sunset. This is the perfered earliest time to pray
1740             * <em>mincha</em> in the opinion of the Ramba"m and others. For more
1741             * information on this see the documentation on
1742             * <em>{@link #getMinchaGedola() mincha gedola}</em>. This is calculated as
1743             * 9.5 {@link #getShaahZmanis72Minutes()} after alos. The calculation used
1744             * is 9.5 * {@link #getShaahZmanis72Minutes()} after {@link #getAlos72()
1745             * alos}.
1746             * 
1747             * @see #getShaahZmanis16Point1Degrees()
1748             * @see #getMinchaGedola()
1749             * @see #getMinchaKetana()
1750             * @return the <code>Date</code> of the time of mincha ketana. If the
1751             *         calculation can't be computed such as in the Arctic Circle where
1752             *         there is at least one day a year where the sun does not rise, and
1753             *         one where it does not set, a null will be returned. See detailed
1754             *         explanation on top of the {@link AstronomicalCalendar}
1755             *         documentation.
1756             */
1757            public Date getMinchaKetana72Minutes() {
1758                    return getTimeOffset(getAlos72(), getShaahZmanis72Minutes() * 9.5);
1759            }
1760    
1761            /**
1762             * This method returns the time of <em>plag hamincha</em>. This is
1763             * calculated as 10.75 hours after {@link #getAlos60() dawn}. The formula
1764             * used is:<br/>
1765             * 10.75 {@link #getShaahZmanis60Minutes()} after {@link #getAlos60()}.
1766             * 
1767             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1768             *         the calculation can't be computed such as in the Arctic Circle
1769             *         where there is at least one day a year where the sun does not
1770             *         rise, and one where it does not set, a null will be returned. See
1771             *         detailed explanation on top of the {@link AstronomicalCalendar}
1772             *         documentation.
1773             */
1774            public Date getPlagHamincha60Minutes() {
1775                    return getTimeOffset(getAlos60(), getShaahZmanis60Minutes() * 10.75);
1776            }
1777    
1778            /**
1779             * This method returns the time of <em>plag hamincha</em>. This is
1780             * calculated as 10.75 hours after {@link #getAlos72() dawn}. The formula
1781             * used is:<br/>
1782             * 10.75 {@link #getShaahZmanis72Minutes()} after {@link #getAlos72()}.
1783             * 
1784             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1785             *         the calculation can't be computed such as in the Arctic Circle
1786             *         where there is at least one day a year where the sun does not
1787             *         rise, and one where it does not set, a null will be returned. See
1788             *         detailed explanation on top of the {@link AstronomicalCalendar}
1789             *         documentation.
1790             */
1791            public Date getPlagHamincha72Minutes() {
1792                    return getTimeOffset(getAlos72(), getShaahZmanis72Minutes() * 10.75);
1793            }
1794    
1795            /**
1796             * This method returns the time of <em>plag hamincha</em>. This is
1797             * calculated as 10.75 hours after {@link #getAlos90() dawn}. The formula
1798             * used is:<br/>
1799             * 10.75 {@link #getShaahZmanis90Minutes()} after {@link #getAlos90()}.
1800             * 
1801             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1802             *         the calculation can't be computed such as in the Arctic Circle
1803             *         where there is at least one day a year where the sun does not
1804             *         rise, and one where it does not set, a null will be returned. See
1805             *         detailed explanation on top of the {@link AstronomicalCalendar}
1806             *         documentation.
1807             */
1808            public Date getPlagHamincha90Minutes() {
1809                    return getTimeOffset(getAlos90(), getShaahZmanis90Minutes() * 10.75);
1810            }
1811    
1812            /**
1813             * This method returns the time of <em>plag hamincha</em>. This is
1814             * calculated as 10.75 hours after {@link #getAlos96() dawn}. The formula
1815             * used is:<br/>
1816             * 10.75 {@link #getShaahZmanis96Minutes()} after {@link #getAlos96()}.
1817             * 
1818             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1819             *         the calculation can't be computed such as in the Arctic Circle
1820             *         where there is at least one day a year where the sun does not
1821             *         rise, and one where it does not set, a null will be returned. See
1822             *         detailed explanation on top of the {@link AstronomicalCalendar}
1823             *         documentation.
1824             */
1825            public Date getPlagHamincha96Minutes() {
1826                    return getTimeOffset(getAlos96(), getShaahZmanis96Minutes() * 10.75);
1827            }
1828    
1829            /**
1830             * This method returns the time of <em>plag hamincha</em>. This is
1831             * calculated as 10.75 hours after {@link #getAlos96Zmanis() dawn}. The
1832             * formula used is:<br/>
1833             * 10.75 * {@link #getShaahZmanis96MinutesZmanis()} after
1834             * {@link #getAlos96Zmanis() dawn}.
1835             * 
1836             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1837             *         the calculation can't be computed such as in the Arctic Circle
1838             *         where there is at least one day a year where the sun does not
1839             *         rise, and one where it does not set, a null will be returned. See
1840             *         detailed explanation on top of the {@link AstronomicalCalendar}
1841             *         documentation.
1842             */
1843            public Date getPlagHamincha96MinutesZmanis() {
1844                    return getTimeOffset(getAlos96Zmanis(),
1845                                    getShaahZmanis96MinutesZmanis() * 10.75);
1846            }
1847    
1848            /**
1849             * This method returns the time of <em>plag hamincha</em>. This is
1850             * calculated as 10.75 hours after {@link #getAlos90Zmanis() dawn}. The
1851             * formula used is:<br/>
1852             * 10.75 * {@link #getShaahZmanis90MinutesZmanis()} after
1853             * {@link #getAlos90Zmanis() dawn}.
1854             * 
1855             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1856             *         the calculation can't be computed such as in the Arctic Circle
1857             *         where there is at least one day a year where the sun does not
1858             *         rise, and one where it does not set, a null will be returned. See
1859             *         detailed explanation on top of the {@link AstronomicalCalendar}
1860             *         documentation.
1861             */
1862            public Date getPlagHamincha90MinutesZmanis() {
1863                    return getTimeOffset(getAlos90Zmanis(),
1864                                    getShaahZmanis90MinutesZmanis() * 10.75);
1865            }
1866    
1867            /**
1868             * This method returns the time of <em>plag hamincha</em>. This is
1869             * calculated as 10.75 hours after {@link #getAlos72Zmanis() dawn}. The
1870             * formula used is:<br/>
1871             * 10.75 * {@link #getShaahZmanis72MinutesZmanis()} after
1872             * {@link #getAlos72Zmanis() dawn}.
1873             * 
1874             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1875             *         the calculation can't be computed such as in the Arctic Circle
1876             *         where there is at least one day a year where the sun does not
1877             *         rise, and one where it does not set, a null will be returned. See
1878             *         detailed explanation on top of the {@link AstronomicalCalendar}
1879             *         documentation.
1880             */
1881            public Date getPlagHamincha72MinutesZmanis() {
1882                    return getTimeOffset(getAlos72Zmanis(),
1883                                    getShaahZmanis72MinutesZmanis() * 10.75);
1884            }
1885    
1886            /**
1887             * This method returns the time of <em>plag hamincha</em> based on the
1888             * opinion that the day starts at
1889             * <em>{@link #getAlos16Point1Degrees() alos 16.1&deg;}</em> and ends at
1890             * <em>{@link #getTzais16Point1Degrees() tzais 16.1&deg;}</em>. This is
1891             * calculated as 10.75 hours <em>zmaniyos</em> after
1892             * {@link #getAlos16Point1Degrees() dawn}. The formula is<br/>
1893             * 10.75 * {@link #getShaahZmanis16Point1Degrees()} after
1894             * {@link #getAlos16Point1Degrees()}.
1895             * 
1896             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1897             *         the calculation can't be computed such as northern and southern
1898             *         locations even south of the Arctic Circle and north of the
1899             *         Antarctic Circle where the sun may not reach low enough below the
1900             *         horizon for this calculation, a null will be returned. See
1901             *         detailed explanation on top of the {@link AstronomicalCalendar}
1902             *         documentation.
1903             */
1904            public Date getPlagHamincha16Point1Degrees() {
1905                    return getTimeOffset(getAlos16Point1Degrees(),
1906                                    getShaahZmanis16Point1Degrees() * 10.75);
1907            }
1908    
1909            /**
1910             * This method returns the time of <em>plag hamincha</em> based on the
1911             * opinion that the day starts at
1912             * <em>{@link #getAlos19Point8Degrees() alos 19.8&deg;}</em> and ends at
1913             * <em>{@link #getTzais19Point8Degrees() tzais 19.8&deg;}</em>. This is
1914             * calculated as 10.75 hours <em>zmaniyos</em> after
1915             * {@link #getAlos19Point8Degrees() dawn}. The formula is<br/>
1916             * 10.75 * {@link #getShaahZmanis19Point8Degrees()} after
1917             * {@link #getAlos19Point8Degrees()}.
1918             * 
1919             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1920             *         the calculation can't be computed such as northern and southern
1921             *         locations even south of the Arctic Circle and north of the
1922             *         Antarctic Circle where the sun may not reach low enough below the
1923             *         horizon for this calculation, a null will be returned. See
1924             *         detailed explanation on top of the {@link AstronomicalCalendar}
1925             *         documentation.
1926             */
1927            public Date getPlagHamincha19Point8Degrees() {
1928                    return getTimeOffset(getAlos19Point8Degrees(),
1929                                    getShaahZmanis19Point8Degrees() * 10.75);
1930            }
1931    
1932            /**
1933             * This method returns the time of <em>plag hamincha</em> based on the
1934             * opinion that the day starts at
1935             * <em>{@link #getAlos26Degrees() alos 26&deg;}</em> and ends at
1936             * <em>{@link #getTzais26Degrees() tzais 26&deg;}</em>. This is calculated
1937             * as 10.75 hours <em>zmaniyos</em> after {@link #getAlos26Degrees() dawn}.
1938             * The formula is<br/>
1939             * 10.75 * {@link #getShaahZmanis26Degrees()} after
1940             * {@link #getAlos26Degrees()}.
1941             * 
1942             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1943             *         the calculation can't be computed such as northern and southern
1944             *         locations even south of the Arctic Circle and north of the
1945             *         Antarctic Circle where the sun may not reach low enough below the
1946             *         horizon for this calculation, a null will be returned. See
1947             *         detailed explanation on top of the {@link AstronomicalCalendar}
1948             *         documentation.
1949             */
1950            public Date getPlagHamincha26Degrees() {
1951                    return getTimeOffset(getAlos26Degrees(),
1952                                    getShaahZmanis26Degrees() * 10.75);
1953            }
1954    
1955            /**
1956             * This method returns the time of <em>plag hamincha</em> based on the
1957             * opinion that the day starts at
1958             * <em>{@link #getAlos18Degrees() alos 18&deg;}</em> and ends at
1959             * <em>{@link #getTzais18Degrees() tzais 18&deg;}</em>. This is calculated
1960             * as 10.75 hours <em>zmaniyos</em> after {@link #getAlos18Degrees() dawn}.
1961             * The formula is<br/>
1962             * 10.75 * {@link #getShaahZmanis18Degrees()} after
1963             * {@link #getAlos18Degrees()}.
1964             * 
1965             * @return the <code>Date</code> of the time of <em>plag hamincha</em>. If
1966             *         the calculation can't be computed such as northern and southern
1967             *         locations even south of the Arctic Circle and north of the
1968             *         Antarctic Circle where the sun may not reach low enough below the
1969             *         horizon for this calculation, a null will be returned. See
1970             *         detailed explanation on top of the {@link AstronomicalCalendar}
1971             *         documentation.
1972             */
1973            public Date getPlagHamincha18Degrees() {
1974                    return getTimeOffset(getAlos18Degrees(),
1975                                    getShaahZmanis18Degrees() * 10.75);
1976            }
1977    
1978            /**
1979             * This method returns the time of <em>plag hamincha</em> based on the
1980             * opinion that the day starts at
1981             * <em>{@link #getAlos16Point1Degrees() alos 16.1&deg;}</em> and ends at
1982             * {@link #getSunset() sunset}. 10.75 shaos zmaniyos are calculated based on
1983             * this day and added to {@link #getAlos16Point1Degrees() alos} to reach
1984             * this time. This time is 10.75 <em>shaos zmaniyos</em> (temporal hours)
1985             * after {@link #getAlos16Point1Degrees() dawn} based on the opinion that
1986             * the day is calculated from a {@link #getAlos16Point1Degrees() dawn} of
1987             * 16.1 degrees before sunrise to {@link #getSeaLevelSunset() sea level
1988             * sunset}. This returns the time of 10.75 * the calculated
1989             * <em>shaah zmanis</em> after {@link #getAlos16Point1Degrees() dawn}.
1990             * 
1991             * @return the <code>Date</code> of the plag. If the calculation can't be
1992             *         computed such as northern and southern locations even south of
1993             *         the Arctic Circle and north of the Antarctic Circle where the sun
1994             *         may not reach low enough below the horizon for this calculation,
1995             *         a null will be returned. See detailed explanation on top of the
1996             *         {@link AstronomicalCalendar} documentation.
1997             * @see #getAlos16Point1Degrees()
1998             * @see #getSeaLevelSunset()
1999             */
2000            public Date getPlagAlosToSunset() {
2001                    long shaahZmanis = getTemporalHour(getAlos16Point1Degrees(),
2002                                    getSeaLevelSunset());
2003                    return getTimeOffset(getAlos16Point1Degrees(), shaahZmanis * 10.75);
2004            }
2005    
2006            /**
2007             * This method returns the time of <em>plag hamincha</em> based on the
2008             * opinion that the day starts at
2009             * <em>{@link #getAlos16Point1Degrees() alos 16.1&deg;}</em> and ends at
2010             * {@link #getTzaisGeonim7Point083Degrees() tzais}. 10.75 shaos zmaniyos are
2011             * calculated based on this day and added to
2012             * {@link #getAlos16Point1Degrees() alos} to reach this time. This time is
2013             * 10.75 <em>shaos zmaniyos</em> (temporal hours) after
2014             * {@link #getAlos16Point1Degrees() dawn} based on the opinion that the day
2015             * is calculated from a {@link #getAlos16Point1Degrees() dawn} of 16.1
2016             * degrees before sunrise to {@link #getTzaisGeonim7Point083Degrees() tzais}
2017             * . This returns the time of 10.75 * the calculated <em>shaah zmanis</em>
2018             * after {@link #getAlos16Point1Degrees() dawn}.
2019             * 
2020             * @return the <code>Date</code> of the plag. If the calculation can't be
2021             *         computed such as northern and southern locations even south of
2022             *         the Arctic Circle and north of the Antarctic Circle where the sun
2023             *         may not reach low enough below the horizon for this calculation,
2024             *         a null will be returned. See detailed explanation on top of the
2025             *         {@link AstronomicalCalendar} documentation.
2026             * @see #getAlos16Point1Degrees()
2027             * @see #getTzaisGeonim7Point083Degrees()
2028             */
2029            public Date getPlagAlos16Point1ToTzaisGeonim7Point083Degrees() {
2030                    long shaahZmanis = getTemporalHour(getAlos16Point1Degrees(),
2031                                    getTzaisGeonim7Point083Degrees());
2032                    return getTimeOffset(getAlos16Point1Degrees(), shaahZmanis * 10.75);
2033            }
2034    
2035            /**
2036             * This method returns Bain Hashmashos of Rabainu Tam calculated as the time
2037             * the sun is 13&deg; below {@link #GEOMETRIC_ZENITH geometric zenith}
2038             * (90&deg;). <br/>
2039             * <br/>
2040             * <b>FIXME:</b> As per Yisroel Vehazmanim Vol III page 1028 No 50, the
2041             * 13&deg; is slightly inaccurate. He lists it as a drop less than 13&deg;.
2042             * Calculations show that is seems to be 13.2477&deg; below the horizon at
2043             * that time. This makes a difference of 1 minute and 10 seconds in
2044             * Jerusalem in the Equinox, and 1 minute 29 seconds in the solstice. for NY
2045             * in the solstice, the difference is 1 minute 56 seconds.
2046             * 
2047             * @return the <code>Date</code> of the sun being 13&deg; below
2048             *         {@link #GEOMETRIC_ZENITH geometric zenith} (90&deg;). If the
2049             *         calculation can't be computed such as northern and southern
2050             *         locations even south of the Arctic Circle and north of the
2051             *         Antarctic Circle where the sun may not reach low enough below the
2052             *         horizon for this calculation, a null will be returned. See
2053             *         detailed explanation on top of the {@link AstronomicalCalendar}
2054             *         documentation.
2055             * @see #ZENITH_13_DEGREES
2056             * 
2057             */
2058            public Date getBainHasmashosRT13Degrees() {
2059                    return getSunsetOffsetByDegrees(ZENITH_13_DEGREES);
2060            }
2061    
2062            /**
2063             * This method returns Bain Hashmashos of Rabainu Tam calculated as a 58.5
2064             * minute offset after sunset. Bain hashmashos is 3/4 of a mil before tzais
2065             * or 3 1/4 mil after sunset. With a mil calculated as 18 minutes, 3.25 * 18
2066             * = 58.5 minutes.
2067             * 
2068             * @return the <code>Date</code> of 58.5 minutes after sunset. If the
2069             *         calculation can't be computed such as in the Arctic Circle where
2070             *         there is at least one day a year where the sun does not rise, and
2071             *         one where it does not set, a null will be returned. See detailed
2072             *         explanation on top of the {@link AstronomicalCalendar}
2073             *         documentation.
2074             * 
2075             */
2076            public Date getBainHasmashosRT58Point5Minutes() {
2077                    return getTimeOffset(getSeaLevelSunset(), 58.5 * MINUTE_MILLIS);
2078            }
2079    
2080            /**
2081             * This method returns the time of <em>bain hashmashos</em> based on the
2082             * calculation of 13.5 minutes (3/4 of an 18 minute mil before shkiah
2083             * calculated as {@link #getTzaisGeonim7Point083Degrees() 7.083&deg;}.
2084             * 
2085             * @return the <code>Date</code> of the bain hashmashos of Rabainu Tam in
2086             *         this calculation. If the calculation can't be computed such as
2087             *         northern and southern locations even south of the Arctic Circle
2088             *         and north of the Antarctic Circle where the sun may not reach low
2089             *         enough below the horizon for this calculation, a null will be
2090             *         returned. See detailed explanation on top of the
2091             *         {@link AstronomicalCalendar} documentation.
2092             * @see #getTzaisGeonim7Point083Degrees()
2093             */
2094            public Date getBainHasmashosRT13Point5MinutesBefore7Point083Degrees() {
2095                    return getTimeOffset(getSunsetOffsetByDegrees(ZENITH_7_POINT_083),
2096                                    -13.5 * MINUTE_MILLIS);
2097            }
2098    
2099            /**
2100             * This method returns <em>bain hashmashos</em> of Rabainu Tam calculated in
2101             * the opinion of the Divray Yosef (see Yisrael Vehazmanim) calculated
2102             * 5/18th (27.77%) of the time between alos (calculated as 19.8&deg; before
2103             * sunrise) and sunrise. This is added to sunset to arrive at the time for
2104             * bain hashmashos of Rabainu Tam).
2105             * 
2106             * @return the <code>Date</code> of bain hashmashos of Rabainu Tam for this
2107             *         calculation. If the calculation can't be computed such as
2108             *         northern and southern locations even south of the Arctic Circle
2109             *         and north of the Antarctic Circle where the sun may not reach low
2110             *         enough below the horizon for this calculation, a null will be
2111             *         returned. See detailed explanation on top of the
2112             *         {@link AstronomicalCalendar} documentation.
2113             */
2114            public Date getBainHasmashosRT2Stars() {
2115                    Date alos19Point8 = getAlos19Point8Degrees();
2116                    Date sunrise = getSeaLevelSunrise();
2117                    if (alos19Point8 == null || sunrise == null) {
2118                            return null;
2119                    }
2120                    return getTimeOffset(getSeaLevelSunset(),
2121                                    (sunrise.getTime() - alos19Point8.getTime()) * (5 / 18d));
2122            }
2123    
2124            /**
2125             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2126             * of the <em>Geonim</em> calculated at the sun's position at
2127             * {@link #ZENITH_5_POINT_95 5.95&deg;} below the western horizon.
2128             * 
2129             * @return the <code>Date</code> representing the time when the sun is
2130             *         5.95&deg; below sea level.
2131             * @see #ZENITH_5_POINT_95
2132             */
2133            // public Date getTzaisGeonim3Point7Degrees() {
2134            // return getSunsetOffsetByDegrees(ZENITH_3_POINT_7);
2135            // }
2136            /**
2137             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2138             * of the <em>Geonim</em> calculated at the sun's position at
2139             * {@link #ZENITH_5_POINT_95 5.95&deg;} below the western horizon.
2140             * 
2141             * @return the <code>Date</code> representing the time when the sun is
2142             *         5.95&deg; below sea level. If the calculation can't be computed
2143             *         such as northern and southern locations even south of the Arctic
2144             *         Circle and north of the Antarctic Circle where the sun may not
2145             *         reach low enough below the horizon for this calculation, a null
2146             *         will be returned. See detailed explanation on top of the
2147             *         {@link AstronomicalCalendar} documentation.
2148             * @see #ZENITH_5_POINT_95
2149             */
2150            public Date getTzaisGeonim5Point95Degrees() {
2151                    return getSunsetOffsetByDegrees(ZENITH_5_POINT_95);
2152            }
2153    
2154            /**
2155             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2156             * of the <em>Geonim</em> calculated calculated as 3/4 of a <a href=
2157             * "http://en.wikipedia.org/wiki/Biblical_and_Talmudic_units_of_measurement"
2158             * >Mil</a> based on an 18 minute Mil, or 13.5 minutes. It is the sun's
2159             * position at {@link #ZENITH_3_POINT_65 3.65&deg;} below the western
2160             * horizon. This is a very early zman and should not be relied on without
2161             * Rabbinical guidance.
2162             * 
2163             * @return the <code>Date</code> representing the time when the sun is
2164             *         3.65&deg; below sea level. If the calculation can't be computed
2165             *         such as northern and southern locations even south of the Arctic
2166             *         Circle and north of the Antarctic Circle where the sun may not
2167             *         reach low enough below the horizon for this calculation, a null
2168             *         will be returned. See detailed explanation on top of the
2169             *         {@link AstronomicalCalendar} documentation.
2170             * @see #ZENITH_3_POINT_65
2171             */
2172            public Date getTzaisGeonim3Point65Degrees() {
2173                    return getSunsetOffsetByDegrees(ComplexZmanimCalendar.ZENITH_3_POINT_65);
2174            }
2175    
2176            /**
2177             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2178             * of the <em>Geonim</em> calculated as 3/4 of a <a href=
2179             * "http://en.wikipedia.org/wiki/Biblical_and_Talmudic_units_of_measurement"
2180             * >Mil</a> based on a 24 minute Mil, or 18 minutes. It is the sun's
2181             * position at {@link #ZENITH_4_POINT_61 4.61&deg;} below the western
2182             * horizon. This is a very early zman and should not be relied on without
2183             * Rabbinical guidance.
2184             * 
2185             * @return the <code>Date</code> representing the time when the sun is
2186             *         4.61&deg; below sea level. If the calculation can't be computed
2187             *         such as northern and southern locations even south of the Arctic
2188             *         Circle and north of the Antarctic Circle where the sun may not
2189             *         reach low enough below the horizon for this calculation, a null
2190             *         will be returned. See detailed explanation on top of the
2191             *         {@link AstronomicalCalendar} documentation.
2192             * @see #ZENITH_4_POINT_61
2193             */
2194            public Date getTzaisGeonim4Point61Degrees() {
2195                    return getSunsetOffsetByDegrees(ComplexZmanimCalendar.ZENITH_4_POINT_61);
2196            }
2197    
2198            /**
2199             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2200             * of the <em>Geonim</em> calculated as 3/4 of a <a href=
2201             * "http://en.wikipedia.org/wiki/Biblical_and_Talmudic_units_of_measurement"
2202             * >Mil</a>, based on a 22.5 minute Mil, or 16 7/8 minutes. It is the sun's
2203             * position at {@link #ZENITH_4_POINT_37 4.37&deg;} below the western
2204             * horizon. This is a very early zman and should not be relied on without
2205             * Rabbinical guidance.
2206             * 
2207             * @return the <code>Date</code> representing the time when the sun is
2208             *         4.37&deg; below sea level. If the calculation can't be computed
2209             *         such as northern and southern locations even south of the Arctic
2210             *         Circle and north of the Antarctic Circle where the sun may not
2211             *         reach low enough below the horizon for this calculation, a null
2212             *         will be returned. See detailed explanation on top of the
2213             *         {@link AstronomicalCalendar} documentation.
2214             * @see #ZENITH_4_POINT_37
2215             */
2216            public Date getTzaisGeonim4Point37Degrees() {
2217                    return getSunsetOffsetByDegrees(ComplexZmanimCalendar.ZENITH_4_POINT_37);
2218            }
2219    
2220            /**
2221             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2222             * of the <em>Geonim</em> calculated as 3/4 of a <a href=
2223             * "http://en.wikipedia.org/wiki/Biblical_and_Talmudic_units_of_measurement"
2224             * >Mil</a>. It is based on the Baal Hatanya based on a Mil being 24
2225             * minutes, and is calculated as 18 +2 + 4 for a total of 24 minutes (FIXME:
2226             * additional details needed). It is the sun's position at
2227             * {@link #ZENITH_5_POINT_88 5.88&deg;} below the western horizon. This is a
2228             * very early zman and should not be relied on without Rabbinical guidance.
2229             * 
2230             * @return the <code>Date</code> representing the time when the sun is
2231             *         5.88&deg; below sea level. If the calculation can't be computed
2232             *         such as northern and southern locations even south of the Arctic
2233             *         Circle and north of the Antarctic Circle where the sun may not
2234             *         reach low enough below the horizon for this calculation, a null
2235             *         will be returned. See detailed explanation on top of the
2236             *         {@link AstronomicalCalendar} documentation.
2237             * @see #ZENITH_5_POINT_88
2238             */
2239            public Date getTzaisGeonim5Point88Degrees() {
2240                    return getSunsetOffsetByDegrees(ComplexZmanimCalendar.ZENITH_5_POINT_88);
2241            }
2242    
2243            /**
2244             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2245             * of the <em>Geonim</em> calculated as 3/4 of a <a href=
2246             * "http://en.wikipedia.org/wiki/Biblical_and_Talmudic_units_of_measurement"
2247             * >Mil</a>. It is the sun's position at {@link #ZENITH_4_POINT_8 4.8&deg;}
2248             * below the western horizon based on Rabbi Leo Levi's calculations. (FIXME:
2249             * additional documentation needed) This is the This is a very early zman
2250             * and should not be relied on without Rabbinical guidance.
2251             * 
2252             * @return the <code>Date</code> representing the time when the sun is
2253             *         4.8&deg; below sea level. If the calculation can't be computed
2254             *         such as northern and southern locations even south of the Arctic
2255             *         Circle and north of the Antarctic Circle where the sun may not
2256             *         reach low enough below the horizon for this calculation, a null
2257             *         will be returned. See detailed explanation on top of the
2258             *         {@link AstronomicalCalendar} documentation.
2259             * @see #ZENITH_4_POINT_8
2260             */
2261            public Date getTzaisGeonim4Point8Degrees() {
2262                    return getSunsetOffsetByDegrees(ComplexZmanimCalendar.ZENITH_4_POINT_8);
2263            }
2264    
2265            /**
2266             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2267             * of the <em>Geonim</em> calculated at the sun's position at
2268             * {@link #ZENITH_7_POINT_083 7.083&deg;} below the western horizon.
2269             * 
2270             * @return the <code>Date</code> representing the time when the sun is
2271             *         7.083&deg; below sea level. If the calculation can't be computed
2272             *         such as northern and southern locations even south of the Arctic
2273             *         Circle and north of the Antarctic Circle where the sun may not
2274             *         reach low enough below the horizon for this calculation, a null
2275             *         will be returned. See detailed explanation on top of the
2276             *         {@link AstronomicalCalendar} documentation.
2277             * @see #ZENITH_7_POINT_083
2278             */
2279            public Date getTzaisGeonim7Point083Degrees() {
2280                    return getSunsetOffsetByDegrees(ZENITH_7_POINT_083);
2281            }
2282    
2283            /**
2284             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2285             * of the <em>Geonim</em> calculated at the sun's position at
2286             * {@link #ZENITH_8_POINT_5 8.5&deg;} below the western horizon.
2287             * 
2288             * @return the <code>Date</code> representing the time when the sun is
2289             *         8.5&deg; below sea level. If the calculation can't be computed
2290             *         such as northern and southern locations even south of the Arctic
2291             *         Circle and north of the Antarctic Circle where the sun may not
2292             *         reach low enough below the horizon for this calculation, a null
2293             *         will be returned. See detailed explanation on top of the
2294             *         {@link AstronomicalCalendar} documentation.
2295             * @see #ZENITH_8_POINT_5
2296             */
2297            public Date getTzaisGeonim8Point5Degrees() {
2298                    return getSunsetOffsetByDegrees(ZENITH_8_POINT_5);
2299            }
2300    
2301            /**
2302             * This method returns the <em>tzais</em> (nightfall) based on the opinion
2303             * of the Chavas Yair and Divray Malkiel that the time to walk the distance
2304             * of a Mil is 15 minutes for a total of 60 minutes for 4 mil after
2305             * {@link #getSeaLevelSunset() sea level sunset}.
2306             * 
2307             * @return the <code>Date</code> representing 60 minutes after sea level
2308             *         sunset. If the calculation can't be computed such as in the
2309             *         Arctic Circle where there is at least one day a year where the
2310             *         sun does not rise, and one where it does not set, a null will be
2311             *         returned. See detailed explanation on top of the
2312             *         {@link AstronomicalCalendar} documentation.
2313             * @see #getAlos60()
2314             */
2315            public Date getTzais60() {
2316                    return getTimeOffset(getSeaLevelSunset(), 60 * MINUTE_MILLIS);
2317            }
2318    
2319            /**
2320             * This method returns tzais usually calculated as 40 minutes after sunset.
2321             * Please note that Chacham Yosef Harari-Raful of Yeshivat Ateret Torah who
2322             * uses this time, does so only for calculating various other zmanai hayom
2323             * such as Sof Zman Krias Shema and Plag Hamincha. His calendars do not
2324             * publish a zman for Tzais. It should also be noted that Chacham
2325             * Harari-Raful provided a 25 minute zman for Israel. This API uses 40
2326             * minutes year round in any place on the globe by default. This offset can
2327             * be changed by calling {@link #setAteretTorahSunsetOffset(double)}.
2328             * 
2329             * @return the <code>Date</code> representing 40 minutes (setable via
2330             *         {@link #setAteretTorahSunsetOffset}) after sea level sunset. If
2331             *         the calculation can't be computed such as in the Arctic Circle
2332             *         where there is at least one day a year where the sun does not
2333             *         rise, and one where it does not set, a null will be returned. See
2334             *         detailed explanation on top of the {@link AstronomicalCalendar}
2335             *         documentation.
2336             * @see #getAteretTorahSunsetOffset()
2337             * @see #setAteretTorahSunsetOffset(double)
2338             */
2339            public Date getTzaisAteretTorah() {
2340                    return getTimeOffset(getSeaLevelSunset(), getAteretTorahSunsetOffset()
2341                                    * MINUTE_MILLIS);
2342            }
2343    
2344            /**
2345             * Returns the offset in minutes after sunset used to calculate
2346             * <em>tzais</em> for the Ateret Torah zmanim. The defaullt value is 40
2347             * minutes.
2348             * 
2349             * @return the number of minutes after sunset for Tzais.
2350             * @see #setAteretTorahSunsetOffset(double)
2351             */
2352            public double getAteretTorahSunsetOffset() {
2353                    return this.ateretTorahSunsetOffset;
2354            }
2355    
2356            /**
2357             * Allows setting the offset in minutes after sunset for the Ateret Torah
2358             * zmanim. The default if unset is 40 minutes. Chacham Yosef Harari-Raful of
2359             * Yeshivat Ateret Torah uses 40 minutes globally with the exception of
2360             * Israel where a 25 minute offset is used. This 25 minute (or any other)
2361             * offset can be overridden by this methd. This offset impacts all Ateret
2362             * Torah methods.
2363             * 
2364             * @param ateretTorahSunsetOffset
2365             *            the number of minutes after sunset to use as an offset for the
2366             *            Ateret Torah <em>tzais</em>
2367             * @see #getAteretTorahSunsetOffset()
2368             */
2369            public void setAteretTorahSunsetOffset(double ateretTorahSunsetOffset) {
2370                    this.ateretTorahSunsetOffset = ateretTorahSunsetOffset;
2371            }
2372    
2373            /**
2374             * This method returns the latest <em>zman krias shema</em> (time to say
2375             * Shema in the morning) based on the calculation of Chacham Yosef
2376             * Harari-Raful of Yeshivat Ateret Torah, that the day starts
2377             * {@link #getAlos72Zmanis() 1/10th of the day} before sunrise and is
2378             * usually calculated as ending {@link #getTzaisAteretTorah() 40 minutes
2379             * after sunset}. <em>shaos zmaniyos</em> are calculated based on this day
2380             * and added to {@link #getAlos72Zmanis() alos} to reach this time. This
2381             * time is 3 <em> {@link #getShaahZmanisAteretTorah() shaos zmaniyos}</em>
2382             * (temporal hours) after {@link #getAlos72Zmanis() alos 72 zmaniyos}.<br />
2383             * <b>Note: </b> Based on this calculation <em>chatzos</em> will not be at
2384             * midday.
2385             * 
2386             * @return the <code>Date</code> of the latest zman shema based on this
2387             *         calculation. If the calculation can't be computed such as in the
2388             *         Arctic Circle where there is at least one day a year where the
2389             *         sun does not rise, and one where it does not set, a null will be
2390             *         returned. See detailed explanation on top of the
2391             *         {@link AstronomicalCalendar} documentation.
2392             * @see #getAlos72Zmanis()
2393             * @see #getTzaisAteretTorah()
2394             * @see #getAteretTorahSunsetOffset()
2395             * @see #setAteretTorahSunsetOffset(double)
2396             * @see #getShaahZmanisAteretTorah()
2397             */
2398            public Date getSofZmanShmaAteretTorah() {
2399                    return getTimeOffset(getAlos72Zmanis(), getShaahZmanisAteretTorah() * 3);
2400            }
2401    
2402            /**
2403             * This method returns the latest <em>zman tfila</em> (time to say the
2404             * morning prayers) based on the calculation of Chacham Yosef Harari-Raful
2405             * of Yeshivat Ateret Torah, that the day starts {@link #getAlos72Zmanis()
2406             * 1/10th of the day} before sunrise and and is usually calculated as ending
2407             * {@link #getTzaisAteretTorah() 40 minutes after sunset}.
2408             * <em>shaos zmaniyos</em> are calculated based on this day and added to
2409             * {@link #getAlos72Zmanis() alos} to reach this time. This time is 4
2410             * <em>{@link #getShaahZmanisAteretTorah() shaos zmaniyos}</em> (temporal
2411             * hours) after {@link #getAlos72Zmanis() alos 72 zmaniyos}.<br />
2412             * <b>Note: </b> Based on this calculation <em>chatzos</em> will not be at
2413             * midday.
2414             * 
2415             * @return the <code>Date</code> of the latest zman shema based on this
2416             *         calculation. If the calculation can't be computed such as in the
2417             *         Arctic Circle where there is at least one day a year where the
2418             *         sun does not rise, and one where it does not set, a null will be
2419             *         returned. See detailed explanation on top of the
2420             *         {@link AstronomicalCalendar} documentation.
2421             * @see #getAlos72Zmanis()
2422             * @see #getTzaisAteretTorah()
2423             * @see #getShaahZmanisAteretTorah()
2424             * @see #setAteretTorahSunsetOffset(double)
2425             */
2426            public Date getSofZmanTfilahAteretTorah() {
2427                    return getTimeOffset(getAlos72Zmanis(), getShaahZmanisAteretTorah() * 4);
2428            }
2429    
2430            /**
2431             * This method returns the time of <em>mincha gedola</em> based on the
2432             * calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that
2433             * the day starts {@link #getAlos72Zmanis() 1/10th of the day} before
2434             * sunrise and and is usually calculated as ending
2435             * {@link #getTzaisAteretTorah() 40 minutes after sunset}. This is the
2436             * perfered earliest time to pray <em>mincha</em> in the opinion of the
2437             * Ramba"m and others. For more information on this see the documentation on
2438             * <em>{@link #getMinchaGedola() mincha gedola}</em>. This is calculated as
2439             * 6.5 {@link #getShaahZmanisAteretTorah() solar hours} after alos. The
2440             * calculation used is 6.5 * {@link #getShaahZmanisAteretTorah()} after
2441             * {@link #getAlos72Zmanis() alos}.
2442             * 
2443             * @see #getAlos72Zmanis()
2444             * @see #getTzaisAteretTorah()
2445             * @see #getShaahZmanisAteretTorah()
2446             * @see #getMinchaGedola()
2447             * @see #getMinchaKetanaAteretTorah()
2448             * @see ZmanimCalendar#getMinchaGedola()
2449             * @return the <code>Date</code> of the time of mincha gedola. If the
2450             *         calculation can't be computed such as in the Arctic Circle where
2451             *         there is at least one day a year where the sun does not rise, and
2452             *         one where it does not set, a null will be returned. See detailed
2453             *         explanation on top of the {@link AstronomicalCalendar}
2454             *         documentation.
2455             */
2456            public Date getMinchaGedolaAteretTorah() {
2457                    return getTimeOffset(getAlos72Zmanis(),
2458                                    getShaahZmanisAteretTorah() * 6.5);
2459            }
2460    
2461            /**
2462             * This method returns the time of <em>mincha ketana</em> based on the
2463             * calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that
2464             * the day starts {@link #getAlos72Zmanis() 1/10th of the day} before
2465             * sunrise and and is usually calculated as ending
2466             * {@link #getTzaisAteretTorah() 40 minutes after sunset}. This is the
2467             * perfered earliest time to pray <em>mincha</em> in the opinion of the
2468             * Ramba"m and others. For more information on this see the documentation on
2469             * <em>{@link #getMinchaGedola() mincha gedola}</em>. This is calculated as
2470             * 9.5 {@link #getShaahZmanisAteretTorah() solar hours} after
2471             * {@link #getAlos72Zmanis() alos}. The calculation used is 9.5 *
2472             * {@link #getShaahZmanisAteretTorah()} after {@link #getAlos72Zmanis()
2473             * alos}.
2474             * 
2475             * @see #getAlos72Zmanis()
2476             * @see #getTzaisAteretTorah()
2477             * @see #getShaahZmanisAteretTorah()
2478             * @see #getMinchaGedola()
2479             * @see #getMinchaKetana()
2480             * @return the <code>Date</code> of the time of mincha ketana. If the
2481             *         calculation can't be computed such as in the Arctic Circle where
2482             *         there is at least one day a year where the sun does not rise, and
2483             *         one where it does not set, a null will be returned. See detailed
2484             *         explanation on top of the {@link AstronomicalCalendar}
2485             *         documentation.
2486             */
2487            public Date getMinchaKetanaAteretTorah() {
2488                    return getTimeOffset(getAlos72Zmanis(),
2489                                    getShaahZmanisAteretTorah() * 9.5);
2490            }
2491    
2492            /**
2493             * This method returns the time of <em>plag hamincha</em> based on the
2494             * calculation of Chacham Yosef Harari-Raful of Yeshivat Ateret Torah, that
2495             * the day starts {@link #getAlos72Zmanis() 1/10th of the day} before
2496             * sunrise and and is usually calculated as ending
2497             * {@link #getTzaisAteretTorah() 40 minutes after sunset}.
2498             * <em>shaos zmaniyos</em> are calculated based on this day and added to
2499             * {@link #getAlos72Zmanis() alos} to reach this time. This time is 10.75
2500             * <em>{@link #getShaahZmanisAteretTorah() shaos zmaniyos}</em> (temporal
2501             * hours) after {@link #getAlos72Zmanis() dawn}.
2502             * 
2503             * @return the <code>Date</code> of the plag. If the calculation can't be
2504             *         computed such as in the Arctic Circle where there is at least one
2505             *         day a year where the sun does not rise, and one where it does not
2506             *         set, a null will be returned. See detailed explanation on top of
2507             *         the {@link AstronomicalCalendar} documentation.
2508             * @see #getAlos72Zmanis()
2509             * @see #getTzaisAteretTorah()
2510             * @see #getShaahZmanisAteretTorah()
2511             */
2512            public Date getPlagHaminchaAteretTorah() {
2513                    return getTimeOffset(getAlos72Zmanis(),
2514                                    getShaahZmanisAteretTorah() * 10.75);
2515            }
2516    
2517            /**
2518             * This method returns the time of <em>misheyakir</em> based on the common
2519             * calculation of the Syrian community in NY that the alos is a fixed minute
2520             * offset from day starting {@link #getAlos72Zmanis() 1/10th of the day}
2521             * before sunrise. The common offsets are 6 minutes (based on th Pri
2522             * Megadim, but not linked to the calculation of Alos as 1/10th of the day),
2523             * 8 and 18 minutes (possibly attributed to Chacham Baruch Ben Haim). Since
2524             * there is no universal accepted offset, the user of this API will have to
2525             * specify one. Chacham Yosef Harari-Raful of Yeshivat Ateret Torah does not
2526             * supply any zman for misheyakir and does not endorse any specific
2527             * calculation for misheyakir. For that reason, this method is not enabled.
2528             * 
2529             * @param minutes
2530             *            the number of minutes after alos calculated as
2531             *            {@link #getAlos72Zmanis() 1/10th of the day}
2532             * @return the <code>Date</code> of misheyakir. If the calculation can't be
2533             *         computed such as in the Arctic Circle where there is at least one
2534             *         day a year where the sun does not rise, and one where it does not
2535             *         set, a null will be returned. See detailed explanation on top of
2536             *         the {@link AstronomicalCalendar} documentation.
2537             * @see #getAlos72Zmanis()
2538             */
2539            // public Date getMesheyakirAteretTorah(double minutes) {
2540            // return getTimeOffset(getAlos72Zmanis(), minutes * MINUTE_MILLIS);
2541            // }
2542            /**
2543             * Method to return <em>tzais</em> (dusk) calculated as 72 minutes zmaniyos,
2544             * or 1/10th of the day after {@link #getSeaLevelSunset() sea level sunset}.
2545             * 
2546             * @return the <code>Date</code> representing the time. If the calculation
2547             *         can't be computed such as in the Arctic Circle where there is at
2548             *         least one day a year where the sun does not rise, and one where
2549             *         it does not set, a null will be returned. See detailed
2550             *         explanation on top of the {@link AstronomicalCalendar}
2551             *         documentation.
2552             * @see #getAlos72Zmanis()
2553             */
2554            public Date getTzais72Zmanis() {
2555                    long shaahZmanis = getShaahZmanisGra();
2556                    if (shaahZmanis == Long.MIN_VALUE) {
2557                            return null;
2558                    }
2559                    return getTimeOffset(getSeaLevelSunset(), shaahZmanis * 1.2);
2560            }
2561    
2562            /**
2563             * Method to return <em>tzais</em> (dusk) calculated using 90 minutes
2564             * zmaniyos (<em>GR"A</em> and the <em>Baal Hatanya</em>) after
2565             * {@link #getSeaLevelSunset() sea level sunset}.
2566             * 
2567             * @return the <code>Date</code> representing the time. If the calculation
2568             *         can't be computed such as in the Arctic Circle where there is at
2569             *         least one day a year where the sun does not rise, and one where
2570             *         it does not set, a null will be returned. See detailed
2571             *         explanation on top of the {@link AstronomicalCalendar}
2572             *         documentation.
2573             * @see #getAlos90Zmanis()
2574             */
2575            public Date getTzais90Zmanis() {
2576                    long shaahZmanis = getShaahZmanisGra();
2577                    if (shaahZmanis == Long.MIN_VALUE) {
2578                            return null;
2579                    }
2580                    return getTimeOffset(getSeaLevelSunset(), shaahZmanis * 1.5);
2581            }
2582    
2583            /**
2584             * Method to return <em>tzais</em> (dusk) calculated using 96 minutes
2585             * zmaniyos (<em>GR"A</em> and the <em>Baal Hatanya</em>) after
2586             * {@link #getSeaLevelSunset() sea level sunset}.
2587             * 
2588             * @return the <code>Date</code> representing the time. If the calculation
2589             *         can't be computed such as in the Arctic Circle where there is at
2590             *         least one day a year where the sun does not rise, and one where
2591             *         it does not set, a null will be returned. See detailed
2592             *         explanation on top of the {@link AstronomicalCalendar}
2593             *         documentation.
2594             * @see #getAlos96Zmanis()
2595             */
2596            public Date getTzais96Zmanis() {
2597                    long shaahZmanis = getShaahZmanisGra();
2598                    if (shaahZmanis == Long.MIN_VALUE) {
2599                            return null;
2600                    }
2601                    return getTimeOffset(getSeaLevelSunset(), shaahZmanis * 1.6);
2602            }
2603    
2604            /**
2605             * Method to return <em>tzais</em> (dusk) calculated as 90 minutes after sea
2606             * level sunset. This method returns <em>tzais</em> (nightfall) based on the
2607             * opinion of the Magen Avraham that the time to walk the distance of a Mil
2608             * in the Ramba"m's opinion is 18 minutes for a total of 90 minutes based on
2609             * the opinion of <em>Ula</em> who calculated <em>tzais</em> as 5 Mil after
2610             * sea level shkiah (sunset). A similar calculation
2611             * {@link #getTzais19Point8Degrees()}uses solar position calculations based
2612             * on this time.
2613             * 
2614             * @return the <code>Date</code> representing the time. If the calculation
2615             *         can't be computed such as in the Arctic Circle where there is at
2616             *         least one day a year where the sun does not rise, and one where
2617             *         it does not set, a null will be returned. See detailed
2618             *         explanation on top of the {@link AstronomicalCalendar}
2619             *         documentation.
2620             * @see #getTzais19Point8Degrees()
2621             * @see #getAlos90()
2622             */
2623            public Date getTzais90() {
2624                    return getTimeOffset(getSeaLevelSunset(), 90 * MINUTE_MILLIS);
2625            }
2626    
2627            /**
2628             * This method returns <em>tzais</em> (nightfall) based on the opinion of
2629             * the Magen Avraham that the time to walk the distance of a Mil in the
2630             * Ramba"ms opinion is 2/5 of an hour (24 minutes) for a total of 120
2631             * minutes based on the opinion of <em>Ula</em> who calculated
2632             * <em>tzais</em> as 5 Mil after sea level shkiah (sunset). A similar
2633             * calculation {@link #getTzais26Degrees()} uses temporal calculations based
2634             * on this time.
2635             * 
2636             * @return the <code>Date</code> representing the time. If the calculation
2637             *         can't be computed such as in the Arctic Circle where there is at
2638             *         least one day a year where the sun does not rise, and one where
2639             *         it does not set, a null will be returned. See detailed
2640             *         explanation on top of the {@link AstronomicalCalendar}
2641             *         documentation.
2642             * @see #getTzais26Degrees()
2643             * @see #getAlos120()
2644             */
2645            public Date getTzais120() {
2646                    return getTimeOffset(getSeaLevelSunset(), 120 * MINUTE_MILLIS);
2647            }
2648    
2649            /**
2650             * Method to return <em>tzais</em> (dusk) calculated using 120 minutes
2651             * zmaniyos (<em>GR"A</em> and the <em>Baal Hatanya</em>) after
2652             * {@link #getSeaLevelSunset() sea level sunset}.
2653             * 
2654             * @return the <code>Date</code> representing the time. If the calculation
2655             *         can't be computed such as in the Arctic Circle where there is at
2656             *         least one day a year where the sun does not rise, and one where
2657             *         it does not set, a null will be returned. See detailed
2658             *         explanation on top of the {@link AstronomicalCalendar}
2659             *         documentation.
2660             * @see #getAlos120Zmanis()
2661             */
2662            public Date getTzais120Zmanis() {
2663                    long shaahZmanis = getShaahZmanisGra();
2664                    if (shaahZmanis == Long.MIN_VALUE) {
2665                            return null;
2666                    }
2667                    return getTimeOffset(getSeaLevelSunset(), shaahZmanis * 2.0);
2668            }
2669    
2670            /**
2671             * For information on how this is calculated see the comments on
2672             * {@link #getAlos16Point1Degrees()}
2673             * 
2674             * @return the <code>Date</code> representing the time. If the calculation
2675             *         can't be computed such as northern and southern locations even
2676             *         south of the Arctic Circle and north of the Antarctic Circle
2677             *         where the sun may not reach low enough below the horizon for this
2678             *         calculation, a null will be returned. See detailed explanation on
2679             *         top of the {@link AstronomicalCalendar} documentation.
2680             * @see #getTzais72()
2681             * @see #getAlos16Point1Degrees() for more information on this calculation.
2682             */
2683            public Date getTzais16Point1Degrees() {
2684                    return getSunsetOffsetByDegrees(ZENITH_16_POINT_1);
2685            }
2686    
2687            /**
2688             * For information on how this is calculated see the comments on
2689             * {@link #getAlos26Degrees()}
2690             * 
2691             * @return the <code>Date</code> representing the time. If the calculation
2692             *         can't be computed such as northern and southern locations even
2693             *         south of the Arctic Circle and north of the Antarctic Circle
2694             *         where the sun may not reach low enough below the horizon for this
2695             *         calculation, a null will be returned. See detailed explanation on
2696             *         top of the {@link AstronomicalCalendar} documentation.
2697             * @see #getTzais120()
2698             * @see #getAlos26Degrees()
2699             */
2700            public Date getTzais26Degrees() {
2701                    return getSunsetOffsetByDegrees(ZENITH_26_DEGREES);
2702            }
2703    
2704            /**
2705             * For information on how this is calculated see the comments on
2706             * {@link #getAlos18Degrees()}
2707             * 
2708             * @return the <code>Date</code> representing the time. If the calculation
2709             *         can't be computed such as northern and southern locations even
2710             *         south of the Arctic Circle and north of the Antarctic Circle
2711             *         where the sun may not reach low enough below the horizon for this
2712             *         calculation, a null will be returned. See detailed explanation on
2713             *         top of the {@link AstronomicalCalendar} documentation.
2714             * @see #getAlos18Degrees()
2715             */
2716            public Date getTzais18Degrees() {
2717                    return getSunsetOffsetByDegrees(ASTRONOMICAL_ZENITH);
2718            }
2719    
2720            /**
2721             * For information on how this is calculated see the comments on
2722             * {@link #getAlos19Point8Degrees()}
2723             * 
2724             * @return the <code>Date</code> representing the time. If the calculation
2725             *         can't be computed such as northern and southern locations even
2726             *         south of the Arctic Circle and north of the Antarctic Circle
2727             *         where the sun may not reach low enough below the horizon for this
2728             *         calculation, a null will be returned. See detailed explanation on
2729             *         top of the {@link AstronomicalCalendar} documentation.
2730             * @see #getTzais90()
2731             * @see #getAlos19Point8Degrees()
2732             */
2733            public Date getTzais19Point8Degrees() {
2734                    return getSunsetOffsetByDegrees(ZENITH_19_POINT_8);
2735            }
2736    
2737            /**
2738             * A method to return <em>tzais</em> (dusk) calculated as 96 minutes after
2739             * sea level sunset. For information on how this is calculated see the
2740             * comments on {@link #getAlos96()}.
2741             * 
2742             * @return the <code>Date</code> representing the time. If the calculation
2743             *         can't be computed such as in the Arctic Circle where there is at
2744             *         least one day a year where the sun does not rise, and one where
2745             *         it does not set, a null will be returned. See detailed
2746             *         explanation on top of the {@link AstronomicalCalendar}
2747             *         documentation.
2748             * @see #getAlos96()
2749             */
2750            public Date getTzais96() {
2751                    return getTimeOffset(getSeaLevelSunset(), 96 * MINUTE_MILLIS);
2752            }
2753    
2754            /**
2755             * A method that returns the local time for fixed <em>chatzos</em>. This
2756             * time is noon and midnight adjusted from standard time to account for the
2757             * local latitude. The 360&deg; of the globe divided by 24 calculates to
2758             * 15&deg; per hour with 4 minutes per degree, so at a longitude of 0 , 15,
2759             * 30 etc Chatzos in 12:00 noon. Lakewood, NJ whose longitude is -74.2094 is
2760             * 0.7906 away from the closest multiple of 15 at -75&deg;. This is
2761             * multiplied by 4 to yeild 3 minutes and 10 seconds for a chatzos of
2762             * 11:56:50. This method is not tied to the theoretical 15&deg; timezones,
2763             * but will adjust to the actual timezone and <a
2764             * href="http://en.wikipedia.org/wiki/Daylight_saving_time">Daylight saving
2765             * time</a>.
2766             * 
2767             * @return the Date representing the local <em>chatzos</em>
2768             * @see GeoLocation#getLocalMeanTimeOffset()
2769             */
2770            public Date getFixedLocalChatzos() {
2771                    return getTimeOffset(getDateFromTime(12.0
2772                                    - getGeoLocation().getTimeZone().getRawOffset() / HOUR_MILLIS),
2773                                    -getGeoLocation().getLocalMeanTimeOffset());
2774            }
2775    
2776            /**
2777             * A method that returns the latest <em>zman krias shema</em> (time to say
2778             * Shema in the morning) calculated as 3 hours before
2779             * {@link #getFixedLocalChatzos()}.
2780             * 
2781             * @return the <code>Date</code> of the latest zman shema.
2782             * @see #getFixedLocalChatzos()
2783             * @see #getSofZmanTfilaFixedLocal()
2784             */
2785            public Date getSofZmanShmaFixedLocal() {
2786                    return getTimeOffset(getFixedLocalChatzos(), -180 * MINUTE_MILLIS);
2787            }
2788    
2789            /**
2790             * This method returns the latest <em>zman tfila</em> (time to say the
2791             * morning prayers) calculated as 2 hours before
2792             * {@link #getFixedLocalChatzos()}.
2793             * 
2794             * @return the <code>Date</code> of the latest zman tfila.
2795             * @see #getFixedLocalChatzos()
2796             * @see #getSofZmanShmaFixedLocal()
2797             */
2798            public Date getSofZmanTfilaFixedLocal() {
2799                    return getTimeOffset(getFixedLocalChatzos(), -120 * MINUTE_MILLIS);
2800            }
2801    
2802            /**
2803             * @see java.lang.Object#equals(Object)
2804             */
2805            public boolean equals(Object object) {
2806                    if (this == object) {
2807                            return true;
2808                    }
2809                    if (!(object instanceof ComplexZmanimCalendar)) {
2810                            return false;
2811                    }
2812                    ComplexZmanimCalendar cCal = (ComplexZmanimCalendar) object;
2813                    // return getCalendar().getTime().equals(cCal.getCalendar().getTime())
2814                    return getCalendar().equals(cCal.getCalendar())
2815                                    && getGeoLocation().equals(cCal.getGeoLocation())
2816                                    && getAstronomicalCalculator().equals(
2817                                                    cCal.getAstronomicalCalculator());
2818            }
2819    
2820            /**
2821             * @see java.lang.Object#hashCode()
2822             */
2823            public int hashCode() {
2824                    int result = 17;
2825                    result = 37 * result + getClass().hashCode(); // needed or this and
2826                                                                                                                    // subclasses will
2827                                                                                                                    // return identical hash
2828                    result += 37 * result + getCalendar().hashCode();
2829                    result += 37 * result + getGeoLocation().hashCode();
2830                    result += 37 * result + getAstronomicalCalculator().hashCode();
2831                    return result;
2832            }
2833    }