#include <qavrgacquisition.h>

Inheritance diagram for QavrgAcquisition:

Public Slots
void	acquireData ()
void	acquireReference ()
void	acquireDark ()
void	acquireOnce ()
void	acquireScope ()
void	acquireCancel ()
int	acquireWait (double time)
void	loadData (QString fileName)
void	saveData (QString fileName)
void	newSaveFile (QString f, int n)
void	closeSaveFile ()
void	startNewScan (QcepStringVector header)
void	saveAcquisitionResult (QcepDoubleVector data)
QVector< double >	readResult (int chan, int parm, int start, int nbins)
QVector< double >	readResult (int chan, int parm)
double	readResult (int chan, int parm, int bin)
QString	resultHeader (int chan, int parm, int bin)
double	readResultAverage (int chan, int parm, int start, int nbins)
double	readResultBunchAverage (int chan, int parm, int bunch, int norbits)
int	orbitNumber (int n) const
int	bucketNumber (int n) const
void	fillPatternChanged ()
void	timingResetDefaults ()
void	triggerResetDefaults ()
Signals
void	noDeviceAvailable ()
void	acquisitionStarted ()
void	acquisitionCancelled ()
void	acquisitionProgress (double pct)
void	acquisitionCompleted ()
Public Member Functions
	QavrgAcquisition (QavrgAcquisitionThread acq, QavrgApplication app, QObject *parent)
	~QavrgAcquisition ()
void	initialize ()
int	resultSize ()
int	getAcquisitionLock ()
void	releaseAcquisitionLock ()
virtual QcepSettingsSaverWPtr	saver () const
Private Member Functions
void	findDevices ()
void	configureAverager (AcquisitionMode mode)
void	setupAcquisition (AcquisitionMode mode)
void	startAcquisition (int rep, int nrep)
void	waitAcquisition (int rep, int nrep)
void	readoutAcquisition (int rep, int nrep)
bool	checkStatus (int line, ViStatus status)
Private Attributes
QMutex	m_AcquisitionMutex
QMutex	m_SaveFileMutex
QMutex	m_BufferMutex
QavrgApplication *	m_Application
QavrgAcquisitionThread *	m_AcquisitionThread
ViInt32	m_NInstruments
ViSession *	m_InstrumentID
ViInt32 *	m_CardNChannels
long	m_TotalChannels
QTime	m_Time
FILE *	m_SaveFile
QVector< double >	m_Buffer
QMutex	m_Acquiring
QWaitCondition	m_StatusWaiting

Detailed Description

Definition at line 19 of file qavrgacquisition.h.

Constructor & Destructor Documentation

QavrgAcquisition::QavrgAcquisition	(	QavrgAcquisitionThread *	acq,
		QavrgApplication *	app,
		QObject *	parent
	)

Definition at line 22 of file qavrgacquisition.cpp.

References fillPatternChanged(), findDevices(), m_CardNChannels, m_InstrumentID, newSaveFile(), and valueChanged().

  : 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()));
}

QavrgAcquisition::~QavrgAcquisition ( )

Definition at line 61 of file qavrgacquisition.cpp.

References m_CardNChannels, QavrgAcquisitionParms::m_Fitters, m_InstrumentID, m_NInstruments, and m_SaveFile.

{
  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);
  }
}

Member Function Documentation

void QavrgAcquisition::acquireCancel ( ) [slot]

Definition at line 181 of file qavrgacquisition.cpp.

References acquisitionCancelled(), QavrgAcquisitionData::m_AcquireCancel, and m_Acquiring.

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

    emit acquisitionCancelled();

    m_AcquireCancel = 1;
  }
}

void QavrgAcquisition::acquireDark ( ) [slot]

Definition at line 255 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireDark, QavrgAcquisitionParms::AcquireDone, acquisitionCompleted(), acquisitionProgress(), QavrgAcquisitionData::m_AcquireCancel, readoutAcquisition(), releaseAcquisitionLock(), QavrgAcquisitionData::saveDarkData(), setupAcquisition(), startAcquisition(), and waitAcquisition().

