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

setiloc.cpp

Go to the documentation of this file.

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

#include <qglobal.h>
#include <qmessagebox.h>
#include <qdir.h>
#include <qtextstream.h>
#include <qregexp.h>
#include <qcstring.h>
#include <qfontmetrics.h>

#include <math.h>

#include "setiloc.h"
#include "setigraph.h"
#include "gaussianplot.h"
#include "pulseplot.h"
#include "tripletplot.h"
#include "csvdatabase.h"

struct csvHeaderField {
                      const char* text; 
                      int type;         
                      };

csvHeaderField csv_userinfo[] =   {
                                  {"date", 1},
                                  {"id", 0},
                                  {"key", 0},
                                  {"email_addr", 1},
                                  {"user_name", 1},
                                  {"url", 1},
                                  {"country", 1},
                                  {"postal_code", 0},
                                  {"show_name", 1},
                                  {"show_email", 1},
                                  {"venue", 0},
                                  {"register_time", 1},
                                  {"last_wu_time", 1},
                                  {"last_result_time", 1},
                                  {"nwus", 0},
                                  {"nresults", 0},
                                  {"total_cpu", 0},
                                  {"params_index", 0}
                                  };
#define CSV_USERINFO_COLUMNS 18

csvHeaderField csv_datainfo[] =   {
                                  {"task", 1},
                                  {"version", 0},
                                  {"name", 1},
                                  {"data_type", 1},
                                  {"data_class", 0},
                                  {"splitter_version", 1},
                                  {"start_ra", 0},
                                  {"start_dec", 0},
                                  {"end_ra", 0},
                                  {"end_dec", 0},
                                  {"angle_range", 0},
                                  {"time_recorded", 1},
                                  {"subband_center", 0},
                                  {"subband_base", 0},
                                  {"subband_sample_rate", 0},
                                  {"fft_len", 0},
                                  {"ifft_len", 0},
                                  {"subband_number", 0},
                                  {"receiver", 1},
                                  {"nsamples", 0},
                                  {"tape_version", 0}
                                  };
#define CSV_DATAINFO_COLUMNS 21

csvHeaderField csv_state[] =  {
                              {"ncfft", 0},
                              {"cr", 0},
                              {"fl", 0},
                              {"cpu", 0},
                              {"prog", 0},
                              {"bs_power", 0},
                              {"bs_score", 0},
                              {"bs_bin", 0},
                              {"bs_fft_ind", 0},
                              {"bs_chirp_rate", 0},
                              {"bs_fft_len", 0},
                              {"bg_score", 0},
                              {"bg_power", 0},
                              {"bg_chisq", 0},
                              {"bg_bin", 0},
                              {"bg_fft_ind", 0},
                              {"bg_chirp_rate", 0},
                              {"bg_fft_len", 0},
                              {"bp_score", 0},
                              {"bp_power", 0},
                              {"bp_mean", 0},
                              {"bp_period", 0},
                              {"bp_freq_bin", 0},
                              {"bp_time_bin", 0},
                              {"bp_chirp_rate", 0},
                              {"bp_fft_len", 0},
                              {"bt_score", 0},
                              {"bt_power", 0},
                              {"bt_mean", 0},
                              {"bt_period", 0},
                              {"bt_bperiod", 0},
                              {"bt_tpotind0_0", 0},
                              {"bt_tpotind0_1", 0},
                              {"bt_tpotind1_0", 0},
                              {"bt_tpotind1_1", 0},
                              {"bt_tpotind2_0", 0},
                              {"bt_tpotind2_1", 0},
                              {"bt_freq_bin", 0},
                              {"bt_time_bin", 0},
                              {"bt_chirp_rate", 0},
                              {"bt_scale", 0},
                              {"bt_fft_len", 0}
                              };
#define CSV_STATE_COLUMNS 42

