num_t UVImager::GetFringeCount(size_t timeIndexStart, size_t timeIndexEnd, unsigned channelIndex, const TimeFrequencyMetaDataCPtr metaData)
{
// For now, I've made this return the negative fringe count, because it does not match
// with the fringe stop frequency returned above otherwise; probably because of a
// mismatch in the signs of u,v,w somewhere...
return -(metaData->UVW()[timeIndexEnd].w - metaData->UVW()[timeIndexStart].w) * metaData->Band().channels[channelIndex].frequencyHz / 299792458.0L;
}
void PlotAction::plotSpectrumPerBaseline(ArtifactSet &artifacts)
{
if(artifacts.FrequencyPowerPlot() == 0)
throw BadUsageException("No frequency power plot in the artifact set");
TimeFrequencyData &data = artifacts.ContaminatedData();
TimeFrequencyMetaDataCPtr meta = artifacts.MetaData();
artifacts.FrequencyPowerPlot()->SetLogYAxis(_logYAxis);
artifacts.FrequencyPowerPlot()->StartNewLine(meta->Antenna1().name + " x " + meta->Antenna2().name);
artifacts.FrequencyPowerPlot()->Add(data, meta);
}
void ImagerAction::Perform(ArtifactSet &artifacts, ProgressListener &progress)
{
boost::mutex::scoped_lock lock(_imagerMutex);
UVImager *imager = artifacts.Imager();
if(imager == 0)
throw BadUsageException("No imager available to create image.");
TimeFrequencyData &data = artifacts.ContaminatedData();
TimeFrequencyMetaDataCPtr metaData = artifacts.MetaData();
if(data.PolarisationCount() > 1)
{
TimeFrequencyData *tmp = data.CreateTFData(StokesIPolarisation);
data = *tmp;
delete tmp;
}
bool btPlaneImager = true;
if(btPlaneImager)
{
typedef double ImagerNumeric;
BaselineTimePlaneImager<ImagerNumeric> btImager;
BandInfo band = metaData->Band();
Image2DCPtr
inputReal = data.GetRealPart(),
inputImag = data.GetImaginaryPart();
Mask2DCPtr mask = data.GetSingleMask();
size_t width = inputReal->Width();
for(size_t t=0;t!=width;++t)
{
UVW uvw = metaData->UVW()[t];
size_t channelCount = inputReal->Height();
std::vector<std::complex<ImagerNumeric> > data(channelCount);
for(size_t ch=0;ch!=channelCount;++ch) {
if(mask->Value(t, ch))
data[ch] = std::complex<ImagerNumeric>(0.0, 0.0);
else
data[ch] = std::complex<ImagerNumeric>(inputReal->Value(t, ch), inputImag->Value(t, ch));
}
btImager.Image(uvw.u, uvw.v, uvw.w, band.channels[0].frequencyHz, band.channels[1].frequencyHz-band.channels[0].frequencyHz, channelCount, &(data[0]), imager->FTReal());
}
} else {
progress.OnStartTask(*this, 0, 1, "Imaging baseline");
for(size_t y=0;y<data.ImageHeight();++y)
{
imager->Image(data, metaData, y);
progress.OnProgress(*this, y, data.ImageHeight());
}
progress.OnEndTask(*this);
}
}
void FrequencyFlagCountPlot::Add(class TimeFrequencyData &data, TimeFrequencyMetaDataCPtr meta)
{
_ignoreFirstChannel = _ignoreFirstChannel && data.ImageHeight() != 1;
size_t yStart = _ignoreFirstChannel ? 1 : 0;
for(size_t maskIndex=0;maskIndex<data.MaskCount();++maskIndex)
{
Mask2DCPtr mask = data.GetMask(maskIndex);
for(size_t y=yStart;y<mask->Height();++y)
{
double frequency = meta->Band().channels[y].frequencyHz;
size_t count = 0;
for(size_t x=0;x<mask->Width();++x)
{
if(mask->Value(x, y))
++count;
}
MapItem item = _counts[frequency];
item.count += count;
item.total += mask->Width();
_counts[frequency] = item;
}
}
}
void UVImager::GetUVPosition(num_t &u, num_t &v, size_t timeIndex, size_t frequencyIndex, TimeFrequencyMetaDataCPtr metaData)
{
num_t frequency = metaData->Band().channels[frequencyIndex].frequencyHz;
u = metaData->UVW()[timeIndex].u * frequency / SpeedOfLight();
v = metaData->UVW()[timeIndex].v * frequency / SpeedOfLight();
return;
const Baseline &baseline = metaData->Baseline();
num_t delayDirectionRA = metaData->Field().delayDirectionRA;
num_t delayDirectionDec = metaData->Field().delayDirectionDec;
double time = metaData->ObservationTimes()[timeIndex];
num_t pointingLattitude = delayDirectionRA;
num_t earthLattitudeAngle = Date::JDToHourOfDay(Date::AipsMJDToJD(time))*M_PIn/12.0L;
// Rotate baseline plane towards source, first rotate around x axis, then around z axis
num_t raRotation = earthLattitudeAngle - pointingLattitude + M_PIn*0.5L;
num_t raCos = cosn(-raRotation);
num_t raSin = sinn(-raRotation);
num_t dx = baseline.antenna1.x - baseline.antenna2.x;
num_t dy = baseline.antenna1.y - baseline.antenna2.y;
num_t dz = baseline.antenna1.z - baseline.antenna2.z;
num_t decCos = cosn(delayDirectionDec);
num_t decSin = sinn(delayDirectionDec);
num_t
du = -dx * raCos * decSin - dy * raSin - dz * raCos * decCos,
dv = -dx * raSin * decSin + dy * raCos - dz * raSin * decCos;
/*
num_t dxProjected = tmpCos*dx - tmpSin*dy;
num_t tmpdy = tmpSin*dx + tmpCos*dy;
num_t dyProjected = tmpCos*tmpdy - tmpSin*dz;*/
// du = dx*cosn(ra) - dy*sinn(ra)
// dv = ( dx*sinn(ra) + dy*cosn(ra) ) * cosn(-dec) - dz * sinn(-dec)
// Now, the newly projected positive z axis of the baseline points to the field
num_t baselineLength = sqrtn(du*du + dv*dv);
num_t baselineAngle;
if(baselineLength == 0.0)
baselineAngle = 0.0;
else {
baselineLength *= frequency / SpeedOfLight();
if(du > 0.0L)
baselineAngle = atann(du/dv);
else
baselineAngle = M_PIn - atann(du/-dv);
}
u = cosn(baselineAngle)*baselineLength;
v = -sinn(baselineAngle)*baselineLength;
std::cout << "Calced: " << u << "," << v
<< ", ori: " << metaData->UVW()[timeIndex].u << "," << metaData->UVW()[timeIndex].v << "(," << metaData->UVW()[timeIndex].w << ")\n";
}
num_t UVImager::GetFringeStopFrequency(size_t timeIndex, const Baseline &/*baseline*/, num_t /*delayDirectionRA*/, num_t delayDirectionDec, num_t /*frequency*/, TimeFrequencyMetaDataCPtr metaData)
{
// earthspeed = rad / sec
const num_t earthSpeed = 2.0L * M_PIn / (24.0L * 60.0L * 60.0L);
//num_t earthLattitudeAngle =
// Date::JDToHourOfDay(Date::AipsMJDToJD(metaData->ObservationTimes()[timeIndex]))*M_PIn/12.0L;
//num_t raSin = sinn(-delayDirectionRA - earthLattitudeAngle);
//num_t raCos = cosn(-delayDirectionRA - earthLattitudeAngle);
//num_t dx = baseline.antenna2.x - baseline.antenna1.x;
//num_t dy = baseline.antenna2.y - baseline.antenna1.y;
//num_t wavelength = 299792458.0L / frequency;
return -earthSpeed * metaData->UVW()[timeIndex].u * cosn(delayDirectionDec);
}
void PlotAction::plotBaselineRMS(ArtifactSet &artifacts)
{
if(artifacts.PolarizationStatistics() == 0)
throw BadUsageException("No polarization statistics in the artifact set");
TimeFrequencyData &data = artifacts.ContaminatedData();
TimeFrequencyMetaDataCPtr metaData = artifacts.MetaData();
double rms = 0.0;
for(unsigned i=0;i<data.PolarisationCount();++i)
{
TimeFrequencyData *polarisation = data.CreateTFDataFromPolarisationIndex(i);
Mask2DCPtr mask = polarisation->GetSingleMask();
for(unsigned j=0;j<polarisation->ImageCount();++j)
{
Image2DCPtr image = polarisation->GetImage(j);
rms += ThresholdTools::RMS(image, mask);
}
delete polarisation;
}
rms /= data.PolarisationCount();
;
AOLogger::Info << "RMS of " << metaData->Antenna1().name << " x " << metaData->Antenna2().name << ": "
<< rms << '\n';
}
void FrequencyPowerPlot::Add(class TimeFrequencyData &data, TimeFrequencyMetaDataCPtr meta)
{
Image2DCPtr image = data.GetSingleImage();
Mask2DCPtr mask = data.GetSingleMask();
for(size_t y=0;y<image->Height();++y)
{
double frequency = meta->Band().channels[y].frequencyHz;
size_t count = 0;
long double value = 0.0L;
for(size_t x=0;x<image->Width();++x)
{
if(!mask->Value(x, y))
{
++count;
value += image->Value(x, y);
}
}
MapItem &item = _values[frequency];
item.total += value;
item.count += count;
}
}
void ComplexPlanePlotWindow::setDetailsLabel()
{
size_t x = (size_t) _xPositionScale.get_value();
size_t y = (size_t) _yPositionScale.get_value();
size_t length = (size_t) _lengthScale.get_value();
size_t avgSize = (size_t) _ySumLengthScale.get_value();
size_t middleY = (2*y + avgSize) / 2;
TimeFrequencyMetaDataCPtr metaData = _msWindow.TimeFrequencyMetaData();
double timeStart = _observationTimes[x];
double deltaTime;
if(_observationTimes.size()>1)
deltaTime = _observationTimes[1] - _observationTimes[0];
else
deltaTime = 1.0;
long double frequency = metaData->Band().channels[middleY].frequencyHz;
Baseline baseline(metaData->Antenna1(), metaData->Antenna2());
long double delayRA = metaData->Field().delayDirectionRA;
long double delayDec = metaData->Field().delayDirectionDec;
long double intFringeFreq =
UVImager::GetFringeCount(x, x+length, y, metaData);
long double midFringeFreq =
UVImager::GetFringeStopFrequency((x*2 + length)/2, baseline, delayRA, delayDec, frequency, metaData);
std::stringstream s;
s << "Start time: " << Date::AipsMJDToString(timeStart) << std::endl
<< "Frequency: " << frequency/1000000.0L << "Mhz" << std::endl
<< "Baseline: " << baseline.Distance() << "m" << std::endl
<< "Delay direction: " << delayRA << "RA, " << delayDec << "dec." << std::endl
<< "(=" << RightAscension::ToString(delayRA) << " RA, " << Declination::ToString(delayDec) << " dec.)" << std::endl
<< "Mid fringe stopping freq: " << midFringeFreq << "(Hz)" << std::endl
<< "Fringe count: " << intFringeFreq << std::endl
<< "Fringe length: " << 1.0L/intFringeFreq << "(s)" << std::endl
<< "Time step: " << deltaTime << "(s)" << std::endl
<< "Samples/fringe: " << (1.0L / (deltaTime * intFringeFreq)) << std::endl
<< "Fringes in domain: " << intFringeFreq << std::endl;
_detailsLabel.set_text(s.str());
}
