qsenormalizer.cpp

Go to the documentation of this file.

#include "qsenormalizer.h"
#include "qsedataset.h"
#include "qsescan.h"

QseNormalizer::QseNormalizer
(QseDataSet* inData, QseDataSet* outData, const QString& name, QObject* parent)
  : QseEXAFSOperator(inData, outData, name, parent),
    m_ScanPattern(this, "scanpattern",NULL),
    m_MinScanRowCount(this, "minscanrowcount", NULL),
    m_MaxScanRowCount(this, "maxscanrowcount", NULL),
    m_InputEnergyUnits(this, QStringList()<<"eV"<<"keV",
           "inputenergyunits", NULL),
    m_OutputEnergyUnits(this, QStringList()<<"eV"<<"keV",
      "outputenergyunits", NULL)
{
  m_InputEnergyUnits.setValue(1);
  m_OutputEnergyUnits.setValue(1);
}

void QseNormalizer::exec()
{
  m_OutputData -> clear();

  int ns = m_InputData -> scanCount();

  for (int s = 0; s < ns; s++) {
    if (matchesScan(s)) {
      QseScan *osc = m_OutputData -> appendScan();

      normalizeScan(s, osc);
    }
  }

  m_OutputData -> emitLoadCompleted();
}

bool QseNormalizer::matchesScan(int n)
{
  QseScan* s = m_InputData->scan(n);

  if (s) {
    QseScanRole r = UnspecifiedScanRole;

    if (m_ScanExceptions.contains(s)) {
      r = m_ScanExceptions[s];
    }

    bool ok1, ok2;

    double minVal = m_MinScanRowCount.toDouble(&ok1);
    double maxVal = m_MaxScanRowCount.toDouble(&ok2);
  
    if (ok1 || ok2) {
      int nrows = s->maxRowCount();

      if (ok1 && (nrows < minVal)) {
  return FALSE;
      }

      if (ok2 && (nrows > maxVal)) {
  return FALSE;
      }
    }

    if (r == UnspecifiedScanRole) {
      return m_ScanPattern.toRegExp().exactMatch(s->scanCommand());
    } else {
      return r == ScanUsedRole;
    }
  } else {
    return false;
  }
}

void QseNormalizer::normalizeScan(int n, QseScan* osc)
{
  QseScan *sc = m_InputData->scan(n);

  if (sc) {
    int nc = sc -> columnCount();
    int energycol = -1;

    for (int c = 0; c < nc; c++) {
      QseColumn *col = sc -> column(c);

      if (matchesEnergyColumn(col)) {
  energycol = c;
      }
    }

    if (energycol < 0) {
      emit message(QString("No energy column found for scan %1").arg(n));
    } else {
      osc -> mergeHeaders(sc->header());
      osc -> setScanNumber(sc->scanNumber());

      QseColumn *energy = osc -> appendColumn("Energy", sc -> column(energycol));
      QseColumn *normal = osc -> appendColumn("Norm");
      QseColumn *detect = osc -> appendColumn("Detector");
      QseColumn *seconds = osc -> appendColumn("Seconds");

      energy -> multiplication(energyScalingRatio());

      int nnorm = 0, ndet = 0, nsecs = 0;
      
      for (int c = 0; c < nc; c++) {
  QseColumn *col = sc -> column(c);

  if (matchesNormalizationColumn(col)) {
    nnorm += 1;
    normal -> addition(col);
  } else if (matchesDetectorColumn(col)) {
    ndet += 1;
    detect -> addition(col);
  } else if (matchesSecondsColumn(col)) {
    nsecs += 1;
    seconds -> addition(col);
  }
      }
      
      if (nnorm > 0) {
  QseColumn *ratio = osc -> appendColumn("Ratio", detect);
  
  ratio -> division(normal);
  
  emit message(QString("Scan %1 had %2 detector columns, was normalized by %3 ion chambers").arg(n).arg(ndet).arg(nnorm));
      } else if (nsecs > 0) {
  QseColumn *ratio = osc -> appendColumn("Ratio", detect);
  
  ratio -> division(seconds);
  emit message(QString("Scan %1 had %2 detector columns, was normalized by counting time").arg(n).arg(ndet));
      } else {
  QseColumn *ratio = osc -> appendColumn("Ratio", detect);
  
  emit message(QString("Scan %1 had %2 detector columns, no normalization performed").arg(n).arg(ndet));
      }
    }
  }
}

double QseNormalizer::energyScalingRatio()
{
  int inp = m_InputEnergyUnits.toInt();
  int otp = m_OutputEnergyUnits.toInt();

  if (inp == otp) {
    return 1.0;
  } else if (inp == 0 && otp == 1) {
    return 0.001;
  } else if (inp == 1 && otp == 0) {
    return 1000.0;
  } else {
    return 1;
  }
}

---