/*------------------------------------------------------------------------ */
SetiLoc::SetiLoc(const QString& dir, const QString& loc, const QColor& col)
       : SetiContainer(dir), stoppedNormally(true)
{
sets.directory   = dir;
sets.description = loc;
sets.color       = col;

/* Generate the unique id string. */
thisId = QString::number((unsigned int)this, 16);

for(int i=0; i<(int)(sizeof(graphwidget)/sizeof(graphwidget[0])); i++)
  graphwidget[i] = 0;

sresult_timestamp = "";

initMaxScore();

// Catch the output of the client in a text window
clientOutput = new KTextBrowser();
clientOutput->setCaption(QString(i18n("Location %1: Client Output")).arg(loc));
// Calculate approximate size of the window from the chosen font
QFontMetrics fm(clientOutput->font());
clientOutput->resize( 8*fm.width("abcdefghij"), 25*fm.lineSpacing() );
connect(&client, SIGNAL(receivedStdout(KProcess*, char*, int)),
        this,    SLOT(slotDumpClientOutput(KProcess*, char*, int)));

connect(this, SIGNAL(newWorkUnit(WorkUnitData)),
              SLOT(slotInitMaxScore(WorkUnitData)));
}

/*------------------------------------------------------------------------ */
SetiLoc::~SetiLoc()
{
delete clientOutput;
}

/*------------------------------------------------------------------------ */
const QString& SetiLoc::id() const
{
return((const QString&)thisId);
}

/*------------------------------------------------------------------------ */
void SetiLoc::setOptions(const LocSettings& ls)
{
initMaxScore();
sets = ls;
sets.arguments = sets.arguments.simplifyWhiteSpace();
// set the directory so that the SetiContainer knows about it
setDirectory(sets.directory);
}

/*------------------------------------------------------------------------ */
void SetiLoc::showGraph(int id)
{
switch(id)
  {
  case GaussianGraph:
    if(graphwidget[id] == 0)
      graphwidget[id] = new GaussianPlot(this);
    graphwidget[id]->show();
    break;
  case PulseGraph:
    if(graphwidget[id] == 0)
      graphwidget[id] = new PulsePlot(this);
    graphwidget[id]->show();
    break;
  case TripletGraph:
    if(graphwidget[id] == 0)
      graphwidget[id] = new TripletPlot(this);
    graphwidget[id]->show();
    break;
  case ClientOutput:
    clientOutput->show();
    break;
  default:
    break;
  }
}

/*------------------------------------------------------------------------ */
void SetiLoc::initMaxScore()
{
// clear the max score
initWUScore(&mymax);
// this ensures that all data are read when checking for the first time
mymax.spike.power    = -1.0;
mymax.gaussian.score = -1.0;
mymax.pulse.score    = -1.0;
mymax.triplet.score  = -1.0;
}

/*------------------------------------------------------------------------ */
void SetiLoc::slotInitMaxScore(WorkUnitData wud)
{
initWUScore(&mymax);

// Hide the old graph widgets if present; implement a more elegant way
// later.
for(int i=0;i<(int)(sizeof(graphwidget)/sizeof(graphwidget[0]));i++)
  if(graphwidget[i])
    graphwidget[i]->hide();

// Delete the '.triplets.dat' file
QDir d(logDirectory());
d.remove(".triplets.dat");

// ...and notify graph widgets with extended information
emit newWorkUnit(wud, description(), color());
}

/*------------------------------------------------------------------------ */
void SetiLoc::checkWUStatus()
{
if(sets.log == true)
  {
  // we're using the timestamp of the result file to prevent multiple logging
  QFileInfo fi(rsfFileName);
  QDateTime dt = QDateTime(fi.lastModified());
  QString res_dt = dt.toString();
  if(res_dt != timestamp())
    {
    setTimestamp(res_dt);
    logResults();
    logWorkUnit();
    // Save the config to make sure that the timestamp is written to
    // disk.
    emit workUnitLogged(this);
    }
  }
}

/*------------------------------------------------------------------------ */
QString SetiLoc::logDirectory()
{
QString logdir;

// determine the right log directory
if(sets.redirectLog)
  {
  if(sets.logDirectory.isEmpty())
    logdir = directory();
  else
    logdir = sets.logDirectory;
  }
else
  {
  logdir = directory();
  }

return(logdir);
}

