qavrgacquisition.cpp

Go to the documentation of this file.

#include "qavrgacquisition.h"

#include <QTime>
#include <QTimer>
#include <QMetaObject>
#include <QMetaProperty>
#include <QList>
#include <QtConcurrentRun>
#include "AcqirisImport.h"
#include "AcqirisD1Import.h"
#include "qavrgapplication.h"
#include "qavrgfillpattern.h"
#include "qavrgfitter.h"
#include "qavrgsettings.h"
#include <math.h>
#include <QMutexLocker>
#include "qavrgacquisitionthread.h"
#include <stdio.h>

#define CHECK_STATUS(val) checkStatus(__LINE__,val)

QavrgAcquisition::QavrgAcquisition(QavrgAcquisitionThread *acq, QavrgApplication *app, QObject *parent)
  : QavrgAcquisitionSimulated(acq, app, parent),
//    m_Mutex(QMutex::Recursive),
    m_Application(app),
    m_AcquisitionThread(acq),
    m_NInstruments(0),
    m_InstrumentID(NULL),
    m_CardNChannels(NULL),
    m_TotalChannels(0),
    m_SaveFile(NULL)
//    m_ParametersChanged(false)
{
  m_InstrumentID = new ViSession[20];
  m_CardNChannels = new ViInt32[20];

  newSaveFile("saveddata",1);

  findDevices();

  connect(prop_FillPatternMode(), SIGNAL(valueChanged(int,int)), this, SLOT(fillPatternChanged()));
}

void QavrgAcquisition::initialize()
{
  THREAD_CHECK;

//  printf("Enter QavrgAcquisition::initialize(), nChannels = %d\n", get_NChannels());

  if (get_SimulationMode()) {
    emit noDeviceAvailable();
  }

//  loadParameters();
  loadReferenceData();
  loadDarkData();

//  printf("Leave QavrgAcquisition::initialize()\n");
}

QavrgAcquisition::~QavrgAcquisition()
{
  for (int i=0; i<m_NInstruments; i++) {
    AcqrsD1_stopAcquisition(m_InstrumentID[i]);
  }
      
  Acqrs_closeAll();

  delete [] m_InstrumentID;
  delete [] m_CardNChannels;

  QavrgFitter *t;

  foreach(t, m_Fitters) {
    delete t;
  }

  if (m_SaveFile) {
    fclose(m_SaveFile);
  }
}

void QavrgAcquisition::timingResetDefaults()
{
  reset_NChannels();
  reset_NSamples();
}

void QavrgAcquisition::triggerResetDefaults()
{
  reset_TriggerLevel();
  reset_TriggerSlope();
  reset_TriggerSource();
}

int QavrgAcquisition::resultSize()
{
  int maxsize = 0;

  int nchan = get_NChannels();

  for (int chan=0; chan<nchan; chan++) {
    QavrgFitter *t = fitter(chan);

    if (t) {
      int resultsize = t -> resultSize();
      if (resultsize > maxsize) {
        maxsize = resultsize;
      }
    }
  }

  return maxsize;
}

void QavrgAcquisition::fillPatternChanged()
{
//  printf("QavrgAcquisition::fillPatternChanged\n");

  QcepBoolVector patt;
  int bpo = get_BucketsPerOrbit();
  int nbunches;

  switch (get_FillPatternMode()) {
  case 0:   // Automatic mode
    if (m_Application -> fillPattern()) {
      patt = m_Application -> fillPattern() -> fillPattern();
    }
    break;

  case 1:   // 24 bunch mode
    patt.resize(bpo);
    for (int i=0; i<24; i++) {
      patt[i*bpo/24] = true;
    }
    break;

  case 2:   // Single bunch mode;
    patt.resize(bpo);
    patt[0] = 1;
    break;

  case 3:
    nbunches = get_CustomFilledBucketsPerOrbit();
    patt.resize(bpo);
    for (int i=0; i<nbunches; i++) {
      patt[i*bpo/nbunches] = true;
    }
    break;

  case 4:   // Custom fill mode
    patt = get_CustomFillPattern();
    break;
  }

  set_FillPattern(patt);
}

