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
void setTimeSpec(Qt::TimeSpec spec)
QDateTime currentDateTime()
QDateTime currentDateTimeUtc()
QDate date() const const
QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
int offsetFromUtc() const const
void setDate(QDate date)
void setTime(QTime time)
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 Fri Jun 14 2024 11:55:04 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.