QxrdIntegratorCache Class Reference

#include <qxrdintegratorcache.h>

Inheritance diagram for QxrdIntegratorCache:

Collaboration diagram for QxrdIntegratorCache:

Public Member Functions
	QxrdIntegratorCache (QxrdExperimentWPtr exp, QxrdIntegratorWPtr integ, QxrdPolarTransformWPtr xform, QxrdCenterFinderWPtr cf)
virtual	~QxrdIntegratorCache ()
int	get_NRows () const
int	get_NCols () const
void	grabScriptEngine ()
void	releaseScriptEngine ()
QcepInt32ImageDataPtr	cachedGeometry ()
QcepInt32ImageDataPtr	cachedPolarGeometry ()
QcepDoubleImageDataPtr	cachedIntensity ()
void	performIntegration (QcepDataObjectPtr res, QcepDoubleImageDataPtr dimg, QcepMaskDataPtr mask, int normalize)

Private Member Functions
double	getTTH (double x, double y)
double	getDistance (double x, double y)
double	getChi (double x, double y)
double	getQ (double x, double y)
double	getR (double x, double y)
double	XValue (double x, double y)
double	YValue (double x, double y)
double	NormValue (double x, double y)
QString	XLabel () const
QString	XUnits () const
QString	YLabel () const
QString	YUnits () const
void	partialIntegrationStep1 (int i, int n)
void	partialIntegrationStep2 (int i, int n)
void	partialIntegrationStep3 (int i, int n, QcepDoubleImageDataPtr dimg, QcepMaskDataPtr mask, int normalize)

Private Attributes
QMutex	m_Mutex
int	m_ThreadCount
int	m_Oversample
double	m_RadialStep
double	m_RadialNSteps
double	m_RadialStart
double	m_RadialEnd
int	m_RadialUnits
double	m_PolarStep
double	m_PolarNSteps
double	m_PolarStart
double	m_PolarEnd
int	m_PolarUnits
double	m_CenterX
double	m_CenterY
double	m_DetectorXPixelSize
double	m_DetectorYPixelSize
double	m_DetectorDistance
double	m_Energy
bool	m_ImplementTilt
double	m_DetectorTilt
double	m_TiltPlaneRotation
bool	m_EnableGeometry
bool	m_EnablePolarization
double	m_Polarization
bool	m_EnableAbsorption
double	m_AttenuationLength
int	m_NRows
int	m_NCols
int	m_NPix
double	m_RStep
bool	m_RFirst
double	m_RMin
double	m_RMax
double	m_CStep
bool	m_CFirst
double	m_CMin
double	m_CMax
int	m_ResultSize
int	m_NRSteps
int	m_NCSteps
double	m_Beta
double	m_CosBeta
double	m_SinBeta
double	m_Rot
double	m_CosRot
double	m_SinRot
int	m_EnableUserGeometry
QString	m_UserGeometryScript
QString	m_UserGeometryFunction
int	m_EnableUserAbsorption
QString	m_UserAbsorptionScript
QString	m_UserAbsorptionFunction
double	m_ScalingFactor
bool	m_SelfNormalization
double	m_SelfNormalizationMinimum
double	m_SelfNormalizationMaximum
QAtomicInt	m_CacheFillLevel
QAtomicInt	m_CacheFullLevel
bool	m_HasChi
QcepInt32ImageDataPtr	m_CachedRadialBinNumbers
QcepInt32ImageDataPtr	m_CachedPolarBinNumbers
QcepDoubleImageDataPtr	m_CachedNormalization
QcepDoubleImageDataPtr	m_CachedRadialValues
QcepDoubleImageDataPtr	m_CachedPolarValues
QVector< double >	m_Integral
QVector< double >	m_SumValue
QxrdExperimentWPtr	m_Experiment
QxrdIntegratorWPtr	m_Integrator
QxrdPolarTransformWPtr	m_PolarTransform
QxrdCenterFinderWPtr	m_CenterFinder
QScriptValue	m_UserGeometryFunctionValue
QScriptValue	m_UserAbsorptionFunctionValue

Detailed Description

Definition at line 21 of file qxrdintegratorcache.h.

Constructor & Destructor Documentation

QxrdIntegratorCache::QxrdIntegratorCache	(	QxrdExperimentWPtr	exp,
		QxrdIntegratorWPtr	integ,
		QxrdPolarTransformWPtr	xform,
		QxrdCenterFinderWPtr	cf
	)

Definition at line 28 of file qxrdintegratorcache.cpp.

