欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java获取当地的日出日落时间代码分享

程序员文章站 2024-02-29 12:13:28
根据经纬度和当前日期获取当地的日出日落时间,强大的google搜索让我迅速找到了一个外国人写的一个java类,代码中的注释写得很清楚。这里直接贴出代码来:复制代码 代码如下...

根据经纬度和当前日期获取当地的日出日落时间,强大的google搜索让我迅速找到了一个外国人写的一个java类,代码中的注释写得很清楚。
这里直接贴出代码来:

复制代码 代码如下:

/******************************************************************************
*
*       sunrisesunset.java
*
*******************************************************************************
*
* java class: sunrisesunset
*
* this java class is part of a collection of classes developed for the
* reading and processing of oceanographic and meterological data collected
* since 1970 by environmental buoys and stations.  this dataset is
* maintained by the national oceanographic data center and is publicly
* available.  these java classes were written for the us environmental
* protection agency's national exposure research laboratory under contract
* no. gs-10f-0073k with neptune and company of los alamos, new mexico.
*
* purpose:
*
*  this java class performs calculations to determine the time of
* sunrise and sunset given lat, long, and date.
*
* inputs:
*
*  latitude, longitude, date/time, and time zone.
*
* outputs:
*
*  local time of sunrise and sunset as calculated by the
*   program.
* if no sunrise or no sunset occurs, or if the sun is up all day
*   or down all day, appropriate boolean values are set.
* a boolean is provided to identify if the time provided is during the day.
*
* the above values are accessed by the following methods:
*
*  date getsunrise() returns date/time of sunrise
*  date getsunset()  returns date/time of sunset
*  boolean issunrise()  returns true if there was a sunrise, else false
*  boolean issunset()  returns true if there was a sunset, else false
*  boolean issunup()  returns true if sun is up all day, else false
*  boolean issundown()  returns true if sun is down all day, else false
*  boolean isdaytime()  returns true if sun is up at the time
*         specified, else false
*
* required classes from the java library:
*
*  java.util.date
*  java.text.simpledateformat
*  java.text.parseexception;
*  java.math.bigdecimal;
*
* package of which this class is a member:
*
* default
*
* known limitations:
*
* it is assumed that the data provided are within valie ranges
* (i.e. latitude between -90 and +90, longitude between 0 and 360,
* a valid date, and time zone between -14 and +14.
*
* compatibility:
*
* java 1.1.8
*
* references:

* the mathematical algorithms used in this program are patterned
* after those debveloped by roger sinnott in his basic program,
* sunup.bas, published in sky & telescope magazine:
* sinnott, roger w. "sunrise and sunset: a challenge"
* sky & telescope, august, 1994 p.84-85
*
* the following is a cross-index of variables used in sunup.bas.
* a single definition from multiple reuse of variable names in
* sunup.bas was clarified with various definitions in this program.
*
* sunup.bas this class
*
* a   dfa
* a(2)  dfaa1, dfaa2
* a0   dfa0
* a2   dfa2
* a5   dfa5
* az   not used
* c   dfcoslat
* c0   dfc0
* d   iday
* d(2)  dfdd1, dfdd2
* d0   dfd0
* d1   dfd1
* d2   dfd2
* d5   dfd5
* d7   not used
* da   dfda
* dd   dfdd
* g   bgregorian, dfgg
* h   dftimezone
* h0   dfh0
* h1   dfh1
* h2   dfh2
* h3   dfhourrise, dfhourset
* h7   not used
* j   dfj
* j3   dfj3
* k1   dfk1
* l   dfll
* l0   dfl0
* l2   dfl2
* l5   dflon
* m   imonth
* m3   dfminrise, dfminset
* n7   not used
* p   dfp
* s   isign, dfsinlat, dfss
* t   dft
* t0   dft0
* t3   not used
* tt   dftt
* u   dfuu
* v   dfvv
* v0   dfv0
* v1   dfv1
* v2   dfv2
* w   dfww
* y   iyear
* z   dfzenith
* z0   dftimezone


* author/company:
*
*  jdt: john tauxe, neptune and company
* jmg: jo marie green
*
* change log:

* date       ver    by description of change
* _________  _____  ___ ______________________________________________
*  5 jan 01  0.006  jdt excised from ssapp.java v. 0.005.
* 11 jan 01  0.007  jdt minor modifications to comments based on
*         material from sinnott, 1994.
*  7 feb 01  0.008  jdt fixed backwards time zone.  the standard is that
*         local time zone is specified in hours east of
*         greenwich, so that est would be -5, for example.
*         for some reason, sunup.bas does this backwards
*         (probably an americocentric perspective) and
*         sunrisesunset adopted that convention.  oops.
*         so the sign in the math is changed.
*  7 feb 01  0.009  jdt well, that threw off the azimuth calculation...
*         removed the azimuth calculations.
* 14 feb 01  0.010  jdt added ability to accept a time (hh:mm) in
*         dateinput, and decide if that time is daytime
*         or nighttime.
* 27 feb 01  0.011  jdt added accessor methods in place of having public
*         variables to get results.
* 28 feb 01  0.012  jdt cleaned up list of imported classes.
* 28 mar 01  1.10   jdt final version accompanying deliverable 1b.
*    4 apr 01  1.11   jdt moved logic supporting .isdaytime into method.
*         moved calculations out of constructor.
*   01 may 01  1.12   jmg   added 'gmt' designation and testing lines.
*   16 may 01  1.13   jdt   added setlenient( false ) and settimezone( tz )
*                           to dfmtday, dfmtmonth, and dfmtyear in
*       docalculations.
*   27 jun 01  1.14   jdt removed reliance on stationconstants (gmt).
* 13 aug 01  1.20   jdt final version accompanying deliverable 1c.
*  6 sep 01  1.21   jdt thorough code and comment review.
* 21 sep 01  1.30   jdt final version accompanying deliverable 2.
* 17 dec 01  1.40   jdt version accompanying final deliverable.
*    
*----------------------------------------------------------------------------*/