/*------------------------------------------------------------------------ */
void SetiLoc::storeTripletData(const TripletScore& triplet)
{
QString trip_file;

trip_file = logDirectory() + "/.triplets.dat";
QFile f_trip(trip_file);

if(f_trip.open(IO_Append | IO_WriteOnly))
  {
  QTextStream t(&f_trip);
  QString line = QString("%1,%2,%3,%4,%5,").arg(triplet.power)
                                           .arg(triplet.period)
                                           .arg(triplet.tpotind0_0)
                                           .arg(triplet.tpotind1_0)
                                           .arg(triplet.tpotind2_0);
  for(int i=0;i<512;i++)
    {
    QString byte;
    byte.sprintf("%02hx", (unsigned short int)triplet.data[i]);
    line += byte;
    }
  t << line << endl;
  f_trip.close();
  }
}

/*------------------------------------------------------------------------ */
void SetiLoc::logWorkUnit()
{
QString buffer, entry;
int i;
int error(0);
int warn(0);
QString setilog_file;

setilog_file = logDirectory() + "/SETILog.csv";
QFile f_sel(setilog_file);

// check if SETILog.csv needs to be upgraded
CSVDataBase csv(setilog_file);
bool upgrade = false;
if(f_sel.exists())
  {
  if(csv.open(IO_ReadOnly))
    {
    int cols = csv.columnCount();
    if(cols < CSV_USERINFO_COLUMNS+CSV_DATAINFO_COLUMNS+CSV_STATE_COLUMNS)
      {
      // rename SETILog.csv to SETILog.old
      if(0 != rename((const char*)setilog_file,
                     (const char*)(logDirectory()+"/SETILog.old")))
        {
        error = 3;
        debug("Renaming SETILog.csv failed.");
        }
      else
        {
        upgrade = true;
        }
      }
    csv.close();
    }
  }

// create new SETILog.csv if necessary
if(f_sel.exists() == false && error == 0)
  {
  if(f_sel.open(IO_ReadWrite))
    {
    // write the definition line
    for(i=0;i<CSV_USERINFO_COLUMNS;i++)
      {
      f_sel.putch('"');
      f_sel.writeBlock(csv_userinfo[i].text, strlen(csv_userinfo[i].text));
      f_sel.putch('"'); f_sel.putch(',');
      }
    for(i=0;i<CSV_DATAINFO_COLUMNS;i++)
      {
      f_sel.putch('"');
      f_sel.writeBlock(csv_datainfo[i].text, strlen(csv_datainfo[i].text));
      f_sel.putch('"'); f_sel.putch(',');
      }
    for(i=0;i<CSV_STATE_COLUMNS;i++)
      {
      f_sel.putch('"');
      f_sel.writeBlock(csv_state[i].text, strlen(csv_state[i].text));
      f_sel.putch('"');
    if(i < CSV_STATE_COLUMNS-1)
      f_sel.putch(',');
    }
    // If the upgrade flag is set copy the data from SETILog.old to the new
    // file.
    if(upgrade)
      {
      QFile oldf_sel(logDirectory()+"/SETILog.old");
      if(oldf_sel.open(IO_ReadWrite))
        {
        QTextStream tout(&oldf_sel);
        QTextStream tin(&f_sel);
        QString s;
        i = 0;
        while(!oldf_sel.atEnd())
          {
          s = tout.readLine();
          // discard the first line
          if(i > 0)
            tin << endl << s;
          i++;
          }
        oldf_sel.close();
        }
      else
        {
        error = 4;
        debug("Could not create new SETILog.csv.");
        }
      }
    f_sel.close();
    }
  }

QFileInfo finfo(rsfFileName);
QDateTime dt = finfo.lastModified();
if(dt.isValid())
  {
  QDate d = dt.date();
  buffer.sprintf("\"%d.%02d.%02d ", d.year(), d.month(), d.day() );
  QTime t = dt.time();
  buffer += t.toString() + "\",";
  }
else
  {
  QDate d = QDate::currentDate();
  buffer.sprintf("\"%d.%02d.%02d ", d.year(), d.month(), d.day() );
  QTime t = QTime::currentTime();
  buffer += t.toString() + "\",";
  }

// Read the user info information.
if(exists(SC_UserInfoFile) && error == 0)
  {
  for(i=1; i<CSV_USERINFO_COLUMNS; i++)
    {
    if(i == 4) // instead of "user_name" take "name" to retrieve the users's name
      entry = readEntry(SC_UserInfoFile, "name");
    else
      entry = readEntry(SC_UserInfoFile, csv_userinfo[i].text);
    buffer += constructEntry(entry, csv_userinfo[i].type);
    }
  }
else
  error = 1;

// Read the result information.
if(exists(SC_ResultFile) && error == 0)
  {
  for(i=0; i<CSV_DATAINFO_COLUMNS; i++)
    {
    if(i == 1) // version
      {
      entry.sprintf("%.2f,", (double)clientVersion()/100.0);
      buffer += entry;
      }
    else
      {
      entry = readEntry(SC_ResultFile, csv_datainfo[i].text);
      buffer += constructEntry(entry, csv_datainfo[i].type);
      }
    }
  }
else
  if(error == 0) error = 2;

// Read the state file information. If state file could not be found
// issue a warning, but try it anyway (maybe we have some data in memory).
if(exists(SC_StateFile) == false) warn = 1;
if(error == 0)
  {
  for(i=0;i<CSV_STATE_COLUMNS;i++)
    {
    if(strcmp(csv_state[i].text, "cpu") == 0 && warn == 1)
      {
      // try to get at least cpu time from result.sah
      entry = readEntry(rsfFileName, "cpu_time");
      }
    else if(strcmp(csv_state[i].text, "prog") == 0 && warn == 1)
      {
      // assume progress is 100 %
      entry = "0.99994457";
      }
    else
      entry = readEntry(SC_StateFile, csv_state[i].text);
    buffer += constructEntry(entry, csv_state[i].type);
    }
  buffer = buffer.left(buffer.length()-1);
  }

if(error == 0)
  {
  if(f_sel.open(IO_Append | IO_WriteOnly))
    {
    QTextStream tlog(&f_sel);
    tlog << endl << buffer;
    f_sel.close();

    if(warn)
      {
      QString buf;
      buf = i18n("Ksetiwatch has logged the work unit for \"%1\" without\n"
            "existing 'state.sah' file. Some values might therefore be wrong\n"
            "or out of date. Consider adding the '-stop_after_process' \n"
            "command line option when starting the SETI@home client.").arg(description());
      QMessageBox* mb = new QMessageBox(i18n("Warning"), buf,
                                        QMessageBox::Information,
                                        QMessageBox::Ok|QMessageBox::Default,
                                        0, 0, 0, 0, false,
                                        WStyle_DialogBorder|WDestructiveClose);
      mb->show();
      }
    }
  }
else
  {
  buffer = i18n("Missing file(s). Logging of work unit failed.\n"
                "Error code: %1").arg(error);
  KMessageBox::error(0, buffer);
  }
}

