//! convert an MJD to long double
long double from_MJD (const MJD& t)
{
const long double secs_in_day = 86400.0L;
return
(long double) (t.intday()) +
(long double) (t.get_secs()) / secs_in_day +
(long double) (t.get_fracsec()) / secs_in_day;
}
//! Return the spin frequency, given the epoch
long double Pulsar::SimplePredictor::frequency (const MJD& t) const
{
if (reference_epoch == MJD::zero)
const_cast<SimplePredictor*>(this)->reference_epoch = t;
MJD diff = t - reference_epoch;
long double seconds = diff.get_secs();
seconds += diff.get_fracsec();
long double power_of_t = 1.0;
long double result = 0;
for (unsigned i=0; i<coefs.size(); i++)
{
result += coefs[i] * (i+1) * power_of_t;
power_of_t *= seconds;
}
return result;
}
//! Return the phase, given the epoch
Pulsar::Phase Pulsar::SimplePredictor::phase (const MJD& t) const
{
if (reference_epoch == MJD::zero)
const_cast<SimplePredictor*>(this)->reference_epoch = t;
MJD diff = t - reference_epoch;
long double seconds = diff.get_secs();
seconds += diff.get_fracsec();
long double power_of_t = seconds;
long double result = 0;
for (unsigned i=0; i<coefs.size(); i++)
{
result += coefs[i] * power_of_t;
power_of_t *= seconds;
}
int64_t iphase = int64_t(result);
return Pulsar::Phase(iphase,result-iphase);
}
std::string dsp::FilenameEpoch::get_filename (const PhaseSeries* data)
{
MJD epoch = data->get_start_time();
if (Observation::verbose)
cerr << "dsp::FilenameEpoch::get_filename epoch="
<< epoch.printall() << endl;
if (integer_seconds)
{
// ensure that the epoch is rounded up into the current division
epoch = data->get_mid_time (false);
DEBUG("dsp::FilenameEpoch::get_filename mid_time=" << epoch.printall());
unsigned seconds = epoch.get_secs();
unsigned divisions = seconds / integer_seconds;
epoch = MJD (epoch.intday(), divisions * integer_seconds, 0.0);
if (Observation::verbose)
cerr << "dsp::FilenameEpoch::get_filename division_start="
<< epoch.printall() << endl;
}
vector<char> fname (FILENAME_MAX);
char* filename = &fname[0];
if (!epoch.datestr( filename, FILENAME_MAX, datestr_pattern.c_str() ))
throw Error (FailedSys, "dsp::PhaseSeriesUnloader::get_filename",
"error MJD::datestr(" + datestr_pattern + ")");
if (report_unload)
cerr << "unloading " << tostring(data->get_integration_length(),2)
<< " seconds: " << filename << endl;
return filename;
}
double second (const MJD& mjd)
{
return mjd.get_secs() + mjd.get_fracsec();
}
void dsp::ASCIIObservation::unload (char* header)
{
if (header == NULL)
throw Error (InvalidState, "ASCIIObservation::unload", "no header!");
// //////////////////////////////////////////////////////////////////////
//
// HDR_VERSION
//
float version = 1.0;
if (ascii_header_set (header, hdr_version.c_str(), "%f", version) < 0)
cerr << "ASCIIObservation: failed unload " << hdr_version << endl;
// //////////////////////////////////////////////////////////////////////
//
// TELESCOPE
//
if (ascii_header_set (header, "TELESCOPE", "%s",
get_telescope().c_str() ) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload TELESCOPE");
// //////////////////////////////////////////////////////////////////////
//
// RECEIVER
//
if (ascii_header_set (header, "RECEIVER", "%s", get_receiver().c_str()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload RECEIVER");
// //////////////////////////////////////////////////////////////////////
//
// SOURCE
//
if (ascii_header_set (header, "SOURCE", "%s", get_source().c_str()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload SOURCE");
// //////////////////////////////////////////////////////////////////////
//
// MODE
//
string mode;
switch (get_type())
{
case Signal::Pulsar: mode = "PSR"; break;
case Signal::PolnCal: mode = "CAL"; break;
default: mode = "UNKNOWN"; break;
}
ascii_header_set (header, "MODE", "%s", mode.c_str());
if (get_type() == Signal::PolnCal
&& ascii_header_set (header, "CALFREQ", "%lf", get_calfreq()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload FREQ");
// //////////////////////////////////////////////////////////////////////
//
// FREQ
//
if (ascii_header_set (header, "FREQ", "%lf", get_centre_frequency()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload FREQ");
// //////////////////////////////////////////////////////////////////////
//
// BW
//
if (ascii_header_set (header, "BW", "%lf", get_bandwidth()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload BW");
// //////////////////////////////////////////////////////////////////////
//
// NCHAN
//
if (ascii_header_set (header, "NCHAN", "%d", get_nchan()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload NCHAN");
// //////////////////////////////////////////////////////////////////////
//
// NPOL
//
if (ascii_header_set (header, "NPOL", "%d", get_npol()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload NPOL");
// //////////////////////////////////////////////////////////////////////
//
// NBIT
//
if (ascii_header_set (header, "NBIT", "%d", get_nbit()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload NBIT");
// //////////////////////////////////////////////////////////////////////
//
// NDIM
//
if (ascii_header_set (header, "NDIM", "%d", get_ndim()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload NDIM");
// //////////////////////////////////////////////////////////////////////
//
// STATE
//
std::string state = Signal::State2string( get_state() );
if (ascii_header_set (header, "STATE", "%s", state.c_str()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload STATE");
// //////////////////////////////////////////////////////////////////////
//
// TSAMP
//
/* IMPORTANT: TSAMP is the sampling period in microseconds */
double sampling_interval = 1e6 / get_rate();
if (ascii_header_set (header, "TSAMP", "%lf", sampling_interval)<0)
throw Error (InvalidState, "ASCIIObservation", "failed unload TSAMP");
// //////////////////////////////////////////////////////////////////////
//
// UTC_START
//
MJD epoch = get_start_time();
MJD integer_second ( epoch.intday(), epoch.get_secs(), 0.0 );
char datestr [64];
integer_second.datestr( datestr, 64, "%Y-%m-%d-%H:%M:%S" );
if (ascii_header_set (header, "UTC_START", "%s", datestr) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload UTC_START");
// //////////////////////////////////////////////////////////////////////
//
// OBS_OFFSET
//
double offset_samples = epoch.get_fracsec() * get_rate();
uint64_t offset_bytes = get_nbytes( (uint64_t)offset_samples );
if (ascii_header_set (header, "OBS_OFFSET", UI64, offset_bytes) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload OBS_OFFSET");
// //////////////////////////////////////////////////////////////////////
//
// INSTRUMENT
//
if (ascii_header_set (header, "INSTRUMENT", "%s", get_machine().c_str()) < 0)
throw Error (InvalidState, "ASCIIObservation", "failed unload INSTRUMENT");
}