References DEBUG_CONSTRUCTORS, m_AttenuationLength, m_CenterFinder, m_CenterX, m_CenterY, m_DetectorDistance, m_DetectorTilt, m_DetectorXPixelSize, m_DetectorYPixelSize, m_EnableAbsorption, m_EnableGeometry, m_EnablePolarization, m_EnableUserAbsorption, m_EnableUserGeometry, m_Energy, m_HasChi, m_ImplementTilt, m_Integrator, m_Oversample, m_PolarEnd, m_Polarization, m_PolarNSteps, m_PolarStart, m_PolarStep, m_PolarTransform, m_PolarUnits, m_RadialEnd, m_RadialNSteps, m_RadialStart, m_RadialStep, m_RadialUnits, m_ScalingFactor, m_SelfNormalization, m_SelfNormalizationMaximum, m_SelfNormalizationMinimum, m_TiltPlaneRotation, m_UserAbsorptionFunction, m_UserAbsorptionScript, m_UserGeometryFunction, m_UserGeometryScript, and qcepDebug().

                            :
  QObject(),
  m_ThreadCount(QThreadPool::globalInstance()->maxThreadCount()),
  m_Oversample(1),
  m_RadialStep(0.001),
  m_RadialNSteps(0),
  m_RadialStart(0),
  m_RadialEnd(100000),
  m_RadialUnits(QxrdIntegrator::RadialIntegrateTTH),
  m_PolarStep(0.5),
  m_PolarNSteps(0),
  m_PolarStart(0),
  m_PolarEnd(360),
  m_PolarUnits(QxrdIntegrator::PolarIntegrateNone),
  m_CenterX(0),
  m_CenterY(0),
  m_DetectorXPixelSize(200),
  m_DetectorYPixelSize(200),
  m_DetectorDistance(1000),
  m_Energy(20000),
  m_ImplementTilt(false),
  m_DetectorTilt(0),
  m_TiltPlaneRotation(90),
  m_EnableGeometry(false),
  m_EnablePolarization(false),
  m_Polarization(1.0),
  m_EnableAbsorption(false),
  m_AttenuationLength(0.0),
  m_NRows(-1),
  m_NCols(-1),
  m_NPix(-1),
  m_RStep(0),
  m_RMin(0),
  m_RMax(0),
  m_Beta(0),
  m_CosBeta(1),
  m_SinBeta(0),
  m_Rot(0),
  m_CosRot(0),
  m_SinRot(0),
  m_EnableUserGeometry(0),
  m_EnableUserAbsorption(0),
  m_ScalingFactor(1.0),
  m_CacheFillLevel(-1),
  m_CacheFullLevel(-1),
  m_HasChi(false),
  m_Experiment(exp),
  m_Integrator(integ),
  m_PolarTransform(xform),
  m_CenterFinder(cf)
{
  if (qcepDebug(DEBUG_CONSTRUCTORS)) {
    printf("QxrdIntegratorCache::QxrdIntegratorCache(%p)\n", this);
  }

  QxrdIntegratorPtr     integp(m_Integrator);
  QxrdPolarTransformPtr xformp(m_PolarTransform);

  if (integp == NULL && xformp) {
    integp = xformp->integrator();
  }

  if (integp) {
    m_Oversample         = integp->get_Oversample();
    m_RadialStep    = integp->get_IntegrationStep();
    m_RadialNSteps  = integp->get_IntegrationNSteps();
    m_RadialStart = integp->get_IntegrationMinimum();
    m_RadialEnd = integp->get_IntegrationMaximum();
    m_RadialUnits  = integp->get_IntegrationXUnits();

    m_EnableGeometry     = integp->get_EnableGeometricCorrections();
    m_EnablePolarization = integp->get_EnablePolarizationCorrections();
    m_Polarization       = integp->get_Polarization();
    m_EnableAbsorption   = integp->get_EnableAbsorptionCorrections();
    m_AttenuationLength  = integp->get_AttenuationLength();

    m_EnableUserGeometry     = integp->get_EnableUserGeometry();
    m_UserGeometryScript     = integp->get_UserGeometryScript();
    m_UserGeometryFunction   = integp->get_UserGeometryFunction();

    m_EnableUserAbsorption   = integp->get_EnableUserAbsorption();
    m_UserAbsorptionScript   = integp->get_UserAbsorptionScript();
    m_UserAbsorptionFunction = integp->get_UserAbsorptionFunction();

    m_ScalingFactor          = integp->get_ScalingFactor();

    m_SelfNormalization      = integp->get_SelfNormalization();
    m_SelfNormalizationMinimum = integp->get_SelfNormalizationMinimum();
    m_SelfNormalizationMaximum = integp->get_SelfNormalizationMaximum();
  }

  if (xformp) {
    m_RadialStep   = xformp->get_RadialStep();
    m_RadialNSteps = xformp->get_RadialNSteps();
    m_RadialStart  = xformp->get_RadialStart();
    m_RadialEnd    = xformp->get_RadialEnd();
    m_RadialUnits  = xformp->get_RadialUnits();

    m_PolarStep    = xformp->get_PolarStep();
    m_PolarNSteps  = xformp->get_PolarNSteps();
    m_PolarStart   = xformp->get_PolarStart();
    m_PolarEnd     = xformp->get_PolarEnd();
    m_PolarUnits   = xformp->get_PolarUnits();

    m_Oversample   = xformp->get_Oversample();
    m_EnableGeometry     = xformp->get_EnableGeometricCorrections();
    m_EnablePolarization = xformp->get_EnablePolarizationCorrections();
    m_Polarization       = xformp->get_Polarization();

    m_HasChi       = true;
  }

  QxrdCenterFinderPtr cfp(m_CenterFinder);

  if (cfp) {
    m_CenterX            = cfp->get_CenterX();
    m_CenterY            = cfp->get_CenterY();
    m_DetectorXPixelSize = cfp->get_DetectorXPixelSize();
    m_DetectorYPixelSize = cfp->get_DetectorYPixelSize();
    m_DetectorDistance   = cfp->get_DetectorDistance();
    m_Energy             = cfp->get_Energy();
    m_ImplementTilt      = cfp->get_ImplementTilt();
    m_DetectorTilt       = cfp->get_DetectorTilt();
    m_TiltPlaneRotation  = cfp->get_TiltPlaneRotation();
  }
}

Here is the call graph for this function:

QxrdIntegratorCache::~QxrdIntegratorCache ( )

virtual

Definition at line 158 of file qxrdintegratorcache.cpp.

References DEBUG_CONSTRUCTORS, and qcepDebug().

{
  if (qcepDebug(DEBUG_CONSTRUCTORS)) {
    printf("QxrdIntegratorCache::~QxrdIntegratorCache(%p)\n", this);
  }
}

Here is the call graph for this function:

Member Function Documentation

QcepInt32ImageDataPtr QxrdIntegratorCache::cachedGeometry

(

)

Definition at line 1052 of file qxrdintegratorcache.cpp.

References m_CachedRadialBinNumbers.

{
  return m_CachedRadialBinNumbers;
}

QcepDoubleImageDataPtr QxrdIntegratorCache::cachedIntensity

(

)

Definition at line 1057 of file qxrdintegratorcache.cpp.

References m_CachedNormalization.

{
  return m_CachedNormalization;
}

QcepInt32ImageDataPtr QxrdIntegratorCache::cachedPolarGeometry

(

)

int QxrdIntegratorCache::get_NCols

(

)

const

Definition at line 170 of file qxrdintegratorcache.cpp.

References m_NCols.

{
  return m_NCols;
}

int QxrdIntegratorCache::get_NRows

(

)

const

Definition at line 165 of file qxrdintegratorcache.cpp.

References m_NRows.

{
  return m_NRows;
}

double QxrdIntegratorCache::getChi ( double  x, double  y  )

private

Definition at line 198 of file qxrdintegratorcache.cpp.

References QxrdDetectorGeometry::getQChi(), m_CenterX, m_CenterY, m_DetectorDistance, m_DetectorTilt, m_DetectorXPixelSize, m_DetectorYPixelSize, m_Energy, m_ImplementTilt, and m_TiltPlaneRotation.

Referenced by NormValue(), and YValue().