/*------------------------------------------------------------------------ */
QString SetiLoc::constructEntry(const QString& entry, int type)
{
QString val = entry;

if(type == 0)
  val.append(",");
if(type == 1)
  {
  if(!val.isEmpty())
    {
    val.insert(0, '\"');
    val.append("\",");
    }
  else
    {
    val.append(",");
    }
  }

return(val);
}

/*------------------------------------------------------------------------ */
void SetiLoc::logResults()
{
QFile resFile(rsfFileName);
if(resFile.open(IO_ReadOnly))
  {
  QString reslog_file;

  reslog_file = logDirectory() + "/SETIResult.log";
  QFile resLog(reslog_file);

  // used to prevent empty line at the beginning
  bool logEx = resLog.exists();
  if(resLog.open(IO_Append | IO_WriteOnly))
    {
    QTextStream tin(&resLog);
    QTextStream tout(&resFile);
    QString line;
    // take the WU name as group name
    if(logEx) tin << endl;
    tin << "[" << readEntry(SC_ResultFile, "name") << "]";
    // skip past the header
    while(line.find("end_seti_header") != 0 && !resFile.atEnd())
      line = tout.readLine();
    // now scan for signal lines
    int sCnt = 1, gCnt = 1, pCnt = 1, tCnt = 1;
    int idlen = strlen("gaussian:");
    QString id;
    QString key;
    while(!resFile.atEnd())
      {
      line = tout.readLine();
      // take the left part as identifier
      id = line.left(idlen);
      if(id.find("spike:") == 0)
        {
        key.sprintf("spike%02d=", sCnt);
        tin << endl << key << line.mid(strlen("spike:"));
        sCnt++;
        }
      else if(id.find("gaussian:") == 0)
        {
        key.sprintf("gaussian%02d=", gCnt);
        tin << endl << key << line.mid(strlen("gaussian:"));
        gCnt++;
        }
      else if(id.find("pulse:") == 0)
        {
        key.sprintf("pulse%02d=", pCnt);
        tin << endl << key << line.mid(strlen("pulse:"));
        pCnt++;
        }
      else if(id.find("triplet:") == 0)
        {
        key.sprintf("triplet%02d=", tCnt);
        QString tdat = line.mid(strlen("triplet:"));
        tdat += loggedTripletProfile(tdat);
        tin << endl << key << tdat;
        tCnt++;
        }
      }
    resLog.close();
    }
  resFile.close();
  }
}

