def read_simulation_data_non_blocking(self, file_number: int) -> bool:
"""
reads content of the serialized file
:param file_number: {int}
:return: {bool} flag whether read was successful or not
"""
# this flag is used to prevent calling draw function
self.newFileBeingLoaded = True
# when new data is read from hard drive
if file_number >= len(self.ldsFileList):
return False
fileName = self.ldsFileList[file_number]
self.simulationDataReader = vtk.vtkStructuredPointsReader()
self.currentFileName = os.path.join(self.ldsDir, fileName)
print('self.currentFileName=', self.currentFileName)
extracted_mcs = self.extract_mcs_number_from_file_name(
file_name=self.currentFileName)
if extracted_mcs < 0:
extracted_mcs = file_number
self.simulationDataReader.SetFileName(self.currentFileName)
# print "path= ", os.path.join(self.ldsDir,fileName)
data_reader_int_addr = extract_address_int_from_vtk_object(
vtkObj=self.simulationDataReader)
# swig wrapper on top of vtkStructuredPointsReader.Update() - releases GIL,
# hence can be used in multithreaded program that does not block GUI
self.__ui.fieldExtractor.readVtkStructuredPointsData(
data_reader_int_addr)
# # # self.simulationDataReader.Update() # does not erlease GIL - VTK ISSUE -
# cannot be used in multithreaded program - blocks GUI
self.simulationData = self.simulationDataReader.GetOutput()
self.fieldDimPrevious = self.fieldDim
# self.fieldDimPrevious=CompuCell.Dim3D()
dim_from_vtk = self.simulationData.GetDimensions()
self.fieldDim = CompuCell.Dim3D(dim_from_vtk[0], dim_from_vtk[1],
dim_from_vtk[2])
self.currentStep = extracted_mcs
# # # self.currentStep = self.frequency * _i # this is how we set CMS for CML reading before
self.setCurrentStep(self.currentStep)
self.newFileBeingLoaded = False
return True
def extract_lattice_dim_from_file_name(_lds_file) -> Dim3D:
"""
Extract field dimensions from the xml that summarizes serialized simulation files
:param _lds_file:{str} xml metadata file name
:return: {Dim3D} field dimensions
"""
lds_xml = _LatticeDataXMLReader(_lds_file)
field_dim = CompuCell.Dim3D()
field_dim.x = int(lds_xml.dim_element.getAttribute("x"))
field_dim.y = int(lds_xml.dim_element.getAttribute("y"))
field_dim.z = int(lds_xml.dim_element.getAttribute("z"))
return field_dim
def read_simulation_data(self, file_number: int) -> (bool, int):
"""
reads content of the serialized file
:param file_number: {int}
:return: {(bool, int)} flag whether read was successful or not, extracted mcs
"""
# By this point, either field extractor is set, or parent has cml field extractor
if self.field_extractor is None:
assert hasattr(self._parent, 'fieldExtractor') or hasattr(self._parent, 'field_extractor')
if hasattr(self._parent, 'field_extractor'):
_a = 'field_extractor'
else:
_a = 'fieldExtractor'
self.field_extractor = getattr(self._parent, _a)
assert isinstance(self.field_extractor, PlayerPython.FieldExtractorCML)
# when new data is read from hard drive
if file_number >= len(self.ldsFileList):
return False, -1
fileName = self.ldsFileList[file_number]
self.simulationDataReader = vtk.vtkStructuredPointsReader()
self.currentFileName = os.path.join(self.ldsDir, fileName)
print('self.currentFileName=', self.currentFileName)
extracted_mcs = self.extract_mcs_number_from_file_name(file_name=self.currentFileName)
if extracted_mcs < 0:
extracted_mcs = file_number
self.simulationDataReader.SetFileName(self.currentFileName)
data_reader_int_addr = extract_address_int_from_vtk_object(vtkObj=self.simulationDataReader)
# swig wrapper on top of vtkStructuredPointsReader.Update() - releases GIL,
# hence can be used in multithreaded program that does not block GUI
self.field_extractor.readVtkStructuredPointsData(data_reader_int_addr)
# # # self.simulationDataReader.Update() # does not erlease GIL - VTK ISSUE -
# limited use in multithreaded program - blocks GUI
self.simulationData = self.simulationDataReader.GetOutput()
self.fieldDimPrevious = self.fieldDim
dim_from_vtk = self.simulationData.GetDimensions()
self.fieldDim = CompuCell.Dim3D(dim_from_vtk[0], dim_from_vtk[1], dim_from_vtk[2])
return True, extracted_mcs
def extract_lattice_description_info(self, file_name: str) -> None:
"""
Reads the xml that summarizes serialized simulation files
:param file_name:{str} xml metadata file name
:return: None
"""
# lattice data simulation file
lds_file = os.path.abspath(file_name)
self.ldsDir = os.path.dirname(lds_file)
xml2_obj_converter = XMLUtils.Xml2Obj()
root_element = xml2_obj_converter.Parse(lds_file)
dim_element = root_element.getFirstElement("Dimensions")
self.fieldDim = CompuCell.Dim3D()
self.fieldDim.x = int(dim_element.getAttribute("x"))
self.fieldDim.y = int(dim_element.getAttribute("y"))
self.fieldDim.z = int(dim_element.getAttribute("z"))
output_element = root_element.getFirstElement("Output")
self.ldsCoreFileName = output_element.getAttribute("CoreFileName")
self.frequency = int(output_element.getAttribute("Frequency"))
self.numberOfSteps = int(output_element.getAttribute("NumberOfSteps"))
# obtaining list of files in the ldsDir
lattice_element = root_element.getFirstElement("Lattice")
self.latticeType = lattice_element.getAttribute("Type")
# getting information about cell type names and cell ids.
# It is necessary during generation of the PIF files from VTK output
cell_types_elements = root_element.getElements("CellType")
list_cell_type_elements = CC3DXMLListPy(cell_types_elements)
for cell_type_element in list_cell_type_elements:
type_name = cell_type_element.getAttribute("TypeName")
type_id = cell_type_element.getAttributeAsInt("TypeId")
self.typeIdTypeNameDict[type_id] = type_name
# now will convert python dictionary into C++ map<int, string>
self.typeIdTypeNameCppMap = CC3DXML.MapIntStr()
for type_id in list(self.typeIdTypeNameDict.keys()):
self.typeIdTypeNameCppMap[int(
type_id)] = self.typeIdTypeNameDict[type_id]
lds_file_list = os.listdir(self.ldsDir)
for fName in lds_file_list:
if re.match(".*\.vtk$", fName):
self.ldsFileList.append(fName)
self.ldsFileList.sort()
# extracting information about fields in the lds file
fields_element = root_element.getFirstElement("Fields")
if fields_element:
field_list = XMLUtils.CC3DXMLListPy(
fields_element.getElements("Field"))
for field_elem in field_list:
field_name = field_elem.getAttribute("Name")
self.fieldsUsed[field_elem.getAttribute(
"Name")] = field_elem.getAttribute("Type")
if field_elem.findAttribute(
"Script"): # True or False if present
# ToDo: if a "CustomVis" Type was provided,
# require that a "Script" was also provided; else warn user
custom_vis_script = field_elem.getAttribute("Script")
self.customVis = CompuCellSetup.createCustomVisPy(
field_name)
self.customVis.registerVisCallbackFunction(
CompuCellSetup.vtkScriptCallback)
self.customVis.addActor(field_name, "vtkActor")
# we'll piggyback off the actorsDict
self.customVis.addActor("customVTKScript",
custom_vis_script)
