//! Return the phase, given the epoch
Phase Tempo2::Predictor::phase (const MJD& t) const
{
if (verbose)
cerr << "Tempo2::Predictor::phase epoch=" << t << " frequency="
<< observing_frequency << endl;
if (observing_frequency <= 0)
Error error (InvalidState, "Tempo2::Predictor::phase",
"observing_frequency=%lf", (double) observing_frequency);
long double p = T2Predictor_GetPhase ( &predictor, from_MJD (t),
observing_frequency );
if (ChebyModelSet_OutOfRange)
throw Error (InvalidParam, "Tempo2::Predictor::phase",
"epoch %s not spanned by ChebyModelSet",
t.printdays(20).c_str());
if (!finite(p)) {
Error error (InvalidState, "Tempo2::Predictor::phase",
"T2Predictor_GetPhase result = ");
error << p;
throw error;
}
return to_Phase( p );
}
//! Return the spin frequency, given the epoch
long double Tempo2::Predictor::frequency (const MJD& t) const
{
long double f = T2Predictor_GetFrequency (&predictor, from_MJD (t),
observing_frequency);
if (ChebyModelSet_OutOfRange)
throw Error (InvalidParam, "Tempo2::Predictor::frequency",
"epoch %s not spanned by ChebyModelSet",
t.printdays(20).c_str());
return f;
}
MJD dsp::LoadToFold::parse_epoch (const std::string& epoch_string)
{
MJD epoch;
if (epoch_string == "start")
{
epoch = manager->get_info()->get_start_time();
epoch += manager->get_input()->tell_seconds();
if (Operation::verbose)
cerr << "dsp::LoadToFold::parse reference epoch=start_time="
<< epoch.printdays(13) << endl;
}
else if (!epoch_string.empty())
{
epoch = MJD( epoch_string );
if (Operation::verbose)
cerr << "dsp::LoadToFold::parse reference epoch="
<< epoch.printdays(13) << endl;
}
return epoch;
}
void qt_MJD::setMJD (const MJD& mjd)
{
value.setText (mjd.printdays(val_precision).c_str());
valset = mjd;
}
/*! This function assumes that the Integration will have the global
attributes of the file. */
Pulsar::Integration*
Pulsar::FITSArchive::load_Integration (const char* filename, unsigned isubint)
try {
if (!filename)
throw Error (InvalidParam, "FITSArchive::load_Integration",
"filename unspecified");
if (search_mode)
throw Error (InvalidParam, "FITSArchive::load_Integration",
"SEARCH mode data -- no Integrations to load");
Reference::To<Pulsar::Integration> integ = new_Integration();
init_Integration (integ);
int row = isubint + 1;
int status = 0;
if (verbose > 2)
cerr << "FITSArchive::load_Integration number " << isubint << endl;
double nulldouble = 0.0;
float nullfloat = 0.0;
int initflag = 0;
int colnum = 0;
// Open the file
fitsfile* fptr = 0;
if (verbose > 2)
cerr << "FITSArchive::load_Integration"
" fits_open_file (" << filename << ")" << endl;
fits_open_file (&fptr, filename, READONLY, &status);
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_open_file(%s)", filename);
// Move to the SUBINT Header Data Unit
fits_movnam_hdu (fptr, BINARY_TBL, "SUBINT", 0, &status);
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_movnam_hdu SUBINT");
// Load the convention for the epoch definition
string epoch_def;
string default_def = "STT_MJD";
psrfits_read_key (fptr, "EPOCHS", &epoch_def,
default_def, verbose > 2);
if (verbose > 2)
cerr << "FITSArchive::load_Integration epochs are " << epoch_def << endl;
// By default, correct epochs using the phase model
bool correct_epoch_phase = true;
// By default, correct epochs such that phase(epoch)=phase(start)
bool phase_match_start_time = true;
if (epoch_def == "VALID")
correct_epoch_phase = phase_match_start_time = false;
if (epoch_def == "MIDTIME")
phase_match_start_time = false;
if (get<Pulsar::IntegrationOrder>())
{
colnum = 0;
fits_get_colnum (fptr, CASEINSEN, "INDEXVAL", &colnum, &status);
double value = 0.0;
fits_read_col (fptr, TDOUBLE, colnum, row, 1, 1, &nulldouble,
&value, &initflag, &status);
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_read_col INDEXVAL");
get<Pulsar::IntegrationOrder>()->set_Index(row-1,value);
}
// Get the reference epoch from the primary header
const Pulsar::FITSHdrExtension* hdr_ext = get<Pulsar::FITSHdrExtension>();
if (!hdr_ext)
{
throw Error (InvalidParam, "FITSArchive::load_Integration",
"No FITSHdrExtension found");
}
// Set the duration of the integration
colnum = 0;
fits_get_colnum (fptr, CASEINSEN, "TSUBINT", &colnum, &status);
double duration = 0.0;
fits_read_col (fptr, TDOUBLE, colnum, row, 1, 1, &nulldouble,
&duration, &initflag, &status);
integ->set_duration (duration);
// Set the start time of the integration
initflag = 0;
colnum = 0;
fits_get_colnum (fptr, CASEINSEN, "OFFS_SUB", &colnum, &status);
double time = 0.0;
fits_read_col (fptr, TDOUBLE, colnum, row, 1, 1, &nulldouble,
&time, &initflag, &status);
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_read_col OFFS_SUB");
MJD epoch = hdr_ext->get_start_time() + time;
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration"
" header epoch=" << hdr_ext->get_start_time().printdays(13) << "\n "
" offset=" << time << "s epoch=" << epoch.printdays(13) << endl;
// Set a preliminary epoch to avoid problems loading the polyco
integ->set_epoch (epoch);
// Set the folding period to 0 until one of three possible methods succeeds
integ->set_folding_period (0.0);
/* **********************************************************************
METHOD 1: folding period defined by a pulse phase model
********************************************************************** */
if (hdr_model)
{
// Set the folding period, using the polyco from the file header
// This was taken out of the condition clause below because period
// wasn't set when TSUB was 0
integ->set_folding_period (1.0 / hdr_model->frequency(epoch));
if (integ->get_folding_period() <= 0.0)
throw Error( InvalidState, "Pulsar::FITSArchive::load_Integration",
"header polyco/predictor corrupted; "
"period(epoch=%s)=%lf", epoch.printdays(5).c_str(),
integ->get_folding_period() );
if (integ->get_folding_period() < 1.0e-3)
warning << "Pulsar::FITSArchive::load_Integration folding_period="
<< integ->get_folding_period() << " is less than 1ms" << endl;
else if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration folding_period = "
<< integ->get_folding_period () << endl;
if (duration && correct_epoch_phase)
{
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration correcting epoch phase"
<< endl;
Phase reference_phs = 0.0;
if (phase_match_start_time)
{
// Correct epoch such that its phase equals that of the start time
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration matching phase(start)"
<< endl;
reference_phs = hdr_model->phase(hdr_ext->get_start_time());
}
Phase off_phs = hdr_model->phase(epoch);
Phase dphase = off_phs - reference_phs;
double dtime = dphase.fracturns() * integ->get_folding_period();
epoch -= dtime;
integ->set_epoch (epoch);
if (verbose > 2)
{
cerr << "Pulsar::FITSArchive::load_Integration row=" << row <<
"\n PRED_PHS=" << predicted_phase;
if (phase_match_start_time)
cerr << "\n reference epoch="
<< hdr_ext->get_start_time().printdays(13);
cerr <<
"\n reference phase=" << reference_phs <<
"\n input phase=" << off_phs <<
"\n phase offset=" << dphase << " = " << dtime << "s"
"\n subint epoch=" << epoch.printdays(13) <<
"\n subint phase=" << hdr_model->phase(epoch) << endl;
}
}
}
else
{
/* *******************************************************************
METHOD 2: folding period defined by CAL_FREQ in primary header
******************************************************************* */
CalInfoExtension* calinfo = get<CalInfoExtension>();
if (calinfo && calinfo->cal_frequency > 0.0)
{
if (verbose > 2)
cerr << "FITSArchive::load_Integration CAL_FREQ="
<< calinfo->cal_frequency << endl;
integ->set_folding_period( 1.0/calinfo->cal_frequency );
}
/* *******************************************************************
METHOD 3: folding period defined by PERIOD column of SUBINT HDU
******************************************************************* */
double period = 0.0;
status = 0;
fits_get_colnum (fptr, CASEINSEN, "PERIOD", &colnum, &status);
fits_read_col (fptr, TDOUBLE, colnum, row, 1, 1, &nulldouble,
&period, &initflag, &status);
if (status == 0 && period > 0.0)
{
if (verbose > 2)
cerr << "FITSArchive::load_Integration PERIOD=" << period << endl;
integ->set_folding_period (period);
}
if (integ->get_folding_period() == 0.0)
throw FITSError (status, "FITSArchive::load_Integration",
"folding period unknown: no model, CAL_FREQ or PERIOD");
}
status = 0;
// Load other useful info
load_Pointing (fptr,row,integ);
load_Plasma (fptr,row,integ);
// Set up the data vector, only Pulsar::Archive base class is friend
resize_Integration (integ);
const unsigned nchan = get_nchan();
if (naux_profile)
for (unsigned ichan=0; ichan < nchan; ichan++)
{
FourthMoments* fourth = new FourthMoments;
fourth->resize (naux_profile, get_nbin());
integ->get_Profile(0,ichan)->add_extension (fourth);
}
// Load the channel centre frequencies
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration reading channel freqs"
<< endl;
int counter = 1;
vector < float > chan_freqs(get_nchan());
colnum = 0;
fits_get_colnum (fptr, CASEINSEN, "DAT_FREQ", &colnum, &status);
fits_read_col (fptr, TFLOAT, colnum, row, counter, get_nchan(),
&nullfloat, &(chan_freqs[0]), &initflag, &status);
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_read_col DAT_FREQ");
// Set the profile channel centre frequencies
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration setting frequencies"
<< endl;
bool all_ones = true;
for (unsigned j = 0; j < get_nchan(); j++)
if (chan_freqs[j] != 1)
all_ones = false;
double chanbw = get_bandwidth() / get_nchan();
if ( all_ones )
{
if (verbose > 2)
cerr << "FITSArchive::load_Integration all frequencies unity - reseting"
<< endl;
for (unsigned j = 0; j < get_nchan(); j++)
integ->set_centre_frequency (j, get_centre_frequency()
-0.5*(get_bandwidth()+chanbw)+j*chanbw);
}
else
{
for (unsigned j = 0; j < get_nchan(); j++)
integ->set_centre_frequency(j, chan_freqs[j]);
}
// Load the profile weights
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration reading weights"
<< endl;
counter = 1;
vector < float > weights(get_nchan());
colnum = 0;
fits_get_colnum (fptr, CASEINSEN, "DAT_WTS", &colnum, &status);
for (unsigned b = 0; b < get_nchan(); b++) {
fits_read_col (fptr, TFLOAT, colnum, row, counter, 1, &nullfloat,
&weights[b], &initflag, &status);
counter ++;
}
if (status != 0)
throw FITSError (status, "FITSArchive::load_Integration",
"fits_read_col DAT_WTS");
// Set the profile weights
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration setting weights"
<< endl;
for(unsigned j = 0; j < get_nchan(); j++)
integ->set_weight(j, weights[j]);
// Load the profile offsets
if (!Profile::no_amps)
{
vector<Profile*> profiles;
setup_profiles_dat (integ, profiles);
setup_dat (fptr, load_dat_io);
if (verbose > 2)
cerr << "FITSArchive::load_Integration dat_io=" << load_dat_io.ptr()
<< endl;
load_dat_io->load (isubint + 1, profiles);
if (scale_cross_products && integ->get_state() == Signal::Coherence)
for (unsigned ichan=0; ichan < get_nchan(); ichan++)
{
integ->get_Profile(2, ichan)->scale(2.0);
integ->get_Profile(3, ichan)->scale(2.0);
}
if (naux_profile)
{
setup_profiles<MoreProfiles> (integ, profiles);
setup_aux (fptr, load_aux_io, naux_profile);
load_aux_io->load (isubint + 1, profiles);
}
}
if (verbose > 2)
cerr << "Pulsar::FITSArchive::load_Integration load complete" << endl;
// Finished with the file for now
fits_close_file (fptr, &status);
return integ.release();
}
catch (Error& error)
{
throw error += "Pulsar::FITSArchive::load_Integration";
}
bool dsp::PhaseSeries::mixable (const Observation& obs, unsigned nbin,
int64_t istart, int64_t fold_ndat)
{
MJD obsStart = obs.get_start_time() + double (istart) / obs.get_rate();
if (verbose)
cerr << "PhaseSeries::mixable start mix=" << obsStart.printdays(8)
<< " cur=" << get_start_time().printdays(8) << endl;
MJD obsEnd;
// if fold_ndat is not specified, fold to the end of the Observation
// (works also for special case of adding dsp::PhaseSeriess together;
// where using ndat=nbin would not make sense)
if (fold_ndat == 0)
obsEnd = obs.get_end_time();
else
obsEnd = obsStart + double (fold_ndat) / obs.get_rate();
if (integration_length == 0.0)
{
// the integration is currently empty; prepare for integration
if (verbose)
cerr << "PhaseSeries::mixable reset" << endl;
Observation::operator = (obs);
if (verbose)
cerr << "dsp::PhaseSeries::mixable rate=" << get_rate() << endl;
const TimeSeries* series = dynamic_cast<const TimeSeries*> (&obs);
if (series)
{
if (verbose)
cerr << "dsp::PhaseSeries::mixable calling set_order" << endl;
set_order( series->get_order() );
if (verbose)
cerr << "dsp::PhaseSeries::mixable calling set_zeroed_data" << endl;
set_zeroed_data( series->get_zeroed_data() );
if (get_zeroed_data())
set_hits_nchan( series->get_nchan() );
}
end_time = obsEnd;
start_time = obsStart;
/*
the integration length may be zero only because all of the samples
have been dropped - maintain the record of dropped samples
*/
uint64_t backup_ndat_total = ndat_total;
if (verbose)
cerr << "dsp::PhaseSeries::mixable calling resize(" << nbin << ")" << endl;
resize (nbin);
if (verbose)
cerr << "dsp::PhaseSeries::mixable calling zero()" << endl;
zero ();
ndat_total = backup_ndat_total;
return true;
}
if (!combinable (obs)) {
cerr << "PhaseSeries::mixable differing observations" << endl;
return false;
}
if (get_nbin() != nbin) {
cerr << "PhaseSeries::mixable nbin=" << get_nbin() <<" != "<< nbin <<endl;
return false;
}
end_time = std::max (end_time, obsEnd);
start_time = std::min (start_time, obsStart);
if (verbose)
cerr << "PhaseSeries::mixable combine start=" << start_time.printdays(8)
<< " end=" << end_time.printdays(8) << endl;
return true;
}
void Calibration::SignalPath::disengage_time_variations (const MJD& epoch)
try
{
#ifdef _DEBUG
cerr << "DISENGAGE epoch=" << epoch.printdays(16) << endl;
#endif
if (!time_variations_engaged)
return;
time_variations_engaged = false;
BackendFeed* physical = dynamic_cast<BackendFeed*>( response.get() );
if (!physical)
return;
time.set_value (epoch);
Univariate<Scalar>* zero = 0;
#ifdef _DEBUG
cerr << "before disengage nparam = " << physical->get_nparam() << endl;
#endif
if (gain)
{
#ifdef _DEBUG
cerr << "disengage gain" << endl;
#endif
if (!constant_pulsar_gain)
{
physical->set_gain( zero );
physical->set_gain( gain->estimate() );
}
else if (pcal_gain_chain)
{
pcal_gain_chain->set_constraint( 0, zero );
pcal_gain->set_gain( gain->estimate() );
}
}
if (pcal_gain)
physical->set_gain( pcal_gain->get_gain() );
if (diff_gain)
{
#ifdef _DEBUG
cerr << "disengage diff_gain value=" << diff_gain->estimate() << endl;
#endif
physical->set_diff_gain( zero );
physical->set_diff_gain( diff_gain->estimate() );
}
if (diff_phase)
{
#ifdef _DEBUG
cerr << "disengage diff_phase value=" << diff_phase->estimate() << endl;
#endif
physical->set_diff_phase( zero );
physical->set_diff_phase( diff_phase->estimate() );
}
#ifdef _DEBUG
cerr << "after disengage nparam = " << physical->get_nparam() << endl;
#endif
}
catch (Error& error)
{
throw error += "Calibration::SignalPath::disengage_time_variations";
}