def step(self, mcs): for cell in self.cell_list: if cell.type == 3: pt = CompuCell.Point3D() for x in range(9, 17): for y in range(9, 17): pt.x = x pt.y = y if int(self.boundary_array.get(pt)): print('pt=', pt, ' boundary=', int(self.boundary_array.get(pt))) if not self.pixel_assigned: pt = CompuCell.Point3D(12, 12, 0) self.cell_field.set(pt, self.medium_cell) self.pixel_assigned = True if mcs == 3: self.cell_field[12, 12, 0] = cell print('REASSIGNMNET COMPLETED') if mcs == 4: self.cell_field[12, 10, 0] = self.medium_cell if mcs == 5: self.cell_field[12, 11, 0] = self.medium_cell break
def __init__(self, inventory, *args): self.inventory = inventory self.types = CompuCell.vectorint() self.inventoryByType = CompuCell.mapLongCellGPtr() self.initTypeVec(args) self.inventory.initCellInventoryByMultiType(self.inventoryByType, self.types)
def copy_sbml_simulators(self, from_cell: object, to_cell: object, sbml_names: Union[list, None] = None, options: Union[dict, None] = None): """ Copies SBML solvers (with their states - effectively clones the solver) from one cell to another :param from_cell: source CellG cell :param to_cell: target CellG cell :param sbml_names: list of SBML model name whose solver are to be copied :param options: - deprecated - list of SBML solver options :return: None """ sbml_names = self.__default_mutable_type(sbml_names, []) options = self.__default_mutable_type(options, {}) sbml_names_to_copy = [] if not (len(sbml_names)): # if user does not specify _sbmlNames we copy all SBML networks try: dict_attrib = CompuCell.getPyAttrib(from_cell) sbml_dict = dict_attrib['SBMLSolver'] sbml_names_to_copy = list(sbml_dict.keys()) except LookupError as e: pass else: sbml_names_to_copy = sbml_names try: dict_attrib_from = CompuCell.getPyAttrib(from_cell) sbml_dict_from = dict_attrib_from['SBMLSolver'] except LookupError: return try: dict_attrib_to = CompuCell.getPyAttrib(to_cell) # sbml_dict_to = dict_attrib_to['SBMLSolver'] except LookupError: pass # if _toCell does not have SBMLSolver dictionary entry we simply add it # dict_attrib_to['SBMLSolver'] = {} # sbml_dict_to = dict_attrib_to['SBMLSolver'] for sbml_name in sbml_names_to_copy: rr_from = sbml_dict_from[sbml_name] current_state_sbml = sbml_dict_from[sbml_name].getCurrentSBML() self.add_sbml_to_cell( model_file=rr_from.path, # necessary to get deserialization working properly model_name=sbml_name, cell=to_cell, step_size=rr_from.stepSize, options=options, current_state_sbml=current_state_sbml )
def extra_init_simulation_objects(sim, simthread, init_using_restart_snapshot_enabled=False): """ Performs extra initializations. Also checks for validity of concentration field names (those defined in C++) :param sim: :param simthread: :param init_using_restart_snapshot_enabled: :return: """ # after all xml steppables and plugins have been loaded we call extraInit to complete initialization sim.extraInit() concentration_field_names = CompuCell.getConcentrationFieldNames(sim) for conc_field_name in concentration_field_names: validate_cc3d_entity_identifier( entity_identifier=conc_field_name, entity_type_label='Concentration Field Label') # passing output directory to simulator object sim.setOutputDirectory(CompuCellSetup.persistent_globals.output_directory) # simthread.preStartInit() # we skip calling start functions of steppables if restart is enabled and we are using restart # directory to restart simulation from a given MCS if not init_using_restart_snapshot_enabled: sim.start() if simthread is not None: # sends signal to player to prepare for the upcoming simulation simthread.postStartInit() # waits for player to complete initialization simthread.waitForPlayerTaskToFinish()
def step(self, mcs): if self.pixel_tracker_plugin is None: return # Test modification of field values outside of core routines mcs_change_rate = 10e3 if mcs % mcs_change_rate == 0: for cell in self.cell_list: new_val = random.random() for ptd in self.get_cell_pixel_list(cell): self.yes_fluc_comp[ptd.pixel.x, ptd.pixel.y, 0] = new_val self.no_fluc_comp[ptd.pixel.x, ptd.pixel.y, 0] = new_val # Without this call, modifications (other than by core routines) to a field with a solver using # FluctuationCompensator will likely cause numerical errors CompuCell.updateFluctuationCompensators()
def __init__(self, _cellList): self.inventory = _cellList.inventory self.invItr = CompuCell.compartmentinventoryPtrPyItr() self.invItr.initialize(self.inventory) self.invItr.setToBegin() self.compartmentList = None self.next = self.__next__
def delete_sbml_from_cell_ids(self, model_name: str, cell_ids: Union[None, list] = None) -> None: """ Deletes SBML model from cells whose ids match those stered int he _ids list :param model_name: model name :param cell_ids: list of cell ids :return: """ """ :param _modelName {str}: :param _ids {list}: :return: None """ cell_ids = self.__default_mutable_type(cell_ids, []) for cell_id in cell_ids: cell = self.inventory.attemptFetchingCellById(cell_id) if not cell: continue dict_attrib = CompuCell.getPyAttrib(cell) try: sbml_dict = dict_attrib['SBMLSolver'] del sbml_dict[model_name] except LookupError as e: pass
def __init__(self, _cellNeighborList): self.neighborTrackerAccessor = _cellNeighborList.neighborTrackerAccessor self.cell = _cellNeighborList.cell self.nsdItr = CompuCell.nsdSetPyItr() self.nTracker = self.neighborTrackerAccessor.get( self.cell.extraAttribPtr) self.nsdItr.initialize(self.nTracker.cellNeighbors) self.nsdItr.setToBegin()
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 __init__(self, _cellPixelList): self.pixelTrackerAccessor = _cellPixelList.pixelTrackerAccessor self.pixelTrackerPlugin = _cellPixelList.pixelTrackerPlugin self.cell = _cellPixelList.cell self.pixelItr = CompuCell.pixelSetPyItr() self.pixelTracker = self.pixelTrackerAccessor.get( self.cell.extraAttribPtr) self.pixelItr.initialize(self.pixelTracker.pixelSet) self.pixelItr.setToBegin()
def __init__(self, elasticity_data_list): self.elasticity_tracker_accessor = elasticity_data_list.elasticity_tracker_accessor self.cell = elasticity_data_list.cell self.elasticity_tracker_plugin = elasticity_data_list.elasticity_tracker_plugin self.elasticity_tracker = self.elasticity_tracker_accessor.get( self.cell.extraAttribPtr) self.elasticity_data_set_itr = CompuCell.elasticitySetPyItr() self.elasticity_data_set_itr.initialize( self.elasticity_tracker.elasticityNeighbors) self.elasticity_data_set_itr.setToBegin()
def step_sbml_model_cell(cell, sbml_model_name=vr_model_name): """ Steps SBML model for a cell :param cell: cell with a SBML model to step :param sbml_model_name: name of SBML model to step :return: None """ dict_attrib = CompuCell.getPyAttrib(cell) assert 'SBMLSolver' in dict_attrib dict_attrib['SBMLSolver'][sbml_model_name].timestep()
def __init__(self, plasticity_data_list): self.plasticityTrackerAccessor = plasticity_data_list.plasticityTrackerAccessor self.cell = plasticity_data_list.cell self.plasticity_tracker_plugin = plasticity_data_list.plasticity_tracker_plugin self.plasticityTracker = self.plasticityTrackerAccessor.get( self.cell.extraAttribPtr) self.plasticityDataSetItr = CompuCell.plasticitySetPyItr() self.plasticityDataSetItr.initialize( self.plasticityTracker.plasticityNeighbors) self.plasticityDataSetItr.setToBegin()
def __init__(self, _focalPointPlasticityDataList): self.focalPointPlasticityTrackerAccessor = _focalPointPlasticityDataList.focalPointPlasticityTrackerAccessor self.cell = _focalPointPlasticityDataList.cell self.focalPointPlasticityPlugin = _focalPointPlasticityDataList.focalPointPlasticityPlugin self.focalPointPlasticityTracker = self.focalPointPlasticityTrackerAccessor.get( self.cell.extraAttribPtr) self.focalPointPlasticityDataSetItr = CompuCell.focalPointPlasticitySetPyItr( ) self.focalPointPlasticityDataSetItr.initialize( self.focalPointPlasticityTracker.anchors) self.focalPointPlasticityDataSetItr.setToBegin()
def get_core_simulation_objects(): persistent_globals = CompuCellSetup.persistent_globals simulator = CompuCell.Simulator() simthread = None # todo 5 - fix logic regarding simthread initialization if persistent_globals.simthread is not None: simthread = persistent_globals.simthread simulator.setNewPlayerFlag(True) simulator.setBasePath( join(dirname(persistent_globals.simulation_file_name))) xml_fname = CompuCellSetup.cc3dSimulationDataHandler.cc3dSimulationData.xmlScript if persistent_globals.cc3d_xml_2_obj_converter is None: # We only call parseXML if previous steps do not initialize XML tree # Such situation usually happen when we specify XML tree using Python API in configure_simulation function # that is typically called from the Python main script cc3d_xml2_obj_converter = parseXML(xml_fname=xml_fname) # cc3d_xml2_obj_converter cannot be garbage colected hence goes to persisten storage # declared at the global level in CompuCellSetup persistent_globals.cc3d_xml_2_obj_converter = cc3d_xml2_obj_converter # locating all XML elements with attribute id - presumably to be used for programmatic steering persistent_globals.xml_id_locator = XMLIdLocator( root_elem=persistent_globals.cc3d_xml_2_obj_converter.root) persistent_globals.xml_id_locator.locate_id_elements() init_modules(simulator, persistent_globals.cc3d_xml_2_obj_converter) # # this loads all plugins/steppables - need to recode it to make loading on-demand only CompuCell.initializePlugins() simulator.initializeCC3D() # sim.extraInit() return simulator, simthread
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 delete_sbml_from_cell(self, model_name: str = '', cell: object = None) -> None: """ Deletes SBML from a particular cell :param model_name: model name :param cell: CellG cell obj :return: None """ dict_attrib = CompuCell.getPyAttrib(cell) try: sbml_dict = dict_attrib['SBMLSolver'] del sbml_dict[model_name] except LookupError: pass
def timestep_cell_sbml(self): """ advances (integrats forward) models stored as attributes of cells :return: None """ # time-stepping SBML attached to cells for cell in self.cellList: dict_attrib = CompuCell.getPyAttrib(cell) if 'SBMLSolver' in dict_attrib: sbml_dict = dict_attrib['SBMLSolver'] for model_name, rrTmp in sbml_dict.items(): # integrating SBML rrTmp.timestep()
def start(self): """ any code in the start function runs before MCS=0 """ # Generate plots for graphical reporting self.plot_win1 = self.add_new_plot_window( title='Total medium concentration', x_axis_title='Monte Carlo Step', y_axis_title='Total medium concentration', x_scale_type='linear', y_scale_type='linear', grid=True, config_options={'legend': True}) self.plot_win1.add_plot("ConcPTPMed", style='Dots', color='red', size=5) self.plot_win1.add_plot("ConcManMed", style='Dots', color='green', size=5) self.plot_win1.add_plot("ConcMan", style='Dots', color='blue', size=5) # Create plot window for Cell 1 volume and surface self.plot_win2 = self.add_new_plot_window( title='Total medium concentration errors', x_axis_title='Monte Carlo Step', y_axis_title='Errors', x_scale_type='linear', y_scale_type='linear', grid=True, config_options={'legend': True}) self.plot_win2.add_plot("ErrorConcPTPMed", style='Dots', color='red', size=5) self.plot_win2.add_plot("ErrorConcManMod", style='Dots', color='green', size=5) # Set all values to zero in cells f = CompuCell.getConcentrationField(self.simulator, "F1") for x, y, z in self.every_pixel(): if self.cell_field[x, y, z]: f[x, y, z] = 0.0
def set_step_size_for_cell(self, model_name: str = '', cell: object = None, step_size: float = 1.0): """ Sets integration step size for SBML model attached to _cell :param model_name: model name :param cell: CellG cell object :param step_size: integration step size :return: None """ dict_attrib = CompuCell.getPyAttrib(cell) try: sbmlSolver = dict_attrib['SBMLSolver'][model_name] except LookupError: return sbmlSolver.stepSize = step_size
def timestep_model(self, model_name: str): """ Integrate an ode model one step in time. :param model_name: name of the ode model :return: None """ if model_name not in self.model_names: raise ValueError('Model not registered:', model_name) o = self._ode_models[model_name] if o.cell_types is None: from cc3d.CompuCellSetup import persistent_globals as pg pg.free_floating_sbml_simulators[model_name].timestep() else: for cell in self.cell_list_by_type( *self.cell_types_by_model(model_name)): dict_attrib = CompuCell.getPyAttrib(cell) dict_attrib['SBMLSolver'][model_name].timestep()
def __init__(self, cell_pixel_list, neighbor_order=-1): self.boundary_pixel_tracker_accessor = cell_pixel_list.boundary_pixel_tracker_accessor self.boundary_pixel_tracker_plugin = cell_pixel_list.boundary_pixel_tracker_plugin self.cell = cell_pixel_list.cell self.boundary_pixel_itr = CompuCell.boundaryPixelSetPyItr() self.boundary_pixel_tracker = self.boundary_pixel_tracker_accessor.get( self.cell.extraAttribPtr) if neighbor_order <= 0: self.pixelSet = self.boundary_pixel_tracker.pixelSet else: self.pixelSet = self.boundary_pixel_tracker_plugin.getPixelSetForNeighborOrderPtr( self.cell, neighbor_order) if not self.pixelSet: raise LookupError( 'LookupError: CellBoundaryPixelIterator could not locate pixel set ' 'for neighbor order = %s. Make sure your BoundaryPixelTracker plugin definition ' 'requests tracking of neighbor order =%s boundary' % (neighbor_order, neighbor_order)) # self.boundaryPixelItr.initialize(self.boundaryPixelTracker.pixelSet) self.boundary_pixel_itr.initialize(self.pixelSet) self.boundary_pixel_itr.setToBegin()
def get_sbml_simulator(self, model_name: str, cell: object = None) -> Union[object, None]: """ Returns a reference to RoadRunnerPy or None :param model_name: model name :param cell: CellG cell object :return {instance of RoadRunnerPy} or {None}: """ pg = CompuCellSetup.persistent_globals if not cell: try: return pg.free_floating_sbml_simulators[model_name] except LookupError: return None else: try: dict_attrib = CompuCell.getPyAttrib(cell) return dict_attrib['SBMLSolver'][model_name] except LookupError: return None
def delete_sbml_from_cell_types(self, model_name: str, cell_types: Union[None, list] = None) -> None: """ Deletes SBML model from cells whose type match those stered in the cell_types list :param model_name: model name :param cell_types: list of cell cell types :return: """ """ :param _modelName {str}: :param types: :return: None """ cell_types = self.__default_mutable_type(cell_types, []) for cell in self.cellListByType(*cell_types): dict_attrib = CompuCell.getPyAttrib(cell) try: sbml_dict = dict_attrib['SBMLSolver'] del sbml_dict[model_name] except LookupError: pass
def step(self, mcs): """ type here the code that will run every frequency MCS :param mcs: current Monte Carlo step """ pt_1 = [10, 11, 4] pt_2 = [11, 15, 2] pt_hex_1 = self.cartesian_2_hex(pt_1) pt_1_cart = self.hex_2_cartesian(pt_hex_1) print('pt_1=', pt_1, ' pt_hex_1=', pt_hex_1, ' pt_1_cart=', pt_1_cart) pt_hex_2 = self.cartesian_2_hex(pt_2) pt_2_cart = self.hex_2_cartesian(pt_hex_2) print('pt_2=', pt_2, ' pt_hex_1=', pt_hex_2, ' pt_1_cart=', pt_2_cart) pt = CompuCell.Point3D(10, 12, 2) pt_np = self.point_3d_to_numpy(pt) print('pt=', pt, ' pt_np=', pt_np) pt_np = [12, 23, 32] pt = self.numpy_to_point_3d(pt_np) print('pt=', pt, ' pt_np=', pt_np) cell_1 = self.cell_field[30, 30, 0] cell_2 = self.cell_field[50, 50, 0] cells_different_flag = self.are_cells_different(cell1=cell_1, cell2=cell_2) print('cell_1=', cell_1, ' cell_2=', cell_2, ' cells_different_flag=', cells_different_flag) print('self.simulator.getNumSteps() = ', self.simulator.getNumSteps())
def init_fpp_links_actors(self, actor_specs, drawing_params=None): """ initializes fpp links actors :param actor_specs: :param drawing_params: :return: None """ fppPlugin = CompuCell.getFocalPointPlasticityPlugin() # if (fppPlugin == 0): # bogus check if not fppPlugin: # bogus check print(' fppPlugin is null, returning') return actors_dict = actor_specs.actors_dict field_dim = self.currentDrawingParameters.bsd.fieldDim scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) xdim = field_dim.x ydim = field_dim.y try: cellField = self.currentDrawingParameters.bsd.sim.getPotts( ).getCellFieldG() inventory = self.currentDrawingParameters.bsd.sim.getPotts( ).getCellInventory() except AttributeError: raise AttributeError('Could not access Potts object') cellList = CellList(inventory) points = vtk.vtkPoints() lines = vtk.vtkCellArray() beginPt = 0 lineNum = 0 for cell in cellList: vol = cell.volume if vol < self.eps: continue xmid0 = cell.xCOM ymid0 = cell.yCOM zmid0 = cell.zCOM points.InsertNextPoint(xmid0, ymid0, zmid0) endPt = beginPt + 1 for fppd in InternalFocalPointPlasticityDataList(fppPlugin, cell): xmid = fppd.neighborAddress.xCOM ymid = fppd.neighborAddress.yCOM zmid = fppd.neighborAddress.zCOM xdiff = xmid - xmid0 ydiff = ymid - ymid0 zdiff = zmid - zmid0 actualDist = math.sqrt(xdiff**2 + ydiff**2 + zdiff**2) if actualDist > fppd.maxDistance: # implies we have wraparound (via periodic BCs) # we are not drawing those links that wrap around the lattice - leaving the code for now # todo - most likely will redo this part later continue # add dangling "out" line to beginning cell if abs(xdiff) > abs(ydiff): # wraps around in x-direction if xdiff < 0: xmid0end = xmid0 + self.stubSize else: xmid0end = xmid0 - self.stubSize ymid0end = ymid0 points.InsertNextPoint(xmid0end, ymid0end, 0) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) actualDist = xdim - actualDist # compute (approximate) real actualDist lineNum += 1 endPt += 1 else: # wraps around in y-direction xmid0end = xmid0 if ydiff < 0: ymid0end = ymid0 + self.stubSize else: ymid0end = ymid0 - self.stubSize points.InsertNextPoint(xmid0end, ymid0end, 0) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) actualDist = ydim - actualDist # compute (approximate) real actualDist lineNum += 1 endPt += 1 # link didn't wrap around on lattice else: points.InsertNextPoint(xmid, ymid, zmid) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) lineNum += 1 endPt += 1 for fppd in FocalPointPlasticityDataList(fppPlugin, cell): xmid = fppd.neighborAddress.xCOM ymid = fppd.neighborAddress.yCOM zmid = fppd.neighborAddress.zCOM xdiff = xmid - xmid0 ydiff = ymid - ymid0 zdiff = ymid - zmid0 actualDist = math.sqrt(xdiff**2 + ydiff**2 + zdiff**2) if actualDist > fppd.maxDistance: # implies we have wraparound (via periodic BCs) # we are not drawing those links that wrap around the lattice - leaving the code for now # todo - most likely will redo this part later continue # add dangling "out" line to beginning cell if abs(xdiff) > abs(ydiff): # wraps around in x-direction # print '>>>>>> wraparound X' if xdiff < 0: xmid0end = xmid0 + self.stubSize else: xmid0end = xmid0 - self.stubSize ymid0end = ymid0 points.InsertNextPoint(xmid0end, ymid0end, 0) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) # coloring the FPP links actualDist = xdim - actualDist # compute (approximate) real actualDist lineNum += 1 endPt += 1 else: # wraps around in y-direction xmid0end = xmid0 if ydiff < 0: ymid0end = ymid0 + self.stubSize else: ymid0end = ymid0 - self.stubSize points.InsertNextPoint(xmid0end, ymid0end, 0) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) # coloring the FPP links actualDist = ydim - actualDist # compute (approximate) real actualDist lineNum += 1 endPt += 1 # link didn't wrap around on lattice else: points.InsertNextPoint(xmid, ymid, zmid) lines.InsertNextCell(2) # our line has 2 points lines.InsertCellPoint(beginPt) lines.InsertCellPoint(endPt) lineNum += 1 endPt += 1 beginPt = endPt # update point index # ----------------------- if lineNum == 0: return FPPLinksPD = vtk.vtkPolyData() FPPLinksPD.SetPoints(points) FPPLinksPD.SetLines(lines) fpp_links_actor = actors_dict['fpp_links_actor'] if VTK_MAJOR_VERSION >= 6: self.FPPLinksMapper.SetInputData(FPPLinksPD) else: FPPLinksPD.Update() self.FPPLinksMapper.SetInput(FPPLinksPD) fpp_links_actor.SetMapper(self.FPPLinksMapper) fpp_links_color = to_vtk_rgb( mdata.get('FPPLinksColor', data_type='color')) # coloring borders fpp_links_actor.GetProperty().SetColor(*fpp_links_color)
def start(self): self.yes_fluc_comp = CompuCell.getConcentrationField( self.simulator, "YesFlucComp") self.no_fluc_comp = CompuCell.getConcentrationField( self.simulator, "NoFlucComp")
def start(self): # initial condition for diffusion field field = CompuCell.getConcentrationField(self.simulator, "FGF") field[26:28, 26:28, 0:5] = 2000.0
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)