qsenormalizer.cpp

Go to the documentation of this file.

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

#include <stdio.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_MinScanColumnCount(this, "minscancolumncount", NULL),
    m_MaxScanColumnCount(this, "maxscancolumncount", 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()
{
//   printf("QseNormalizer::exec()\n");
  QString fnam = m_InputData -> fileName();

  m_OutputData -> clear();
  m_OutputData -> setFileName(fnam+"_norm");
  m_OutputData -> setHeader(m_InputData -> header());

  int ns = m_InputData -> scanCount();

//   printf("%d scans\n", ns);

  for (int s = 0; s < ns; s++) {
    if (matchesScan(s)) {
//       printf("scan %d matches\n", s);

      QseScan *osc = m_OutputData -> appendScan();

      normalizeScan(s, osc);
    }
  }

//   printf("%d output scans\n", m_OutputData -> scanCount());

  m_OutputData -> emitOperationCompleted();
}

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

  if (s) {
    bool ok1, ok2;

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

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

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

    minVal = m_MinScanColumnCount.value().toDouble(&ok1);
    maxVal = m_MaxScanColumnCount.value().toDouble(&ok2);
        
    if (ok1 || ok2) {
      int ncols = s->columnCount();

      if (ok1 && (ncols < minVal)) {
        return false;
      }

      if (ok2 && (ncols > maxVal)) {
        return false;
      }
    }
    
    return m_ScanPattern.value().toRegExp().exactMatch(s->scanCommand());
  } else {
    return false;
  }
}

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.value().toDouble(&ok1);
    double maxVal = m_MaxScanRowCount.value().toDouble(&ok2);
        
    if (ok1 || ok2) {
      int nrows = s->maxRowCount();

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

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

    minVal = m_MinScanColumnCount.value().toDouble(&ok1);
    maxVal = m_MaxScanColumnCount.value().toDouble(&ok2);
        
    if (ok1 || ok2) {
      int ncols = s->columnCount();

      if (ok1 && (ncols < minVal)) {
        return false;
      }

      if (ok2 && (ncols > maxVal)) {
        return false;
      }
    }

    if (r == UnspecifiedScanRole) {
      return m_ScanPattern.value().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,c)) {
        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());
      osc -> setName(sc->name()+"_norm");
      osc -> setScanCommand(sc->scanCommand()+"_norm");
      osc -> setScanDateTime(QDateTime::currentDateTime());

      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,c)) {
          nnorm += 1;
          normal -> addition(col);
        } else if (matchesDetectorColumn(col,c)) {
          ndet += 1;
          detect -> addition(col);
        } else if (matchesSecondsColumn(col,c)) {
          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));
      }

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

        if (matchesCopyNormalizedColumn(col, c)) {
          QseColumn *copy = osc->appendColumn(col->name(), col);

          copy->division(normal);
        } else if (matchesCopyRateColumn(col, c)) {
          QseColumn *copy = osc->appendColumn(col->name(), col);

          copy->division(seconds);
        } else if (matchesCopyTotalCountsColumn(col, c)) {
          QseColumn *copy = osc->appendColumn(col->name(), col);

          copy->multiplication(seconds);
        } else if (matchesCopyColumn(col, c)) {
          QseColumn *copy = osc->appendColumn(col->name(), col);
        }
      }
    }
  }
}

double QseNormalizer::energyScalingRatio()
{
  int inp = m_InputEnergyUnits.value().toInt();
  int otp = m_OutputEnergyUnits.value().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;
  }
}

void QseNormalizer::setScanException(int s, QseScanRole role)
{
  QseScan* scan = m_InputData -> scan(s);

  if (scan) {
    if (role == UnspecifiedScanRole) {
      m_ScanExceptions.remove(scan);
    } else {
      m_ScanExceptions.insert(scan,role);
    }
  }
}

void QseNormalizer::setColumnException(int s, int c, QseColumnRole role)
{
  QseScan* scan = m_InputData -> scan(s);
  
  if (scan) {
    QseColumn* col = scan -> column(c);

    if (col) {
      if (role == UnspecifiedRole) {
        m_Exceptions.remove(col);
      } else {
        m_Exceptions.insert(col,role);
      }
    }
  }
}

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

  return m_ScanExceptions.contains(scan);
}

bool QseNormalizer::matchesColumnException(int s, int c)
{
  QseScan* scan = m_InputData -> scan(s);
  
  if (scan) {
    QseColumn* col = scan -> column(c);

    return m_Exceptions.contains(col);
  } else {
    return false;
  }
}

QseNormalizer::QseColumnRole QseNormalizer::exceptionalColumnRole(int s, int c)
{
  QseScan* scan = m_InputData -> scan(s);

  if (scan) {
    QseColumn* col = scan -> column(c);

    if (m_Exceptions.contains(col)) {
      return m_Exceptions[col];
    }
  }

  return UnspecifiedRole;
}

QseNormalizer::QseColumnRole QseNormalizer::patternColumnRole(int s, int c)
{
  QseScan* scan = m_InputData -> scan(s);

  if (scan) {
    QseColumn* col = scan -> column(c);

    if (matchesEnergyPattern(col, c)) {
      return EnergyRole;
    } else if (matchesDetectorPattern(col, c)) {
      return DetectorRole;
    } else if (matchesNormalizationPattern(col, c)) {
      return NormalizationRole;
    } else if (matchesSecondsPattern(col, c)) {
      return SecondsRole;
    } else if (matchesCopyNormalizedPattern(col, c)) {
      return CopyNormalizedRole;
    } else if (matchesCopyRatePattern(col, c)) {
      return CopyRateRole;
    } else if (matchesCopyTotalCountsPattern(col, c)) {
      return CopyTotalCountsRole;
    } else if (matchesCopyPattern(col, c)) {
      return CopyRole;
    }
  }

  return UnspecifiedRole;
}

QseNormalizer::QseColumnRole QseNormalizer::columnRole(int s, int c)
{
  QseColumnRole role = exceptionalColumnRole(s, c);

  if (role != UnspecifiedRole) {
    return role;
  } else {
    return patternColumnRole(s, c);
  }
}