// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int VoxelDataContainerWriter::writeFieldData(hid_t dcGid)
{
std::stringstream ss;
int err = 0;
VoxelDataContainer* m = getVoxelDataContainer();
#if WRITE_FIELD_XDMF
// Get the name of the .dream3d file that we are writing to:
ssize_t nameSize = H5Fget_name(m_HdfFileId, NULL, 0) + 1;
std::vector<char> nameBuffer(nameSize, 0);
nameSize = H5Fget_name(m_HdfFileId, &(nameBuffer.front()), nameSize);
std::string hdfFileName(&(nameBuffer.front()), nameSize);
hdfFileName = MXAFileInfo::filename(hdfFileName);
std::string xdmfGroupPath = std::string(":/") + VoxelDataContainer::ClassName() + std::string("/") + H5_FIELD_DATA_GROUP_NAME;
#endif
int64_t volDims[3] = { 0,0,0 };
// Write the Field Data
err = H5Utilities::createGroupsFromPath(H5_FIELD_DATA_GROUP_NAME, dcGid);
if(err < 0)
{
std::cout << "Error creating HDF Group " << H5_FIELD_DATA_GROUP_NAME << std::endl;
return err;
}
err = H5Lite::writeStringAttribute(dcGid, H5_FIELD_DATA_GROUP_NAME, H5_NAME, H5_FIELD_DATA_DEFAULT);
if(err < 0)
{
return err;
}
hid_t fieldGroupId = H5Gopen(dcGid, H5_FIELD_DATA_GROUP_NAME, H5P_DEFAULT);
if(err < 0)
{
ss.str("");
ss << "Error opening field Group " << H5_FIELD_DATA_GROUP_NAME << std::endl;
setErrorCondition(-65);
notifyErrorMessage( ss.str(), err);
H5Gclose(dcGid); // Close the Data Container Group
return err;
}
size_t total = 0;
typedef std::vector<IDataArray*> VectorOfIDataArrays_t;
VectorOfIDataArrays_t neighborListArrays;
NameListType names = m->getFieldArrayNameList();
if (names.size() > 0)
{
IDataArray::Pointer array = m->getFieldData(names.front());
total = array->GetSize();
volDims[0] = total;
volDims[1] = 1;
volDims[2] = 1;
#if WRITE_FIELD_XDMF
ss.str("");
ss << "Field Data (" << total << ")";
writeFieldXdmfGridHeader(total, ss.str());
#endif
}
// Now loop over all the field data and write it out, possibly wrapping it with XDMF code also.
for (NameListType::iterator iter = names.begin(); iter != names.end(); ++iter)
{
IDataArray::Pointer array = m->getFieldData(*iter);
if (array->getTypeAsString().compare(NeighborList<int>::ClassName()) == 0)
{
neighborListArrays.push_back(array.get());
}
else if (NULL != array.get())
{
err = array->writeH5Data(fieldGroupId);
if(err < 0)
{
ss.str("");
ss << "Error writing field array '" << (*iter).c_str() << "' to the HDF5 File";
notifyErrorMessage( ss.str(), err);
setErrorCondition(err);
H5Gclose(fieldGroupId); // Close the Cell Group
H5Gclose(dcGid); // Close the Data Container Group
return err;
}
#if WRITE_FIELD_XDMF
array->writeXdmfAttribute( *m_XdmfPtr, volDims, hdfFileName, xdmfGroupPath, " (Field)");
#endif
}
}
#if WRITE_FIELD_XDMF
if (names.size() > 0)
{
writeXdmfGridFooter("Field Data");
}
#endif
// Write the NeighborLists onto their own grid
// We need to determine how many total elements we are going to end up with and group the arrays by
// those totals so we can minimize the number of grids
typedef std::map<size_t, VectorOfIDataArrays_t> SizeToIDataArrays_t;
SizeToIDataArrays_t sizeToDataArrays;
for(VectorOfIDataArrays_t::iterator iter = neighborListArrays.begin(); iter < neighborListArrays.end(); ++iter)
{
IDataArray* array = (*iter);
sizeToDataArrays[array->GetSize()].push_back(array);
}
// Now loop over each pair in the map creating a section in the XDMF and also writing the data to the HDF5 file
for(SizeToIDataArrays_t::iterator pair = sizeToDataArrays.begin(); pair != sizeToDataArrays.end(); ++pair)
{
total = (*pair).first;
VectorOfIDataArrays_t& arrays = (*pair).second;
volDims[0] = total;
volDims[1] = 1;
volDims[2] = 1;
#if WRITE_FIELD_XDMF
ss.str("");
ss << "Neighbor Data (" << total << ")";
writeFieldXdmfGridHeader(total, ss.str());
#endif
for(VectorOfIDataArrays_t::iterator iter = arrays.begin(); iter < arrays.end(); ++iter)
{
err = (*iter)->writeH5Data(fieldGroupId);
if(err < 0)
{
ss.str("");
ss << "Error writing neighbor list field array '" << (*iter)->GetName() << "' to the HDF5 File";
notifyErrorMessage( ss.str(), err);
setErrorCondition(err);
H5Gclose(fieldGroupId); // Close the Cell Group
H5Gclose(dcGid); // Close the Data Container Group
return err;
}
#if WRITE_FIELD_XDMF
(*iter)->writeXdmfAttribute( *m_XdmfPtr, volDims, hdfFileName, xdmfGroupPath, " (Neighbor Data)");
#endif
}
#if WRITE_FIELD_XDMF
writeXdmfGridFooter(ss.str());
#endif
}
H5Gclose(fieldGroupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FieldDataCSVWriter::execute()
{
int err = 0;
setErrorCondition(err);
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
std::string parentPath = MXAFileInfo::parentPath(m_FieldDataFile);
if(!MXADir::mkdir(parentPath, true))
{
std::stringstream ss;
ss << "Error creating parent path '" << parentPath << "'";
notifyErrorMessage(ss.str(), -1);
setErrorCondition(-1);
return;
}
std::string filename = getFieldDataFile();
std::ofstream outFile;
outFile.open(filename.c_str(), std::ios_base::binary);
char space = DREAM3D::GrainData::Delimiter;
// Write the total number of grains
outFile << m->getNumFieldTuples()-1 << std::endl;
// Get all the names of the arrays from the Data Container
std::list<std::string> headers = m->getFieldArrayNameList();
std::vector<IDataArray::Pointer> data;
//For checking if an array is a neighborlist
NeighborList<int>::Pointer neighborlistPtr = NeighborList<int>::New();
// Print the GrainIds Header before the rest of the headers
outFile << DREAM3D::GrainData::GrainID;
// Loop throught the list and print the rest of the headers, ignoring those we don't want
for(std::list<std::string>::iterator iter = headers.begin(); iter != headers.end(); ++iter)
{
// Only get the array if the name does NOT match those listed
IDataArray::Pointer p = m->getFieldData(*iter);
if(p->getNameOfClass().compare(neighborlistPtr->getNameOfClass()) != 0)
{
if (p->GetNumberOfComponents() == 1) {
outFile << space << (*iter);
}
else // There are more than a single component so we need to add multiple header values
{
for(int k = 0; k < p->GetNumberOfComponents(); ++k)
{
outFile << space << (*iter) << "_" << k;
}
}
// Get the IDataArray from the DataContainer
data.push_back(p);
}
}
outFile << std::endl;
// Get the number of tuples in the arrays
size_t numTuples = data[0]->GetNumberOfTuples();
std::stringstream ss;
float threshold = 0.0f;
// Skip the first grain
for(size_t i = 1; i < numTuples; ++i)
{
if (((float)i / numTuples) * 100.0f > threshold) {
ss.str("");
ss << "Writing Field Data - " << ((float)i / numTuples) * 100 << "% Complete";
notifyStatusMessage(ss.str());
threshold = threshold + 5.0f;
if (threshold < ((float)i / numTuples) * 100.0f) {
threshold = ((float)i / numTuples) * 100.0f;
}
}
// Print the grain id
outFile << i;
// Print a row of data
for( std::vector<IDataArray::Pointer>::iterator p = data.begin(); p != data.end(); ++p)
{
outFile << space;
(*p)->printTuple(outFile, i, space);
}
outFile << std::endl;
}
if(m_WriteNeighborListData == true)
{
// Print the GrainIds Header before the rest of the headers
// Loop throught the list and print the rest of the headers, ignoring those we don't want
for(std::list<std::string>::iterator iter = headers.begin(); iter != headers.end(); ++iter)
{
// Only get the array if the name does NOT match those listed
IDataArray::Pointer p = m->getFieldData(*iter);
if(p->getNameOfClass().compare(neighborlistPtr->getNameOfClass()) == 0)
{
outFile << DREAM3D::GrainData::GrainID << space << DREAM3D::GrainData::NumNeighbors << space << (*iter) << std::endl;
size_t numTuples = p->GetNumberOfTuples();
// float threshold = 0.0f;
// Skip the first grain
for(size_t i = 1; i < numTuples; ++i)
{
// Print the grain id
outFile << i;
// Print a row of data
outFile << space;
p->printTuple(outFile, i, space);
outFile << std::endl;
}
}
}
}
outFile.close();
// If there is an error set this to something negative and also set a message
notifyStatusMessage("FieldDataCSVWriter Completed");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindNeighbors::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
VoxelDataContainer* m = getVoxelDataContainer();
// Cell Data
GET_PREREQ_DATA( m, DREAM3D, CellData, GrainIds, ss, -300, int32_t, Int32ArrayType, voxels, 1)
CREATE_NON_PREREQ_DATA(m, DREAM3D, CellData, SurfaceVoxels, ss, int8_t, Int8ArrayType, 0, voxels, 1)
// Field Data
// Do this whole block FIRST otherwise the side effect is that a call to m->getNumFieldTuples will = 0
// because we are just creating an empty NeighborList object.
// Now we are going to get a "Pointer" to the NeighborList object out of the DataContainer
m_NeighborList = NeighborList<int>::SafeObjectDownCast<IDataArray*, NeighborList<int>* >
(m->getFieldData(m_NeighborListArrayName).get());
if(m_NeighborList == NULL)
{
NeighborList<int>::Pointer neighborlistPtr = NeighborList<int>::New();
neighborlistPtr->SetName(m_NeighborListArrayName);
neighborlistPtr->Resize(fields);
neighborlistPtr->setNumNeighborsArrayName(getNumNeighborsArrayName());
m->addFieldData(m_NeighborListArrayName, neighborlistPtr);
if (neighborlistPtr.get() == NULL) {
ss << "NeighborLists Array Not Initialized at Beginning of FindNeighbors Filter" << std::endl;
setErrorCondition(-308);
}
m_NeighborList = NeighborList<int>::SafeObjectDownCast<IDataArray*, NeighborList<int>* >
(m->getFieldData(m_NeighborListArrayName).get());
CreatedArrayHelpIndexEntry::Pointer e = CreatedArrayHelpIndexEntry::New();
e->setFilterName(this->getNameOfClass());
e->setFilterHumanLabel(this->getHumanLabel());
e->setFilterGroup(this->getGroupName());
e->setFilterSubGroup(this->getSubGroupName());
e->setArrayDefaultName(m_NeighborListArrayName);
e->setArrayGroup("Field");
e->setArrayNumComponents(0);
e->setArrayType("NeighborList");
addCreatedArrayHelpIndexEntry(e);
}
// And we do the same for the SharedSurfaceArea list
m_SharedSurfaceAreaList = NeighborList<float>::SafeObjectDownCast<IDataArray*, NeighborList<float>*>
(m->getFieldData(m_SharedSurfaceAreaListArrayName).get());
if(m_SharedSurfaceAreaList == NULL)
{
NeighborList<float>::Pointer sharedSurfaceAreaListPtr = NeighborList<float>::New();
sharedSurfaceAreaListPtr->SetName(m_SharedSurfaceAreaListArrayName);
sharedSurfaceAreaListPtr->Resize(fields);
sharedSurfaceAreaListPtr->setNumNeighborsArrayName(getNumNeighborsArrayName());
m->addFieldData(m_SharedSurfaceAreaListArrayName, sharedSurfaceAreaListPtr);
if (sharedSurfaceAreaListPtr.get() == NULL)
{
ss.str("");
ss << "SurfaceAreaLists Array Not Initialized correctly at Beginning of FindNeighbors Filter" << std::endl;
setErrorCondition(-308);
addErrorMessage(getHumanLabel(), ss.str(), -308);
}
m_SharedSurfaceAreaList = NeighborList<float>::SafeObjectDownCast<IDataArray*, NeighborList<float>*>
(m->getFieldData(m_SharedSurfaceAreaListArrayName).get());
CreatedArrayHelpIndexEntry::Pointer e = CreatedArrayHelpIndexEntry::New();
e->setFilterName(this->getNameOfClass());
e->setFilterHumanLabel(this->getHumanLabel());
e->setFilterGroup(this->getGroupName());
e->setFilterSubGroup(this->getSubGroupName());
e->setArrayDefaultName(m_SharedSurfaceAreaListArrayName);
e->setArrayGroup("Field");
e->setArrayNumComponents(0);
e->setArrayType("SurfaceAreaLists");
addCreatedArrayHelpIndexEntry(e);
}
CREATE_NON_PREREQ_DATA(m, DREAM3D, FieldData, SurfaceFields, ss, bool, BoolArrayType, false, fields, 1)
CREATE_NON_PREREQ_DATA(m, DREAM3D, FieldData, NumNeighbors, ss, int32_t, Int32ArrayType, 0, fields, 1)
}