/*------------------------------------------------------------------------ */
bool SetiLoc::startClient()
{
bool running = false;

// take care of the -stop_after_send option
QFile sas(directory() + "/stop_after_send.txt");
if(sets.stopAfterSend)
  {
  if(sas.exists() == false)
    {
    sas.open(IO_WriteOnly);
    sas.close();
    }
  }
else
  {
  if(sas.exists())
    {
    sas.remove();
    }
  }

if(!isClientRunning(true))
  {
  client.clearArguments();
  // check for customized executable file
  if(sets.useCustomStartExe && !sets.customStartExe.isEmpty())
    {
    QStringList sl = QStringList::split(' ', sets.customStartExe);
    for(QStringList::Iterator it=sl.begin(); it!=sl.end(); it++)
      client << (*it);
    }
  else
    {
    client << (directory() + "/setiathome");
    // check the settings of the check boxes
    if(sets.stopAfterProcess)
      client << "-stop_after_process";
    if(sets.email)
      client << "-email";
    if(sets.graphics)
      client << "-graphics";
    // nice level
    client << "-nice" << QString::number(20 - sets.priority);
    // proxy settings
    if(sets.useProxy)
      client << "-proxy"
             << sets.proxyServer + ":" + QString::number(sets.proxyPort);
    // and now any text in the arguments field
    if(!sets.arguments.isEmpty())
      {
      QStringList sl = QStringList::split(' ', sets.arguments);
      for(QStringList::Iterator it=sl.begin(); it!=sl.end(); it++)
        client << (*it);
      }
    }
  // we have to change to the setiathome directory to properly start the client
  pid_t oldPid = getClientPid();
  QString curdir = QDir::currentDirPath();
  QDir::setCurrent(directory());
  client.start(KProcess::DontCare, KProcess::Stdout);
  QDir::setCurrent(curdir);
  // wait 0.2 secs at maximum
  int i = 20;
  while((cltPid = getClientPid()) == oldPid && i > 0)
    {
    usleep(10000);
    i--;
    }
  // and check if the process is running
  running = isClientRunning();
  }
else
  running = true;

if(running)
  stoppedNormally = false;

return(running);
}

/*------------------------------------------------------------------------ */
int SetiLoc::stopClient()
{
int ret(-1);

if(sets.useCustomStopExe && !sets.customStopExe.isEmpty())
  {
  stopProc.clearArguments();
  QStringList sl = QStringList::split(' ', sets.customStopExe);
  for(QStringList::Iterator it=sl.begin(); it!=sl.end(); it++)
    client << (*it);
  stopProc.start(KProcess::DontCare, KProcess::NoCommunication);
  ret = 0;
  }
else
  {
  if(cltPid > 0)
    ret = ::kill(cltPid, SIGTERM);
  }

stoppedNormally = true;

return(ret);
}

/*------------------------------------------------------------------------ */
void SetiLoc::slotDumpClientOutput(KProcess*, char* buffer, int len)
{
QString output = clientOutput->text();
if(output.length() > 5000)
  {
  output = output.right(output.length() - len);
  int linebrk = output.find('\n');
  if(linebrk >= 0)
    output = output.right(output.length() - linebrk - 1);
  }
output += QCString(buffer, len) + '\n';
clientOutput->setText(output);
// scroll to bottom of window (only Qt3)
#if QT_VERSION >= 0x030000
    clientOutput->scrollToBottom();
#endif
}

