Kstars

kstarsdatetime.cpp
1/*
2 SPDX-FileCopyrightText: 2004 Jason Harris <jharris@30doradus.org>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include "kstarsdatetime.h"
8
9#include "dms.h"
10#include "ksnumbers.h"
11
12#include <KLocalizedString>
13
14#include <kstars_debug.h>
15
21
23{
24 *this = kdt;
25}
26
27KStarsDateTime& KStarsDateTime::operator=(const KStarsDateTime &kdt) noexcept
28{
29 setDJD(kdt.djd());
30 setTimeSpec(kdt.timeSpec());
31 //utcoffset deprecated
32 //setUtcOffset(kdt.utcOffset());
33 return *this;
34}
35
36/*KStarsDateTime::KStarsDateTime( const QDateTime &kdt ) :
37 QDateTime( kdt )
38{
39 //don't call setDJD() because we don't need to compute the time; just set DJD directly
40 QTime _t = kdt.time();
41 QDate _d = kdt.date();
42 long double jdFrac = ( _t.hour()-12 + ( _t.minute() + ( _t.second() + _t.msec()/1000.)/60.)/60.)/24.;
43 DJD = static_cast<long double>( _d.toJulianDay() ) + jdFrac;
44}*/
45
46KStarsDateTime::KStarsDateTime(const QDateTime &qdt) : QDateTime(qdt) //, QDateTime::Spec::UTC() )
47{
48 // FIXME: This method might be buggy. Need to write some tests -- asimha (Oct 2016)
49 QTime _t = qdt.time();
50 QDate _d = qdt.date();
51 long double jdFrac = (_t.hour() - 12 + (_t.minute() + (_t.second() + _t.msec() / 1000.) / 60.) / 60.) / 24.;
52 DJD = static_cast<long double>(_d.toJulianDay()) + jdFrac;
53 setTimeSpec(qdt.timeSpec());
54 //setUtcOffset(qdt.utcOffset());
55}
56
58 : //QDateTime( _d, _t, QDateTime::Spec::UTC() )
59 QDateTime(_d, _t, timeSpec)
60{
61 //don't call setDJD() because we don't need to compute the time; just set DJD directly
62 long double jdFrac = (_t.hour() - 12 + (_t.minute() + (_t.second() + _t.msec() / 1000.) / 60.) / 60.) / 24.;
63 DJD = static_cast<long double>(_d.toJulianDay()) + jdFrac;
64}
65
71
72//KStarsDateTime KStarsDateTime::currentDateTime( QDateTime::Spec spec ) {
74{
76 // if ( dt.time().hour()==0 && dt.time().minute()==0 ) // midnight or right after?
77 // dt.setDate( QDateTime::currentDateTime(spec).date() ); // fetch date again
78
79 return dt;
80}
81
83{
85 //if ( dt.time().hour()==0 && dt.time().minute()==0 ) // midnight or right after?
86 // dt.setDate( QDateTime::currentDateTime(spec).date() ); // fetch date again
87
88 return dt;
89}
90
92{
93 //DEBUG
94 qCDebug(KSTARS) << "Date string: " << s;
95
97
98 if (dtResult.isValid())
99 return dtResult;
100
102 if (dtResult.isValid())
103 return dtResult;
104
105 //dtResult = QDateTime::fromString( s, QDateTime::RFCDate );
107 if (dtResult.isValid())
108 return dtResult;
109
110 qCWarning(KSTARS) << "Could not parse Date/Time string:" << s;
111 qCWarning(KSTARS) << "Valid date formats:";
112 qCWarning(KSTARS) << " 1950-02-25 ; 1950-02-25T05:30:00";
113 qCWarning(KSTARS) << " 25 Feb 1950 ; 25 Feb 1950 05:30:00";
114 qCWarning(KSTARS) << " Sat Feb 25 1950 ; Sat Feb 25 05:30:00 1950";
115 return KStarsDateTime(QDateTime()); //invalid
116}
117
119{
120 //QDateTime::setTimeSpec( QDateTime::Spec::UTC() );
121 //QDateTime::setTimeSpec(Qt::UTC);
122
123 DJD = _jd;
124 long int ijd = (long int)_jd;
125 double dayfrac = _jd - (double)ijd + 0.5;
126 if (dayfrac > 1.0)
127 {
128 ijd++;
129 dayfrac -= 1.0;
130 }
131
134
135 double hour = 24. * dayfrac;
136 int h = int(hour);
137 int m = int(60. * (hour - h));
138 int s = int(60. * (60. * (hour - h) - m));
139 int ms = int(1000. * (60. * (60. * (hour - h) - m) - s));
140
141 QDateTime::setTime(QTime(h, m, s, ms));
142}
143
145{
146 //Save the JD fraction
147 long double jdFrac = djd() - static_cast<long double>(date().toJulianDay());
148
149 //set the integer portion of the JD and add back the JD fraction:
150 setDJD(static_cast<long double>(_d.toJulianDay()) + jdFrac);
151}
152
154{
155 long double ds = static_cast<long double>(s) / 86400.;
156 KStarsDateTime kdt(djd() + ds);
157 kdt.setTimeSpec(timeSpec());
158 return kdt;
159}
160
162{
164 setDJD(_dt.djd());
165}
166
168{
169 dms gst0 = GSTat0hUT();
170
171 double hr = double(time().hour() - offsetFromUtc() / 3600.0);
172 double mn = double(time().minute());
173 double sc = double(time().second()) + double(0.001 * time().msec());
174 double st = (hr + (mn + sc / 60.0) / 60.0) * SIDEREALSECOND;
175
176 dms gst = dms(gst0.Degrees() + st * 15.0).reduce();
177 return gst;
178}
179
180dms KStarsDateTime::GSTat0hUT() const
181{
182 double sinOb, cosOb;
183
184 // Mean greenwich sidereal time
185 KStarsDateTime t0(date(), QTime(0, 0, 0));
186 long double s = t0.djd() - J2000;
187 double t = s / 36525.0;
188 double t1 = 6.697374558 + 2400.051336 * t + 0.000025862 * t * t + 0.000000002 * t * t * t;
189
190 // To obtain the apparent sidereal time, we have to correct the
191 // mean greenwich sidereal time with nutation in longitude multiplied
192 // by the cosine of the obliquity of the ecliptic. This correction
193 // is called nutation in right ascention, and may amount to 0.3 secs.
194 KSNumbers num(t0.djd());
195 num.obliquity()->SinCos(sinOb, cosOb);
196
197 // nutLong has to be in hours of time since t1 is hours of time.
198 double nutLong = num.dEcLong() * cosOb / 15.0;
199 t1 += nutLong;
200
201 dms gst;
202 gst.setH(t1);
203 return gst.reduce();
204}
205
207{
208 dms gst0 = GSTat0hUT();
209
210 //dt is the number of sidereal hours since UT 0h.
211 double dt = GST.Hours() - gst0.Hours();
212 while (dt < 0.0)
213 dt += 24.0;
214 while (dt >= 24.0)
215 dt -= 24.0;
216
217 //convert to solar time. dt is now the number of hours since 0h UT.
218 dt /= SIDEREALSECOND;
219
220 int hr = int(dt);
221 int mn = int(60.0 * (dt - double(hr)));
222 int sc = int(60.0 * (60.0 * (dt - double(hr)) - double(mn)));
223 int ms = int(1000.0 * (60.0 * (60.0 * (dt - double(hr)) - double(mn)) - double(sc)));
224
225 return (QTime(hr, mn, sc, ms));
226}
227
229{
230 if (epoch == 1950.0) // Assume Besselian
232 else
233 setFromEpoch(epoch, JULIAN); // Assume Julian
234}
235
237{
238 if (type != JULIAN && type != BESSELIAN)
239 return false;
240 else
241 setDJD(epochToJd(epoch, type));
242 return true;
243}
244
246{
247 bool result;
248 double epoch;
249 epoch = stringToEpoch(eName, result);
250
251 if (!result)
252 return false;
253 return setFromEpoch(epoch, JULIAN); // We've already converted
254}
255
256long double KStarsDateTime::epochToJd(double epoch, EpochType type)
257{
258 switch (type)
259 {
260 case BESSELIAN:
261 return B1900 + (epoch - 1900.0) * JD_PER_BYEAR;
262 case JULIAN:
263 return J2000 + (epoch - 2000.0) * 365.25;
264 default:
265 return NaN::d;
266 }
267}
268
270{
271 // Definitions for conversion formulas are from:
272 //
273 // * http://scienceworld.wolfram.com/astronomy/BesselianEpoch.html
274 // * http://scienceworld.wolfram.com/astronomy/JulianEpoch.html
275 //
276
277 switch (type)
278 {
280 return 1900.0 + (jd - KStarsDateTime::B1900) / KStarsDateTime::JD_PER_BYEAR;
282 return 2000.0 + (jd - J2000) / 365.24;
283 default:
284 return NaN::d;
285 }
286}
287
289{
290 double epoch = J2000;
291 ok = false;
292
293 if (eName.isEmpty()) // By default, assume J2000
294 return epoch;
295
296 if (eName.startsWith('J'))
297 epoch = eName.midRef(1).toDouble(&ok);
298 else if (eName.startsWith('B'))
299 {
300 epoch = eName.midRef(1).toDouble(&ok);
301 epoch = jdToEpoch(epochToJd(epoch, BESSELIAN), JULIAN); // Convert Besselian epoch to Julian epoch
302 }
303 // Assume it's Julian
304 else
305 epoch = eName.toDouble(&ok);
306
307 return epoch;
308}
There are several time-dependent values used in position calculations, that are not specific to an ob...
Definition ksnumbers.h:43
Extension of QDateTime for KStars KStarsDateTime can represent the date/time as a Julian Day,...
void setDJD(long double jd)
Assign the static_cast<long double> Julian Day value, which includes the time of day encoded in the f...
static double jdToEpoch(long double jd, EpochType type=JULIAN)
Takes in a Julian Date and returns the corresponding epoch year in the given system.
double epoch() const
This is (approximately) the year expressed as a floating-point value.
QTime GSTtoUT(dms GST) const
Convert a given Greenwich Sidereal Time to Universal Time (=Greenwich Mean Time).
static long double epochToJd(double epoch, EpochType type=JULIAN)
Takes in an epoch and returns a Julian Date.
KStarsDateTime addSecs(double s) const
EpochType
description options
@ BESSELIAN
Besselian epoch (see http://scienceworld.wolfram.com/astronomy/BesselianEpoch.html)
@ JULIAN
Julian epoch (see http://scienceworld.wolfram.com/astronomy/JulianEpoch.html)
static KStarsDateTime fromString(const QString &s)
bool setFromEpoch(double e, EpochType type)
Set the Date/Time from an epoch value, represented as a double.
void setDate(const QDate &d)
Assign the Date according to a QDate object.
static KStarsDateTime currentDateTimeUtc()
KStarsDateTime()
Default constructor Creates a date/time at J2000 (noon on Jan 1, 200)
static KStarsDateTime currentDateTime()
long double djd() const
void setTime(const QTime &t)
Assign the Time according to a QTime object.
static constexpr const double B1900
The following values were obtained from Eric Weisstein's world of science: http://scienceworld....
static double stringToEpoch(const QString &eName, bool &ok)
Takes in a string and returns a Julian epoch.
An angle, stored as degrees, but expressible in many ways.
Definition dms.h:38
virtual void setH(const double &x)
Sets floating-point value of angle, in hours.
Definition dms.h:210
const dms reduce() const
return the equivalent angle between 0 and 360 degrees.
Definition dms.cpp:251
QDate fromJulianDay(qint64 jd)
qint64 toJulianDay() const const
QDateTime currentDateTime()
QDateTime currentDateTimeUtc()
QDate date() const const
QDateTime fromString(const QString &string, Qt::DateFormat format)
int offsetFromUtc() const const
void setDate(const QDate &date)
void setTime(const QTime &time)
void setTimeSpec(Qt::TimeSpec spec)
QTime time() const const
Qt::TimeSpec timeSpec() const const
TextDate
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Sun Feb 25 2024 18:45:35 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.