// import required classes and packages
import java.util.date;
import java.text.simpledateformat;
import java.text.parseexception;
import java.math.bigdecimal;
import java.util.timezone;


/******************************************************************************
* class:     sunrisesunset class
*******************************************************************************
*
*  this java class performs calculations to determine the time of
* sunrise and sunset given lat, long, and date.
*
* it is assumed that the data provided are within valie ranges
* (i.e. latitude between -90 and +90, longitude between 0 and 360,
* a valid date, and time zone between -14 and +14.

*----------------------------------------------------------------------------*/
public class sunrisesunset
{

 // declare and initialize variables
 private double dflat;     // latitude from user
 private double dflon;     // latitude from user
 private date dateinput;    // date/time from user
 private double dftimezone;    // time zone from user

 private date datesunrise;   // date and time of sunrise
 private date datesunset;    // date and time of sunset
 private boolean bsunrisetoday  = false; // flag for sunrise on this date
 private boolean bsunsettoday   = false; // flag for sunset on this date
 private boolean bsunupallday   = false; // flag for sun up all day
 private boolean bsundownallday = false; // flag for sun down all day
 private boolean bdaytime    = false; // flag for daytime, given
           // hour and min in dateinput
 private boolean bsunrise = false;  // sunrise during hour checked
 private boolean bsunset  = false;  // sunset during hour checked
 private boolean bgregorian = false;  // flag for gregorian calendar
 private int  ijulian;    // julian day
 private int  iyear;     // year of date of interest
 private int  imonth;     // month of date of interest
 private int  iday;     // day of date of interest
 private int  icount;     // a simple counter
 private int  isign;     // sunup.bas: s
 private double dfhourrise, dfhourset; // hour of event: sunup.bas h3
 private double dfminrise, dfminset; // minute of event: sunup.bas m3
 private double dfsinlat, dfcoslat;  // sin and cos of latitude
 private double dfzenith;    // sunup.bas z: zenith
 private simpledateformat dfmtdate;  // formatting for date alone
 private simpledateformat dfmtdatetime; // formatting for date and time
 private simpledateformat dfmtyear;  // formatting for year
 private simpledateformat dfmtmonth;  // formatting for month
 private simpledateformat dfmtday;  // formatting for day
 // many variables in sunup.bas have undocumented meanings,
 // and so are translated rather directly to avoid confusion:
 private double dfaa1 = 0, dfaa2 = 0; // sunup.bas a(2)
 private double dfdd1 = 0, dfdd2 = 0; // sunup.bas d(2)
 private double dfc0;     // sunup.bas c0
 private double dfk1;     // sunup.bas k1
 private double dfp;     // sunup.bas p
 private double dfj;     // sunup.bas j
 private double dfj3;     // sunup.bas j3
 private double dfa;     // sunup.bas a
 private double dfa0, dfa2, dfa5;  // sunup.bas a0, a2, a5
 private double dfd0, dfd1, dfd2, dfd5; // sunup.bas d0, d1, d2, d5
 private double dfda, dfdd;    // sunup.bas da, dd
 private double dfh0, dfh1, dfh2;  // sunup.bas h0, h1, h2
 private double dfl0, dfl2;    // sunup.bas l0, l2
 private double dft, dft0, dftt;  // sunup.bas t, t0, tt
 private double dfv0, dfv1, dfv2;  // sunup.bas v0, v1, v2