int QavrgAcquisition::acquireWait(double time)
{
  if (m_Acquiring.tryLock()) {
    m_Acquiring.unlock();

//    printf("Not acquiring\n");

    return AcquireDone;
  }

  QMutex mutex;
  QMutexLocker lock(&mutex);

  if (m_StatusWaiting.wait(&mutex, (int)(time*1000))) {
//    printf("Waited for %g and succeeded\n", time);
    return AcquireDone;
  } else {
//    printf("Waited for %g and timed out\n", time);
    return AcquireData/*get_Status()*/;
  }
}

void QavrgAcquisition::acquireCancel()
{
//  printf("Acquire cancel\n");
//
  if (m_Acquiring.tryLock()) {
    m_Acquiring.unlock();
    return;
  } else {
//    printf("Emit cancelled\n");

    emit acquisitionCancelled();

    m_AcquireCancel = 1;
  }
}

void QavrgAcquisition::acquireData()
{
  THREAD_CHECK;
//
//  QMutexLocker  lock(&m_Acquiring);

//  printf("QavrgAcquisition::acquireData()\n");

  QTime tm;
  tm.start();
  int cumultime=0;

//  cumultime += tm.restart();
//  emit printMessage(tr("acquireData: cumulative acquisition time %1 msec").arg(cumultime));

  setupAcquisition(AcquireData);

//  cumultime += tm.restart();
//  emit printMessage(tr("setup: cumulative acquisition time %1 msec").arg(cumultime));

  int nrep = get_NRepeats();

  for (int i=0; i<nrep; i++) {
    if (m_AcquireCancel) {
      m_AcquireCancel = 0;
      break;
    } else {
//      cumultime += tm.restart();
//      emit printMessage(tr("start: cumulative acquisition time %1 msec").arg(cumultime));

      startAcquisition(i, nrep);

//      cumultime += tm.restart();
//      emit printMessage(tr("wait: cumulative acquisition time %1 msec").arg(cumultime));

      waitAcquisition(i, nrep);

//      cumultime += tm.restart();
//      emit printMessage(tr("readout: cumulative acquisition time %1 msec").arg(cumultime));

      readoutAcquisition(i, nrep);

      emit acquisitionProgress((i+1)*100.0/nrep);

//      cumultime += tm.restart();
//      emit printMessage(tr("done: cumulative acquisition time %1 msec").arg(cumultime));
    }
  }

  releaseAcquisitionLock();

  set_Status(AcquireDone);
  emit acquisitionCompleted();

  cumultime += tm.restart();
  emit printMessage(tr("acquireData(): cumulative acquisition time %1 msec").arg(cumultime));
}

void QavrgAcquisition::acquireDark()
{
  THREAD_CHECK;
//
//  QMutexLocker  lock(&m_Acquiring);

  setupAcquisition(AcquireDark);

  int nrep = get_DarkNRepeats();

  for (int i=0; i<nrep; i++) {
    if (m_AcquireCancel) {
      m_AcquireCancel = 0;
      break;
    } else {
      startAcquisition(i, nrep);
      waitAcquisition(i, nrep);
      readoutAcquisition(i, nrep);

      emit acquisitionProgress((i+1)*100.0/nrep);
    }
  }

  saveDarkData();

  releaseAcquisitionLock();

  set_Status(AcquireDone);
  emit acquisitionCompleted();
}

void QavrgAcquisition::acquireReference()
{
  THREAD_CHECK;
//
//  QMutexLocker  lock(&m_Acquiring);

  setupAcquisition(AcquireReference);

  int nrep = get_ReferenceNRepeats();

  for (int i=0; i<nrep; i++) {
    if (m_AcquireCancel) {
      m_AcquireCancel = 0;
      break;
    } else {
      startAcquisition(i, nrep);
      waitAcquisition(i, nrep);
      readoutAcquisition(i, nrep);

      emit acquisitionProgress((i+1)*100.0/nrep);
    }
  }

  saveReferenceData();

  releaseAcquisitionLock();

  set_Status(AcquireDone);
  emit acquisitionCompleted();
}

void QavrgAcquisition::acquireOnce()
{
  THREAD_CHECK;
//
//  QMutexLocker  lock(&m_Acquiring);

  setupAcquisition(AcquireOnce);

  startAcquisition(0,1);
  waitAcquisition(0,1);
  readoutAcquisition(0,1);

  emit acquisitionProgress(100);

  releaseAcquisitionLock();

  set_Status(AcquireDone);
  emit acquisitionCompleted();
}

