Ksetiwatch API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Related Pages

completedwulist.cpp

Go to the documentation of this file.

/***************************************************************************/
#include <kapp.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kiconloader.h>

#include <qsplitter.h>
#include <qheader.h>
#include <qcursor.h>
#include <qtextstream.h>
#include <qpainter.h>

#include <math.h>

#include "seticontainer.h"
#include "setiloc.h"
#include "completedwulist.h"
#include "csvdatabase.h"
#include "poplistview.h"
#include "skymap.h"
#include "loggedsigs.h"

/*------------------------------------------------------------------------ */
QString WUListViewItem::key(int column, bool) const
{
// return value must be static
static QString ret;
QString val;
double tmp;

if(column == 2)
  {
  int colon;
  int d(0), h(0), m(0), s(0);

  val = text(column);
  colon = val.contains(':');
  if(colon == 2)
    {
    sscanf(text(column), "%d:%d:%d", &h, &m, &s);
    }
  else if(colon == 3)
    {
    sscanf(text(column), "%dd:%d:%d:%d", &d, &h, &m, &s);
    }
  tmp = 86400*d + 3600*h + 60*m + s;
  ret.sprintf("%032d", (int)tmp);
  }
else if(column == 3 || column == 4 || column == 10)
  {
  val = text(column);
  tmp = val.toDouble();
  val.sprintf("%f", tmp);
  ret = val.rightJustify(32, '0');
  }
else if(column >= 5 && column <= 7)
  {
  if(text(column).isEmpty())
    tmp = 0.0;
  else
    sscanf(text(column), " scr=%lf", &tmp);
  val.sprintf("%f", tmp);
  ret = val.rightJustify(32, '0');
  }
else
  {
  ret = text(column);
  }

return(ret);
}

/*------------------------------------------------------------------------ */
QString SigListViewItem::key(int column, bool) const
{
// return value must be static
static QString ret;
QString val;
double tmp;

switch(column)
  {
  case 2:
  case 4:
  case 6:
  case 8:
    tmp = text(column).toInt();
    ret.sprintf("%032d", (int)tmp);
    break;
  case 3:
  case 5:
  case 7:
  case 9:
    if(text(column).isEmpty())
      tmp = 0.0;
    else
      tmp = text(column).toDouble();
    val.sprintf("%f", tmp);
    ret = val.rightJustify(32, '0');
    break;
  default:
    ret = text(column);
    break;
  }

return(ret);
}