 private timezone tz = timezone.gettimezone( "gmt" );

 
/******************************************************************************
* method:     sunrisesunset
*******************************************************************************
*
* constructor for sunrisesunset class.
*
*----------------------------------------------------------------------------*/
 sunrisesunset(
      double dflatin,    // latitude
      double dflonin,    // longitude
      date  dateinputin,   // date
      double dftimezonein   // time zone
      )
 {
  // copy values supplied as agruments to local variables.
  dflat   = dflatin;
  dflon   = dflonin;
  dateinput  = dateinputin;
  dftimezone  = dftimezonein;

  // call the method to do the calculations.
  docalculations();

 } // end of class constructor


/******************************************************************************
* method:     docalculations
*******************************************************************************
*
* method for performing the calculations done in sunup.bas.
*
*----------------------------------------------------------------------------*/
 private void docalculations()
 {
  try
  {
   // break out day, month, and year from date provided.
   // (this is necesary for the math algorithms.)

   dfmtyear  = new simpledateformat( "yyyy" );
   dfmtyear.setlenient( false );
   dfmtyear.settimezone( tz );

   dfmtmonth = new simpledateformat( "m" );
   dfmtmonth.setlenient( false );
   dfmtmonth.settimezone( tz );

   dfmtday   = new simpledateformat( "d" );
   dfmtday.setlenient( false );
   dfmtday.settimezone( tz );

   iyear  = integer.parseint(  dfmtyear.format( dateinput ) );
   imonth = integer.parseint( dfmtmonth.format( dateinput ) );
   iday   = integer.parseint(   dfmtday.format( dateinput ) );

   // convert time zone hours to decimal days (sunup.bas line 50)
   dftimezone = dftimezone / 24.0;

   // note: (7 feb 2001) here is a non-standard part of sunup.bas:
   // it (and this algorithm) assumes that the time zone is
   // positive west, instead of the standard negative west.
   // classes calling sunrisesunset will be assuming that
   // times zones are specified in negative west, so here the
   // sign is changed so that the sunup algorithm works:
   dftimezone = -dftimezone;

   // convert longitude to fraction (sunup.bas line 50)
   dflon = dflon / 360.0;

   // convert calendar date to julian date:
   // check to see if it's later than 1583: gregorian calendar
   // when declared, bgregorian is initialized to false.
   // ** consider making a separate class of this function. **
   if( iyear >= 1583 ) bgregorian = true;
   // sunup.bas 1210
   dfj = -math.floor( 7.0  // sunup used int, not floor
        * ( math.floor(
              ( imonth + 9.0 )
              / 12.0
             ) + iyear
           ) / 4.0
        )
    // add sunup.bas 1240 and 1250 for g = 0
    + math.floor( imonth * 275.0 / 9.0 )
    + iday
    + 1721027.0
    + iyear * 367.0;

   if ( bgregorian )
   {
    // sunup.bas 1230
    if ( ( imonth - 9.0 ) < 0.0 ) isign = -1;
    else isign = 1;
    dfa = math.abs( imonth - 9.0 );
    // sunup.bas 1240 and 1250
    dfj3 = -math.floor(
          (
       math.floor(
         math.floor( iyear
          + (double)isign
            * math.floor( dfa / 7.0 )
            )
            / 100.0
           ) + 1.0
          ) * 0.75
         );
    // correct dfj as in sunup.bas 1240 and 1250 for g = 1
    dfj = dfj + dfj3 + 2.0;
   }
   // sunup.bas 1290
   ijulian = (int)dfj - 1;

   // sunup.bas 60 and 70 (see also line 1290)
   dft = (double)ijulian - 2451545.0 + 0.5;
   dftt = dft / 36525.0 + 1.0;    // centuries since 1900

   // calculate local sidereal time at 0h in zone time
   // sunup.bas 410 through 460
   dft0 = ( dft * 8640184.813 / 36525.0
     + 24110.5
     + dftimezone * 86636.6
     + dflon * 86400.0
      )
      / 86400.0;
   dft0 = dft0 - math.floor( dft0 ); // note: sunup.bas uses int()
   dft0 = dft0 * 2.0 * math.pi;
   // sunup.bas 90
   dft = dft + dftimezone;

   // sunup.bas 110: get sun's position
   for( icount=0; icount<=1; icount++ ) // loop thru only twice
   {
    // calculate sun's right ascension and declination
    //   at the start and end of each day.
    // sunup.bas 910 - 1160: fundamental arguments
    //   from van flandern and pulkkinen, 1979

    // declare local temporary doubles for calculations
    double dfgg;      // sunup.bas g
    double dfll;      // sunup.bas l
    double dfss;      // sunup.bas s
    double dfuu;      // sunup.bas u
    double dfvv;      // sunup.bas v
    double dfww;      // sunup.bas w

    dfll = 0.779072 + 0.00273790931 * dft;
    dfll = dfll - math.floor( dfll );
    dfll = dfll * 2.0 * math.pi;

    dfgg = 0.993126 + 0.0027377785 * dft;
    dfgg = dfgg - math.floor( dfgg );
    dfgg = dfgg * 2.0 * math.pi;

    dfvv =   0.39785 * math.sin( dfll )
      - 0.01000 * math.sin( dfll - dfgg )
      + 0.00333 * math.sin( dfll + dfgg )
      - 0.00021 * math.sin( dfll ) * dftt;

    dfuu = 1
         - 0.03349 * math.cos( dfgg )
      - 0.00014 * math.cos( dfll * 2.0 )
      + 0.00008 * math.cos( dfll );

    dfww = - 0.00010
      - 0.04129 * math.sin( dfll * 2.0 )
      + 0.03211 * math.sin( dfgg )
      - 0.00104 * math.sin( 2.0 * dfll - dfgg )
      - 0.00035 * math.sin( 2.0 * dfll + dfgg )
      - 0.00008 * math.sin( dfgg ) * dftt;

    // compute sun's ra and dec; sunup.bas 1120 - 1140
    dfss = dfww / math.sqrt( dfuu - dfvv * dfvv );
    dfa5 = dfll
        + math.atan( dfss / math.sqrt( 1.0 - dfss * dfss ));

    dfss = dfvv / math.sqrt( dfuu );
    dfd5 = math.atan( dfss / math.sqrt( 1 - dfss * dfss ));     

    // set values and increment t
    if ( icount == 0 )  // sunup.bas 125
    {
     dfaa1 = dfa5;
     dfdd1 = dfd5;
    }
    else     // sunup.bas 145
    {
     dfaa2 = dfa5;
     dfdd2 = dfd5;
    }
    dft = dft + 1.0;  // sunup.bas 130
   } // end of get sun's position for loop

   if ( dfaa2 < dfaa1 ) dfaa2 = dfaa2 + 2.0 * math.pi;
               // sunup.bas 150

   dfzenith = math.pi * 90.833 / 180.0;   // sunup.bas 160
   dfsinlat = math.sin( dflat * math.pi / 180.0 ); // sunup.bas 170
   dfcoslat = math.cos( dflat * math.pi / 180.0 ); // sunup.bas 170

   dfa0 = dfaa1;         // sunup.bas 190
   dfd0 = dfdd1;         // sunup.bas 190
   dfda = dfaa2 - dfaa1;       // sunup.bas 200
   dfdd = dfdd2 - dfdd1;       // sunup.bas 200

   dfk1 = 15.0 * 1.0027379 * math.pi / 180.0;  // sunup.bas 330

   // initialize sunrise and sunset times, and other variables
   // hr and min are set to impossible times to make errors obvious
   dfhourrise = 99.0;
   dfminrise  = 99.0;
   dfhourset  = 99.0;
   dfminset   = 99.0;
   dfv0 = 0.0;  // initialization implied by absence in sunup.bas
   dfv2 = 0.0;  // initialization implied by absence in sunup.bas

   // test each hour to see if the sun crosses the horizon
   //   and which way it is heading.
   for( icount=0; icount<24; icount++ )   // sunup.bas 210
   {
    double tempa;        // sunup.bas a
    double tempb;        // sunup.bas b
    double tempd;        // sunup.bas d
    double tempe;        // sunup.bas e

    dfc0 = (double)icount;
    dfp = ( dfc0 + 1.0 ) / 24.0;    // sunup.bas 220
    dfa2 = dfaa1 + dfp * dfda;     // sunup.bas 230
    dfd2 = dfdd1 + dfp * dfdd;     // sunup.bas 230
    dfl0 = dft0 + dfc0 * dfk1;     // sunup.bas 500
    dfl2 = dfl0 + dfk1;       // sunup.bas 500
    dfh0 = dfl0 - dfa0;       // sunup.bas 510
    dfh2 = dfl2 - dfa2;       // sunup.bas 510
    // hour angle at half hour
    dfh1 = ( dfh2 + dfh0 ) / 2.0;    // sunup.bas 520
    // declination at half hour
    dfd1 = ( dfd2 + dfd0 ) / 2.0;    // sunup.bas 530

    // set value of dfv0 only if this is the first hour,
    // otherwise, it will get set to the last dfv2 (sunup.bas 250)
    if ( icount == 0 )       // sunup.bas 550
    { 
     dfv0 = dfsinlat * math.sin( dfd0 )
       + dfcoslat * math.cos( dfd0 ) * math.cos( dfh0 )
       - math.cos( dfzenith );   // sunup.bas 560
    }
    else
     dfv0 = dfv2; // that is, dfv2 from the previous hour.

    dfv2 = dfsinlat * math.sin( dfd2 )
       + dfcoslat * math.cos( dfd2 ) * math.cos( dfh2 )
       - math.cos( dfzenith );   // sunup.bas 570

    // if dfv0 and dfv2 have the same sign, then proceed to next hr
    if (
      ( dfv0 >= 0.0 && dfv2 >= 0.0 )  // both are positive
      ||        // or
      ( dfv0 < 0.0 && dfv2 < 0.0 )   // both are negative
       )
    {
     // break iteration and proceed to test next hour
     dfa0 = dfa2;       // sunup.bas 250
     dfd0 = dfd2;       // sunup.bas 250
     continue;        // sunup.bas 610
    }

    dfv1 = dfsinlat * math.sin( dfd1 )
      + dfcoslat * math.cos( dfd1 ) * math.cos( dfh1 )
      - math.cos( dfzenith );    // sunup.bas 590

    tempa = 2.0 * dfv2 - 4.0 * dfv1 + 2.0 * dfv0;
               // sunup.bas 600
    tempb = 4.0 * dfv1 - 3.0 * dfv0 - dfv2;  // sunup.bas 600
    tempd = tempb * tempb - 4.0 * tempa * dfv0; // sunup.bas 610

    if ( tempd < 0.0 )
    {
     // break iteration and proceed to test next hour
     dfa0 = dfa2;       // sunup.bas 250
     dfd0 = dfd2;       // sunup.bas 250
     continue;        // sunup.bas 610
    }

    tempd = math.sqrt( tempd );     // sunup.bas 620

    // determine occurence of sunrise or sunset.

    // flags to identify occurrence during this day are
    // bsunrisetoday and bsunsettoday, and are initialized false.
    // these are set true only if sunrise or sunset occurs
    // at any point in the hourly loop. never set to false.

    // flags to identify occurrence during this hour:
    bsunrise = false;    // reset before test
    bsunset  = false;    // reset before test

    if ( dfv0 < 0.0 && dfv2 > 0.0 ) // sunrise occurs this hour
    {
     bsunrise = true;   // sunup.bas 640
     bsunrisetoday = true;  // sunrise occurred today
    }

    if ( dfv0 > 0.0 && dfv2 < 0.0 ) // sunset occurs this hour
    {
     bsunset = true;    // sunup.bas 660
     bsunsettoday = true;  // sunset occurred today
    }

    tempe = ( tempd - tempb ) / ( 2.0 * tempa );
    if ( tempe > 1.0 || tempe < 0.0 ) // sunup.bas 670, 680
     tempe = ( -tempd - tempb ) / ( 2.0 * tempa );     

    // set values of hour and minute of sunset or sunrise
    // only if sunrise/set occurred this hour.
    if ( bsunrise )
    {
     dfhourrise = math.floor( dfc0 + tempe + 1.0/120.0 );
     dfminrise  = math.floor(
            ( dfc0 + tempe + 1.0/120.0
               - dfhourrise
            )
            * 60.0
           );
    }

    if ( bsunset )
    {
     dfhourset  = math.floor( dfc0 + tempe + 1.0/120.0 );
     dfminset   = math.floor(
            ( dfc0 + tempe + 1.0/120.0
               - dfhourset
            )
            * 60.0
           );
    }

    // change settings of variables for next loop
    dfa0 = dfa2;        // sunup.bas 250
    dfd0 = dfd2;        // sunup.bas 250

   } // end of loop testing each hour for an event 

   // after having checked all hours, set flags if no rise or set
   // bsunupallday and bsundownallday are initialized as false
   if ( !bsunrisetoday && !bsunsettoday )
   {
    if ( dfv2 < 0.0 )
     bsundownallday = true;
    else
     bsunupallday = true;
   }

   // load datesunrise with data
   dfmtdatetime = new simpledateformat( "d m yyyy hh:mm z" );
   if( bsunrisetoday )
   {
    datesunrise = dfmtdatetime.parse( iday
          + " " + imonth
          + " " + iyear
          + " " + (int)dfhourrise
          + ":" + (int)dfminrise
          + " gmt" );
   }

   // load datesunset with data
   if( bsunsettoday )
   {
    datesunset = dfmtdatetime.parse( iday
          + " " + imonth
          + " " + iyear
          + " " + (int)dfhourset
          + ":" + (int)dfminset
          + " gmt" );
   }
  } // end of try

  // catch errors
  catch( parseexception e )
  {
   system.out.println( "\ncannot parse date" );
   system.out.println( e );
   system.exit( 1 );
  } // end of catch

 }

 
/******************************************************************************
* method:     getsunrise()
*******************************************************************************
*
*   gets the date and time of sunrise.  if there is no sunrise, returns null.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public date getsunrise()
 {
  if ( bsunrisetoday )
   return( datesunrise );
  else
   return( null );
 }


/******************************************************************************
* method:     getsunset()
*******************************************************************************
*
*   gets the date and time of sunset.  if there is no sunset, returns null.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public date getsunset()
 {
  if ( bsunsettoday )
   return( datesunset );
  else
   return( null );
 }


/******************************************************************************
* method:     issunrise()
*******************************************************************************
*
*   returns a boolean identifying if there was a sunrise.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunrise()
 {
  return( bsunrisetoday );
 }


/******************************************************************************
* method:     issunset()
*******************************************************************************
*
*   returns a boolean identifying if there was a sunset.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunset()
 {
  return( bsunsettoday );
 }


/******************************************************************************
* method:     issunup()
*******************************************************************************
*
*   returns a boolean identifying if the sun is up all day.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunup()
 {
  return( bsunupallday );
 }


/******************************************************************************
* method:     issundown()
*******************************************************************************
*
*   returns a boolean identifying if the sun is down all day.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issundown()
 {
  return( bsundownallday );
 }


/******************************************************************************
* method:     isdaytime()
*******************************************************************************
*
*   returns a boolean identifying if it is daytime at the hour contained in
* the date object passed to sunrisesunset on construction.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean isdaytime()
 {
  // determine if it is daytime (at sunrise or later)
  // or nighttime (at sunset or later) at the location of interest
  // but expressed in the time zone requested.
  if ( bsunrisetoday && bsunsettoday )  // sunrise and sunset
  {
   if ( datesunrise.before( datesunset ) ) // sunrise < sunset
   {
    if (
      ( 
      dateinput.after( datesunrise )

      dateinput.equals( datesunrise )
      )
      &&
      dateinput.before( datesunset )
       )
     bdaytime = true;
    else
    bdaytime = false;
    }
   else  // sunrise comes after sunset (in opposite time zones)
   {
    if (
      ( 
      dateinput.after( datesunrise )

      dateinput.equals( datesunrise )
      )
      ||   // use or rather than and
      dateinput.before( datesunset )
       )
     bdaytime = true;
    else
    bdaytime = false;
    }
  }
  else if ( bsunupallday )     // sun is up all day
   bdaytime = true;
  else if ( bsundownallday )    // sun is down all day
   bdaytime = false;
  else if ( bsunrisetoday )     // sunrise but no sunset
  {
   if ( dateinput.before( datesunrise ) )
    bdaytime = false;
   else
    bdaytime = true;
  }
  else if ( bsunsettoday )     // sunset but no sunrise
  {
   if ( dateinput.before( datesunset ) )
    bdaytime = true;
   else
    bdaytime = false;
  }
  else bdaytime = false;     // this should never execute

  return( bdaytime );
 }


} // end of class

/*-----------------------------------------------------------------------------
*       end of class
*----------------------------------------------------------------------------*/