MatrixFloat ClassificationData::getClassHistogramData(UINT classLabel,UINT numBins) const{
const UINT M = getNumSamples();
const UINT N = getNumDimensions();
Vector< MinMax > ranges = getRanges();
VectorFloat binRange(N);
for(UINT i=0; i<ranges.size(); i++){
binRange[i] = (ranges[i].maxValue-ranges[i].minValue)/Float(numBins);
}
MatrixFloat histData(N,numBins);
histData.setAllValues(0);
Float norm = 0;
for(UINT i=0; i<M; i++){
if( data[i].getClassLabel() == classLabel ){
for(UINT j=0; j<N; j++){
UINT binIndex = 0;
bool binFound = false;
for(UINT k=0; k<numBins-1; k++){
if( data[i][j] >= ranges[i].minValue + (binRange[j]*k) && data[i][j] >= ranges[i].minValue + (binRange[j]*(k+1)) ){
binIndex = k;
binFound = true;
break;
}
}
if( !binFound ) binIndex = numBins-1;
histData[j][binIndex]++;
}
norm++;
}
}
if( norm == 0 ) return histData;
//Is this the best way to normalize a multidimensional histogram???
for(UINT i=0; i<histData.getNumRows(); i++){
for(UINT j=0; j<histData.getNumCols(); j++){
histData[i][j] /= norm;
}
}
return histData;
}
/** Unwraps an X array, converting the units to wavelength along the way.
* @param tempWS :: A pointer to the temporary workspace in which the results
* are being stored
* @param spectrum :: The workspace index
* @param Ld :: The flightpath for the detector related to this spectrum
* @return A 3-element vector containing the bins at which the upper and lower
* ranges start & end
*/
const std::vector<int>
UnwrapMonitor::unwrapX(const API::MatrixWorkspace_sptr &tempWS,
const int &spectrum, const double &Ld) {
// Create and initalise the vector that will store the bin ranges, and will be
// returned
// Elements are: 0 - Lower range start, 1 - Lower range end, 2 - Upper range
// start
std::vector<int> binRange(3, -1);
// Calculate cut-off times
const double T1 = m_Tmax - (m_Tmin * (1 - (Ld / m_LRef)));
const double T2 = m_Tmax * (Ld / m_LRef);
// Create a temporary vector to store the lower range of the unwrapped
// histograms
std::vector<double> tempX_L;
tempX_L.reserve(
m_XSize); // Doing this possible gives a small efficiency increase
// Create a vector for the upper range. Make it a reference to the output
// histogram to save an assignment later
MantidVec &tempX_U = tempWS->dataX(spectrum);
tempX_U.clear();
tempX_U.reserve(m_XSize);
// Get a reference to the input x data
const MantidVec &xdata = m_inputWS->readX(spectrum);
// Loop over histogram, selecting bins in appropriate ranges.
// At the moment, the data in the bin in which a cut-off sits is excluded.
for (unsigned int bin = 0; bin < m_XSize; ++bin) {
// This is the time-of-flight value under consideration in the current
// iteration of the loop
const double tof = xdata[bin];
// First deal with bins where m_Tmin < tof < T2
if (tof < T2) {
const double wavelength = (m_conversionConstant * tof) / Ld;
tempX_L.push_back(wavelength);
// Record the bins that fall in this range for copying over the data &
// errors
if (binRange[0] == -1)
binRange[0] = bin;
binRange[1] = bin;
}
// Now do the bins where T1 < tof < m_Tmax
else if (tof > T1) {
const double velocity = Ld / (tof - m_Tmax + m_Tmin);
const double wavelength = m_conversionConstant / velocity;
tempX_U.push_back(wavelength);
// Remove the duplicate boundary bin
if (tof == m_Tmax && std::abs(wavelength - tempX_L.front()) < 1.0e-5)
tempX_U.pop_back();
// Record the bins that fall in this range for copying over the data &
// errors
if (binRange[2] == -1)
binRange[2] = bin;
}
} // loop over X values
// Deal with the (rare) case that a detector (e.g. downstream monitor) is at a
// longer flightpath than m_LRef
if (Ld > m_LRef) {
std::pair<int, int> binLimits =
this->handleFrameOverlapped(xdata, Ld, tempX_L);
binRange[0] = binLimits.first;
binRange[1] = binLimits.second;
}
// Record the point at which the unwrapped sections are joined, first time
// through only
Property *join = getProperty("JoinWavelength");
if (join->isDefault()) {
g_log.information() << "Joining wavelength: " << tempX_L.front()
<< " Angstrom\n";
setProperty("JoinWavelength", tempX_L.front());
}
// Append first vector to back of second
tempX_U.insert(tempX_U.end(), tempX_L.begin(), tempX_L.end());
return binRange;
}