/***************************************************************************/
CompletedWUList::CompletedWUList(QWidget *parent, const char *name)
                : QWidget(parent,name)
{
Ksetiwatch::TableColumn wuList[] =
  {
  {i18n("Date Logged"), -1, AlignLeft},
  {i18n("Work Unit Name"), -1, AlignRight},
  {i18n("CPU Time"), -1, AlignRight},
  {i18n("%/Hour"), -1, AlignRight},
  {i18n("Spike"), 55, AlignRight},
  {i18n("Strongest Gaussian"), -1, AlignLeft},
  {i18n("Strongest Pulse"), -1, AlignLeft},
  {i18n("Strongest Triplet"), -1, AlignLeft},
  {i18n("From"), -1, AlignRight},
  {i18n("Recorded On"), -1, AlignRight},
  {i18n("Base Frequency"), -1, AlignRight},
  {i18n("Angle Range"), 90, AlignRight},
  {i18n("TeraFlops"), 80, AlignRight},
  {QString::null, 0, 0}
  };

Ksetiwatch::TableColumn wuSum[] =
  {
  {i18n("Location"), -1, AlignLeft},
  {i18n("WUs"), -1, AlignRight},
  {i18n("Total CPU Time"), -1, AlignRight},
  {i18n("Avg. CPU Time"), -1, AlignRight},
  {i18n("Avg. %/Hour"), -1, AlignRight},
  {i18n("Record Spike"), -1, AlignRight},
  {i18n("Record Gaussian"), -1, AlignLeft},
  {i18n("Record Pulse"), -1, AlignLeft},
  {i18n("Record Triplet"), -1, AlignLeft},
  {QString::null, 0, 0}
  };

Ksetiwatch::TableColumn sigList[] =
  {
  {i18n("Date Logged"), 150, AlignLeft},
  {i18n("Work Unit Name"), -1, AlignRight},
  {i18n("Spikes"), -1, AlignRight},
  {i18n("Top Spike"), -1, AlignRight},
  {i18n("Gauss'ns"), -1, AlignRight},
  {i18n("Top Gauss'n"), -1, AlignRight},
  {i18n("Pulses"), -1, AlignRight},
  {i18n("Top Pulse"), -1, AlignRight},
  {i18n("Triplets"), -1, AlignRight},
  {i18n("Top Triplet"), -1, AlignRight},
  {QString::null, 0, 0}
  };

Ksetiwatch::TableColumn sigSum[] =
  {
  {i18n("Location"), -1, AlignLeft},
  {i18n("WUs"), -1, AlignRight},
  {i18n("Total Spikes"), -1, AlignRight},
  {i18n("Top Spike"), -1, AlignRight},
  {i18n("Total Gauss'ns"), -1, AlignRight},
  {i18n("Top Gauss'n"), -1, AlignRight},
  {i18n("Total Pulses"), -1, AlignRight},
  {i18n("Top Pulse"), -1, AlignRight},
  {i18n("Total Triplets"), -1, AlignRight},
  {i18n("Top Triplet"), -1, AlignRight},
  {QString::null, 0, 0}
  };

folder_icon = SmallIcon("folder_open");
dish_icon = SmallIcon("mini-seti");

cwuList[WUSummary]     = 0;
cwuList[WUList]        = 0;
cwuList[SignalSummary] = 0;
cwuList[SignalList]    = 0;
currentView            = WUSummary;

splitview = new QSplitter(this);
splitview->move(5,1);

// set up the tree list
treelist = new popListView(splitview);
treelist->setRootIsDecorated(true);
treelist->addColumn("", -1);
// The second column is used to identify the locations in the tree list.
// loc->id() are stored here.
treelist->addColumn("", 0);
treelist->header()->hide();
treelist->insertPopupItem(SmallIcon("mini-starmap"),
                          i18n("Show on Sky Map"), ShowSkymap);
treelist->insertPopupItem(SmallIcon("reload"),
                          i18n("Reload Locations"), ReloadLocations);
treelist->setPopupStyle(popListView::OverItem);
// this results in better splitting
splitview->setResizeMode(treelist, QSplitter::FollowSizeHint);
connect(treelist->popupMenu(), SIGNAL(aboutToShow()),
                         this, SLOT(prepareTreeListPopupMenu()));
connect(treelist->popupMenu(), SIGNAL(activated(int)),
                         this, SLOT(handleTreeListPopupCommand(int)));
treelist->show();

// set up the WU summary list
cwuList[WUSummary] = new popListView(splitview);
createList(cwuList[WUSummary], wuSum);

// set up the WU list
cwuList[WUList] = new popListView(splitview);
createList(cwuList[WUList], wuList);
connect(cwuList[WUList]->header(), SIGNAL(sectionClicked(int)),
                             this, SLOT(toggleSorting(int)));
sortorder = true;
cwuList[WUList]->setShowSortIndicator(false);
cwuList[WUList]->insertPopupItem(SmallIcon("mini-starmap"),
                   i18n("Show on Sky Map"), ShowSkymap);
cwuList[WUList]->insertPopupItem(SmallIcon("mini-triplet"),
                   i18n("Show Logged Signals"), ShowLoggedSignals);
cwuList[WUList]->setPopupStyle(popListView::OverItem);
connect(cwuList[WUList]->popupMenu(), SIGNAL(activated(int)),
                       this, SLOT(handleWUListPopupCommand(int)));

// set up the signal summary list
cwuList[SignalSummary] = new popListView(splitview);
createList(cwuList[SignalSummary], sigSum);

// set up the signal list
cwuList[SignalList] = new popListView(splitview);
cwuList[SignalList]->setShowSortIndicator(false);
cwuList[SignalList]->insertPopupItem(SmallIcon("mini-triplet"),
                       i18n("Show Logged Signals"), ShowLoggedSignals);
cwuList[SignalList]->setPopupStyle(popListView::OverItem);
connect(cwuList[SignalList]->popupMenu(), SIGNAL(activated(int)),
                       this, SLOT(handleSigListPopupCommand(int)));
connect(cwuList[SignalList], SIGNAL(doubleClicked(QListViewItem*)),
                       this, SLOT(handleSigListDoubleClick(QListViewItem*)));
createList(cwuList[SignalList], sigList);
connect(cwuList[SignalList]->header(), SIGNAL(sectionClicked(int)),
                                 this, SLOT(toggleSorting(int)));

// hide all list views at the beginning
for(int i=0; i<4; i++)
  cwuList[i]->hide();

fillTreeList();
}

/*------------------------------------------------------------------------ */
CompletedWUList::~CompletedWUList()
{
}

/*------------------------------------------------------------------------ */
void CompletedWUList::resizeEvent(QResizeEvent*)
{
splitview->resize(this->width()-10, this->height()-5);
}