/*------------------------------------------------------------------------ */
QString SetiLoc::loggedTripletProfile(const QString& tdata)
{
QString ret = "";
QString tripfile = logDirectory() + "/.triplets.dat";

QFile tfile(tripfile);
if(!tdata.isEmpty() && tfile.open(IO_ReadOnly))
  {
  // Split the line into separate strings. This allows us to...
  QStringList tlist = QStringList::split(' ', tdata);
  // use SetiContainer's method to retrieve the entries.
  double tpower1  = readEntry(tlist, "power").toDouble();
  double tperiod1 = readEntry(tlist, "period").toDouble();

  QTextStream t(&tfile);
  QString line;

  QStringList ll;
  QStringList::Iterator it;
  bool found = false;
  while(!t.atEnd())
    {
    line = t.readLine();
    // extra info is a comma-separated line; split it up
    ll = QStringList::split(',', line);
    // first entry is power
    it = ll.begin();
    double tpower2 = (*it).toDouble();
    // second entry is period
    it++;
    double tperiod2 = (*it).toDouble();
    // if entries match with values in result.sah jump out of while loop
    if(fabs(tpower1-tpower2) < 0.0001 &&
       fabs(tperiod1-tperiod2) < 0.0001 &&
       tpower1 > 0.0 && tpower2 > 0.0 &&
       tperiod1 > 0.0 && tperiod2 > 0.0) {found = true; break;}
    }
  if(found)
    {
    // next entries are triplet positions
    for(int i=0;i<3;i++)
      {
      it++;
      ret += QString(" index%1=%2").arg(i).arg((*it).toInt());
      }
    // triplet profile has always 512 points
    ret += " len_prof=512";
    // finally copy the triplet data
    it++;
    ret += " prof=" + (*it);
    }

  tfile.close();
  }

return(ret);
}

/*------------------------------------------------------------------------ */
SpikeScore SetiLoc::loggedSpikeSignal(QString& line)
{
WUScore score;

initWUScore(&score);

// replace all occurences of '= ' with '='
line.replace(QRegExp("= +"), "=");
// Split the line into separate strings. This allows us to...
QStringList llist = QStringList::split(' ', line);
// use SetiContainer's method to retrieve the entries.
score.spike.power     = readEntry(llist, "power").toDouble();
score.spike.ra        = readEntry(llist, "ra").toDouble();
score.spike.dec       = readEntry(llist, "dec").toDouble();
score.spike.fft_len   = readEntry(llist, "fft_len").toInt();
score.spike.frequency = readEntry(llist, "freq").toDouble();
score.spike.chirprate = readEntry(llist, "chirp_rate").toDouble();

return(score.spike);
}

/*------------------------------------------------------------------------ */
GaussianScore SetiLoc::loggedGaussianSignal(QString & line)
{
WUScore score;
QString pot;
unsigned short int data[64];

initWUScore(&score);

// replace all occurences of '= ' with '='
line.replace(QRegExp("= +"), "=");
// Split the line into separate strings. This allows us to...
QStringList llist = QStringList::split(' ', line);
// use SetiContainer's method to retrieve the entries.
score.gaussian.power     = readEntry(llist, "peak").toDouble();
score.gaussian.true_mean = readEntry(llist, "mean").toDouble();
score.gaussian.ra        = readEntry(llist, "ra").toDouble();
score.gaussian.dec       = readEntry(llist, "dec").toDouble();
score.gaussian.sigma     = readEntry(llist, "sigma").toDouble();
score.gaussian.chisq     = readEntry(llist, "chisqr").toDouble();
score.gaussian.fft_len   = readEntry(llist, "fft_len").toInt();
score.gaussian.frequency = readEntry(llist, "freq").toDouble();
score.gaussian.chirprate = readEntry(llist, "chirprate").toDouble();
score.gaussian.score     = score.gaussian.power/score.gaussian.chisq;

pot = readEntry(llist, "pot");
int dl = readDataString(&data[0], pot, 64);
if(dl > 0)
  {
  double maxPower = readEntry(llist, "maxpow").toDouble();
  for(int i=0;i<dl;i++)
    score.gaussian.data[i] = maxPower*((double)data[i]/255.0);
  score.gaussian.data_len = dl;
  score.gaussian.fft_index = calcGaussianFFTIndex(&score.gaussian);
  }

return(score.gaussian);
}

