std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadSingleBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadAllBeamlets(timestepStart, timestepEnd, beamletCount);
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, 1);
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(width, 1);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr maskWithBeamlets = data.first.GetSingleMask();
for(unsigned x=0;x<width;++x)
{
realX->SetValue(x, 0, xr->Value(x, beamletIndex));
imaginaryX->SetValue(x, 0, xi->Value(x, beamletIndex));
realY->SetValue(x, 0, yr->Value(x, beamletIndex));
imaginaryY->SetValue(x, 0, yi->Value(x, beamletIndex));
mask->SetValue(x, 0, maskWithBeamlets->Value(x, beamletIndex));
}
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
BandInfo band = data.second->Band();
band.channels[0] = data.second->Band().channels[beamletIndex];
band.channels.resize(1);
data.second->SetBand(band);
return data;
}
TimeFrequencyData TimeFrequencyImager::GetData() const
{
TimeFrequencyData data;
if(
_realXX != 0 && _imaginaryXX != 0 &&
_realXY != 0 && _imaginaryXY != 0 &&
_realYX != 0 && _imaginaryYX != 0 &&
_realYY != 0 && _imaginaryYY != 0)
{
data = TimeFrequencyData(_realXX, _imaginaryXX, _realXY, _imaginaryXY, _realYX, _imaginaryYX, _realYY, _imaginaryYY);
} else if(
_realXX != 0 && _imaginaryXX != 0 &&
_realYY != 0 && _imaginaryYY != 0)
{
data = TimeFrequencyData(AutoDipolePolarisation, _realXX, _imaginaryXX, _realYY, _imaginaryYY);
} else if(_realStokesI != 0 && _imaginaryStokesI != 0)
{
data = TimeFrequencyData(StokesIPolarisation, _realStokesI, _imaginaryStokesI);
}
if(_flagXX != 0 && _flagXY != 0 && _flagYX != 0 && _flagYY != 0)
{
if(data.Polarisation() != DipolePolarisation)
throw BadUsageException("Trying to read dipole polarisation masks, but TF data does not have the dipole polarisations");
data.SetIndividualPolarisationMasks(_flagXX, _flagXY, _flagYX, _flagYY);
} else if(_flagXX != 0 && _flagYY != 0)
{
if(data.Polarisation() != AutoDipolePolarisation)
throw BadUsageException("Trying to read auto dipole polarisation masks, but TF data does not have the auto dipole polarisations");
data.SetIndividualPolarisationMasks(_flagXX, _flagYY);
} else if(_flagCombined != 0)
{
data.SetGlobalMask(_flagCombined);
}
return data;
}
TimeFrequencyData BaselineReader::GetNextResult(std::vector<class UVW>& uvw)
{
size_t requestIndex = 0;
TimeFrequencyData data;
data = TimeFrequencyData(
_polarizations.data(),
_polarizations.size(),
_results[requestIndex]._realImages.data(),
_results[requestIndex]._imaginaryImages.data());
data.SetIndividualPolarizationMasks(_results[requestIndex]._flags.data());
uvw = _results[0]._uvw;
_results.erase(_results.begin() + requestIndex);
return data;
}
std::pair<TimeFrequencyData, TimeFrequencyMetaDataCPtr> TimeFrequencyPlotPage::ConstructImage()
{
if(HasStatistics())
{
const QualityTablesFormatter::StatisticKind kind = GetSelectedStatisticKind();
StatisticsDerivator derivator(*_statCollection);
std::pair<TimeFrequencyData, TimeFrequencyMetaDataCPtr> data = derivator.CreateTFData(kind);
if(data.second == 0)
{
GrayScaleWidget().SetXAxisDescription("Time index");
GrayScaleWidget().SetYAxisDescription("Frequency index");
} else {
GrayScaleWidget().SetXAxisDescription("Time");
GrayScaleWidget().SetYAxisDescription("Frequency (MHz)");
}
return data;
} else {
return std::pair<TimeFrequencyData, TimeFrequencyMetaDataCPtr>(TimeFrequencyData(), TimeFrequencyMetaDataCPtr());
}
}
void BHFitsImageSet::loadImageData(TimeFrequencyData &data, const TimeFrequencyMetaDataPtr &metaData, const BHFitsImageSetIndex &index)
{
std::vector<num_t> buffer(_width * _height);
_file->ReadCurrentImageData(0, &buffer[0], _width * _height);
int
rangeStart = _timeRanges[index._imageIndex].start,
rangeEnd = _timeRanges[index._imageIndex].end;
Image2DPtr image = Image2D::CreateZeroImagePtr(rangeEnd-rangeStart, _height);
std::vector<num_t>::const_iterator bufferPtr = buffer.begin() + _height*rangeStart;
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
image->SetValue(x-rangeStart, y, *bufferPtr);
++bufferPtr;
}
}
data = TimeFrequencyData(TimeFrequencyData::AmplitudePart, SinglePolarisation, image);
try {
FitsFile flagFile(flagFilePath());
flagFile.Open(FitsFile::ReadOnlyMode);
flagFile.ReadCurrentImageData(0, &buffer[0], _width * _height);
bufferPtr = buffer.begin() + _height*rangeStart;
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(rangeEnd-rangeStart, _height);
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
bool flag = false;
if(*bufferPtr == 0.0)
flag = false;
else if(*bufferPtr == 1.0)
flag = true;
else std::runtime_error("Expecting a flag file with only ones and zeros, but this file contained other values.");
mask->SetValue(x-rangeStart, y, flag);
++bufferPtr;
}
}
data.SetGlobalMask(mask);
} catch(std::exception &)
{
// Flag file could not be read; probably does not exist. Ignore this, flags will be initialized to false.
}
double
frequencyDelta = _file->GetDoubleKeywordValue("CDELT1"),
timeDelta = _file->GetDoubleKeywordValue("CDELT2");
BandInfo band;
for(int ch=0; ch!=_height; ++ch)
{
ChannelInfo channel;
channel.frequencyHz = ch * frequencyDelta * 1000000.0;
band.channels.push_back(channel);
}
metaData->SetBand(band);
const int rangeWidth = rangeEnd-rangeStart;
std::vector<double> observationTimes(rangeWidth);
for(int t=0; t!=rangeWidth; ++t)
observationTimes[t] = (t + rangeStart) * timeDelta;
metaData->SetObservationTimes(observationTimes);
AntennaInfo antennaInfo;
antennaInfo.id = 0;
antennaInfo.name = RangeName(index._imageIndex);
antennaInfo.diameter = 0.0;
antennaInfo.mount = "Unknown";
antennaInfo.station = GetTelescopeName();
metaData->SetAntenna1(antennaInfo);
metaData->SetAntenna2(antennaInfo);
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadChannelBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
const unsigned width = timestepEnd - timestepStart;
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadSingleBeamlet(timestepStart*(unsigned long) 256, timestepEnd*(unsigned long) 256, beamletCount, beamletIndex);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr mask = data.first.GetSingleMask();
Image2DPtr
outXR = Image2D::CreateUnsetImagePtr(width, 256),
outXI = Image2D::CreateUnsetImagePtr(width, 256),
outYR = Image2D::CreateUnsetImagePtr(width, 256),
outYI = Image2D::CreateUnsetImagePtr(width, 256);
Mask2DPtr
outMask = Mask2D::CreateUnsetMaskPtr(width, 256);
std::vector<double> observationTimes;
for(unsigned long timestep = 0;timestep < timestepEnd-timestepStart;++timestep)
{
unsigned long timestepIndex = timestep * 256;
SampleRow
realX = SampleRow::MakeFromRow(xr.get(), timestepIndex, 256, 0),
imaginaryX = SampleRow::MakeFromRow(xi.get(), timestepIndex, 256, 0),
realY = SampleRow::MakeFromRow(yr.get(), timestepIndex, 256, 0),
imaginaryY = SampleRow::MakeFromRow(yi.get(), timestepIndex, 256, 0);
FFTTools::FFT(realX, imaginaryX);
FFTTools::FFT(realY, imaginaryY);
realX.SetVerticalImageValues(outXR.get(), timestep);
imaginaryX.SetVerticalImageValues(outXI.get(), timestep);
realY.SetVerticalImageValues(outYR.get(), timestep);
imaginaryY.SetVerticalImageValues(outYI.get(), timestep);
observationTimes.push_back(data.second->ObservationTimes()[timestepIndex + 256/2]);
size_t validValues = 0;
for(unsigned y=0;y<256;++y)
{
if(!mask->Value(timestepIndex + y, 0))
++validValues;
}
for(unsigned y=0;y<256;++y)
{
outMask->SetValue(timestep, y , validValues == 0);
}
}
data.first = TimeFrequencyData(Polarization::XX, outXR, outXI, Polarization::YY, outYR, outYI);
data.first.SetGlobalMask(outMask);
BandInfo band = data.second->Band();
band.channels.clear();
for(unsigned i=0;i<256;++i)
{
ChannelInfo channel;
channel.frequencyHz = i+1;
channel.frequencyIndex = i;
band.channels.push_back(channel);
}
data.second->SetBand(band);
data.second->SetObservationTimes(observationTimes);
return data;
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadAllBeamlets(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount)
{
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, beamletCount);
Mask2DPtr mask = Mask2D::CreateSetMaskPtr<true>(width, beamletCount);
std::ifstream file(_rawFile.c_str(), std::ios_base::binary | std::ios_base::in);
size_t frame = 0;
std::set<short> stations;
TimeFrequencyMetaDataPtr metaData = TimeFrequencyMetaDataPtr(new TimeFrequencyMetaData());
BandInfo band;
for(size_t i=0;i<beamletCount;++i)
{
ChannelInfo channel;
channel.frequencyHz = i+1;
channel.frequencyIndex = i;
band.channels.push_back(channel);
}
metaData->SetBand(band);
std::vector<double> observationTimes;
// Read a header and determine the reading start position
// Because timestepStart might fall within a block, the
RCPApplicationHeader firstHeader;
firstHeader.Read(file);
const unsigned long bytesPerFrame = beamletCount * firstHeader.nofBlocks * RCPBeamletData::SIZE + RCPApplicationHeader::SIZE;
const unsigned long startFrame = timestepStart / (unsigned long) firstHeader.nofBlocks;
const unsigned long startByte = startFrame * bytesPerFrame;
const unsigned long offsetFromStart = timestepStart - (startFrame * firstHeader.nofBlocks);
//Logger::Debug << "Seeking to " << startByte << " (timestepStart=" << timestepStart << ", offsetFromStart=" << offsetFromStart << ", startFrame=" << startFrame << ",bytesPerFrame=" << bytesPerFrame << ")\n";
file.seekg(startByte, std::ios_base::beg);
// Read the frames
unsigned long x=0;
while(x < width + offsetFromStart && file.good()) {
RCPApplicationHeader header;
header.Read(file);
if(header.versionId != 2)
{
std::stringstream s;
s << "Corrupted header found in frame " << frame << "!";
throw std::runtime_error(s.str());
}
if(stations.count(header.stationId)==0)
{
stations.insert(header.stationId);
AntennaInfo antenna;
std::stringstream s;
s << "LOFAR station with index " << header.stationId;
antenna.name = s.str();
metaData->SetAntenna1(antenna);
metaData->SetAntenna2(antenna);
}
for(size_t j=0;j<beamletCount;++j)
{
for(size_t i=0;i<header.nofBlocks;++i)
{
RCPBeamletData data;
data.Read(file);
if(i + x < width + offsetFromStart && i + x >= offsetFromStart)
{
const unsigned long pos = i + x - offsetFromStart;
realX->SetValue(pos, j, data.xr);
imaginaryX->SetValue(pos, j, data.xi);
realY->SetValue(pos, j, data.yr);
imaginaryY->SetValue(pos, j, data.yi);
mask->SetValue(pos, j, false);
}
}
}
x += header.nofBlocks;
++frame;
}
//Logger::Debug << "Read " << frame << " frames.\n";
for(unsigned long i=0;i<width;++i)
{
const unsigned long pos = i + timestepStart;
const double time =
(double) pos * (double) STATION_INTEGRATION_STEPS / (double) _clockSpeed;
observationTimes.push_back(time);
}
metaData->SetObservationTimes(observationTimes);
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data;
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
data.second = metaData;
return data;
}