void QavrgAcquisition::acquireScope()
{
  THREAD_CHECK;
//
//  QMutexLocker  lock(&m_Acquiring);

  setupAcquisition(AcquireScope);

  for (int i=0; ; i++) {
//    printf("m_AcquireCancel = %d\n", (int) m_AcquireCancel);
//
    if (m_AcquireCancel) {
      m_AcquireCancel = 0;
      break;
    } else {
      configureAverager(AcquireScope);

      startAcquisition(0,1);
      waitAcquisition(0,1);
      readoutAcquisition(0,1);

      emit acquisitionProgress(-1);
    }
  }

  releaseAcquisitionLock();

  set_Status(AcquireDone);
  emit acquisitionCompleted();
}

int QavrgAcquisition::getAcquisitionLock()
{
  if (m_Acquiring.tryLock()) {
//    printf("Got acquisition lock\n");
    return 1;
  } else {
//    printf("Failed to get acquisition lock\n");
    return 0;
  }
}

void QavrgAcquisition::releaseAcquisitionLock()
{
//  printf("Release acquisition lock\n");

  m_Acquiring.unlock();

  m_StatusWaiting.wakeAll();
}

bool QavrgAcquisition::checkStatus(int line, ViStatus status)
{
  ViChar message[512];

  if (status == VI_SUCCESS/* || status == ACQIRIS_WARN_SETUP_ADAPTED*/) {
    return (status == VI_SUCCESS);
  } else {
    AcqrsD1_errorMessageEx(VI_NULL, status, message, sizeof(message));

    printf("%d: checkStatus(%lx) = %s\n", line, status, message);

    return false;
  }
}

void QavrgAcquisition::findDevices()
{
  QMutexLocker lock(&m_AcquisitionMutex);

//  printf("QavrgAcquisition::findDevices()\n");

  ViStatus status;
  ViChar options[] = "cal=0 dma=1";

  status = AcqrsD1_multiInstrAutoDefine(options, &m_NInstruments);

//  printf("Status = %d, NInstruments = %ld\n", (int) status, m_NInstruments);

  if ((!CHECK_STATUS(status)) || (m_NInstruments <= 0)) {
    set_SimulationMode(true);

    m_TotalChannels = 4;
  }

//  printf("Found %ld Acqiris Instruments\n", m_NInstruments);

  for (int i=0; i<m_NInstruments; i++) {
    char resourceName[20];
    sprintf(resourceName, "PCI::INSTR%d",i);

    status = AcqrsD1_InitWithOptions(resourceName, VI_FALSE, VI_FALSE,
                                     options, &m_InstrumentID[i]);
    CHECK_STATUS(status);

    status = AcqrsD1_getNbrChannels(m_InstrumentID[i], &m_CardNChannels[i]);
    CHECK_STATUS(status);

    printf("Instrument %d has %ld channels\n", i, m_CardNChannels[i]);

    CHECK_STATUS(AcqrsD1_configMode(m_InstrumentID[i], 2, 0, 0)); // 0 for dig, 2 for avg

    m_TotalChannels += m_CardNChannels[i];
  }

  setdef_NChannels(m_TotalChannels);

//  printf("Starting fitter threads...\n");

  QMutexLocker lock2(&m_FittersMutex);

  m_Fitters.resize(m_TotalChannels);

  for (int i=0; i < m_TotalChannels; i++) {
    m_Fitters[i] = new QavrgFitter(this, i);
  }

//  printf("Ready..\n");
}

void QavrgAcquisition::newSaveFile(QString f, int n)
{
  printf("QavrgAcquisition::newSaveFile(%s,%d)\n", qPrintable(f), n);

  QFileInfo finfo(f);
  QDateTime dt = QDateTime::currentDateTime();
  QString datePath = dt.toString("yyyy/MM/dd/");
  QString filePath;

  if (finfo.isRelative()) {
    QDir od(get_OutputDirectory());
    filePath = od.absolutePath()+"/saveddata/"+datePath+f;
    od.mkpath(od.absolutePath()+"/saveddata/"+datePath);
    printf("filePath = %s\n", qPrintable(filePath));
  } else {
    filePath = f;
  }

  FILE* nf = fopen(qPrintable(filePath),"a+");

  if (nf) {
    QMutexLocker lock(&m_SaveFileMutex);

    if (m_SaveFile) {
      fclose(m_SaveFile);
      m_SaveFile = NULL;
    }

    m_SaveFile = nf;
    set_FileName(f);
    set_FilePath(filePath);
    set_ScanNumber(n);

    fprintf(m_SaveFile, "#F %s\n", qPrintable(f));
    fprintf(m_SaveFile, "#E %d\n", (int) ::time(NULL));
    fprintf(m_SaveFile, "#D %s\n", qPrintable(QDateTime::currentDateTime().toString()));
    fprintf(m_SaveFile, "\n");
    fflush(m_SaveFile);
  }
}