{
  double q,chi;
  double beta = m_DetectorTilt*M_PI/180.0;
  double rot  = m_TiltPlaneRotation*M_PI/180.0;

  if (m_ImplementTilt) {
    QxrdDetectorGeometry::getQChi(m_CenterX, m_CenterY, m_DetectorDistance,
                                  m_Energy,
                                  x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                  rot, cos(beta), sin(beta), 1.0, 0.0, cos(rot), sin(rot),
                                  &q, &chi);
  } else {
    QxrdDetectorGeometry::getQChi(m_CenterX, m_CenterY, m_DetectorDistance,
                                  m_Energy,
                                  x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                  0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
                                  &q, &chi);
  }

  return chi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double QxrdIntegratorCache::getDistance ( double  x, double  y  )

private

Definition at line 191 of file qxrdintegratorcache.cpp.

References getTTH(), and m_DetectorDistance.

Referenced by NormValue().

{
  double tth = getTTH(x, y)*M_PI/180.0;

  return m_DetectorDistance/cos(tth);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double QxrdIntegratorCache::getQ ( double  x, double  y  )

private

Definition at line 221 of file qxrdintegratorcache.cpp.

References QxrdDetectorGeometry::getQChi(), m_CenterX, m_CenterY, m_DetectorDistance, m_DetectorTilt, m_DetectorXPixelSize, m_DetectorYPixelSize, m_Energy, m_ImplementTilt, and m_TiltPlaneRotation.

Referenced by NormValue(), and XValue().

{
  double q,chi;
  double beta = m_DetectorTilt*M_PI/180.0;
  double rot  = m_TiltPlaneRotation*M_PI/180.0;

  if (m_ImplementTilt) {
    QxrdDetectorGeometry::getQChi(m_CenterX, m_CenterY, m_DetectorDistance,
                                  m_Energy,
                                  x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                  rot, cos(beta), sin(beta), 1.0, 0.0, cos(rot), sin(rot),
                                  &q, &chi);
  } else {
    QxrdDetectorGeometry::getQChi(m_CenterX, m_CenterY, m_DetectorDistance,
                                  m_Energy,
                                  x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                  0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
                                  &q, &chi);
  }

  return q;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double QxrdIntegratorCache::getR ( double  x, double  y  )

private

Definition at line 244 of file qxrdintegratorcache.cpp.

References getTTH(), and m_DetectorDistance.

Referenced by NormValue(), and XValue().

{
  double tth = getTTH(x, y);
  double r = m_DetectorDistance*tan(tth*M_PI/180.0);

  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double QxrdIntegratorCache::getTTH ( double  x, double  y  )

private

Definition at line 175 of file qxrdintegratorcache.cpp.

References QxrdDetectorGeometry::getTwoTheta(), m_CenterX, m_CenterY, m_DetectorDistance, m_DetectorTilt, m_DetectorXPixelSize, m_DetectorYPixelSize, m_ImplementTilt, and m_TiltPlaneRotation.

Referenced by getDistance(), getR(), NormValue(), and XValue().

{
  double beta = m_DetectorTilt*M_PI/180.0;
  double rot  = m_TiltPlaneRotation*M_PI/180.0;

  if (m_ImplementTilt) {
    return QxrdDetectorGeometry::getTwoTheta(m_CenterX, m_CenterY, m_DetectorDistance,
                                             x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                             cos(beta), sin(beta), cos(rot), sin(rot));
  } else {
    return QxrdDetectorGeometry::getTwoTheta(m_CenterX, m_CenterY, m_DetectorDistance,
                                             x, y, m_DetectorXPixelSize, m_DetectorYPixelSize,
                                             1.0, 0.0, 1.0, 0.0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdIntegratorCache::grabScriptEngine

(

)

Definition at line 980 of file qxrdintegratorcache.cpp.

References m_EnableUserAbsorption, m_EnableUserGeometry, m_Experiment, m_UserAbsorptionFunction, m_UserAbsorptionFunctionValue, m_UserAbsorptionScript, m_UserGeometryFunction, m_UserGeometryFunctionValue, and m_UserGeometryScript.

Referenced by performIntegration().

{
  QxrdExperimentPtr exp(m_Experiment);

  if (exp) {
    QxrdScriptEnginePtr engine = exp->scriptEngine();

    if (engine) {
      engine->lock();

      m_UserGeometryFunctionValue = QScriptValue();
      m_UserAbsorptionFunctionValue = QScriptValue();

      if (m_EnableUserGeometry) {
        engine->evaluate(m_UserGeometryScript);

        m_UserGeometryFunctionValue = engine->evaluate(m_UserGeometryFunction);

        if (!m_UserGeometryFunctionValue.isFunction()) {
          m_UserGeometryFunctionValue = engine->globalObject().property(m_UserGeometryFunctionValue.toString());
        }

        if (m_UserGeometryFunctionValue.isFunction()) {
          exp->printMessage(tr("Using User Geometry Function %1").arg(m_UserGeometryFunctionValue.toString()));
        } else {
          exp->printMessage(tr("User Geometry Function %1 is not a function").arg(m_UserGeometryFunctionValue.toString()));
        }
      }

      if (m_EnableUserAbsorption) {
        engine->evaluate(m_UserAbsorptionScript);

        m_UserAbsorptionFunctionValue = engine->evaluate(m_UserAbsorptionFunction);

        if (!m_UserAbsorptionFunctionValue.isFunction()) {
          m_UserAbsorptionFunctionValue = engine->globalObject().property(m_UserAbsorptionFunctionValue.toString());
        }

        if (m_UserAbsorptionFunctionValue.isFunction()) {
          exp->printMessage(tr("Using User Absorption Function %1").arg(m_UserAbsorptionFunctionValue.toString()));
        } else {
          exp->printMessage(tr("User Absorption Function %1 is not a function").arg(m_UserAbsorptionFunctionValue.toString()));
        }
      }
    }
  }
}

Here is the caller graph for this function:

double QxrdIntegratorCache::NormValue ( double  x, double  y  )

private

Definition at line 289 of file qxrdintegratorcache.cpp.

References getChi(), getDistance(), getQ(), getR(), getTTH(), m_AttenuationLength, m_CenterX, m_CenterY, m_DetectorDistance, m_EnableAbsorption, m_EnableGeometry, m_EnablePolarization, m_EnableUserAbsorption, m_Polarization, m_UserAbsorptionFunctionValue, QxrdCenterFinder::UserAbsorptionFromCenter, QxrdCenterFinder::UserAbsorptionPixelCoords, QxrdCenterFinder::UserAbsorptionQChi, and QxrdCenterFinder::UserAbsorptionRChi.

Referenced by partialIntegrationStep2().

{
  double res = 1;

  if (m_EnableGeometry || m_EnablePolarization || m_EnableAbsorption || m_EnableUserAbsorption) {
    double distance = getDistance(x, y);
    double tth      = getTTH(x,y)*M_PI/180.0;
    double chi      = getChi(x,y)*M_PI/180.0;

    if (m_EnableGeometry) {
      res *= pow(distance/m_DetectorDistance, 2)/cos(tth);
    }

    if (m_EnableAbsorption) {
      res *= exp((distance-m_DetectorDistance)/m_AttenuationLength);
    }

    if (m_EnablePolarization) {
      res *= (m_Polarization      *(1 - pow(sin(chi)*sin(tth),2)) +
              (1 - m_Polarization)*(1 - pow(cos(chi)*sin(tth),2)));
    }

    switch (m_EnableUserAbsorption) {
    case QxrdCenterFinder::UserAbsorptionPixelCoords:
      res *= m_UserAbsorptionFunctionValue.call(QScriptValue(), QScriptValueList() << x << y).toNumber();
      break;

    case QxrdCenterFinder::UserAbsorptionFromCenter:
      res *= m_UserAbsorptionFunctionValue.call(QScriptValue(), QScriptValueList() << x - m_CenterX << y - m_CenterY).toNumber();
      break;

    case QxrdCenterFinder::UserAbsorptionRChi:
      res *= m_UserAbsorptionFunctionValue.call(QScriptValue(), QScriptValueList() << getR(x,y) << chi).toNumber();
      break;

    case QxrdCenterFinder::UserAbsorptionQChi:
      res *= m_UserAbsorptionFunctionValue.call(QScriptValue(), QScriptValueList() << getQ(x,y) << chi).toNumber();
      break;

    default:
      break;
    }
  }

  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdIntegratorCache::partialIntegrationStep1 ( int  i, int  n  )

private

Definition at line 406 of file qxrdintegratorcache.cpp.

References m_CachedPolarValues, m_CachedRadialValues, m_CFirst, m_CMax, m_CMin, m_CStep, m_HasChi, m_Mutex, m_NCols, m_NRows, m_Oversample, m_PolarNSteps, m_PolarStep, m_RadialNSteps, m_RadialStep, m_RFirst, m_RMax, m_RMin, m_RStep, m_ThreadCount, XValue(), and YValue().

Referenced by performIntegration().

{
  int strideSize = m_NRows / m_ThreadCount;

  while (strideSize*m_ThreadCount < m_NRows) {
    strideSize++;
  }

  int rowStart = strideSize*i;
  int rowEnd   = rowStart + strideSize;

  if (rowEnd > m_NRows) {
    rowEnd = m_NRows;
  }

  int noversample = m_Oversample;
  double oversampleStep = 1.0/m_Oversample;
  double halfOversampleStep = oversampleStep/2.0;

  double rMin=0, rMax=0, cMin=0, cMax=0;
  bool rFirst=true, cFirst=true;

  for(int y = rowStart; y<rowEnd; y++) {
    for (int x = 0; x < m_NCols; x++) {
      for (int oversampley = 0; oversampley < noversample; oversampley++) {
        double yy = y+oversampley*oversampleStep+halfOversampleStep;
        int iy = y*noversample+oversampley;
        for (int oversamplex = 0; oversamplex < noversample; oversamplex++) {
          double xx = x+oversamplex*oversampleStep+halfOversampleStep;
          int ix = x*noversample+oversamplex;

          double r = XValue(xx, yy);

          if (r==r) {
            if (rFirst) {
              rMin = r;
              rMax = r;
              rFirst = false;
            } else if (r > rMax) {
              rMax = r;
            } else if (r < rMin) {
              rMin = r;
            }
          }

          m_CachedRadialValues->setValue(ix, iy, r);

          if (m_HasChi) {
            double c = YValue(xx, yy);

            if (c==c) {
              if (cFirst) {
                cMin = c;
                cMax = c;
                cFirst = false;
              } else if (c > cMax) {
                cMax = c;
              } else if (c < cMin) {
                cMin = c;
              }
            }

            m_CachedPolarValues->setValue(ix, iy, c);
          }
        }
      }
    }
  }

  if (rFirst == false || cFirst == false) {
    QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex);

    if (rFirst == false) {
      if (m_RFirst) {
        m_RMin = rMin;
        m_RMax = rMax;
        m_RFirst = false;
      } else {
        m_RMin = qMin(m_RMin, rMin);
        m_RMax = qMax(m_RMax, rMax);
      }

      m_RStep = m_RadialStep;

      if (m_RStep == 0) {
        int nStep = m_RadialNSteps;

        if (nStep <= 0) {
          nStep = 512;
        }

        m_RStep = (m_RMax - m_RMin)/nStep;
      }
    }

    if (cFirst == false) {
      if (m_CFirst) {
        m_CMin = cMin;
        m_CMax = cMax;
        m_CFirst = false;
      } else {
        m_CMin = qMin(m_CMin, cMin);
        m_CMax = qMax(m_CMax, cMax);
      }

      m_CStep = m_PolarStep;

      if (m_CStep == 0) {
        int nStep = m_PolarNSteps;

        if (nStep <= 0) {
          nStep = 360;
        }

        m_CStep = (m_CMax - m_CMin)/nStep;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdIntegratorCache::partialIntegrationStep2 ( int  i, int  n  )

private

Definition at line 526 of file qxrdintegratorcache.cpp.

References m_CachedNormalization, m_CachedPolarBinNumbers, m_CachedPolarValues, m_CachedRadialBinNumbers, m_CachedRadialValues, m_CStep, m_HasChi, m_NCols, m_NCSteps, m_NRows, m_NRSteps, m_Oversample, m_PolarStart, m_RadialStart, m_RStep, m_ThreadCount, and NormValue().

Referenced by performIntegration().

{
  int strideSize = m_NRows / m_ThreadCount;

  while (strideSize*m_ThreadCount < m_NRows) {
    strideSize++;
  }

  int rowStart = strideSize*i;
  int rowEnd   = rowStart + strideSize;

  if (rowEnd > m_NRows) {
    rowEnd = m_NRows;
  }

  int noversample = m_Oversample;
  double oversampleStep = 1.0/m_Oversample;
  double halfOversampleStep = oversampleStep/2.0;

  for(int y = rowStart; y<rowEnd; y++) {
    for (int x = 0; x < m_NCols; x++) {
      for (int oversampley = 0; oversampley < noversample; oversampley++) {
        double yy = y+oversampley*oversampleStep+halfOversampleStep;
        int iy = y*noversample+oversampley;
        for (int oversamplex = 0; oversamplex < noversample; oversamplex++) {
          double xx = x+oversamplex*oversampleStep+halfOversampleStep;
          int ix = x*noversample+oversamplex;

          double r = m_CachedRadialValues->value(ix, iy) - m_RadialStart;
          double n = -1;

          if (r == r) {
            n = floor(r / m_RStep);
          }

          if (n >= 0 && n < m_NRSteps) {
            m_CachedRadialBinNumbers->setValue(ix, iy, n);
            m_CachedNormalization->setValue(ix, iy, NormValue(xx, yy));
          } else {
            m_CachedRadialBinNumbers->setValue(ix, iy, -1);
            m_CachedNormalization->setValue(ix, iy, 0.0);
          }

          if (m_HasChi) {
            double chi = m_CachedPolarValues->value(ix, iy) - m_PolarStart;
            double n   = -1;

            if (chi == chi) {
              n = floor(chi / m_CStep);
            }

            if (n >= 0 && n < m_NCSteps) {
              m_CachedPolarBinNumbers->setValue(ix, iy, n);
            } else {
              m_CachedPolarBinNumbers->setValue(ix, iy, -1);
            }
          }
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdIntegratorCache::partialIntegrationStep3 ( int  i, int  n, QcepDoubleImageDataPtr  dimg, QcepMaskDataPtr  mask, int  normalize  )

private

Definition at line 589 of file qxrdintegratorcache.cpp.

References m_CachedNormalization, m_CachedPolarBinNumbers, m_CachedRadialBinNumbers, m_HasChi, m_Integral, m_Mutex, m_NCols, m_NRows, m_NRSteps, m_Oversample, m_ResultSize, m_SumValue, and m_ThreadCount.

Referenced by performIntegration().

{
  int strideSize = m_NRows / m_ThreadCount;

  while (strideSize*m_ThreadCount < m_NRows) {
    strideSize++;
  }

  int rowStart = strideSize*i;
  int rowEnd   = rowStart + strideSize;

  if (rowEnd > m_NRows) {
    rowEnd = m_NRows;
  }

  int noversample = m_Oversample;
  double oversampleStep = 1.0/m_Oversample;
  double halfOversampleStep = oversampleStep/2.0;

  QVector<double> integral(m_ResultSize), sumValue(m_ResultSize);

  for(int y = rowStart; y<rowEnd; y++) {
    for (int x = 0; x < m_NCols; x++) {
      if ((mask == NULL) || (mask->value(x, y))) {
        double val = dimg->value(x,y);
        for (int oversampley = 0; oversampley < noversample; oversampley++) {
          int iy = y*noversample+oversampley;
          for (int oversamplex = 0; oversamplex < noversample; oversamplex++) {
            int    ix = x*noversample+oversamplex;

            int    rbin = m_CachedRadialBinNumbers->value(ix,iy);
            double norm = m_CachedNormalization->value(ix,iy);

            int    bin  = -1;

            if (m_HasChi) {
              int cbin = m_CachedPolarBinNumbers->value(ix,iy);

              if (cbin >= 0) {
                bin = cbin*m_NRSteps + rbin;
              }
            } else {
              bin = rbin;
            }

            if (bin >= 0) {
              integral[bin] += val*norm;
              sumValue[bin] += 1;
            }
          }
        }
      }
    }
  }

  {
    QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex);

    double *s1 = m_SumValue.data();
    double *s2 = sumValue.data();
    double *v1 = m_Integral.data();
    double *v2 = integral.data();

    for (int i=0; i<m_ResultSize; i++) {
      if (s2[i] > 0) {
        v1[i] += v2[i];
        s1[i] += s2[i];
      }
    }
  }
}

Here is the caller graph for this function:

void QxrdIntegratorCache::performIntegration	(	QcepDataObjectPtr	res,
		QcepDoubleImageDataPtr	dimg,
		QcepMaskDataPtr	mask,
		int	normalize
	)

Definition at line 666 of file qxrdintegratorcache.cpp.

References QcepAllocator::AlwaysAllocate, DEBUG_INTEGRATOR, grabScriptEngine(), m_CachedNormalization, m_CachedPolarBinNumbers, m_CachedPolarValues, m_CachedRadialBinNumbers, m_CachedRadialValues, m_CacheFillLevel, m_CacheFullLevel, m_CenterX, m_CenterY, m_CFirst, m_CStep, m_EnableUserAbsorption, m_EnableUserGeometry, m_Experiment, m_HasChi, m_Integral, m_NCols, m_NCSteps, m_NPix, m_NRows, m_NRSteps, m_Oversample, m_PolarEnd, m_PolarNSteps, m_PolarStart, m_PolarStep, m_PolarTransform, m_RadialEnd, m_RadialNSteps, m_RadialStart, m_RadialStep, m_ResultSize, m_RFirst, m_RMin, m_RStep, m_ScalingFactor, m_SelfNormalization, m_SelfNormalizationMaximum, m_SelfNormalizationMinimum, m_SumValue, m_ThreadCount, QThreadAccess::msleep(), QcepAllocator::newDoubleImage(), QcepAllocator::newInt32Image(), partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), qcepDebug(), releaseScriptEngine(), XLabel(), XUnits(), YLabel(), and YUnits().

{
  QTime tic;
  tic.start();

  QxrdExperimentPtr expt(m_Experiment);

  if (expt) {
    if (qcepDebug(DEBUG_INTEGRATOR)) {
      expt->printMessage(tr("QxrdIntegratorCache::performIntegration"));
    }

    m_Integral.resize(0);
    m_SumValue.resize(0);

    if (res && dimg) {
      int noversample = m_Oversample;
      double oversampleStep = 1.0/m_Oversample;
      double halfOversampleStep = oversampleStep/2.0;

      m_NRows = dimg->get_Height();
      m_NCols = dimg->get_Width();
      m_NPix  = m_NRows*m_NCols*m_Oversample*m_Oversample;

      m_CacheFullLevel.fetchAndStoreOrdered(m_NPix);

      QcepDoubleList norm = dimg->get_Normalization();

      double normVal = 1;

      if (norm.length()>=1) {
        normVal = norm[0];
      }

      if (m_CacheFillLevel.testAndSetOrdered(-1,0)) {
        if (qcepDebug(DEBUG_INTEGRATOR)) {
          expt->printMessage(tr("QxrdIntegratorCache::performIntegration - fill cache"));
        }

        // Allocate new cache and fill it...

        m_CachedRadialBinNumbers =  QcepAllocator::newInt32Image(QcepAllocator::AlwaysAllocate,
                                                           m_NCols*m_Oversample,
                                                           m_NRows*m_Oversample, expt.data());

        m_CachedRadialValues = QcepAllocator::newDoubleImage(QcepAllocator::AlwaysAllocate,
                                                              m_NCols*m_Oversample,
                                                              m_NRows*m_Oversample, expt.data());

        m_CachedNormalization = QcepAllocator::newDoubleImage(QcepAllocator::AlwaysAllocate,
                                                              m_NCols*m_Oversample,
                                                              m_NRows*m_Oversample, expt.data());

        if (m_PolarTransform) {
          m_CachedPolarBinNumbers = QcepAllocator::newInt32Image(QcepAllocator::AlwaysAllocate,
                                                                 m_NCols*m_Oversample,
                                                                 m_NRows*m_Oversample, expt.data());

          m_CachedPolarValues = QcepAllocator::newDoubleImage(QcepAllocator::AlwaysAllocate,
                                                              m_NCols*m_Oversample,
                                                              m_NRows*m_Oversample, expt.data());
        }

        if (m_CachedRadialBinNumbers && m_CachedNormalization) {
          m_CachedRadialBinNumbers -> clear();
          m_CachedNormalization -> clear();

          if (m_CachedPolarBinNumbers) {
            m_CachedPolarBinNumbers -> clear();
          }

          if (m_CachedPolarValues) {
            m_CachedPolarValues -> clear();
          }

          if (m_EnableUserGeometry || m_EnableUserAbsorption) {
            expt->printMessage(tr("Threaded integration disabled because of user supplied functions"));

            m_ThreadCount = 1;

            grabScriptEngine();
          }

          m_RFirst = true;
          m_CFirst = true;

          // Step one fills m_CachedRadialValues ( & m_CachedPolarValues if 2D)
          // and sets m_RMin, m_RMax (& m_CMin and m_CMax) to range of values

          if (m_ThreadCount == 1) {
            partialIntegrationStep1(0, 1);
          } else {
            QVector< QFuture<void> > res;

            for (int i=0; i<m_ThreadCount; i++) {
              res.append(QtConcurrent::run(this, &QxrdIntegratorCache::partialIntegrationStep1, i, m_ThreadCount));
            }

            for (int i=0; i<m_ThreadCount; i++) {
              res[i].waitForFinished();
            }
          }

          m_RStep = m_RadialStep;

          if (m_RStep == 0) {
            m_NRSteps = m_RadialNSteps;

            if (m_NRSteps <= 0) {
              m_NRSteps = 512;
            }

            m_RStep = (m_RadialEnd - m_RadialStart)/m_NRSteps;
          } else {
            m_NRSteps = ceil((m_RadialEnd - m_RadialStart)/m_RStep);
          }

          if (m_HasChi) {
            m_CStep = m_PolarStep;

            if (m_CStep == 0) {
              m_NCSteps = m_PolarNSteps;

              if (m_NCSteps <= 0) {
                m_NCSteps = 512;
              }

              m_CStep = (m_PolarEnd - m_PolarStart)/m_NCSteps;
            } else {
              m_NCSteps = ceil((m_PolarEnd - m_PolarStart)/m_CStep);
            }
          }

          if (qcepDebug(DEBUG_INTEGRATOR)) {
            expt->printMessage(tr("1st stage complete after %1 msec").arg(tic.elapsed()));
          }

          // Step two calculates the bin numbers and stores them in m_CachedRadialBinNumbers
          // and m_CachedPolarBinNumbers

          if (m_ThreadCount == 1) {
            partialIntegrationStep2(0, 1);
          } else {
            QVector< QFuture<void> > res;

            for (int i=0; i<m_ThreadCount; i++) {
              res.append(QtConcurrent::run(this, &QxrdIntegratorCache::partialIntegrationStep2, i, m_ThreadCount));
            }

            for (int i=0; i<m_ThreadCount; i++) {
              res[i].waitForFinished();
            }
          }

          if (m_HasChi) {
            m_ResultSize = m_NRSteps * m_NCSteps;
          } else {
            m_ResultSize = m_NRSteps;
          }

          if (qcepDebug(DEBUG_INTEGRATOR)) {
            expt->printMessage(tr("2nd stage complete after %1 msec").arg(tic.elapsed()));
          }

          m_CacheFillLevel.fetchAndStoreOrdered(m_NPix);

          if (m_EnableUserGeometry || m_EnableUserAbsorption) {
            releaseScriptEngine();
          }
        }

        if (qcepDebug(DEBUG_INTEGRATOR)) {
          expt->printMessage(tr("QxrdIntegratorCache::performIntegration - cache finished"));
        }
      }

      while (m_CacheFillLevel.fetchAndAddOrdered(0) < m_CacheFullLevel.fetchAndAddOrdered(0)) {
        if (qcepDebug(DEBUG_INTEGRATOR)) {
          expt->printMessage(tr("QxrdIntegratorCache::performIntegration - waiting for cache [%1,%2]")
                             .arg(m_CacheFillLevel.fetchAndAddOrdered(0))
                             .arg(m_CacheFullLevel.fetchAndAddOrdered(0)));
        }

        QThreadAccess::msleep(100);
      }

      if (m_CacheFillLevel.fetchAndAddOrdered(0) != m_CacheFullLevel.fetchAndAddOrdered(0)) {
        expt->printMessage(tr("QxrdIntegratorCache::performIntegration - anomalous cache [%1,%2]")
                           .arg(m_CacheFillLevel.fetchAndAddOrdered(0))
                           .arg(m_CacheFullLevel.fetchAndAddOrdered(0)));
      } else {
        if (qcepDebug(DEBUG_INTEGRATOR)) {
          expt->printMessage(tr("QxrdIntegratorCache::performIntegration - use cache"));
        }

        m_Integral.resize(m_ResultSize);
        m_SumValue.resize(m_ResultSize);

        if (m_ThreadCount == 1) {
          partialIntegrationStep3(0, 1, dimg, mask, normalize);
        } else {
          QVector< QFuture<void> > res;

          for (int i=0; i<m_ThreadCount; i++) {
            res.append(QtConcurrent::run(this, &QxrdIntegratorCache::partialIntegrationStep3,
                                         i, m_ThreadCount, dimg, mask, normalize));
          }

          for (int i=0; i<m_ThreadCount; i++) {
            res[i].waitForFinished();
          }
        }

        if (qcepDebug(DEBUG_INTEGRATOR)) {
          expt->printMessage(tr("Stage 3 complete after %1 msec").arg(tic.elapsed()));
        }

        double scalingFactor = m_ScalingFactor;

        if (m_SelfNormalization) {
          double nsum = 0, ninteg = 0;

          for(int ir=0; ir<m_ResultSize; ir++) {
            int sv = m_SumValue[ir];

            if (sv > 0) {
              double xv = m_RMin + (ir+0.5)*m_RStep;

              if (xv >= m_SelfNormalizationMinimum && xv < m_SelfNormalizationMaximum) {
                nsum   += sv;
                ninteg += m_Integral[ir];
              }
            }
          }

          if ((nsum > 0) && (ninteg != 0)) {
            scalingFactor = m_ScalingFactor * nsum / ninteg;
          }
        }

        if (m_HasChi) {
          QcepDoubleImageDataPtr img = qSharedPointerDynamicCast<QcepDoubleImageData>(res);

          img->resize(m_NRSteps, m_NCSteps);

          img->set_HStart(m_RadialStart);
          img->set_HStep(m_RStep);
          img->set_VStart(m_PolarStart);
          img->set_VStep(m_CStep);

          img->set_HLabel(XLabel());
          img->set_HUnits(XUnits());
          img->set_VLabel(YLabel());
          img->set_VUnits(YUnits());

          img->set_Title(dimg->get_Title());

          for (int y=0; y<m_NCSteps; y++) {
            for (int x=0; x<m_NRSteps; x++) {
              int bin = y*m_NRSteps + x;

              int   sv = m_SumValue[bin];
              double v = m_Integral[bin];

              if (sv > 0) {
                img->setValue(x,y, scalingFactor*normVal*v/sv);
              } else {
                img->setValue(x,y, qQNaN());
              }
            }
          }

          img->dataObjectChanged();
        } else {
          QcepIntegratedDataPtr integ = qSharedPointerDynamicCast<QcepIntegratedData>(res);

          if (integ) {
            integ -> resize(0);
            integ -> set_Center(m_CenterX, m_CenterY);

            for(int ir=0; ir<m_ResultSize; ir++) {
              int sv = m_SumValue[ir];

              if (sv > 0) {
                double xv = m_RadialStart + (ir+0.5)*m_RStep;

                if (normalize) {
                  integ -> append(xv, scalingFactor*normVal*m_Integral[ir]/sv);
                } else {
                  integ -> append(xv, scalingFactor*normVal*m_Integral[ir]/sv*(ir*oversampleStep+halfOversampleStep));
                }
              }
            }

            integ->set_XUnitsLabel(XLabel());
            integ->set_Oversample(m_Oversample);
            // Integrate entirely out of cache
          }
        }
      }

      expt->printMessage(tr("Integration of %1 took %2 msec")
                         .arg(dimg->get_Title())
                         .arg(tic.restart()));
    } else {
      expt->printMessage(tr("QxrdIntegratorCache::performIntegration - integration failed"));
    }
  }
}

Here is the call graph for this function:

void QxrdIntegratorCache::releaseScriptEngine

(

)

Definition at line 1028 of file qxrdintegratorcache.cpp.

References m_EnableUserAbsorption, m_EnableUserGeometry, m_Experiment, m_UserAbsorptionFunctionValue, and m_UserGeometryFunctionValue.

Referenced by performIntegration().

{
  QxrdExperimentPtr exp(m_Experiment);

  m_UserGeometryFunctionValue = QScriptValue();
  m_UserAbsorptionFunctionValue = QScriptValue();

  if (exp) {
    QxrdScriptEnginePtr engine = exp->scriptEngine();

    if (engine) {
      engine->unlock();

      if (m_EnableUserGeometry) {
        exp->printMessage(tr("User Geometry Function Completed"));
      }

      if (m_EnableUserAbsorption) {
        exp->printMessage(tr("User Absorption Function Completed"));
      }
    }
  }
}

Here is the caller graph for this function:

QString QxrdIntegratorCache::XLabel ( ) const

private

Definition at line 354 of file qxrdintegratorcache.cpp.

References m_RadialUnits, QxrdIntegrator::RadialIntegrateQ, QxrdIntegrator::RadialIntegrateR, and QxrdIntegrator::RadialIntegrateTTH.

Referenced by performIntegration().

{
  QString label = "";

  switch(m_RadialUnits) {
  case QxrdIntegrator::RadialIntegrateTTH:
    label = "TTH";
    break;

  case QxrdIntegrator::RadialIntegrateQ:
    label = "Q";
    break;

  case QxrdIntegrator::RadialIntegrateR:
    label = "r";
    break;
  }

  return label;
}

Here is the caller graph for this function:

QString QxrdIntegratorCache::XUnits ( ) const

private

Definition at line 375 of file qxrdintegratorcache.cpp.

References m_RadialUnits, QxrdIntegrator::RadialIntegrateQ, QxrdIntegrator::RadialIntegrateR, and QxrdIntegrator::RadialIntegrateTTH.

Referenced by performIntegration().

{
  QString units = "";

  switch(m_RadialUnits) {
  case QxrdIntegrator::RadialIntegrateTTH:
    units = "deg";
    break;

  case QxrdIntegrator::RadialIntegrateQ:
    units = "/&Ang;";
    break;

  case QxrdIntegrator::RadialIntegrateR:
    units = "mm";
    break;
  }

  return units;
}

Here is the caller graph for this function:

double QxrdIntegratorCache::XValue ( double  x, double  y  )

private

Definition at line 252 of file qxrdintegratorcache.cpp.

References getQ(), getR(), getTTH(), m_EnableUserGeometry, m_RadialUnits, m_UserGeometryFunctionValue, QxrdIntegrator::RadialIntegrateQ, QxrdIntegrator::RadialIntegrateR, and QxrdIntegrator::RadialIntegrateTTH.

Referenced by partialIntegrationStep1().

{
  double xVal = 0;

  if (m_EnableUserGeometry == 0) {
    switch(m_RadialUnits) {
    case QxrdIntegrator::RadialIntegrateTTH:
      xVal = getTTH(x,y);
      break;

    case QxrdIntegrator::RadialIntegrateQ:
      xVal = getQ(x,y);
      break;

    case QxrdIntegrator::RadialIntegrateR:
      xVal = getR(x,y);
      break;
    }
  } else {
    xVal = m_UserGeometryFunctionValue.call(QScriptValue(), QScriptValueList() << x << y).toNumber();
  }

  return xVal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

QString QxrdIntegratorCache::YLabel ( ) const

private

Definition at line 396 of file qxrdintegratorcache.cpp.

Referenced by performIntegration().

{
  return "Chi";
}

Here is the caller graph for this function:

QString QxrdIntegratorCache::YUnits ( ) const

private

Definition at line 401 of file qxrdintegratorcache.cpp.

Referenced by performIntegration().

{
  return "deg";
}

Here is the caller graph for this function:

double QxrdIntegratorCache::YValue ( double  x, double  y  )

private

Definition at line 277 of file qxrdintegratorcache.cpp.

References getChi(), m_PolarUnits, and QxrdIntegrator::PolarIntegrateChi.

Referenced by partialIntegrationStep1().

{
  double yVal = 0;

  switch (m_PolarUnits) {
  case QxrdIntegrator::PolarIntegrateChi:
    yVal = getChi(x,y);
  }

  return yVal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

double QxrdIntegratorCache::m_AttenuationLength

private

Definition at line 68 of file qxrdintegratorcache.h.

Referenced by NormValue(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_Beta

private

Definition at line 85 of file qxrdintegratorcache.h.

QcepDoubleImageDataPtr QxrdIntegratorCache::m_CachedNormalization

private

Definition at line 132 of file qxrdintegratorcache.h.

Referenced by cachedIntensity(), partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

QcepInt32ImageDataPtr QxrdIntegratorCache::m_CachedPolarBinNumbers

private

Definition at line 131 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

QcepDoubleImageDataPtr QxrdIntegratorCache::m_CachedPolarValues

private

Definition at line 134 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), and performIntegration().

QcepInt32ImageDataPtr QxrdIntegratorCache::m_CachedRadialBinNumbers

private

Definition at line 130 of file qxrdintegratorcache.h.

Referenced by cachedGeometry(), partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

QcepDoubleImageDataPtr QxrdIntegratorCache::m_CachedRadialValues

private

Definition at line 133 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), and performIntegration().

QAtomicInt QxrdIntegratorCache::m_CacheFillLevel

private

Definition at line 127 of file qxrdintegratorcache.h.

Referenced by performIntegration().

QAtomicInt QxrdIntegratorCache::m_CacheFullLevel

private

Definition at line 128 of file qxrdintegratorcache.h.

Referenced by performIntegration().

QxrdCenterFinderWPtr QxrdIntegratorCache::m_CenterFinder

private

Definition at line 140 of file qxrdintegratorcache.h.

Referenced by QxrdIntegratorCache().

double QxrdIntegratorCache::m_CenterX

private

Definition at line 55 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), NormValue(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_CenterY

private

Definition at line 56 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), NormValue(), performIntegration(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_CFirst

private

Definition at line 77 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), and performIntegration().

double QxrdIntegratorCache::m_CMax

private

Definition at line 79 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1().

double QxrdIntegratorCache::m_CMin

private

Definition at line 78 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1().

double QxrdIntegratorCache::m_CosBeta

private

Definition at line 86 of file qxrdintegratorcache.h.

double QxrdIntegratorCache::m_CosRot

private

Definition at line 89 of file qxrdintegratorcache.h.

double QxrdIntegratorCache::m_CStep

private

Definition at line 76 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), and performIntegration().

double QxrdIntegratorCache::m_DetectorDistance

private

Definition at line 59 of file qxrdintegratorcache.h.

Referenced by getChi(), getDistance(), getQ(), getR(), getTTH(), NormValue(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_DetectorTilt

private

Definition at line 62 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_DetectorXPixelSize

private

Definition at line 57 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_DetectorYPixelSize

private

Definition at line 58 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_EnableAbsorption

private

Definition at line 67 of file qxrdintegratorcache.h.

Referenced by NormValue(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_EnableGeometry

private

Definition at line 64 of file qxrdintegratorcache.h.

Referenced by NormValue(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_EnablePolarization

private

Definition at line 65 of file qxrdintegratorcache.h.

Referenced by NormValue(), and QxrdIntegratorCache().

int QxrdIntegratorCache::m_EnableUserAbsorption

private

Definition at line 94 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), NormValue(), performIntegration(), QxrdIntegratorCache(), and releaseScriptEngine().

int QxrdIntegratorCache::m_EnableUserGeometry

private

Definition at line 91 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), performIntegration(), QxrdIntegratorCache(), releaseScriptEngine(), and XValue().

double QxrdIntegratorCache::m_Energy

private

Definition at line 60 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), and QxrdIntegratorCache().

QxrdExperimentWPtr QxrdIntegratorCache::m_Experiment

private

Definition at line 137 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), performIntegration(), and releaseScriptEngine().

bool QxrdIntegratorCache::m_HasChi

private

Definition at line 129 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), performIntegration(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_ImplementTilt

private

Definition at line 61 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), and QxrdIntegratorCache().

QVector<double> QxrdIntegratorCache::m_Integral

private

Definition at line 135 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep3(), and performIntegration().

QxrdIntegratorWPtr QxrdIntegratorCache::m_Integrator

private

Definition at line 138 of file qxrdintegratorcache.h.

Referenced by QxrdIntegratorCache().

QMutex QxrdIntegratorCache::m_Mutex

private

Definition at line 42 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), and partialIntegrationStep3().

int QxrdIntegratorCache::m_NCols

private

Definition at line 70 of file qxrdintegratorcache.h.

Referenced by get_NCols(), partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

int QxrdIntegratorCache::m_NCSteps

private

Definition at line 83 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep2(), and performIntegration().

int QxrdIntegratorCache::m_NPix

private

Definition at line 71 of file qxrdintegratorcache.h.

Referenced by performIntegration().

int QxrdIntegratorCache::m_NRows

private

Definition at line 69 of file qxrdintegratorcache.h.

Referenced by get_NRows(), partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

int QxrdIntegratorCache::m_NRSteps

private

Definition at line 82 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

int QxrdIntegratorCache::m_Oversample

private

Definition at line 44 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_PolarEnd

private

Definition at line 53 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_Polarization

private

Definition at line 66 of file qxrdintegratorcache.h.

Referenced by NormValue(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_PolarNSteps

private

Definition at line 51 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_PolarStart

private

Definition at line 52 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep2(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_PolarStep

private

Definition at line 50 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), performIntegration(), and QxrdIntegratorCache().

QxrdPolarTransformWPtr QxrdIntegratorCache::m_PolarTransform

private

Definition at line 139 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

int QxrdIntegratorCache::m_PolarUnits

private

Definition at line 54 of file qxrdintegratorcache.h.

Referenced by QxrdIntegratorCache(), and YValue().

double QxrdIntegratorCache::m_RadialEnd

private

Definition at line 48 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_RadialNSteps

private

Definition at line 46 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_RadialStart

private

Definition at line 47 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep2(), performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_RadialStep

private

Definition at line 45 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), performIntegration(), and QxrdIntegratorCache().

int QxrdIntegratorCache::m_RadialUnits

private

Definition at line 49 of file qxrdintegratorcache.h.

Referenced by QxrdIntegratorCache(), XLabel(), XUnits(), and XValue().

int QxrdIntegratorCache::m_ResultSize

private

Definition at line 81 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep3(), and performIntegration().

bool QxrdIntegratorCache::m_RFirst

private

Definition at line 73 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), and performIntegration().

double QxrdIntegratorCache::m_RMax

private

Definition at line 75 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1().

double QxrdIntegratorCache::m_RMin

private

Definition at line 74 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), and performIntegration().

double QxrdIntegratorCache::m_Rot

private

Definition at line 88 of file qxrdintegratorcache.h.

double QxrdIntegratorCache::m_RStep

private

Definition at line 72 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), and performIntegration().

double QxrdIntegratorCache::m_ScalingFactor

private

Definition at line 97 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

bool QxrdIntegratorCache::m_SelfNormalization

private

Definition at line 98 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_SelfNormalizationMaximum

private

Definition at line 100 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_SelfNormalizationMinimum

private

Definition at line 99 of file qxrdintegratorcache.h.

Referenced by performIntegration(), and QxrdIntegratorCache().

double QxrdIntegratorCache::m_SinBeta

private

Definition at line 87 of file qxrdintegratorcache.h.

double QxrdIntegratorCache::m_SinRot

private

Definition at line 90 of file qxrdintegratorcache.h.

QVector<double> QxrdIntegratorCache::m_SumValue

private

Definition at line 136 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep3(), and performIntegration().

int QxrdIntegratorCache::m_ThreadCount

private

Definition at line 43 of file qxrdintegratorcache.h.

Referenced by partialIntegrationStep1(), partialIntegrationStep2(), partialIntegrationStep3(), and performIntegration().

double QxrdIntegratorCache::m_TiltPlaneRotation

private

Definition at line 63 of file qxrdintegratorcache.h.

Referenced by getChi(), getQ(), getTTH(), and QxrdIntegratorCache().

QString QxrdIntegratorCache::m_UserAbsorptionFunction

private

Definition at line 96 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), and QxrdIntegratorCache().

QScriptValue QxrdIntegratorCache::m_UserAbsorptionFunctionValue

private

Definition at line 142 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), NormValue(), and releaseScriptEngine().

QString QxrdIntegratorCache::m_UserAbsorptionScript

private

Definition at line 95 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), and QxrdIntegratorCache().

QString QxrdIntegratorCache::m_UserGeometryFunction

private

Definition at line 93 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), and QxrdIntegratorCache().

QScriptValue QxrdIntegratorCache::m_UserGeometryFunctionValue

private

Definition at line 141 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), releaseScriptEngine(), and XValue().

QString QxrdIntegratorCache::m_UserGeometryScript

private

Definition at line 92 of file qxrdintegratorcache.h.

Referenced by grabScriptEngine(), and QxrdIntegratorCache().

---

The documentation for this class was generated from the following files:

• qxrdintegratorcache.h (Commit a65ccc9... : jennings : 2016-03-15 14:00:18 -0500)
• qxrdintegratorcache.cpp (Commit a65ccc9... : jennings : 2016-03-15 14:00:18 -0500)