void actionCollect(const std::string &filename, enum CollectingMode mode, StatisticsCollection &statisticsCollection, HistogramCollection &histogramCollection, bool mwaChannels, size_t flaggedTimesteps, const std::set<size_t> &flaggedAntennae)
{
MeasurementSet *ms = new MeasurementSet(filename);
const unsigned polarizationCount = ms->PolarizationCount();
const unsigned bandCount = ms->BandCount();
const bool ignoreChannelZero = ms->IsChannelZeroRubish();
const std::string stationName = ms->GetStationName();
BandInfo *bands = new BandInfo[bandCount];
double **frequencies = new double*[bandCount];
unsigned totalChannels = 0;
for(unsigned b=0;b<bandCount;++b)
{
bands[b] = ms->GetBandInfo(b);
frequencies[b] = new double[bands[b].channels.size()];
totalChannels += bands[b].channels.size();
for(unsigned c=0;c<bands[b].channels.size();++c)
{
frequencies[b][c] = bands[b].channels[c].frequencyHz;
}
}
delete ms;
std::cout
<< "Polarizations: " << polarizationCount << '\n'
<< "Bands: " << bandCount << '\n'
<< "Channels/band: " << (totalChannels / bandCount) << '\n';
if(ignoreChannelZero)
std::cout << "Channel zero will be ignored, as this looks like a LOFAR data set with bad channel 0.\n";
else
std::cout << "Channel zero will be included in the statistics, as it seems that channel 0 is okay.\n";
// Initialize statisticscollection
statisticsCollection.SetPolarizationCount(polarizationCount);
if(mode == CollectDefault)
{
for(unsigned b=0;b<bandCount;++b)
{
if(ignoreChannelZero)
statisticsCollection.InitializeBand(b, (frequencies[b]+1), bands[b].channels.size()-1);
else
statisticsCollection.InitializeBand(b, frequencies[b], bands[b].channels.size());
}
}
// Initialize Histograms collection
histogramCollection.SetPolarizationCount(polarizationCount);
// get columns
casa::Table table(filename, casa::Table::Update);
const char *dataColumnName = "DATA";
casa::ROArrayColumn<casa::Complex> dataColumn(table, dataColumnName);
casa::ROArrayColumn<bool> flagColumn(table, "FLAG");
casa::ROScalarColumn<double> timeColumn(table, "TIME");
casa::ROScalarColumn<int> antenna1Column(table, "ANTENNA1");
casa::ROScalarColumn<int> antenna2Column(table, "ANTENNA2");
casa::ROScalarColumn<int> windowColumn(table, "DATA_DESC_ID");
std::cout << "Collecting statistics..." << std::endl;
size_t channelCount = bands[0].channels.size();
bool *correlatorFlags = new bool[channelCount];
bool *correlatorFlagsForBadAntenna = new bool[channelCount];
for(size_t ch=0; ch!=channelCount; ++ch)
{
correlatorFlags[ch] = false;
correlatorFlagsForBadAntenna[ch] = true;
}
if(mwaChannels)
{
if(channelCount%24 != 0)
std::cout << "MWA channels requested, but nr of channels not a multiply of 24. Ignoring.\n";
else {
size_t chanPerSb = channelCount/24;
for(size_t x=0;x!=24;++x)
{
correlatorFlags[x*chanPerSb] = true;
correlatorFlags[x*chanPerSb + chanPerSb/2] = true;
correlatorFlags[x*chanPerSb + chanPerSb-1] = true;
}
}
}
const unsigned nrow = table.nrow();
size_t timestepIndex = (size_t) -1;
double prevtime = -1.0;
for(unsigned row = 0; row!=nrow; ++row)
{
const double time = timeColumn(row);
const unsigned antenna1Index = antenna1Column(row);
const unsigned antenna2Index = antenna2Column(row);
const unsigned bandIndex = windowColumn(row);
if(time != prevtime)
{
++timestepIndex;
prevtime = time;
}
const BandInfo &band = bands[bandIndex];
const casa::Array<casa::Complex> dataArray = dataColumn(row);
const casa::Array<bool> flagArray = flagColumn(row);
std::vector<std::complex<float>* > samples(polarizationCount);
bool **isRFI = new bool*[polarizationCount];
for(unsigned p = 0; p < polarizationCount; ++p)
{
isRFI[p] = new bool[band.channels.size()];
samples[p] = new std::complex<float>[band.channels.size()];
}
const bool antennaIsFlagged =
flaggedAntennae.find(antenna1Index) != flaggedAntennae.end() ||
flaggedAntennae.find(antenna2Index) != flaggedAntennae.end();
casa::Array<casa::Complex>::const_iterator dataIter = dataArray.begin();
casa::Array<bool>::const_iterator flagIter = flagArray.begin();
const unsigned startChannel = ignoreChannelZero ? 1 : 0;
if(ignoreChannelZero)
{
for(unsigned p = 0; p < polarizationCount; ++p)
{
++dataIter;
++flagIter;
}
}
for(unsigned channel = startChannel ; channel<band.channels.size(); ++channel)
{
for(unsigned p = 0; p < polarizationCount; ++p)
{
samples[p][channel - startChannel] = *dataIter;
isRFI[p][channel - startChannel] = *flagIter;
++dataIter;
++flagIter;
}
}
for(unsigned p = 0; p < polarizationCount; ++p)
{
switch(mode)
{
case CollectDefault:
if(antennaIsFlagged || timestepIndex < flaggedTimesteps)
statisticsCollection.Add(antenna1Index, antenna2Index, time, bandIndex, p, &samples[p]->real(), &samples[p]->imag(), isRFI[p], correlatorFlagsForBadAntenna, band.channels.size() - startChannel, 2, 1, 1);
else
statisticsCollection.Add(antenna1Index, antenna2Index, time, bandIndex, p, &samples[p]->real(), &samples[p]->imag(), isRFI[p], correlatorFlags, band.channels.size() - startChannel, 2, 1, 1);
break;
case CollectHistograms:
histogramCollection.Add(antenna1Index, antenna2Index, p, samples[p], isRFI[p], band.channels.size() - startChannel);
break;
}
}
for(unsigned p = 0; p < polarizationCount; ++p)
{
delete[] isRFI[p];
delete[] samples[p];
}
delete[] isRFI;
reportProgress(row, nrow);
}
delete[] correlatorFlags;
delete[] correlatorFlagsForBadAntenna;
for(unsigned b=0;b<bandCount;++b)
delete[] frequencies[b];
delete[] frequencies;
delete[] bands;
std::cout << "100\n";
}
void TimeFrequencyImager::WriteNewFlagsPart(Mask2DCPtr newXX, Mask2DCPtr newXY, Mask2DCPtr newYX, Mask2DCPtr newYY, int antenna1, int antenna2, int spectralWindow, size_t timeOffset, size_t timeEnd, size_t leftBorder, size_t rightBorder)
{
initializePolarizations();
checkPolarizations();
size_t frequencyCount = _measurementSet->FrequencyCount();
std::map<double,size_t> observationTimes;
setObservationTimes(*_measurementSet, observationTimes);
casa::Table *table = _measurementSet->OpenTable(true);
casa::ScalarColumn<int> antenna1Column(*table, "ANTENNA1");
casa::ScalarColumn<int> antenna2Column(*table, "ANTENNA2");
casa::ScalarColumn<int> windowColumn(*table, "DATA_DESC_ID");
casa::ScalarColumn<double> timeColumn(*table, "TIME");
casa::ArrayColumn<bool> flagColumn(*table, "FLAG");
ScalarColumnIterator<int> antenna1Iter = ScalarColumnIterator<int>::First(antenna1Column);
ScalarColumnIterator<int> antenna2Iter = ScalarColumnIterator<int>::First(antenna2Column);
ScalarColumnIterator<int> windowIter = ScalarColumnIterator<int>::First(windowColumn);
ScalarColumnIterator<double> timeIter = ScalarColumnIterator<double>::First(timeColumn);
ArrayColumnIterator<bool> flagIter = ArrayColumnIterator<bool>::First(flagColumn);
if(frequencyCount != newXX->Height())
{
std::cerr << "The frequency count in the measurement set (" << frequencyCount << ") does not match the image!" << std::endl;
}
if(timeEnd - timeOffset != newXX->Width())
{
std::cerr << "The number of time scans to write in the measurement set (" << (timeEnd - timeOffset) << ") does not match the image (" << newXX->Width() << ") !" << std::endl;
}
size_t rowsWritten = 0;
for(size_t i=0;i<table->nrow();++i) {
if((*antenna1Iter) == (int) antenna1 &&
(*antenna2Iter) == (int) antenna2 &&
(*windowIter) == (int) spectralWindow)
{
double time = *timeIter;
size_t timeIndex = observationTimes.find(time)->second;
if(timeIndex >= timeOffset + leftBorder && timeIndex < timeEnd - rightBorder)
{
casa::Array<bool> flag = *flagIter;
casa::Array<bool>::iterator j = flag.begin();
for(size_t f=0;f<(size_t) frequencyCount;++f) {
if(_stokesIIndex >= 0)
{
if(_readStokesIDirectly) *j = newXX->Value(timeIndex - timeOffset, f);
++j;
}
if(_xxIndex >= 0)
{
if(_readXX) *j = newXX->Value(timeIndex - timeOffset, f);
++j;
}
if(_xyIndex >= 0)
{
if(_readXY) *j = newXY->Value(timeIndex - timeOffset, f);
++j;
}
if(_yxIndex >= 0)
{
if(_readYX) *j = newYX->Value(timeIndex - timeOffset, f);
++j;
}
if(_yyIndex >= 0)
{
if(_readYY) *j = newYY->Value(timeIndex - timeOffset, f);
++j;
}
}
flagIter.Set(flag);
++rowsWritten;
}
}
++antenna1Iter;
++antenna2Iter;
++timeIter;
++windowIter;
++flagIter;
}
AOLogger::Debug << "Rows written: " << rowsWritten << '\n';
delete table;
}