{
  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::acquireData ( ) [slot]

Definition at line 197 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireData, QavrgAcquisitionParms::AcquireDone, acquisitionCompleted(), acquisitionProgress(), QavrgAcquisitionData::m_AcquireCancel, QavrgAcquisitionParms::printMessage(), readoutAcquisition(), releaseAcquisitionLock(), setupAcquisition(), startAcquisition(), and waitAcquisition().

{
  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::acquireOnce ( ) [slot]

Definition at line 317 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireDone, QavrgAcquisitionParms::AcquireOnce, acquisitionCompleted(), acquisitionProgress(), readoutAcquisition(), releaseAcquisitionLock(), setupAcquisition(), startAcquisition(), and waitAcquisition().

{
  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::acquireReference ( ) [slot]

Definition at line 286 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireDone, QavrgAcquisitionParms::AcquireReference, acquisitionCompleted(), acquisitionProgress(), QavrgAcquisitionData::m_AcquireCancel, readoutAcquisition(), releaseAcquisitionLock(), QavrgAcquisitionData::saveReferenceData(), setupAcquisition(), startAcquisition(), and waitAcquisition().

{
  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::acquireScope ( ) [slot]

Definition at line 337 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireDone, QavrgAcquisitionParms::AcquireScope, acquisitionCompleted(), acquisitionProgress(), configureAverager(), QavrgAcquisitionData::m_AcquireCancel, readoutAcquisition(), releaseAcquisitionLock(), setupAcquisition(), startAcquisition(), and waitAcquisition().

{
  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::acquireWait ( double time ) [slot]

Definition at line 159 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireData, QavrgAcquisitionParms::AcquireDone, m_Acquiring, and m_StatusWaiting.

{
  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::acquisitionCancelled ( ) [signal]

Referenced by acquireCancel().

void QavrgAcquisition::acquisitionCompleted ( ) [signal]

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

void QavrgAcquisition::acquisitionProgress ( double pct ) [signal]

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

void QavrgAcquisition::acquisitionStarted ( ) [signal]

Referenced by setupAcquisition().

int QavrgAcquisition::bucketNumber ( int n ) const [slot]

Definition at line 667 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::get_FilledBucketsPerOrbit().

Referenced by QavrgResultsModel::headerData(), and resultHeader().

{
  int norb = get_FilledBucketsPerOrbit();

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

bool QavrgAcquisition::checkStatus	(	int	line,
		ViStatus	status
	)		`[private]`

Definition at line 388 of file qavrgacquisition.cpp.

{
  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::closeSaveFile ( ) [slot]

Definition at line 498 of file qavrgacquisition.cpp.

References m_SaveFile, and m_SaveFileMutex.

{
  QMutexLocker lock(&m_SaveFileMutex);

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

void QavrgAcquisition::configureAverager ( AcquisitionMode mode ) [private]

Definition at line 679 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::AcquireScope, CHECK_STATUS, QavrgAcquisitionParms::fitter(), m_CardNChannels, m_InstrumentID, m_NInstruments, QavrgAcquisitionParms::printMessage(), QavrgAcquisitionParms::set_AcquisitionMode(), and QavrgAcquisitionSimulated::simulatedConfigureAverager().

Referenced by acquireScope(), and setupAcquisition().

{
  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::fillPatternChanged ( ) [slot]

Definition at line 116 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fillPattern, QavrgAcquisitionParms::get_CustomFillPattern(), m_Application, and QavrgAcquisitionParms::set_FillPattern().

Referenced by QavrgAcquisition().

{
//  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);
}

void QavrgAcquisition::findDevices ( ) [private]

Definition at line 403 of file qavrgacquisition.cpp.

References CHECK_STATUS, m_AcquisitionMutex, m_CardNChannels, QavrgAcquisitionParms::m_Fitters, QavrgAcquisitionParms::m_FittersMutex, m_InstrumentID, m_NInstruments, m_TotalChannels, and QavrgAcquisitionParms::status.

Referenced by QavrgAcquisition().

{
  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");
}

int QavrgAcquisition::getAcquisitionLock ( )

Definition at line 368 of file qavrgacquisition.cpp.

References m_Acquiring.

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

void QavrgAcquisition::initialize ( )

Definition at line 44 of file qavrgacquisition.cpp.

References QavrgAcquisitionData::loadDarkData(), QavrgAcquisitionData::loadReferenceData(), and noDeviceAvailable().

{
  THREAD_CHECK;

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

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

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

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

void QavrgAcquisition::loadData ( QString fileName ) [slot]

Definition at line 1028 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::warningMessage().

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

void QavrgAcquisition::newSaveFile	(	QString	f,
		int	n
	)		`[slot]`

Definition at line 457 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::filePath, m_SaveFile, and m_SaveFileMutex.

Referenced by QavrgAcquisition().

{
  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::noDeviceAvailable ( ) [signal]

Referenced by initialize().

int QavrgAcquisition::orbitNumber ( int n ) const [slot]

Definition at line 656 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::get_FilledBucketsPerOrbit().

Referenced by QavrgResultsModel::headerData(), and resultHeader().

{
  int norb = get_FilledBucketsPerOrbit();

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

void QavrgAcquisition::readoutAcquisition	(	int	rep,
		int	nrep
	)		`[private]`

Definition at line 850 of file qavrgacquisition.cpp.

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

{
  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()));
      }
    }
  }
}

QVector< double > QavrgAcquisition::readResult	(	int	chan,
		int	parm,
		int	start,
		int	nbins
	)		`[slot]`

Definition at line 616 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), and QavrgFitter::readResult().

Referenced by saveAcquisitionResult().

{
  QavrgFitter *f = fitter(chan);

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

double QavrgAcquisition::readResult	(	int	chan,
		int	parm,
		int	bin
	)		`[slot]`

Definition at line 638 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), and QavrgFitter::readResult().

{
  QavrgFitter *f = fitter(chan);

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

QVector< double > QavrgAcquisition::readResult	(	int	chan,
		int	parm
	)		`[slot]`

Definition at line 627 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), and QavrgFitter::readResult().

{
  QavrgFitter *f = fitter(chan);

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

double QavrgAcquisition::readResultAverage	(	int	chan,
		int	parm,
		int	start,
		int	nbins
	)		`[slot]`

Definition at line 594 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), and QavrgFitter::readResultAverage().

{
  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
	)		`[slot]`

Definition at line 605 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), and QavrgFitter::readResultBunchAverage().

{
  QavrgFitter *f = fitter(chan);

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

void QavrgAcquisition::releaseAcquisitionLock ( )

Definition at line 379 of file qavrgacquisition.cpp.

References m_Acquiring, and m_StatusWaiting.

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

{
//  printf("Release acquisition lock\n");

  m_Acquiring.unlock();

  m_StatusWaiting.wakeAll();
}

QString QavrgAcquisition::resultHeader	(	int	chan,
		int	parm,
		int	bin
	)		`[slot]`

Definition at line 649 of file qavrgacquisition.cpp.

References bucketNumber(), and orbitNumber().

Referenced by startNewScan().

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

int QavrgAcquisition::resultSize ( )

Definition at line 96 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter().

Referenced by QavrgResultsModel::rowCount().

{
  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::saveAcquisitionResult ( QcepDoubleVector data ) [slot]

Definition at line 559 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), m_SaveFile, m_SaveFileMutex, QavrgFitter::PeakHeight, readResult(), and QavrgFitter::resultSize().

{
  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);
}

void QavrgAcquisition::saveData ( QString fileName ) [slot]

Definition at line 996 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), QavrgFitter::get_RawData(), and QavrgAcquisitionParms::warningMessage().

{
  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));
  }
}

QcepSettingsSaverWPtr QavrgAcquisition::saver ( ) const [virtual]

Implements QavrgAcquisitionParms.

Definition at line 1033 of file qavrgacquisition.cpp.

References m_Application, and QavrgApplication::saver().

{
  return m_Application->saver();
}

void QavrgAcquisition::setupAcquisition ( AcquisitionMode mode ) [private]

Definition at line 761 of file qavrgacquisition.cpp.

References acquisitionStarted(), configureAverager(), QavrgAcquisitionData::m_AcquireCancel, and m_Acquiring.

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

{
  THREAD_CHECK;

  m_Acquiring.tryLock();

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

  configureAverager(mode);
}

void QavrgAcquisition::startAcquisition	(	int	rep,
		int	nrep
	)		`[private]`

Definition at line 774 of file qavrgacquisition.cpp.

References CHECK_STATUS, QavrgAcquisitionData::m_Accumulator, m_Buffer, m_InstrumentID, m_NInstruments, m_Time, m_TotalChannels, and QavrgAcquisitionSimulated::simulatedStartAcquisition().

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

{
  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::startNewScan ( QcepStringVector header ) [slot]

Definition at line 508 of file qavrgacquisition.cpp.

References QavrgAcquisitionParms::fitter(), m_SaveFile, m_SaveFileMutex, QavrgFitter::PeakHeight, resultHeader(), and QavrgFitter::resultSize().

{
  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::timingResetDefaults ( ) [slot]

Definition at line 83 of file qavrgacquisition.cpp.

{
  reset_NChannels();
  reset_NSamples();
}

void QavrgAcquisition::triggerResetDefaults ( ) [slot]

Definition at line 89 of file qavrgacquisition.cpp.

{
  reset_TriggerLevel();
  reset_TriggerSlope();
  reset_TriggerSource();
}

void QavrgAcquisition::waitAcquisition	(	int	rep,
		int	nrep
	)		`[private]`

Definition at line 813 of file qavrgacquisition.cpp.

References CHECK_STATUS, QavrgAcquisitionData::m_AcquireCancel, m_InstrumentID, m_NInstruments, m_Time, QavrgAcquisitionParms::printMessage(), QavrgAcquisitionSimulated::simulatedWaitAcquisition(), and QavrgAcquisitionParms::status.

Referenced by acquireDark(), acquireData(), acquireOnce(), acquireReference(), and acquireScope().

{
  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()));
}