// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindModulusMismatch::execute()
{
setErrorCondition(0);
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles),
FindModulusMismatchImpl(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus), tbb::auto_partitioner());
}
else
#endif
{
FindModulusMismatchImpl serial(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus);
serial.generate(0, numTriangles);
}
notifyStatusMessage(getHumanLabel(), "Completed");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateFaceSchuhMisorientationColoring::execute()
{
int err = 0;
setErrorCondition(err);
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), "Starting");
// Run the data check to allocate the memory for the centroid array
int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles),
CalculateFaceSchuhMisorientationColorsImpl(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures), tbb::auto_partitioner());
}
else
#endif
{
CalculateFaceSchuhMisorientationColorsImpl serial(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures);
serial.generate(0, numTriangles);
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindModulusMismatch::preflight()
{
setInPreflight(true);
emit preflightAboutToExecute();
emit updateFilterParameters(this);
dataCheckVoxel();
dataCheckSurfaceMesh();
emit preflightExecuted();
setInPreflight(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateFaceSchuhMisorientationColoring::preflight()
{
setInPreflight(true);
emit preflightAboutToExecute();
emit updateFilterParameters(this);
dataCheckSurfaceMesh();
dataCheckVoxel();
emit preflightExecuted();
setInPreflight(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindTwinBoundarySchmidFactors::preflight()
{
setInPreflight(true);
emit preflightAboutToExecute();
emit updateFilterParameters(this);
dataCheckVoxel();
dataCheckSurfaceMesh();
emit preflightExecuted();
setInPreflight(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindGBCD::preflight()
{
setInPreflight(true);
emit preflightAboutToExecute();
emit updateFilterParameters(this);
dataCheckVoxel();
// order here matters...because we are going to use the size of the crystal structures out of the dataCheckVoxel to size the faceAttrMat in dataCheckSurfaceMesh
if (getErrorCondition() >= 0) { dataCheckSurfaceMesh(); }
emit preflightExecuted();
setInPreflight(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindTwinBoundarySchmidFactors::execute()
{
setErrorCondition(0);
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
size_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
float LoadingDir[3] = { 0.0f, 0.0f, 0.0f };
LoadingDir[0] = m_LoadingDir.x;
LoadingDir[1] = m_LoadingDir.y;
LoadingDir[2] = m_LoadingDir.z;
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles),
CalculateTwinBoundarySchmidFactorsImpl(LoadingDir, m_SurfaceMeshFaceLabels, m_SurfaceMeshFaceNormals, m_AvgQuats, m_SurfaceMeshTwinBoundary, m_SurfaceMeshTwinBoundarySchmidFactors), tbb::auto_partitioner());
}
else
#endif
{
CalculateTwinBoundarySchmidFactorsImpl serial(LoadingDir, m_SurfaceMeshFaceLabels, m_SurfaceMeshFaceNormals, m_AvgQuats, m_SurfaceMeshTwinBoundary, m_SurfaceMeshTwinBoundarySchmidFactors);
serial.generate(0, numTriangles);
}
if (m_WriteFile == true)
{
std::ofstream outFile;
outFile.open(m_TwinBoundarySchmidFactorsFile.toLatin1().data(), std::ios_base::binary);
outFile << "Feature1 Feature2 IsTwin Plane Schmid1 Schmid2 Schmid3" << "\n";
for (size_t i = 0; i < numTriangles; i++)
{
outFile << m_SurfaceMeshFaceLabels[2 * i] << " " << m_SurfaceMeshFaceLabels[2 * i + 1] << " " << m_SurfaceMeshTwinBoundary[i] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i + 1] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i + 2] << "\n";
}
outFile.close();
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindGBCD::execute()
{
setErrorCondition(0);
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
// order here matters...because we are going to use the size of the crystal structures out of the dataCheckVoxel to size the faceAttrMat in dataCheckSurfaceMesh
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
size_t totalPhases = m_CrystalStructuresPtr.lock()->getNumberOfTuples();
size_t totalFaces = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
size_t faceChunkSize = 50000;
size_t numMisoReps = 576 * 4;
if (totalFaces < faceChunkSize) { faceChunkSize = totalFaces; }
// call the sizeGBCD function with proper chunkSize and numMisoReps to get Bins array set up properly
sizeGBCD(faceChunkSize, numMisoReps);
int32_t totalGBCDBins = m_GbcdSizes[0] * m_GbcdSizes[1] * m_GbcdSizes[2] * m_GbcdSizes[3] * m_GbcdSizes[4] * 2;
uint64_t millis = QDateTime::currentMSecsSinceEpoch();
uint64_t currentMillis = millis;
uint64_t startMillis = millis;
uint64_t estimatedTime = 0;
float timeDiff = 0.0f;
startMillis = QDateTime::currentMSecsSinceEpoch();
int32_t hemisphere = 0;
//create an array to hold the total face area for each phase and initialize the array to 0.0
DoubleArrayType::Pointer totalFaceAreaPtr = DoubleArrayType::CreateArray(totalPhases, "totalFaceArea");
totalFaceAreaPtr->initializeWithValue(0.0);
double* totalFaceArea = totalFaceAreaPtr->getPointer(0);
QString ss = QObject::tr("Calculating GBCD || 0/%1 Completed").arg(totalFaces);
for (size_t i = 0; i < totalFaces; i = i + faceChunkSize)
{
if(getCancel() == true) { return; }
if (i + faceChunkSize >= totalFaces)
{
faceChunkSize = totalFaces - i;
}
m_GbcdBinsArray->initializeWithValue(-1);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(i, i + faceChunkSize),
CalculateGBCDImpl(i, numMisoReps, m_SurfaceMeshFaceLabelsPtr.lock(), m_SurfaceMeshFaceNormalsPtr.lock(), m_FeatureEulerAnglesPtr.lock(), m_FeaturePhasesPtr.lock(), m_CrystalStructuresPtr.lock(), m_GbcdBinsArray, m_GbcdHemiCheckArray, m_GbcdDeltasArray, m_GbcdSizesArray, m_GbcdLimitsArray), tbb::auto_partitioner());
}
else
#endif
{
CalculateGBCDImpl serial(i, numMisoReps, m_SurfaceMeshFaceLabelsPtr.lock(), m_SurfaceMeshFaceNormalsPtr.lock(), m_FeatureEulerAnglesPtr.lock(), m_FeaturePhasesPtr.lock(), m_CrystalStructuresPtr.lock(), m_GbcdBinsArray, m_GbcdHemiCheckArray, m_GbcdDeltasArray, m_GbcdSizesArray, m_GbcdLimitsArray);
serial.generate(i, i + faceChunkSize);
}
currentMillis = QDateTime::currentMSecsSinceEpoch();
if (currentMillis - millis > 1000)
{
QString ss = QObject::tr("Calculating GBCD || Triangles %1/%2 Completed").arg(i).arg(totalFaces);
timeDiff = ((float)i / (float)(currentMillis - startMillis));
estimatedTime = (float)(totalFaces - i) / timeDiff;
ss = ss + QObject::tr(" || Est. Time Remain: %1").arg(DREAM3D::convertMillisToHrsMinSecs(estimatedTime));
millis = QDateTime::currentMSecsSinceEpoch();
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
}
if(getCancel() == true) { return; }
int32_t phase = 0;
int32_t feature = 0;
double area = 0.0;
for (size_t j = 0; j < faceChunkSize; j++)
{
area = m_SurfaceMeshFaceAreas[i + j];
feature = m_SurfaceMeshFaceLabels[2 * (i + j)];
phase = m_FeaturePhases[feature];
for (size_t k = 0; k < numMisoReps; k++)
{
if (m_GbcdBins[(j * numMisoReps) + (k)] >= 0)
{
hemisphere = 0;
if (m_HemiCheck[(j * numMisoReps) + k] == false) { hemisphere = 1; }
m_GBCD[(phase * totalGBCDBins) + (2 * m_GbcdBins[(j * numMisoReps) + (k)] + hemisphere)] += area;
totalFaceArea[phase] += area;
}
}
}
}
ss = QObject::tr("Starting GBCD Normalization");
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
for (int32_t i = 0; i < totalPhases; i++)
{
size_t phaseShift = i * totalGBCDBins;
double MRDfactor = double(totalGBCDBins) / totalFaceArea[i];
for (int32_t j = 0; j < totalGBCDBins; j++)
{
m_GBCD[phaseShift + j] *= MRDfactor;
}
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
