int main() {
const size_t N = 64;
const size_t n_iter = 20;
const size_t newton_iter = 4;
const bool verbose = false;
std::vector<float> volume(N*N*N, 0.0f);
std::mt19937 mt(0);
std::uniform_real_distribution<> uniform(-1.0f, 1.0f);
for (size_t i=0; i<volume.size(); ++i) {
volume[i] = uniform(mt);
}
std::vector<float> e0s(N*N*N, 0.0f);
std::vector<float> e1s(N*N*N, 0.0f);
std::vector<float> e2s(N*N*N, 0.0f);
timer("reference", n_iter, [&] {
eigen_hessian_3d<newton_iter>(e0s.data(), e1s.data(), e2s.data(), volume.data(), N, N, N, true);
});
std::vector<float> e0s_simd(N*N*N, 0.0f);
std::vector<float> e1s_simd(N*N*N, 0.0f);
std::vector<float> e2s_simd(N*N*N, 0.0f);
timer("SSE1", n_iter, [&] {
eigen_hessian_3d<1>(e0s_simd.data(), e1s_simd.data(), e2s_simd.data(), volume.data(), N, N, N, false);
});
timer("SSE2", n_iter, [&] {
eigen_hessian_3d<2>(e0s_simd.data(), e1s_simd.data(), e2s_simd.data(), volume.data(), N, N, N, false);
});
timer("SSE3", n_iter, [&] {
eigen_hessian_3d<3>(e0s_simd.data(), e1s_simd.data(), e2s_simd.data(), volume.data(), N, N, N, false);
});
timer("SSE", n_iter, [&] {
eigen_hessian_3d<newton_iter>(e0s_simd.data(), e1s_simd.data(), e2s_simd.data(), volume.data(), N, N, N, false);
});
float e0_diff_sum = 0.0f;
float e1_diff_sum = 0.0f;
float e2_diff_sum = 0.0f;
for (size_t i=0; i<volume.size(); ++i) {
if (verbose) {
std::cout << ""
<< e0s[i] << ","
<< e1s[i] << ","
<< e2s[i] << " "
<< e0s_simd[i] << ","
<< e1s_simd[i] << ","
<< e2s_simd[i] << " "
<< std::endl;
}
e0_diff_sum += std::abs(e0s[i] - e0s_simd[i]);
e1_diff_sum += std::abs(e1s[i] - e1s_simd[i]);
e2_diff_sum += std::abs(e2s[i] - e2s_simd[i]);
}
std::cout << N << "x" << N << "x" << N << " volume. Newton iter = " << newton_iter << std::endl;
std::cout << "mean abs error: "
<< e0_diff_sum/volume.size() << ", "
<< e1_diff_sum/volume.size() << ", "
<< e2_diff_sum/volume.size() << std::endl;
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGenODFWidget::on_loadODFTextureBtn_clicked()
{
QString file = angleFilePath->text();
if(true == file.isEmpty())
{
return;
}
QFileInfo fi(angleFilePath->text());
if(fi.exists() == false)
{
return;
}
size_t count = 0;
QVector<float> e1s(count);
QVector<float> e2s(count);
QVector<float> e3s(count);
QVector<float> weights(count);
QVector<float> sigmas(count);
QProgressDialog progress("Loading Data ....", "Cancel", 0, 3, this);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(2000);
if (fi.suffix().compare(Ebsd::Ang::FileExt) == 0)
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
AngReader loader;
loader.setFileName(angleFilePath->text());
int err = loader.readFile();
if(err < 0)
{
QMessageBox::critical(this, "Error loading the ANG file", loader.getErrorMessage(), QMessageBox::Ok);
return;
}
float* phi1 = loader.getPhi1Pointer();
float* phi = loader.getPhiPointer();
float* phi2 = loader.getPhi2Pointer();
int xDim = loader.getXDimension();
int yDim = loader.getYDimension();
count = xDim * yDim;
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = phi1[i];
e2s[i] = phi[i];
e3s[i] = phi2[i];
weights[i] = 1.0;
sigmas[i] = 0.0;
}
}
else if (fi.suffix().compare(Ebsd::Ctf::FileExt) == 0)
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
CtfReader loader;
loader.setFileName(angleFilePath->text());
int err = loader.readFile();
if(err < 0)
{
QMessageBox::critical(this, "Error loading the CTF file", loader.getErrorMessage(), QMessageBox::Ok);
return;
}
float* phi1 = loader.getEuler1Pointer();
float* phi = loader.getEuler2Pointer();
float* phi2 = loader.getEuler3Pointer();
int xDim = loader.getXDimension();
int yDim = loader.getYDimension();
count = xDim * yDim;
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = phi1[i];
e2s[i] = phi[i];
e3s[i] = phi2[i];
weights[i] = 1.0;
sigmas[i] = 0.0;
}
}
else
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
AngleFileLoader::Pointer loader = AngleFileLoader::New();
loader->setInputFile(angleFilePath->text());
loader->setAngleRepresentation(angleRepresentation->currentIndex());
loader->setFileAnglesInDegrees(anglesInDegrees->isChecked());
loader->setOutputAnglesInDegrees(true);
QString delim;
int index = delimiter->currentIndex();
switch(index)
{
case 0:
delim = " ";
break;
case 1:
delim = "\t";
break;
case 2:
delim = ",";
break;
case 3:
delim = ";";
break;
default:
delim = " ";
}
loader->setDelimiter(delim);
FloatArrayType::Pointer data = loader->loadData();
if (loader->getErrorCode() < 0)
{
QMessageBox::critical(this, "Error Loading Angle data", loader->getErrorMessage(), QMessageBox::Ok);
return;
}
count = data->getNumberOfTuples();
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = data->getComponent(i, 0);
e2s[i] = data->getComponent(i, 1);
e3s[i] = data->getComponent(i, 2);
weights[i] = data->getComponent(i, 3);
sigmas[i] = data->getComponent(i, 4);
}
}
progress.setValue(2);
progress.setLabelText("[2/3] Rendering Pole Figure ...");
m_OdfBulkTableModel->removeRows(0, m_OdfBulkTableModel->rowCount());
#if 1
m_OdfBulkTableModel->blockSignals(true);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler1, e1s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler2, e2s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler3, e3s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Weight, weights);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Sigma, sigmas);
m_OdfBulkTableModel->blockSignals(false);
#endif
on_m_CalculateODFBtn_clicked();
progress.setValue(3);
}