/*------------------------------------------------------------------------ */
void CompletedWUList::paintEvent(QPaintEvent* e)
{
for(int i=0; i<4; i++)
  cwuList[i]->setGridEnabled(globalopts->DrawGrid);
QWidget::paintEvent(e);
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillTreeList()
{
SetiLoc* loc;
QList<SetiLoc> seli = Ksetiwatch::locationList();

if(treelist)
  {
  treelist->setSorting(-1);
  QListViewItem* sl = treelist->insertRootItem(i18n("SETI Locations"),
                                               &folder_icon);
  QListViewItem* rs = treelist->insertRootItem(i18n("Returned Signals"),
                                               &folder_icon);
  sl->setOpen(true);
  treelist->setSelected(sl, true);
  for(loc=seli.first(); loc != 0; loc=seli.next())
    updateList(loc, Ksetiwatch::ListAdd);
  sl->sortChildItems(0, true);
  rs->sortChildItems(0, true);
  connect(treelist, SIGNAL(selectionChanged(QListViewItem*)),
              this, SLOT(slotSelect(QListViewItem*)));
  slotSelect(sl);
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::createList(popListView* list, Ksetiwatch::TableColumn tc[])
{

for(int i=0; tc[i].text!=QString::null; i++)
  {
  list->addColumn(tc[i].text, -1);
  if(tc[i].width != -1) list->setColumnWidth(i, tc[i].width);
  list->setColumnAlignment(i, tc[i].alignment);
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::slotSelect(QListViewItem *item)
{
// if the user has clicked white space, leave this place
if(item == 0) return;

if(item->text(0) == i18n("SETI Locations"))
  {
  cwuList[currentView]->hide();
  currentView = WUSummary;
  fillTotalList();
  cwuList[WUSummary]->show();
  }
else if(item->text(0) == i18n("Returned Signals"))
  {
  cwuList[currentView]->hide();
  currentView = SignalSummary;
  fillSigSumList();
  cwuList[SignalSummary]->show();
  }
else
  {
  for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
      loc=Ksetiwatch::locationList().next() )
    {
    if(loc->id() == item->text(1))
      {
      cwuList[currentView]->hide();
      QListViewItem* p = item->parent();
      if(p)
        {
        if(p->text(0) == i18n("SETI Locations"))
          {
          fillWUList(loc);
          currentView = WUList;
          cwuList[WUList]->show();
          break;
          }
        if(p->text(0) == i18n("Returned Signals"))
          {
          fillSigList(loc);
          currentView = SignalList;
          cwuList[SignalList]->show();
          break;
          }
        }
      }
    }
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillWUList(SetiLoc *loc)
{
QString csvfile = loc->logDirectory() + "/SETILog.csv";
QString tmp;
QString entry, date;
QString from;
CSVDataBase csv((const char *)csvfile);
double x, y, z;
int h, m, vrs;
WUListViewItem *wuit;

cwuList[WUList]->clear();

// switch off automatic sorting
cwuList[WUList]->setSorting(-1, false);

if(csv.open(IO_ReadOnly))
  {
  KApplication::setOverrideCursor(WaitCursor);
  int i = 1;
  do
    {
    date = csv.readItem("date", i);
    if(!date.isEmpty())
      {
      // Version number. HACK: multiply with 100.01 to prevent rounding error
      vrs = (int)(csv.readItem("version", i).toDouble()*100.01);

      wuit = new WUListViewItem(cwuList[WUList]);
      if(wuit != 0)
        {
        // log date
        wuit->setText(WulDateLogged, date);
        // WU name
        wuit->setText(WulWuName, csv.readItem("name", i));
        // CPU time
        x = csv.readItem("cpu", i).toDouble();
        wuit->setText(WulCpuTime, SetiLoc::convertTime(x, globalopts->hms));
        // % per hour
        y = csv.readItem("prog", i).toDouble();
        wuit->setText(WulProgRate, entry.setNum((x > 0.0) ?
                      (3600.0/x)*y*100.0 : 0.0, 'f', 5));
        // spike
        x = csv.readItem("bs_power", i).toDouble();
        wuit->setText(WulSpike, " " + ((x > 1.0e6) ? QString::number(x, 'e', 6) :
                                                     QString::number(x, 'f', 3)));
        // gaussian
        x = csv.readItem("bg_score", i).toDouble();
        if(x > 0.0)
          {
          y = csv.readItem("bg_power", i).toDouble();
          z = csv.readItem("bg_chisq", i).toDouble();
          wuit->setText(WulGaussian, QString(" scr=%1, pwr=%2, fit=%3")
                        .arg(x, 0, 'f', 4).arg(y, 0, 'f', 2).arg(z, 0, 'f', 2));
          }
        else
          wuit->setText(WulGaussian, QString::null);
        // pulse
        x = csv.readItem("bp_score", i).toDouble();
        if(x > 0.0)
          {
          y = csv.readItem("bp_power", i).toDouble();
          z = csv.readItem("bp_period", i).toDouble();
          wuit->setText(WulPulse, QString(" scr=%1, pwr=%2, prd=%3")
                        .arg(x, 0, 'f', 4).arg(y, 0, 'f', 2).arg(z, 0, 'f', 4));
          }
        else
          wuit->setText(WulPulse, QString::null);
        // triplet
        x = csv.readItem("bt_score", i).toDouble();
        if(x > 0.0)
          {
          z = csv.readItem("bt_period", i).toDouble();
          wuit->setText(WulTriplet, QString(" scr=%1, prd=%2")
                        .arg(x, 0, 'f', 4).arg(z, 0, 'f', 4));
          }
        else
          wuit->setText(WulTriplet, QString::null);
        // from
        x = csv.readItem("start_ra", i).toDouble();
        from = " " + SetiContainer::convertRAToString(x) + " RA ";
        x = csv.readItem("start_dec", i).toDouble();
        from += (x >= 0.0) ? "+ " : "- ";
        from += SetiContainer::convertDecToString(fabs(x)) + " Dec ";
        wuit->setText(WulFrom, from);
        // time recorded
        entry = csv.readItem("time_recorded", i);
        h = entry.find('(');
        m = entry.find(')');
        entry = entry.mid(h+1, m-h-1) + " ";
        wuit->setText(WulRecordedOn, entry);
        // base frequency
        x = csv.readItem("subband_base", i).toDouble()/1.0e9;
        wuit->setText(WulBaseFreq, QString::number(x, 'f', 9)+" GHz");
        // angle range
        double ar = csv.readItem("angle_range", i).toDouble();
        wuit->setText(WulAngleRange, QString::number(ar, 'f', 3));
        // TeraFlops
        wuit->setText(WulTeraFlops,
                      QString::number(loc->teraFlops(ar, vrs), 'f', 4));
        }
      }
    i++;
    } while(!csv.atEnd());
  csv.close();
  KApplication::restoreOverrideCursor();
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillTotalList()
{
ColorListViewItem* totit;
ColorListViewItem* grandtotal;
double totaltime, totaltime_total;
int nwus, nwus_nz, nwus_total, nwus_nz_total;
WUScore current, max, record;

KApplication::setOverrideCursor(WaitCursor);

// clear the list and enable sorting
cwuList[WUSummary]->clear();
cwuList[WUSummary]->setSorting(0);

// prevent the user from fiddling around with the header
cwuList[WUSummary]->header()->setClickEnabled(false, -1);

// init variables for Grand Total
totaltime_total = 0.0;
nwus_total      = 0;
nwus_nz_total   = 0;
totit           = 0;
SetiContainer::initWUScore(&record);
QList<SetiLoc> seli = Ksetiwatch::locationList();
// now fill the list
for(SetiLoc* loc=seli.first(); loc != 0; loc=seli.next() )
  {
  // data are read from this log file
  QString csvfile = loc->logDirectory() + "/SETILog.csv";
  CSVDataBase csv((const char*)csvfile);

  // create the list view item
  totit = new ColorListViewItem(cwuList[WUSummary]);
  totit->setText(WusLocation, loc->description());

  // see if log files are redirected
  SetiLoc* loc2 = checkForRedirect(loc);
  if(loc2)
    totit->setText(WusWus, i18n("See %1").arg(loc2->description()));
  else
    {
    // init variables for this location
    SetiContainer::initWUScore(&max);
    totaltime = 0.0;
    // counts all WUs
    nwus = 0;
    // counts only WUs with non-zero processing time
    nwus_nz = 0;
    // line in SETILog.csv
    int i = 1;
    if(csv.open(IO_ReadOnly))
      {
      do
        {
        if(!csv.readItem("date", i).isEmpty())
          {
          // spike
          current.spike.power = csv.readItem("bs_power", i).toDouble();
          if(current.spike.power > max.spike.power)
            max.spike.power = current.spike.power;
          if(max.spike.power > record.spike.power)
            {
            record.spike.power     = max.spike.power;
            record.spike.chirprate = csv.readItem("bs_chirp_rate", i).toDouble();
            record.spike.wu_name   = csv.readItem("name", i);
            }
          // gaussian
          current.gaussian.score = csv.readItem("bg_score", i).toDouble();
          if(current.gaussian.score > max.gaussian.score)
            {
            max.gaussian.score = current.gaussian.score;
            max.gaussian.power = csv.readItem("bg_power", i).toDouble();
            max.gaussian.chisq = csv.readItem("bg_chisq", i).toDouble();
            }
          if(max.gaussian.score > record.gaussian.score)
            {
            record.gaussian.score     = max.gaussian.score;
            record.gaussian.power     = max.gaussian.power;
            record.gaussian.chisq     = max.gaussian.chisq;
            record.gaussian.chirprate = csv.readItem("bg_chirp_rate", i).toDouble();
            record.gaussian.wu_name   = csv.readItem("name", i);
            }
          // pulse
          current.pulse.score = csv.readItem("bp_score", i).toDouble();
          if(current.pulse.score > max.pulse.score)
            {
            max.pulse.score  = current.pulse.score;
            max.pulse.power  = csv.readItem("bp_power", i).toDouble();
            max.pulse.period = csv.readItem("bp_period", i).toDouble();
            }
          if(max.pulse.score > record.pulse.score)
            {
            record.pulse.score     = max.pulse.score;
            record.pulse.power     = max.pulse.power;
            record.pulse.period    = max.pulse.period;
            record.pulse.chirprate = csv.readItem("bp_chirp_rate", i).toDouble();
            record.pulse.wu_name   = csv.readItem("name", i);
            }
          // triplet
          current.triplet.score = csv.readItem("bt_score", i).toDouble();
          if(current.triplet.score > max.triplet.score)
            {
            max.triplet.score  = current.triplet.score;
            max.triplet.period = csv.readItem("bt_period", i).toDouble();
            }
          if(max.triplet.score > record.triplet.score)
            {
            record.triplet.score     = max.triplet.score;
            record.triplet.period    = max.triplet.period;
            record.triplet.chirprate = csv.readItem("bt_chirp_rate", i).toDouble();
            record.triplet.wu_name   = csv.readItem("name", i);
            }
          // sum up CPU time
          double prctime = csv.readItem("cpu", i).toDouble();
          totaltime += prctime;
          // count WUs
          nwus++;
          if(prctime > 0.0)
            nwus_nz++;
          }
        i++; // next entry
        } while(!csv.atEnd());
      csv.close();
      }
    // sum up for Grand Total
    nwus_total      += nwus;
    nwus_nz_total   += nwus_nz;
    totaltime_total += totaltime;
    fillTotalColumns(totit, nwus, nwus_nz, totaltime, max);
    }
  }

// Create the Grand Total entry. Make sure that it's the last item.
QListViewItem* last(0);
QListViewItem* li(cwuList[WUSummary]->firstChild());
while(li != 0)
  {
  last = li;
  li = last->itemBelow();
  }
// switch sorting off; otherwise "Grand Total" would be sorted into the list
cwuList[WUSummary]->setSorting(-1);

if(last)
  {
  grandtotal = new ColorListViewItem(cwuList[WUSummary], last, Qt::blue, true);
  grandtotal->setText(WusLocation, i18n("Grand Total"));
  fillTotalColumns(grandtotal, nwus_total, nwus_nz_total, totaltime_total, record);
  }

// update current records if necessary
if(record.spike.power > globalopts->Record.spike.power)
  globalopts->Record.spike = record.spike;
if(record.gaussian.score > globalopts->Record.gaussian.score)
  globalopts->Record.gaussian = record.gaussian;
if(record.pulse.score > globalopts->Record.pulse.score)
  globalopts->Record.pulse = record.pulse;
if(record.triplet.score > globalopts->Record.triplet.score)
  globalopts->Record.triplet = record.triplet;

KApplication::restoreOverrideCursor();
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillSigList(SetiLoc* loc)
{
QFile log(loc->logDirectory() + "/SETIResult.log");

// Needed to get the log time. Maybe do it in a more clever way later.
fillWUList(loc);

cwuList[SignalList]->clear();

// switch off automatic sorting
cwuList[SignalList]->setSorting(-1, false);

if(log.open(IO_ReadOnly))
  {
  KApplication::setOverrideCursor(WaitCursor);
  QTextStream t(&log);
  QString s, wu;
  s = t.readLine();
  while( !t.atEnd() )
    {
    if(s[0] == '[')
      {
      // found a WU marker; add it to the tree
      wu = s.mid(1, s.length()-2);
      QListViewItem* it = new SigListViewItem(cwuList[SignalList]);
      it->setText(SilWuName, wu);
      // now determine the log date
      QListViewItem* wit;
      for(wit=cwuList[WUList]->firstChild(); wit!=0; wit=wit->nextSibling())
        {
        if(wit->text(1) == wu) break;
        }
      if(wit) it->setText(SilDateLogged, wit->text(0));
      // count the signals
      int spikes    = 0;
      int gaussians = 0;
      int pulses    = 0;
      int triplets  = 0;
      double topSpike    = 0.0;
      double topGaussian = 0.0;
      double topPulse    = 0.0;
      double topTriplet  = 0.0;
      do
        {
        s = t.readLine();
        if(s[0] == '[') break;  // outta here
        if(s.startsWith("spike"))
          {
          spikes++;
          int pos = s.find('=') + 1;
          QString st = s.right(s.length()-pos);
          SpikeScore spsc = SetiLoc::loggedSpikeSignal(st);
          double sppow = (spsc.power*MaxFFTLen)/(8*spsc.fft_len);
          if(sppow > topSpike) topSpike = sppow;
          }
        if(s.startsWith("gaussian"))
          {
          gaussians++;
          int pos = s.find('=') + 1;
          QString st = s.right(s.length()-pos);
          GaussianScore gasc = SetiLoc::loggedGaussianSignal(st);
          if(gasc.score > topGaussian) topGaussian = gasc.score;
          }
        if(s.startsWith("pulse"))
          {
          pulses++;
          int pos = s.find('=') + 1;
          QString st = s.right(s.length()-pos);
          PulseScore pusc = SetiLoc::loggedPulseSignal(st);
          if(pusc.score > topPulse) topPulse = pusc.score;
          }
        if(s.startsWith("triplet"))
          {
          triplets++;
          int pos = s.find('=') + 1;
          QString st = s.right(s.length()-pos);
          TripletScore trsc = SetiLoc::loggedTripletSignal(st);
          if(trsc.score > topTriplet) topTriplet = trsc.score;
          }
        } while(!t.atEnd());
      // set the columns
      it->setText(SilSpikes, QString::number(spikes));
      if(topSpike > 0.0)
        it->setText(SilTopSpike, " " + ((topSpike > 1.0e6) ?
                    QString::number(topSpike, 'e', 6) :
                    QString::number(topSpike, 'f', 3)));
      it->setText(SilGaussians, QString::number(gaussians));
      if(topGaussian > 0.0)
        it->setText(SilTopGaussian, QString::number(topGaussian, 'f', 4));
      it->setText(SilPulses, QString::number(pulses));
      if(topPulse > 0.0)
        it->setText(SilTopPulse, QString::number(topPulse, 'f', 4));
      it->setText(SilTriplets, QString::number(triplets));
      if(topTriplet > 0.0)
        it->setText(SilTopTriplet, QString::number(topTriplet, 'f', 4));
      }
    }
  log.close();  
  KApplication::restoreOverrideCursor();
  }
else
  {
  QListViewItem* it = new SigListViewItem(cwuList[SignalList]);
  it->setText(SilDateLogged, i18n("None logged"));
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillSigSumList()
{

KApplication::setOverrideCursor(WaitCursor);

// clear the list and enable sorting
cwuList[SignalSummary]->clear();
cwuList[SignalSummary]->setSorting(0);

// prevent the user from fiddling around with the header
cwuList[SignalSummary]->header()->setClickEnabled(false, -1);

// make a copy of the location list
QList<SetiLoc> SetiList2 = Ksetiwatch::locationList();
// init ints for counting
int total_spikes    = 0;
int total_gaussians = 0;
int total_pulses    = 0;
int total_triplets  = 0;
int total_nrWU      = 0;
WUScore rec;
SetiContainer::initWUScore(&rec);
for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
    loc=Ksetiwatch::locationList().next() )
  {
  QFile log(loc->logDirectory() + "/SETIResult.log");

  // create list view entry
  ColorListViewItem* it = new ColorListViewItem(cwuList[SignalSummary]);
  // set the first column
  it->setText(SisLocation, loc->description());

  // see if log files are redirected
  SetiLoc* loc2 = checkForRedirect(loc);
  if(loc2)
    it->setText(SisWus, i18n("See %1").arg(loc2->description()));
  else
    {
    int loc_spikes    = 0;
    int loc_gaussians = 0;
    int loc_pulses    = 0;
    int loc_triplets  = 0;
    int loc_nrWU      = 0;
    WUScore max;
    SetiContainer::initWUScore(&max);
    if(log.open(IO_ReadOnly))
      {
      QTextStream t(&log);
      QString s;
      s = t.readLine();
      while( !t.atEnd() )
        {
        if(s[0] == '[')
          {
          // found a WU marker; count the signals
          loc_nrWU++;
          do
            {
            s = t.readLine();
            if(s[0] == '[') break;  // outta here
            if(s.startsWith("spike"))
              {
              loc_spikes++;
              int pos = s.find('=') + 1;
              QString st = s.right(s.length()-pos);
              SpikeScore spsc = SetiLoc::loggedSpikeSignal(st);
              double sppow = (spsc.power*MaxFFTLen)/(8*spsc.fft_len);
              if(sppow > max.spike.score) max.spike.score = sppow;
              }
            if(s.startsWith("gaussian"))
              {
              loc_gaussians++;
              int pos = s.find('=') + 1;
              QString st = s.right(s.length()-pos);
              GaussianScore gasc = SetiLoc::loggedGaussianSignal(st);
              if(gasc.score > max.gaussian.score) max.gaussian.score = gasc.score;
              }
            if(s.startsWith("pulse"))
              {
              loc_pulses++;
              int pos = s.find('=') + 1;
              QString st = s.right(s.length()-pos);
              PulseScore pusc = SetiLoc::loggedPulseSignal(st);
              if(pusc.score > max.pulse.score) max.pulse.score = pusc.score;
              }
            if(s.startsWith("triplet"))
              {
              loc_triplets++;
              int pos = s.find('=') + 1;
              QString st = s.right(s.length()-pos);
              TripletScore trsc = SetiLoc::loggedTripletSignal(st);
              if(trsc.score > max.triplet.score) max.triplet.score = trsc.score;
              }
            } while(!t.atEnd());
          }
        }
      log.close();
      }
    // sum up totals
    total_spikes    += loc_spikes;
    total_gaussians += loc_gaussians;
    total_pulses    += loc_pulses;
    total_triplets  += loc_triplets;
    total_nrWU      += loc_nrWU;
    // check for records
    if(max.spike.score > rec.spike.score)
      rec.spike.score = max.spike.score;
    if(max.gaussian.score > rec.gaussian.score)
      rec.gaussian.score = max.gaussian.score;
    if(max.pulse.score > rec.pulse.score)
      rec.pulse.score = max.pulse.score;
    if(max.triplet.score > rec.triplet.score)
      rec.triplet.score = max.triplet.score;
    fillSigSumColumns(it, loc_nrWU, loc_spikes, loc_gaussians, loc_pulses,
                      loc_triplets, max);
    }
  }

// create the Grand Total entry
// make sure that it's the last item
QListViewItem* last = 0;
QListViewItem* li(cwuList[SignalSummary]->firstChild());
while(li != 0)
  {
  last = li;
  li = last->itemBelow();
  }
// switch sorting off; otherwise "Grand Total" would be sorted into the list
cwuList[SignalSummary]->setSorting(-1);

if(last)
  {
  ColorListViewItem* grandtotal;
  grandtotal = new ColorListViewItem(cwuList[SignalSummary], last, Qt::blue, true);
  grandtotal->setText(SisLocation, i18n("Grand Total"));
  fillSigSumColumns(grandtotal, total_nrWU, total_spikes, total_gaussians,
                    total_pulses, total_triplets, rec);
  }

KApplication::restoreOverrideCursor();
}

/*------------------------------------------------------------------------ */
SetiLoc* CompletedWUList::checkForRedirect(SetiLoc* loc)
{
SetiLoc*       rloc = 0;
QString        logDir, setiDir;
QList<SetiLoc> seli = Ksetiwatch::locationList();

for(SetiLoc* loc2=seli.first(); loc2 != 0; loc2=seli.next() )
  {
  if(loc != loc2)
    {
    LocSettings ls = loc->options();
      // before comparing, remove any whitespace and append a trailing '/'
    // if it is missing
    logDir  = loc->logDirectory().stripWhiteSpace();
    if(logDir[logDir.length()-1] != '/')
        logDir.append('/');
    setiDir = loc2->directory().stripWhiteSpace();
    if(setiDir[setiDir.length()-1] != '/')
        setiDir.append('/');
    if( ls.redirectLog && (logDir == setiDir) )
      rloc = loc2;
    }
  }

return(rloc);
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillTotalColumns(QListViewItem* it, const int wus,
                                       const int nzwus, const double totime,
                                       const WUScore& top)
{
// Nr of WUs
it->setText(WusWus, QString::number(wus));
// total time
it->setText(WusTotalTime, SetiLoc::convertTime(totime, globalopts->hms));
// average CPU time
double x = (nzwus > 0) ? totime/nzwus : 0.0;
it->setText(WusAvgTime, SetiLoc::convertTime(x, globalopts->hms));
// average % per hour
it->setText(WusAvgProgRate,
            QString::number((x > 0.0) ? 360000.0/x : 0.0, 'f', 5));
// top peak
it->setText(WusRecSpike, " " + ((top.spike.power > 1.0e6) ?
            QString::number(top.spike.power, 'e', 6) :
            QString::number(top.spike.power, 'f', 3)));
// top gaussian
if(top.gaussian.score > 0.0)
  it->setText(WusRecGaussian, QString(" scr=%1, pwr=%2, fit=%3")
              .arg(top.gaussian.score, 0, 'f', 4)
              .arg(top.gaussian.power, 0, 'f', 2)
              .arg(top.gaussian.chisq, 0, 'f', 2));
// record pulse
if(top.pulse.score > 0.0)
  it->setText(WusRecPulse, QString(" scr=%1, pwr=%2, prd=%3")
              .arg(top.pulse.score, 0, 'f', 4)
              .arg(top.pulse.power, 0, 'f', 2)
              .arg(top.pulse.period, 0, 'f', 4));
// record triplet
if(top.triplet.score > 0.0)
  it->setText(WusRecTriplet, QString(" scr=%1, prd=%2")
              .arg(top.triplet.score, 0, 'f', 4)
              .arg(top.triplet.period, 0, 'f', 4));
}

/*------------------------------------------------------------------------ */
void CompletedWUList::fillSigSumColumns(QListViewItem* it, const int wus,
                                        const int spikes, const int gaussians,
                                        const int pulses, const int triplets,
                                        const WUScore& top)
{
if(wus > 0)
  {
  it->setText(SisWus, QString::number(wus));
  it->setText(SisTotalSpikes, QString::number(spikes) + " (" +
              QString::number((double)(spikes)/wus, 'f', 2) + ")");
  it->setText(SisTopSpike, " " + ((top.spike.score > 1.0e6) ?
              QString::number(top.spike.score, 'e', 6) :
              QString::number(top.spike.score, 'f', 3)));
  it->setText(SisTotalGaussians, QString::number(gaussians) + " (" +
              QString::number((double)(gaussians)/wus, 'f', 2) + ")");
  it->setText(SisTopGaussian, QString::number(top.gaussian.score, 'f', 4));
  it->setText(SisTotalPulses, QString::number(pulses) + " (" +
              QString::number((double)(pulses)/wus, 'f', 2) + ")");
  it->setText(SisTopPulse, QString::number(top.pulse.score, 'f', 4));
  it->setText(SisTotalTriplets, QString::number(triplets) + " (" +
              QString::number((double)(triplets)/wus, 'f', 2) + ")");
  it->setText(SisTopTriplet, QString::number(top.triplet.score, 'f', 4));
  }
else
  it->setText(SisWus, i18n("None logged"));
}

/*------------------------------------------------------------------------ */
void CompletedWUList::prepareTreeListPopupMenu()
{
QListViewItem *it = treelist->currentItem();
if(it)
  {
  QListViewItem* p = it->parent();
  if(it->text(0) == i18n("Returned Signals") ||
     (p && p->text(0) == i18n("Returned Signals")))
    treelist->popupMenu()->setItemEnabled(ShowSkymap, false);
  else
    treelist->popupMenu()->setItemEnabled(ShowSkymap, true);
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::handleTreeListPopupCommand(int id)
{
QListViewItem *it = treelist->currentItem();
SetiLoc* loc = 0;
SkyMap*  map;

if(it) loc = Ksetiwatch::getLocation(it->text(0));
switch(id)
  {
  case ShowSkymap: // show on sky map
    {
    if(it)
      {
      map = SkyMap::showMap();
      if(map)
        {
        map->clearMap();
        // identify corresponding SetiLoc item
        if(it->text(0) == QString("SETI Locations"))
          addAllLoggedWU();
        else if(loc)
          addLoggedWU(loc);
        // update the skymap with added work units
        map->update();
        }
      }
    break;
    }
  case ReloadLocations:
    {
    if(it)
      {
      // identify corresponding SetiLoc item
      if(it->text(0) == i18n("SETI Locations"))
        fillTotalList();
      else if(it->text(0) == i18n("Returned Signals"))
        fillSigSumList();
      else if(loc)
        {
        QListViewItem* p = it->parent();
        if(p->text(0) == i18n("SETI Locations"))
            fillWUList(loc);
        if(p->text(0) == i18n("Returned Signals"))
            fillSigList(loc);
        }
      }
    break;
    }
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::refreshList(SetiLoc* loc)
{
switch(currentView)
  {
  case WUSummary:
    fillTotalList();
    break;
  case SignalSummary:
    fillSigSumList();
    break;
  default:
    QListViewItem* it = treelist->currentItem();
    if(it)
      {
      if(loc->description() == it->text(0))
        {
        QListViewItem* p = it->parent();
        if(p->text(0) == i18n("SETI Locations"))
          fillWUList(loc);
        if(p->text(0) == i18n("Returned Signals"))
          fillSigList(loc);
        }
      }
    break;
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::slotRefreshList(SetiLoc* loc)
{
refreshList(loc);
emit listUpdated();
}

/*------------------------------------------------------------------------ */
void CompletedWUList::updateList(SetiLoc* loc, int type)
{
QListViewItem* it;
QListViewItem* chit;

switch(type)
  {
  case Ksetiwatch::ListAdd:
    {
    for(it = treelist->firstChild(); it != 0; it = it->nextSibling())
      {
      chit = treelist->insertChildItem(loc->description(), &dish_icon, it);
      chit->setText(1, loc->id());
      it->sortChildItems(0, true);
      }
    connect(loc,  SIGNAL(workUnitLogged(SetiLoc*)),
            this, SLOT(slotRefreshList(SetiLoc*)));
    break;
    }
  case Ksetiwatch::ListEdit:
    {
    for(it = treelist->firstChild(); it != 0; it = it->nextSibling())
      {
      for(chit = it->firstChild(); chit != 0; chit = chit->nextSibling())
        if(loc->id() == chit->text(1))
          chit->setText(0, loc->description());
      }
    break;
    }
  case Ksetiwatch::ListDelete:
    {
    for(it = treelist->firstChild(); it != 0; it = it->nextSibling())
      {
      for(chit = it->firstChild(); chit != 0; chit = chit->nextSibling())
      if(loc->id() == chit->text(1))
        delete chit;
      }
    disconnect(loc,  SIGNAL(workUnitLogged(SetiLoc*)),
               this, SLOT(slotRefreshList(SetiLoc*)));
    break;
    }
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::slotUpdateList(SetiLoc* loc, int type)
{
updateList(loc, type);
refreshList(loc);
}

/*------------------------------------------------------------------------ */
void CompletedWUList::addLoggedWU(SetiLoc *loc)
{
SkyMap* map = SkyMap::instance();
QString csv_file(loc->logDirectory() + "/SETILog.csv");
CSVDataBase csv((const char *)csv_file);

if(csv.open(IO_ReadOnly))
  {
  KApplication::setOverrideCursor(WaitCursor);
  int i(1);
  QString entry;
  double ra(0.0), dec(0.0);
  int h, m;
  do
    {
    entry = csv.readItem("start_ra", i);
    if(!entry.isEmpty())
      {
      ra  = csv.readItem("start_ra", i).toDouble();
      dec = csv.readItem("start_dec", i).toDouble();
      entry = csv.readItem("time_recorded", i);
      h = entry.find('(');
      m = entry.find(')');
      entry = entry.mid(h+1, m-h-1);
      }
    map->addLocation(loc->description(), entry, loc->color(), ra, dec);
    i++;
    } while(!csv.atEnd());
  csv.close();
  KApplication::restoreOverrideCursor();
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::addAllLoggedWU()
{
SetiLoc *loc;
for(loc=Ksetiwatch::locationList().first(); loc != 0;
    loc=Ksetiwatch::locationList().next() )
  {
  addLoggedWU(loc);
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::handleWUListPopupCommand(int id)
{
QListViewItem *tree_it = treelist->currentItem();
QListViewItem *wu_it = cwuList[WUList]->currentItem();
double ra, dec;

SetiLoc* loc = 0;
if(tree_it)
  loc = Ksetiwatch::getLocation(tree_it->text(0));
switch(id)
  {
  case ShowSkymap:
    if(loc && wu_it)
      {
      QStringList pos = QStringList::split(' ', wu_it->text(8));
      ra = pos[0].toDouble() + pos[2].toDouble()/60.0 + pos[4].toDouble()/3600.0;
      dec = pos[8].toDouble() + pos[9].toDouble()/60.0 + pos[10].toDouble()/3600.0;
      if(pos[7] == '-')
        dec = -dec;
      SkyMap* map = SkyMap::showMap();
      map->addLocation(loc->description(), wu_it->text(WulRecordedOn),
                       loc->color(), ra, dec);
      map->repaint();
      }
    break;
  case ShowLoggedSignals:
    if(loc && wu_it)
      {
      QString wun = wu_it->text(WulWuName);
      LoggedSigs* ls = new LoggedSigs(loc->description(), wun);
      ls->show();
      }
    break;
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::handleSigListPopupCommand(int id)
{
QListViewItem* tree_it = treelist->currentItem();
QListViewItem* wu_it = cwuList[SignalList]->currentItem();

SetiLoc* loc = 0;
if(tree_it) loc = Ksetiwatch::getLocation(tree_it->text(0));
switch(id)
  {
  case ShowLoggedSignals:
    if(loc && wu_it)
      {
      QString wun = wu_it->text(WulWuName);
      LoggedSigs* ls = new LoggedSigs(loc->description(), wun);
      ls->show();
      }
    break;
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::handleSigListDoubleClick(QListViewItem* sit)
{
QListViewItem* tree_it = treelist->currentItem();
SetiLoc* loc = 0;

if(tree_it) loc = Ksetiwatch::getLocation(tree_it->text(0));
if(loc && sit)
  {
  QString wun = sit->text(WulWuName);
  LoggedSigs* ls = new LoggedSigs(loc->description(), wun);
  ls->show();
  }
}

/*------------------------------------------------------------------------ */
void CompletedWUList::toggleSorting(int column)
{
switch(currentView)
  {
  case WUList:
    sortorder = !sortorder;
    if(cwuList[WUList]) cwuList[WUList]->setSorting(column, sortorder);
    break;
  case SignalList:
    sortorder = !sortorder;
    if(cwuList[SignalList]) cwuList[SignalList]->setSorting(column, sortorder);
    break;
  default:
    if(cwuList[currentView]) cwuList[currentView]->setSorting(-1, false);
    break;
  }
}

#include "completedwulist.moc"

This file is part of the documentation for Ksetiwatch API Version 2.6.1.

Documentation copyright © 2000-2003 Gordon Machel.
Generated on Fri Jun 6 00:28:13 2003 by doxygen 1.2.18, written by Dimitri van Heesch, © 1997-2002