/*------------------------------------------------------------------------ */
int SetiLoc::calcGaussianFFTIndex(GaussianScore* g)
{
int i, k;

int index = 0;
double min = -1.0;
for(i=0; i<64; i++)
  {
  double lss = 0.0;
  double fit;
  // calculate the square sum between fit and experimental data
  for(k=0; k<64; k++)
    {
    fit = g->true_mean + g->power*exp(-((i-k)*(i-k))/(g->sigma*g->sigma));
    lss += (g->data[k] - fit)*(g->data[k] - fit);
    }
  // the minimum value will determine the position
  if(min < 0.0)
    min = lss;
  else
    {
    if(lss < min)
      {
      min = lss;
      index = i;
      }
    }
  }

return(index);
}

/*------------------------------------------------------------------------ */
PulseScore SetiLoc::loggedPulseSignal(QString& line)
{
WUScore score;
QString pot;

initWUScore(&score);

// replace all occurences of '= ' with '='
line.replace(QRegExp("= +"), "=");
// Split the line into separate strings. This allows us to...
QStringList llist = QStringList::split(' ', line);
// use SetiContainer's method to retrieve the entries.
score.pulse.power     = readEntry(llist, "power").toDouble();
score.pulse.mean      = readEntry(llist, "mean").toDouble();
score.pulse.period    = readEntry(llist, "period").toDouble();
score.pulse.ra        = readEntry(llist, "ra").toDouble();
score.pulse.dec       = readEntry(llist, "dec").toDouble();
score.pulse.fft_len   = readEntry(llist, "fft_len").toInt();
score.pulse.frequency = readEntry(llist, "freq").toDouble();
score.pulse.chirprate = readEntry(llist, "chirp_rate").toDouble();

// calculate the score from "thresh" and "snr"
double thresh = readEntry(llist, "thresh").toDouble();
double snr    = readEntry(llist, "snr").toDouble();
if(thresh > 0.0) score.pulse.score = snr/thresh;

int dl = readEntry(llist, "len_prof").toInt();
if(dl > 0)
  {
  pot = readEntry(llist, "prof");
  dl = readDataString(&score.pulse.data[0], pot, dl);
  score.pulse.data_len = dl;
  }

return(score.pulse);
}

/*------------------------------------------------------------------------ */
TripletScore SetiLoc::loggedTripletSignal(QString& line)
{
WUScore score;
QString pot;

initWUScore(&score);

// replace all occurences of '= ' with '='
line.replace(QRegExp("= +"), "=");
// Split the line into separate strings. This allows us to...
QStringList llist = QStringList::split(' ', line);
// use SetiContainer's method to retrieve the entries.
score.triplet.power      = readEntry(llist, "power").toDouble();
score.triplet.score      = score.triplet.power;
score.triplet.mean       = readEntry(llist, "mean").toDouble();
score.triplet.period     = readEntry(llist, "period").toDouble();
score.triplet.ra         = readEntry(llist, "ra").toDouble();
score.triplet.dec        = readEntry(llist, "dec").toDouble();
score.triplet.fft_len    = readEntry(llist, "fft_len").toInt();
score.triplet.frequency  = readEntry(llist, "freq").toDouble();
score.triplet.chirprate  = readEntry(llist, "chirp_rate").toDouble();
score.triplet.tpotind0_0 = readEntry(llist, "index0").toInt();
score.triplet.tpotind0_1 = score.triplet.tpotind0_0;
score.triplet.tpotind1_0 = readEntry(llist, "index1").toInt();
score.triplet.tpotind1_1 = score.triplet.tpotind1_0;
score.triplet.tpotind2_0 = readEntry(llist, "index2").toInt();
score.triplet.tpotind2_1 = score.triplet.tpotind2_0;

int dl = readEntry(llist, "len_prof").toInt();
if(dl > 0)
  {
  pot = readEntry(llist, "prof");
  dl = readDataString(&score.triplet.data[0], pot, dl);
  score.triplet.data_len = dl;
  }

return(score.triplet);
}

#include "setiloc.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:15 2003 by doxygen 1.2.18, written by Dimitri van Heesch, © 1997-2002