void QavrgAcquisition::closeSaveFile()
{
  QMutexLocker lock(&m_SaveFileMutex);

  if (m_SaveFile) {
    fclose(m_SaveFile);
    m_SaveFile = NULL;
  }
}

void QavrgAcquisition::startNewScan(QcepStringVector header)
{
  QMutexLocker lock(&m_SaveFileMutex);

  int n = get_ScanNumber();
  n++; set_ScanNumber(n);

  fprintf(m_SaveFile, "#S %d qavrgscan\n", n);
  fprintf(m_SaveFile, "#D %s\n", qPrintable(QDateTime::currentDateTime().toString()));

  int ncols = 0;

  for (int ch=0; ch < get_NChannels(); ch++) {
    QavrgFitter *f = fitter(ch);

    if (f) {
      ncols += /*3**/(f->resultSize());
    }
  }

  int nhdr  = header.size();

  fprintf(m_SaveFile, "#N %d\n", ncols+nhdr);

  for (int i=0; i<nhdr; i++) {
    if (i == 0) {
      fprintf(m_SaveFile, "#L %s", qPrintable(header[i]));
    } else {
      fprintf(m_SaveFile, "  %s", qPrintable(header[i]));
    }
  }

  for (int ch=0; ch < get_NChannels(); ch++) {
    QavrgFitter *f = fitter(ch);

    if (f) {
      int nbins = f->resultSize();

      for (int bin=0; bin < nbins; bin++) {
//      for (int parm=0; parm<3; parm++) {
//        fprintf(m_SaveFile, "  %s", qPrintable(resultHeader(ch, parm, bin)));
//      }
        fprintf(m_SaveFile, "  %s", qPrintable(resultHeader(ch, QavrgFitter::PeakHeight, bin)));
      }
    }
  }

  fprintf(m_SaveFile, "\n");
  fflush(m_SaveFile);
}

void QavrgAcquisition::saveAcquisitionResult(QcepDoubleVector data)
{
  QMutexLocker lock(&m_SaveFileMutex);

//  printf("acquisition data ready\n");

  int nhdr = data.size();

  for (int i=0; i<nhdr; i++) {
    if (i == 0) {
      fprintf(m_SaveFile, "%g",   data[i]);
    } else {
      fprintf(m_SaveFile, " %g", data[i]);
    }
  }

  for (int ch=0; ch < get_NChannels(); ch++) {
    QavrgFitter *f = fitter(ch);

    if (f) {
      int nbins = f->resultSize();

      for (int bin=0; bin < nbins; bin++) {
//      for (int parm=0; parm<3; parm++) {
//        fprintf(m_SaveFile, " %g", readResult(ch, parm, bin));
//      }
        fprintf(m_SaveFile, " %g", readResult(ch, QavrgFitter::PeakHeight, bin));
      }
    }
  }

  fprintf(m_SaveFile, "\n");
  fflush(m_SaveFile);
}

double QavrgAcquisition::readResultAverage(int chan, int parm, int start, int nbins)
{
  QavrgFitter *f = fitter(chan);

  if (f) {
    return f->readResultAverage(parm,start,nbins);
  } else {
    return 0;
  }
}
  
double QavrgAcquisition::readResultBunchAverage(int chan, int parm, int bunch, int norbits)
{
  QavrgFitter *f = fitter(chan);

  if (f) {
    return f->readResultBunchAverage(parm, bunch, norbits);
  } else {
    return 0;
  }
}

QVector<double> QavrgAcquisition::readResult(int chan, int parm, int start, int nbins)
{
  QavrgFitter *f = fitter(chan);

  if (f) {
    return f->readResult(parm,start,nbins);
  } else {
    return QVector<double>();
  }
}

QVector<double> QavrgAcquisition::readResult(int chan, int parm)
{
  QavrgFitter *f = fitter(chan);

  if (f) {
    return f->readResult(parm);
  } else {
    return QVector<double>();
  }
}

