void QxtLookupLineEdit::showPopup ()
{
/*open wildcard dialog*/
if(!sourceModel())
return;
QString tempText = text();
if(hasSelectedText()){
QString selected = selectedText();
tempText.replace(selected,"");
}
QModelIndex currIndex = QxtFilterDialog::getIndex(this,qxt_d().m_sourceModel,qxt_d().m_lookupColumn,qxt_d().m_lookupRole,tempText);
if(currIndex.isValid()){
QModelIndex dataIndex = sourceModel()->index(currIndex.row(),dataColumn());
if(dataIndex.isValid())
{
setText(dataIndex.data(lookupRole()).toString());
emit selected();
this->nextInFocusChain()->setFocus();
}
}
#if 0
QPoint pos = this->geometry().topLeft();
if(qobject_cast<QWidget*>(this->parent()))
pos = qobject_cast<QWidget*>(this->parent())->mapToGlobal(pos);
qxt_d().filterView->setGeometry(QRect(pos,QSize(400,300)));
qxt_d().filterView->setFilterText(text());
int ret = qxt_d().filterView->exec();
if(ret == QDialog::Accepted)
{
QModelIndex currIndex = qxt_d().filterView->selectedIndex();
QModelIndex dataIndex = sourceModel()->index(currIndex.row(),dataColumn());
if(dataIndex.isValid())
{
setText(dataIndex.data(lookupRole()).toString());
this->nextInFocusChain()->setFocus();
}
}
#endif
}
void ifaGroup::buildRowSkip()
{
rowSkip.assign(rowMap.size(), false);
if (itemDims == 0) return;
// Rows with no information about an ability will obtain the
// prior distribution as an ability estimate. This will
// throw off multigroup latent distribution estimates.
for (size_t rx=0; rx < rowMap.size(); rx++) {
bool hasNA = false;
std::vector<int> contribution(itemDims);
for (int ix=0; ix < numItems(); ix++) {
int pick = dataColumn(ix)[ rowMap[rx] ];
if (pick == NA_INTEGER) {
hasNA = true;
continue;
}
const double *ispec = spec[ix];
int dims = ispec[RPF_ISpecDims];
double *iparam = getItemParam(ix);
for (int dx=0; dx < dims; dx++) {
// assume factor loadings are the first item parameters
if (iparam[dx] == 0) continue;
contribution[dx] += 1;
}
}
if (!hasNA) continue;
if (minItemsPerScore == NA_INTEGER) {
mxThrow("You have missing data. You must set minItemsPerScore");
}
for (int ax=0; ax < itemDims; ++ax) {
if (contribution[ax] < minItemsPerScore) {
// We could compute the other scores, but estimation of the
// latent distribution is in the hot code path. We can reconsider
// this choice when we try generating scores instead of the
// score distribution.
rowSkip[rx] = true;
}
}
}
}
uint64_t BaselineReader::MeasurementSetDataSize(const string& filename)
{
casacore::MeasurementSet ms(filename);
casacore::MSSpectralWindow spwTable = ms.spectralWindow();
casacore::ROScalarColumn<int> numChanCol(spwTable, casacore::MSSpectralWindow::columnName(casacore::MSSpectralWindowEnums::NUM_CHAN));
size_t channelCount = numChanCol.get(0);
if(channelCount == 0) throw std::runtime_error("No channels in set");
if(ms.nrow() == 0) throw std::runtime_error("Table has no rows (no data)");
typedef float num_t;
typedef std::complex<num_t> complex_t;
casacore::ROScalarColumn<int> ant1Column(ms, ms.columnName(casacore::MSMainEnums::ANTENNA1));
casacore::ROScalarColumn<int> ant2Column(ms, ms.columnName(casacore::MSMainEnums::ANTENNA2));
casacore::ROArrayColumn<complex_t> dataColumn(ms, ms.columnName(casacore::MSMainEnums::DATA));
casacore::IPosition dataShape = dataColumn.shape(0);
unsigned polarizationCount = dataShape[0];
return
(uint64_t) polarizationCount * (uint64_t) channelCount *
(uint64_t) ms.nrow() * (uint64_t) (sizeof(num_t) * 2 + sizeof(bool));
}
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";
}
