// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGenODFWidget::extractStatsData(int index, StatsData* statsData, unsigned int phaseType)
{
VectorOfFloatArray arrays;
if(phaseType == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
arrays = pp->getODF_Weights();
}
if(phaseType == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
arrays = pp->getODF_Weights();
}
if(phaseType == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
arrays = tp->getODF_Weights();
}
if (arrays.size() > 0)
{
QVector<float> e1(static_cast<int>(arrays[0]->getNumberOfTuples()));
::memcpy( e1.data(), arrays[0]->getVoidPointer(0), sizeof(float)*e1.size() );
QVector<float> e2(static_cast<int>(arrays[1]->getNumberOfTuples()));
::memcpy( e2.data(), arrays[1]->getVoidPointer(0), sizeof(float)*e2.size() );
QVector<float> e3(static_cast<int>(arrays[2]->getNumberOfTuples()));
::memcpy( e3.data(), arrays[2]->getVoidPointer(0), sizeof(float)*e3.size() );
QVector<float> weights(static_cast<int>(arrays[3]->getNumberOfTuples()));
::memcpy( weights.data(), arrays[3]->getVoidPointer(0), sizeof(float)*weights.size() );
QVector<float> sigmas(static_cast<int>(arrays[4]->getNumberOfTuples()));
::memcpy( sigmas.data(), arrays[4]->getVoidPointer(0), sizeof(float)*sigmas.size() );
// Convert from Radians to Degrees for the Euler Angles
for(int i = 0; i < e1.size(); ++i)
{
e1[i] = e1[i] * 180.0f / M_PI;
e2[i] = e2[i] * 180.0f / M_PI;
e3[i] = e3[i] * 180.0f / M_PI;
}
if(e1.size() > 0)
{
// Load the data into the table model
m_ODFTableModel->setTableData(e1, e2, e3, weights, sigmas);
}
}
// Write the MDF Data if we have that functionality enabled
if (m_MDFWidget != NULL)
{
m_MDFWidget->extractStatsData(index, statsData, phaseType);
}
updatePlots();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGenMDFWidget::extractStatsData(int index, StatsData* statsData, unsigned int phaseType)
{
Q_UNUSED(index)
VectorOfFloatArray arrays;
if(phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
arrays = pp->getMDF_Weights();
}
if(phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
arrays = pp->getMDF_Weights();
}
if(phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
arrays = tp->getMDF_Weights();
}
QVector<float> axis;
QVector<float> angle;
QVector<float> weights;
for (int i = 0; i < arrays.size(); i++)
{
if(arrays[i]->getName().compare(SIMPL::StringConstants::Axis) == 0)
{
axis = QVector<float>(static_cast<int>(arrays[i]->getSize())); // This one is 3xn in size
::memcpy( &(axis.front()), arrays[i]->getVoidPointer(0), sizeof(float)*axis.size() );
}
if(arrays[i]->getName().compare(SIMPL::StringConstants::Angle) == 0)
{
angle = QVector<float>(static_cast<int>(arrays[i]->getNumberOfTuples()));
::memcpy( &(angle.front()), arrays[i]->getVoidPointer(0), sizeof(float)*angle.size() );
}
if(arrays[i]->getName().compare(SIMPL::StringConstants::Weight) == 0)
{
weights = QVector<float>(static_cast<int>(arrays[i]->getNumberOfTuples()));
::memcpy( &(weights.front()), arrays[i]->getVoidPointer(0), sizeof(float)*weights.size() );
}
}
if (arrays.size() > 0)
{
// Load the data into the table model
m_MDFTableModel->setTableData(angle, axis, weights);
}
on_m_MDFUpdateBtn_clicked();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString InitializeSyntheticVolume::estimateNumFeatures(IntVec3_t dims, FloatVec3_t res)
{
float totalvol = 0.0f;
int32_t phase = 0;
totalvol = (dims.x * res.x) * (dims.y * res.y) * (dims.z * res.z);
if (totalvol == 0.0)
{
return "-1";
}
DataContainerArray::Pointer dca = getDataContainerArray();
// Get the PhaseTypes - Remember there is a Dummy PhaseType in the first slot of the array
QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component
UInt32ArrayType::Pointer phaseType = dca->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(NULL, getInputPhaseTypesArrayPath(), cDims);
if (phaseType.get() == NULL)
{
QString ss = QObject::tr("Phase types array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputPhaseTypesArrayPath().serialize());
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return "0";
}
QVector<size_t> statsDims(1, 1);
StatsDataArray::Pointer statsPtr = dca->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims);
if (statsPtr.get() == NULL)
{
QString ss = QObject::tr("Statistics array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputStatsArrayPath().serialize());
notifyErrorMessage(getHumanLabel(), ss, -11001);
return "0";
}
if (!phaseType->isAllocated())
{
if (getInputStatsFile().isEmpty())
{
QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file is empty");
setErrorCondition(-1000);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
QFileInfo fi(getInputStatsFile());
if (fi.exists() == false)
{
QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file does not exist at '%1'").arg(fi.absoluteFilePath());
setErrorCondition(-1001);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
hid_t fileId = -1;
herr_t err = 0;
// open the file
fileId = H5Utilities::openFile(getInputStatsFile().toLatin1().constData(), true);
// This will make sure if we return early from this method that the HDF5 File is properly closed.
HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true);
DataArrayPath dap = getInputPhaseTypesArrayPath();
// Generate the path to the AttributeMatrix
QString hPath = DREAM3D::StringConstants::DataContainerGroupName + "/" + dap.getDataContainerName() + "/" + dap.getAttributeMatrixName();
// Open the AttributeMatrix Group
hid_t amGid = H5Gopen(fileId, hPath.toLatin1().data(), H5P_DEFAULT );
scopedFileSentinel.addGroupId(&amGid);
err = phaseType->readH5Data(amGid);
if (err < 0)
{
QString ss = QObject::tr("Error reading phase type data");
setErrorCondition(-1003);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
if (!phaseType->isAllocated())
{
QString ss = QObject::tr("Phase types Array was not allocated due to an error reading the data from the statistics file %1").arg(fi.absoluteFilePath());
setErrorCondition(-1002);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
}
// Create a Reference Variable so we can use the [] syntax
StatsDataArray& statsDataArray = *(statsPtr.get());
std::vector<int32_t> primaryphases;
std::vector<double> primaryphasefractions;
double totalprimaryfractions = 0.0;
// find which phases are primary phases
for (size_t i = 1; i < phaseType->getNumberOfTuples(); ++i)
{
if (phaseType->getValue(i) == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get());
primaryphases.push_back(i);
primaryphasefractions.push_back(pp->getPhaseFraction());
totalprimaryfractions = totalprimaryfractions + pp->getPhaseFraction();
}
}
// scale the primary phase fractions to total to 1
for (int32_t i = 0; i < primaryphasefractions.size(); i++)
{
primaryphasefractions[i] = primaryphasefractions[i] / totalprimaryfractions;
}
SIMPL_RANDOMNG_NEW()
// generate the Features
int32_t gid = 1;
float currentvol = 0.0f;
float vol = 0.0f;
float diam = 0.0f;
bool volgood = false;
for (int32_t j = 0; j < primaryphases.size(); ++j)
{
float curphasetotalvol = totalvol * primaryphasefractions[j];
while (currentvol < curphasetotalvol)
{
volgood = false;
phase = primaryphases[j];
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[phase].get());
if (NULL == pp)
{
QString ss = QObject::tr("Tried to cast a statsDataArray[%1].get() to a PrimaryStatsData* "
"pointer but this resulted in a NULL pointer.\n")
.arg(phase).arg(phase);
setErrorCondition(-666);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
while (volgood == false)
{
volgood = true;
if (pp->getFeatureSize_DistType() == DREAM3D::DistributionType::LogNormal)
{
float avgdiam = pp->getFeatureSizeDistribution().at(0)->getValue(0);
float sddiam = pp->getFeatureSizeDistribution().at(1)->getValue(0);
diam = rg.genrand_norm(avgdiam, sddiam);
diam = expf(diam);
if (diam >= pp->getMaxFeatureDiameter()) { volgood = false; }
if (diam < pp->getMinFeatureDiameter()) { volgood = false; }
vol = (4.0f / 3.0f) * (M_PI) * ((diam * 0.5f) * (diam * 0.5f) * (diam * 0.5f));
}
}
currentvol = currentvol + vol;
gid++;
}
}
return QString::number(gid);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int StatsGenODFWidget::getOrientationData(StatsData* statsData, unsigned int phaseType)
{
int retErr = 0;
QVector<float> e1s;
QVector<float> e2s;
QVector<float> e3s;
QVector<float> weights;
QVector<float> sigmas;
QVector<float> odf;
// Initialize xMax and yMax....
e1s = m_ODFTableModel->getData(SGODFTableModel::Euler1);
e2s = m_ODFTableModel->getData(SGODFTableModel::Euler2);
e3s = m_ODFTableModel->getData(SGODFTableModel::Euler3);
weights = m_ODFTableModel->getData(SGODFTableModel::Weight);
sigmas = m_ODFTableModel->getData(SGODFTableModel::Sigma);
for (QVector<float>::size_type i = 0; i < e1s.size(); i++)
{
e1s[i] = e1s[i] * M_PI / 180.0;
e2s[i] = e2s[i] * M_PI / 180.0;
e3s[i] = e3s[i] * M_PI / 180.0;
}
size_t numEntries = e1s.size();
if ( Ebsd::CrystalStructure::Cubic_High == m_CrystalStructure)
{
odf.resize(CubicOps::k_OdfSize);
Texture::CalculateCubicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries);
}
else if ( Ebsd::CrystalStructure::Hexagonal_High == m_CrystalStructure)
{
odf.resize(HexagonalOps::k_OdfSize);
Texture::CalculateHexODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries);
}
if (odf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromQVector(odf, DREAM3D::StringConstants::ODF);
if(phaseType == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if(phaseType == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if(phaseType == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF(p);
}
if (e1s.size() > 0)
{
FloatArrayType::Pointer euler1 = FloatArrayType::FromQVector(e1s, DREAM3D::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::FromQVector(e2s, DREAM3D::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::FromQVector(e3s, DREAM3D::StringConstants::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::FromQVector(sigmas, DREAM3D::StringConstants::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::FromQVector(weights, DREAM3D::StringConstants::Weight);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(sigma);
odfWeights.push_back(weight);
if(phaseType == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if(phaseType == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if(phaseType == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF_Weights(odfWeights);
}
}
}
// Write the MDF Data if we have that functionality enabled
if (m_MDFWidget != NULL)
{
m_MDFWidget->getMisorientationData(statsData, phaseType);
}
return retErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateODFBinData(StatsData* statsData,
unsigned int phaseType, unsigned int crystalStructure,
QVector<float> &e1s, QVector<float> &e2s,
QVector<float> &e3s, QVector<float> &weights,
QVector<float> &sigmas, bool computeODF)
{
QVector<float> odf;
size_t numEntries = e1s.size();
if ( Ebsd::CrystalStructure::Cubic_High == crystalStructure)
{
odf.resize(CubicOps::k_OdfSize);
if (computeODF) { Texture::CalculateCubicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries); }
}
else if ( Ebsd::CrystalStructure::Hexagonal_High == crystalStructure)
{
odf.resize(HexagonalOps::k_OdfSize);
if (computeODF) { Texture::CalculateHexODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries); }
}
if (odf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromQVector(odf, SIMPL::StringConstants::ODF);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF(p);
}
if (e1s.size() > 0)
{
FloatArrayType::Pointer euler1 = FloatArrayType::FromQVector(e1s, SIMPL::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::FromQVector(e2s, SIMPL::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::FromQVector(e3s, SIMPL::StringConstants::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::FromQVector(sigmas, SIMPL::StringConstants::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::FromQVector(weights, SIMPL::StringConstants::Weight);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(sigma);
odfWeights.push_back(weight);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF_Weights(odfWeights);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateMisorientationBinData(StatsData* statsData,
unsigned int phaseType, unsigned int crystalStruct,
QVector<float> &odf,
QVector<float> &angles, QVector<float> &axes,
QVector<float> &weights, bool computeMDF)
{
QVector<float> x;
QVector<float> y;
QVector<float> mdf;
if (Ebsd::CrystalStructure::Cubic_High == crystalStruct)
{
mdf.resize(CubicOps::k_MdfSize);
if (computeMDF) { Texture::CalculateMDFData<float, CubicOps>(angles.data(), axes.data(), weights.data(), odf.data(), mdf.data(), angles.size()); }
//nElements = 18 * 18 * 18;
}
else if (Ebsd::CrystalStructure::Hexagonal_High == crystalStruct)
{
mdf.resize(HexagonalOps::k_MdfSize);
if (computeMDF) { Texture::CalculateMDFData<float, HexagonalOps>(angles.data(), axes.data(), weights.data(), odf.data(), mdf.data(), angles.size()); }
//nElements = 36 * 36 * 12;
}
if (mdf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromPointer(mdf.data(), mdf.size(), SIMPL::StringConstants::MisorientationBins);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setMisorientationBins(p);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setMisorientationBins(p);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setMisorientationBins(p);
}
if (angles.size() > 0)
{
FloatArrayType::Pointer anglesArray = FloatArrayType::FromPointer(angles.data(), angles.size(), SIMPL::StringConstants::Angle);
FloatArrayType::Pointer axisArray = FloatArrayType::FromPointer(axes.data(), axes.size(), SIMPL::StringConstants::Axis);
FloatArrayType::Pointer weightArray = FloatArrayType::FromPointer(weights.data(), weights.size(), SIMPL::StringConstants::Weight);
VectorOfFloatArray mdfWeights;
mdfWeights.push_back(anglesArray);
mdfWeights.push_back(axisArray);
mdfWeights.push_back(weightArray);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setMDF_Weights(mdfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setMDF_Weights(mdfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setMDF_Weights(mdfWeights);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateAxisODFBinData(StatsData* statsData, unsigned int phaseType,
QVector<float> &e1s, QVector<float> &e2s,
QVector<float> &e3s, QVector<float> &weights,
QVector<float> &sigmas, bool computeAxisODF)
{
QVector<float> aodf;
size_t numEntries = e1s.size();
aodf.resize(OrthoRhombicOps::k_OdfSize);
if (computeAxisODF) { Texture::CalculateOrthoRhombicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
aodf.data(), numEntries); }
if (aodf.size() > 0)
{
FloatArrayType::Pointer aodfData = FloatArrayType::FromQVector(aodf, SIMPL::StringConstants::AxisOrientation);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setAxisOrientation(aodfData);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setAxisOrientation(aodfData);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setAxisOrientation(aodfData);
}
if (e1s.size() > 0)
{
FloatArrayType::Pointer euler1 = FloatArrayType::FromQVector(e1s, SIMPL::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::FromQVector(e2s, SIMPL::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::FromQVector(e3s, SIMPL::StringConstants::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::FromQVector(sigmas, SIMPL::StringConstants::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::FromQVector(weights, SIMPL::StringConstants::Weight);
VectorOfFloatArray aodfWeights;
aodfWeights.push_back(euler1);
aodfWeights.push_back(euler2);
aodfWeights.push_back(euler3);
aodfWeights.push_back(sigma);
aodfWeights.push_back(weight);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setAxisODF_Weights(aodfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setAxisODF_Weights(aodfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setAxisODF_Weights(aodfWeights);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindAxisODF::execute()
{
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
dataCheck(false, m->getTotalPoints(), m->getNumFieldTuples(), m->getNumEnsembleTuples());
if(getErrorCondition() < 0)
{
return;
}
StatsDataArray& statsDataArray = *m_StatsDataArray;
typedef DataArray<unsigned int> XTalType;
XTalType* crystruct = XTalType::SafeObjectDownCast<IDataArray*, XTalType*>(m->getEnsembleData(DREAM3D::EnsembleData::CrystalStructures).get());
float r1, r2, r3;
int bin;
std::vector<FloatArrayType::Pointer> axisodf;
std::vector<float> totalaxes;
size_t numXTals = crystruct->GetNumberOfTuples();
axisodf.resize(numXTals);
totalaxes.resize(numXTals);
for (size_t i = 1; i < numXTals; i++)
{
totalaxes[i] = 0.0;
axisodf[i] = FloatArrayType::CreateArray((36 * 36 * 36), DREAM3D::HDF5::AxisOrientation);
for (int j = 0; j < (36 * 36 * 36); j++)
{
axisodf[i]->SetValue(j, 0.0);
}
}
size_t numgrains = m->getNumFieldTuples();
for (size_t i = 0; i < numgrains; i++)
{
if(m_SurfaceFields[i] == false)
{
totalaxes[m_FieldPhases[i]]++;
}
}
for (size_t i = 1; i < numgrains; i++)
{
float ea1 = m_AxisEulerAngles[3 * i];
float ea2 = m_AxisEulerAngles[3 * i + 1];
float ea3 = m_AxisEulerAngles[3 * i + 2];
if(m_SurfaceFields[i] == 0)
{
OrientationMath::EulerToRod( ea1, ea2, ea3, r1, r2, r3);
m_OrientationOps[Ebsd::CrystalStructure::OrthoRhombic]->getODFFZRod(r1, r2, r3);
bin = m_OrientationOps[Ebsd::CrystalStructure::OrthoRhombic]->getOdfBin(r1, r2, r3);
axisodf[m_FieldPhases[i]]->SetValue(bin, (axisodf[m_FieldPhases[i]]->GetValue(bin) + static_cast<float>((1.0 / totalaxes[m_FieldPhases[i]]))));
}
}
// int err;
for (size_t i = 1; i < numXTals; i++)
{
if(m_PhaseTypes[i] == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get());
pp->setAxisOrientation(axisodf[i]);
}
if(m_PhaseTypes[i] == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsDataArray[i].get());
pp->setAxisOrientation(axisodf[i]);
}
if(m_PhaseTypes[i] == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsDataArray[i].get());
tp->setAxisOrientation(axisodf[i]);
}
}
notifyStatusMessage("Completed");
}