double QavrgAcquisition::readResult(int chan, int parm, int bin)
{
  QavrgFitter *f = fitter(chan);

  if (f) {
    return f->readResult(parm,bin);
  } else {
    return 0;
  }
}

QString QavrgAcquisition::resultHeader(int chan, int /*parm*/, int bin)
{
//  const char * labels = "BSP";
  
  return tr("c%1o%2b%3").arg(chan).arg(orbitNumber(bin)).arg(bucketNumber(bin));
}

int QavrgAcquisition::orbitNumber(int n) const
{
  int norb = get_FilledBucketsPerOrbit();

  if (norb) {
    return n/norb;
  } else {
    return n;
  }
}

int QavrgAcquisition::bucketNumber(int n) const
{
  int norb = get_FilledBucketsPerOrbit();

  if (norb) {
    return n%norb;
  } else {
    return 0;
  }
}


void QavrgAcquisition::configureAverager(AcquisitionMode mode)
{
  THREAD_CHECK;

  set_AcquisitionMode(mode);

  if (mode == AcquireScope) {
    set_AcquireIntegrationTime(get_ScopeIntegrationTime());
  } else {
    set_AcquireIntegrationTime(get_IntegrationTime());
  }

  if (get_SimulationMode()) {
    simulatedConfigureAverager(mode);
  } else {
    //    printf("configure averager (thread %p, this-thread() %p\n", QThread::currentThread(), thread());

    //   QMutexLocker lock(&m_Mutex);

    double sampInterval = 1.e-9, delayTime = 0.0;
    long trigCoupling = 0;

    long trigSlope = (get_TriggerSlope()==0 ? 1 : 0);
    double trigLevel = get_TriggerLevel()*1000;

    // ### Configuration parameters for averager ###
    long nbrSamples = get_NSamples();
    long nbrWaveForms = (long)(get_AcquireIntegrationTime()*get_LaserRepRate());
    long ditherRange = 0, trigResync = 1;
    long startDelay = 0, stopDelay = 0;

    for (int i=0, chan=0; i<m_NInstruments; i++) {

      // Configure timebase
      CHECK_STATUS(AcqrsD1_configHorizontal(m_InstrumentID[i], sampInterval, delayTime));

      switch (get_TriggerSource()) {
      case 0: // External trigger
        CHECK_STATUS(AcqrsD1_configTrigClass(m_InstrumentID[i], 0, 0x80000000, 0, 0, 0.0, 0.0));
        CHECK_STATUS(AcqrsD1_configTrigSource(m_InstrumentID[i], -1, trigCoupling, trigSlope, trigLevel, 0.0));
        break;
      case 1: // Channel 0 trigger
        CHECK_STATUS(AcqrsD1_configTrigClass(m_InstrumentID[i], 0, 0x00000001, 0, 0, 0.0, 0.0));
        CHECK_STATUS(AcqrsD1_configTrigSource(m_InstrumentID[i], 1, trigCoupling, trigSlope, trigLevel, 0.0));
        break;
      default:
        emit printMessage("Unknown trigger source");
        break;
      }

      ViInt32 temperature;
      CHECK_STATUS(AcqrsD1_getInstrumentInfo(m_InstrumentID[i], "Temperature", &temperature));

      emit printMessage(tr("card %1 temperature %2degC").arg(i).arg(temperature));

      for (long channel = 1; channel <= m_CardNChannels[i]; channel++, chan++) {
        double fullScale = fitter(chan) -> get_InputFullScale();
        double offset    = fitter(chan) -> get_InputOffset();
        long   bandwidth = fitter(chan) -> get_InputBandwidth();
        long   coupling  = fitter(chan) -> get_InputCoupling();

        //        printf("Chan %d : Full Scale %g, Offset %g, Bandwidth %d, Coupling %d\n", chan, fullScale, offset, bandwidth, coupling);

        // Configure vertical settings
        CHECK_STATUS(AcqrsD1_configVertical(m_InstrumentID[i], channel, fullScale, offset, coupling, bandwidth));
        // number of samples
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "NbrSamples", &nbrSamples));
        // number of waveforms
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "NbrWaveforms", &nbrWaveForms));
        // dithering range
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "DitherRange", &ditherRange));
        // trigger resync
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "TrigResync", &trigResync));
        // startDelay
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "StartDelay", &startDelay));
        // stopDelay
        CHECK_STATUS(AcqrsD1_configAvgConfig(m_InstrumentID[i], channel, "StopDelay", &stopDelay));
      }
    }
  }
}

void QavrgAcquisition::setupAcquisition(AcquisitionMode mode)
{
  THREAD_CHECK;

  m_Acquiring.tryLock();

  set_Status(mode);
  emit acquisitionStarted();
  m_AcquireCancel = 0;

  configureAverager(mode);
}

void QavrgAcquisition::startAcquisition(int rep, int nrep)
{
  THREAD_CHECK;

  m_Time.start();

  if (get_SimulationMode()) {
    simulatedStartAcquisition(rep, nrep);
  } else {
    // printf("start acquisition (thread %p, this-thread() %p\n", QThread::currentThread(), thread());

    if (rep == 0) {
      int nchan = get_NChannels();
      int nsamp = get_NSamples();

      m_Accumulator.resize(m_TotalChannels);

      for (int chan=0; chan<m_TotalChannels; chan++) {
        m_Accumulator[chan].resize(nsamp);
        m_Accumulator[chan].fill(0);
      }

      m_Buffer.resize(nsamp);
//
//      m_Futures.resize(nchan);
    }

    for (int i=0; i<m_NInstruments; i++) {
      CHECK_STATUS(AcqrsD1_acquire(m_InstrumentID[i]));

//       if (get_TriggerSource() == 1) {
//         printf("Attempt to force trigger\n");

//         CHECK_STATUS(AcqrsD1_forceTrig(m_InstrumentID[i]));
//       }
    }
  }
}

void QavrgAcquisition::waitAcquisition(int rep, int nrep)
{
  THREAD_CHECK;

  if (get_SimulationMode()) {
    simulatedWaitAcquisition(rep, nrep);
  } else {
//    printf("wait acquisition (thread %p, this-thread() %p\n", QThread::currentThread(), thread());

    unsigned int status = VI_SUCCESS;

    long waitTime = (long)((get_AcquireIntegrationTime()+5.0)*1000);

    for (int i=0; i<m_NInstruments; i++) {
      while (waitTime > 0) {
        status = AcqrsD1_waitForEndOfAcquisition(m_InstrumentID[i], 100);

//      printf("QavrgAcquisition::waitAcquisition waitTime %ld, status %x, i %d\n", waitTime, status, i);

        waitTime -= 100;
        if (status == VI_SUCCESS || m_AcquireCancel) {
          break;
        }
      }

      waitTime = 2000;

      if (status == ACQIRIS_ERROR_ACQ_TIMEOUT) {
        CHECK_STATUS(AcqrsD1_stopAcquisition(m_InstrumentID[i]));
        emit printMessage("Acquisition timeout");
      }
    }
  }

  emit printMessage(tr("Acquisition took %1 msec").arg(m_Time.restart()));
}

void QavrgAcquisition::readoutAcquisition(int rep, int nrep)
{
  THREAD_CHECK;

  if (get_SimulationMode()) {
    simulatedReadoutAcquisition(rep, nrep);
  } else {
    QTime timer;

    AqReadParameters       readParams;
    AqDataDescriptor       wfDesc;
    AqSegmentDescriptorAvg segDesc[1];
    int                    chan=0;

    int nsamples = get_NSamples();

    for (int i=0; i<m_NInstruments; i++) {
      timer.start();

      for (int ch=0; ch<m_CardNChannels[i]; ch++, chan++) {
        readParams.dataType           = ReadReal64;
        readParams.readMode           = ReadModeAvgW; // ReadModeStdW;
        readParams.nbrSegments        = 1;
        readParams.firstSampleInSeg   = 0;
        readParams.firstSegment       = 0;
        readParams.segmentOffset      = 0;
        readParams.segDescArraySize   = (long)sizeof(AqSegmentDescriptorAvg) * 1;
        readParams.nbrSamplesInSeg    = nsamples;
        readParams.dataArraySize      = sizeof(double)*nsamples;
        readParams.flags              = 0;
        readParams.reserved           = 0;
        readParams.reserved2          = 0.0;
        readParams.reserved3          = 0.0;

        CHECK_STATUS(AcqrsD1_readData(m_InstrumentID[i], ch+1, &readParams, m_Buffer.data(),
                                     &wfDesc, &segDesc));

//        printf("rep = %d, nrepetitions = %d\n", rep, nrep);

        for (int i=0; i<nsamples; i++) {
          m_Accumulator[chan][i] += m_Buffer[i];
        }
      }
    }

    if (rep >= (nrep-1)) {
      switch (get_AcquisitionMode()) {

      case AcquireDone:
        printf("Invalid acquisition mode in QavrgAcquisition::readoutAcquisition\n");
        return;

      case AcquireData:
      case AcquireScope:
      case AcquireOnce:
        for (int chan=0; chan<m_TotalChannels; chan++) {
          fitter(chan) -> resize(nsamples);
          QMutexLocker lock(&m_AccumulatorMutex);
          QMutexLocker lock1(fitter(chan)->mutex());

          double *rawData = fitter(chan)->rawDataPtr();
          double *accum   = m_Accumulator[chan].data();

          for (int i = 0; i<nsamples; i++) {
            rawData[i] = accum[i]/nrep;
          }
        }

        if (get_AcquisitionMode() == AcquireScope) {
          incr_NQueuedResults();

          emit new_RawData();
        }
        break;

      case AcquireDark:
        for (int chan=0; chan<m_TotalChannels; chan++) {
          fitter(chan) -> resize(nsamples);
          QMutexLocker lock(&m_AccumulatorMutex);
          QMutexLocker lock1(fitter(chan)->mutex());

          double *darkData = fitter(chan)->darkDataPtr();
          double *accum   = m_Accumulator[chan].data();

          for (int i = 0; i<nsamples; i++) {
            darkData[i] = accum[i]/nrep;
          }

          fitter(chan) -> set_DarkAvailable(true);
        }

        incr_NQueuedResults();

        emit new_DarkData();

        break;

      case AcquireReference:
        for (int chan=0; chan<m_TotalChannels; chan++) {
          fitter(chan) -> resize(nsamples);
          QMutexLocker lock(&m_AccumulatorMutex);
          QMutexLocker lock1(fitter(chan)->mutex());

          double *refData = fitter(chan)->referenceDataPtr();
          double *accum   = m_Accumulator[chan].data();

          for (int i = 0; i<nsamples; i++) {
            refData[i] = accum[i]/nrep;
          }

          fitter(chan) -> set_ReferenceAvailable(true);
        }

        incr_NQueuedResults();

        emit new_ReferenceData();

        break;
      }

      if (get_AcquisitionMode() == AcquireData  || get_AcquisitionMode() == AcquireOnce) {
        QList< QFuture<void> > futures;

        for (int chan=0; chan<m_TotalChannels; chan++) {
          if (fitter(chan) -> get_ReferenceAvailable()) {
            //              printf("concurrent fitting, max Threads = %d\n", QThreadPool::globalInstance()->maxThreadCount());
            futures.append(QtConcurrent::run(fitter(chan), &QavrgFitter::performCalculation));
          }
        }

        foreach(QFuture<void> f, futures) {
          f.waitForFinished();
        }

        incr_NQueuedResults();

        emit new_FitData();  /* implies new_RawData(), also */

        emit new_FittingResults();

        emit printMessage(tr("Fitting complete after %1 msec").arg(m_Time.restart()));
      }
    }
  }
}

void QavrgAcquisition::saveData(QString fileName)
{
  QFile outFile(fileName);

  if (outFile.open(QIODevice::Append)) {
    QTextStream out(&outFile);

    out << "#S 0 qavrg data\n";
    out << "#N " << 1+get_NChannels() << "\n";
    out << "#L n";
    for (int ch=0; ch<get_NChannels(); ch++) {
      out << "  chan" << ch;
    }
    out <<"\n";

    int nsamples = get_NSamples();
    int nchans   = get_NChannels();

    for (int i=0; i<nsamples; i++) {
      out << i;

      for (int ch=0; ch < nchans; ch++) {
        out  << "\t" << fitter(ch)->get_RawData(i);
      }

      out << "\n";
    }
  } else {
    emit warningMessage(tr("Unable to open output file %1").arg(fileName));
  }
}

void QavrgAcquisition::loadData(QString fileName)
{
  emit warningMessage(tr("QavrgAcquisition::loadData has not been implemented"));
}

QcepSettingsSaverWPtr QavrgAcquisition::saver() const
{
  return m_Application->saver();
}