def step(self,mcs):
## count down through initial phase offset for each GZ cell
cells_to_grow=[] # list of cells to evaluate for growth
if mcs <= self.T_double:
for cell in self.cellList:
if cell.type==3: # GZ cells
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["phaseCountdown"]==0: # if cell has reached or surpassed its initial phase offset
cells_to_grow.append(cell) # add cell to list of cells to evaluate for growth
else:
cellDict["phaseCountdown"]-=1 # count down phase offset
else:
for cell in self.cellList:
if cell.type==3: # GZ cells
cells_to_grow.append(cell)
## Grow each cell that meets criteria for growth by increasing target volume and surface parameters:
count=0
if self.pixPerMCS:
for cell in cells_to_grow:
cell.targetVolume+=self.pixPerMCS
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
count+=1
else:
count_timer=0
for cell in cells_to_grow:
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["growth_timer"] < self.mcsPerPix: # if cell has not reached time to grow
cellDict["growth_timer"] += 1 # add to growth timer
count_timer+=1
else: # if cell has reached time to grow, increase target volume and surface
cell.targetVolume+=1
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
cellDict["growth_timer"] = 0
count+=1
def updateAttributes(self):
# self.mitosisSteppable holds important dat from the mitosis
parentCell = self.mitosisSteppable.parentCell
childCell = self.mitosisSteppable.childCell
parentCell.targetVolume/=2.0
#child inherits parent properties
childCell.targetVolume = parentCell.targetVolume
childCell.lambdaVolume = parentCell.lambdaVolume
# randomly select one of the cells to be a different type
if random()<0.5:
childCell.type = parentCell.type
else:
childCell.type = self.DIFFERENTIATEDCONDENSING
# get parent cell lists
parentDict = CompuCell.getPyAttrib(parentCell)
childDict = CompuCell.getPyAttrib(childCell)
mcs=self.simulator.getStep()
data = MitosisData(mcs, parentCell.id, parentCell.type, childCell.id, childCell.type)
childDict['relatives'] = [data]
parentDict['relatives'].append(data)
def updateAttributes(self):
'''
UpdateAttributes is inherited from MitosisSteppableBase
and is called automatically by the divideCell() function.
It sets the attributes of the parent and daughter cells
'''
parent_cell = self.mitosisSteppable.parentCell
child_cell = self.mitosisSteppable.childCell
child_cell.targetVolume = child_cell.volume
child_cell.lambdaVolume = parent_cell.lambdaVolume
child_cell.targetSurface = child_cell.surface
child_cell.lambdaSurface = parent_cell.lambdaSurface
parent_cell.targetVolume = parent_cell.volume
parent_cell.targetSurface = parent_cell.surface
child_cell.type = parent_cell.type
parent_dict = CompuCell.getPyAttrib(parent_cell)
child_dict = CompuCell.getPyAttrib(child_cell)
parent_dict.get('mitosis_times',[]).append(self.mcs - parent_dict.get('last_division_mcs',self.mcs))
parent_dict['last_division_mcs'] = self.mcs
# Make a copy of the parent cell's dictionary and attach to child cell
for key, item in parent_dict.iteritems():
child_dict[key] = deepcopy(item)
child_dict['mitosis_times'] = []
def step(self,mcs):
## find y-position of poster-most GZ cell and center of growth zone
y_post=0
x_min=999
x_max=0
for cell in self.cellList:
if cell.type==3: # GZ cell
yCM=cell.yCM/float(cell.volume)
xCM=cell.xCM/float(cell.volume)
if yCM>y_post:
y_post=yCM
if xCM>x_max:
x_max=xCM
elif xCM<x_min:
x_min=xCM
x_center=x_min + (x_max-x_min)/2.
## count down through initial phase offset for each GZ cell and evaluate for y-position
cells_to_grow=[] # list of cells to evaluate for growth
if mcs <= self.T_double:
for cell in self.cellList:
if cell.type==3: # GZ cells
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["phaseCountdown"]==0: # if cell has reached or surpassed its initial phase offset
yCM = cell.yCM/float(cell.volume)
xCM = cell.xCM/float(cell.volume)
d = sqrt((xCM - x_center)**2 + (yCM - y_post)**2)
if d < self.d_sig:
cells_to_grow.append(cell) # add cell to list of cells to evaluate for growth
else:
cellDict["phaseCountdown"]-=1 # count down phase offset
else:
for cell in self.cellList:
if cell.type==3: # GZ cells
yCM=cell.yCM/float(cell.volume)
xCM=cell.xCM/float(cell.volume)
d = sqrt((xCM - x_center)**2 + (yCM - y_post)**2)
if d < self.d_sig:
cells_to_grow.append(cell)
## Grow each cell that meets criteria for growth by increasing target volume and surface parameters:
count=0
if self.pixPerMCS:
for cell in cells_to_grow:
cell.targetVolume+=self.pixPerMCS
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
count+=1
else:
count_timer=0
for cell in cells_to_grow:
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["growth_timer"] < self.mcsPerPix: # if cell has not reached time to grow
cellDict["growth_timer"] += 1 # add to growth timer
count_timer+=1
else: # if cell has reached time to grow, increase target volume and surface
cell.targetVolume+=1
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
cellDict["growth_timer"] = 0
count+=1
def updateAttributes(self):
self.parentCell.targetVolume /= 2.0 # reducing parent target volume
self.cloneParent2Child()
parentARF = CompuCell.getPyAttrib(self.parentCell)["ARF"]
childDict = CompuCell.getPyAttrib(self.childCell)
childDict["ARF"] = parentARF + ((random.gauss(0.5, 0.17) - 0.5) * 0.1
) # child cell slightly mutates ARF
if childDict["ARF"] >= 0.8:
self.childCell.type = self.RESISTENTBACTERIA
else:
self.childCell.type = self.REGULARBACTERIA
def updateAttributes(self):
parentCell=self.mitosisSteppable.parentCell
childCell=self.mitosisSteppable.childCell
childCell.type=parentCell.type
...
bionetAPI.copyBionetworkFromParent(parentCell,childCell)
...
parentCellDict=CompuCell.getPyAttrib(parentCell)
childCellDict=CompuCell.getPyAttrib(childCell)
for key in parentCellDict:
if (key!="Bionetwork"):
childCellDict[key] = deepcopy(parentCellDict[key])
def updateAttributes(self):
childCell = self.mitosisSteppable.childCell
parentCell = self.mitosisSteppable.parentCell
childCell.type = parentCell.type
parentCell.targetVolume = tVol
childCell.targetVolume = tVol
childCell.lambdaVolume = parentCell.lambdaVolume;
# inherite properties from parent cells
self.copySBMLs(_fromCell=parentCell,_toCell=childCell)
childCellDict=CompuCell.getPyAttrib(childCell)
parentCellDict=CompuCell.getPyAttrib(parentCell)
childCellDict["D"]=random.uniform(0.9,1.0)*parentCellDict["D"]
childCellDict["N"]=random.uniform(0.9,1.0)*parentCellDict["N"]
childCellDict["B"]=random.uniform(0.9,1.0)*parentCellDict["B"]
childCellDict["R"]=random.uniform(0.9,1.0)*parentCellDict["R"]
def step(self, mcs):
#collagen degradation
clCell = self.potts.createCell()
clCell.type = self.C_LYSED
llCell = self.potts.createCell()
llCell.type = self.L_LYSED
state = {}
self.fieldNameMMP = 'MMP'
self.fieldNameI = 'I'
fieldMMP = CompuCell.getConcentrationField(self.simulator,
self.fieldNameMMP)
fieldI = CompuCell.getConcentrationField(self.simulator,
self.fieldNameI)
global var
lysed_id = []
for cell in self.cellList:
state = {}
cellDict = CompuCell.getPyAttrib(cell)
if cell.type == self.C1 or cell.type == self.LAMININ or cell.type == self.NC1:
MMPc = fieldMMP[cell.xCOM, cell.yCOM, cell.zCOM]
Ic = fieldI[cell.xCOM, cell.yCOM, cell.zCOM]
if Ic > 0.0005:
T1 = (MMPc / Ic)
if T1 >= var:
cell.type = self.C_LYSED
lysed_id.append(cell)
for cell in lysed_id:
cellDict = CompuCell.getPyAttrib(cell)
if hasattr(cell, "mcsL") == True:
cell.targetvolume -= 0.005
cell.lambdaVolume = 20.0
else:
cellDict = CompuCell.getPyAttrib(cell)
mcs = self.simulator.getStep()
mcsL = mcs
cellDict["mcsL"] = mcsL
mcs = self.simulator.getStep()
for cell in self.cellList:
cellDict = CompuCell.getPyAttrib(cell)
if cell.type == self.C_LYSED:
for val in cellDict.items():
cd1 = val[1]
if cell.type == self.C_LYSED and mcs == (cd1 + 20):
cell.type = self.NC1
def start(self):
for cell in self.cellList:
vasculo_attributes=CompuCell.getPyAttrib(cell)
if cell.type==1:
vasculo_attributes['cell.receptor.VEGFR1']=100
vasculo_attributes['cell.receptor.VEGFR2']=1000
def step(self,mcs):
for cell in self.cellList:
mitDataList=CompuCell.getPyAttrib(cell)
if len(mitDataList) > 0:
print "MITOSIS DATA FOR CELL ID",cell.id
for mitData in mitDataList:
print mitData
def start(self):
#Loading model
Name = 'DeltaNotch'
Key = 'DN'
simulationDir=os.path.dirname (os.path.abspath( __file__ ))
Path= os.path.join(simulationDir,'DN_Collier.sbml')
Path=os.path.abspath(Path) # normalizing path
IntegrationStep = 0.2
bionetAPI.loadSBMLModel(Name, Path, Key, IntegrationStep)
bionetAPI.addSBMLModelToTemplateLibrary(Name,'TypeA')
bionetAPI.initializeBionetworks()
#Initial conditions
import random
state={} #dictionary to store state veriables of the SBML model
for cell in self.cellList:
if (cell):
state['D'] = random.uniform(0.9,1.0)
state['N'] = random.uniform(0.9,1.0)
bionetAPI.setBionetworkState(cell.id,'DeltaNotch',state)
cellDict=CompuCell.getPyAttrib(cell)
cellDict['D']=state['D']
cellDict['N']=state['N']
def step(self, mcs):
# ######### Update all bionetwork integrator(s) ###########
bionetAPI.timestepBionetworks()
bionetAPI.printBionetworkState(1)
# ######## Implement cell growth by increasing target volume ##########
for cell in self.cellList:
dictionaryAttrib = CompuCell.getPyAttrib( cell )
cell.targetVolume = cell.volume + 0.1*dictionaryAttrib["InitialVolume"]
# ###### Retrieve delta values and set cell bionetwork template libraries according to delta concentration ########
for cell in self.cellList:
currentDelta = bionetAPI.getBionetworkValue( "DN_di", cell.id )
if( currentDelta > 0.5 ):
if self.cellTypeMap[cell.type] == "LowDelta":
bionetAPI.setBionetworkValue( "TemplateLibrary", "HighDelta", cell.id )
else:
if self.cellTypeMap[cell.type] == "HighDelta":
bionetAPI.setBionetworkValue( "TemplateLibrary", "LowDelta", cell.id )
# ####### Set all cell dbari values as a function of neighbor delta values #########
for cell in self.cellList:
weightedSumOfNeighborDeltaValues = 0.0
neighborContactAreas = bionetAPI.getNeighborContactAreas( cell.id )
neighborDeltaValues = bionetAPI.getNeighborProperty( "DN_di", cell.id )
for neighborID in neighborContactAreas.keys():
weightedSumOfNeighborDeltaValues += (neighborContactAreas[neighborID] * neighborDeltaValues[neighborID])
bionetAPI.setBionetworkValue( "DN_dbari", weightedSumOfNeighborDeltaValues/cell.surface, cell.id )
def mitosis_visualization_countdown(self):
for cell in self.cellListByType(4): # Mitosis cell
cellDict = CompuCell.getPyAttrib(cell)
if cellDict['mitosisVisualizationTimer'] <= 0:
cell.type = cellDict['returnToCellType']
else:
cellDict['mitosisVisualizationTimer'] -= 1
def finish(self):
for cell in self.cellList:
dataList = CompuCell.getPyAttrib(cell)
if len(dataList['relatives'])>0:
print "MITOTIC DATA FOR CELL ID:",cell.id
for data in dataList['relatives']:
print data
def step(self,mcs):
## find y-position of poster-most segment boundary, y_border
y_border=0
for cell in self.cellList:
if cell.type==2: # segment 2 cell--most posterior segment
yCM=cell.yCM/float(cell.volume)
if yCM>y_border:
y_border=yCM
## count down through initial phase offset for each GZ cell and evaluate for y-position
cells_to_grow=[] # list of cells to evaluate for growth
if mcs <= self.T_double:
for cell in self.cellList:
if cell.type==3: # GZ cells
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["phaseCountdown"]==0: # if cell has reached or surpassed its initial phase offset
yCM = cell.yCM/float(cell.volume)
if yCM > y_border + self.y_sig:
cells_to_grow.append(cell) # add cell to list of cells to evaluate for growth
else:
cellDict["phaseCountdown"]-=1 # count down phase offset
else:
for cell in self.cellList:
if cell.type==3: # GZ cells
yCM=cell.yCM/float(cell.volume)
if yCM > y_border + self.y_sig:
cells_to_grow.append(cell)
## Grow each cell that meets criteria for growth by increasing target volume and surface parameters:
count=0
if self.pixPerMCS:
for cell in cells_to_grow:
cell.targetVolume+=self.pixPerMCS
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
count+=1
else:
count_timer=0
for cell in cells_to_grow:
cellDict=CompuCell.getPyAttrib(cell)
if cellDict["growth_timer"] < self.mcsPerPix: # if cell has not reached time to grow
cellDict["growth_timer"] += 1 # add to growth timer
count_timer+=1
else: # if cell has reached time to grow, increase target volume and surface
cell.targetVolume+=1
cell.targetSurface=int(4*sqrt(cell.volume)+0.5)
cellDict["growth_timer"] = 0
count+=1
def find_GB_division_count(self):
division_count = 0
for cell in self.cellList:
if cell:
cellDict = CompuCell.getPyAttrib(cell)
division_count += cellDict['divided']
cellDict['divided'] = 0
return division_count
def updateAttributes(self):
parentCell=self.mitosisSteppable.parentCell
childCell=self.mitosisSteppable.childCell
childCell.targetVolume = childCell.volume
childCell.lambdaVolume = parentCell.lambdaVolume
childCell.targetSurface = childCell.surface
childCell.lambdaSurface = parentCell.lambdaSurface
parentCell.targetVolume = parentCell.volume
parentCell.targetSurface = parentCell.surface
childCell.type = parentCell.type
parentDict=CompuCell.getPyAttrib(parentCell)
childDict=CompuCell.getPyAttrib(childCell)
### Make a copy of the parent cell's dictionary and attach to child cell
for key, item in parentDict.items():
childDict[key]=deepcopy(parentDict[key])
def setStepSizeForCell(self, _modelName='', _cell=None, _stepSize=1.0):
import CompuCell
dict_attrib = CompuCell.getPyAttrib(_cell)
try:
sbmlSolver = dict_attrib['SBMLSolver'][_modelName]
except LookupError, e:
return
def mitosisVisualizationCountdown(self):
for cell in self.cellList:
if cell.type == 4: # if Mitosis cell
cellDict = CompuCell.getPyAttrib(cell)
if cellDict['mitosisVisualizationTimer'] <= 0:
cell.type = cellDict['returnToCellType']
else:
cellDict['mitosisVisualizationTimer'] -= 1
def deleteSBMLFromCell(self, _modelName='', _cell=None):
import CompuCell
dict_attrib = CompuCell.getPyAttrib(_cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def updateAttributes(self):
parentCell = self.mitosisSteppable.parentCell
childCell = self.mitosisSteppable.childCell
childCell.targetVolume = childCell.volume
childCell.lambdaVolume = parentCell.lambdaVolume
childCell.targetSurface = childCell.surface
childCell.lambdaSurface = parentCell.lambdaSurface
parentCell.targetVolume = parentCell.volume
parentCell.targetSurface = parentCell.surface
childCell.type = parentCell.type
parentDict = CompuCell.getPyAttrib(parentCell)
childDict = CompuCell.getPyAttrib(childCell)
### Make a copy of the parent cell's dictionary and attach to child cell
for key, item in parentDict.items():
childDict[key] = deepcopy(parentDict[key])
def step(self,mcs):
self.scalarFieldG.clear()
for cell in self.cellList:
if cell:
cellDict=CompuCell.getPyAttrib(cell)
self.scalarFieldG[cell] = cellDict['GTPase']
def setStepSizeForCell(self, _modelName='',_cell=None,_stepSize=1.0):
import CompuCell
dict_attrib = CompuCell.getPyAttrib(_cell)
try:
sbmlSolver=dict_attrib['SBMLSolver'][_modelName]
except LookupError,e:
return
def step(self, mcs):
self.scalarFieldG.clear()
for cell in self.cellList:
if cell:
cellDict = CompuCell.getPyAttrib(cell)
self.scalarFieldG[cell] = cellDict['GTPase']
def deleteSBMLFromCell(self,_modelName='',_cell=None):
import CompuCell
dict_attrib=CompuCell.getPyAttrib(_cell)
try:
sbmlDict=dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError,e:
pass
def deleteSBMLFromCellTypes(self, _modelName, _types=[]):
import CompuCell
for cell in self.cellListByType(*_types):
dict_attrib = CompuCell.getPyAttrib(cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def start(self):
self.y_EN_pos=self.find_posterior_EN_stripe()
self.y_EN_ant=self.find_anterior_EN_stripe()
self.y_GZ_border=self.find_y_GZ_mitosis_border()
for cell in self.cellList:
region=self.assign_cell_region(cell)
# self.initiate_cell_volume(cell) ## Initiates cells with new volumes to distribute mitoses in time
cellDict = CompuCell.getPyAttrib(cell)
cellDict["growth_timer"]=self.attach_growth_timer(cell) ## attached a countdown timer for cell growth
def step(self,mcs):
self.scalarFieldDelta.clear()
self.scalarFieldNotch.clear()
for cell in self.cellList:
if cell:
cellDict=CompuCell.getPyAttrib(cell)
self.scalarFieldDelta[cell]=cellDict['D']
self.scalarFieldNotch[cell]=cellDict['N']
def step(self, mcs):
cells_to_divide = []
for cell in self.cellList:
dictionaryAttrib = CompuCell.getPyAttrib(cell)
if cell.volume > dictionaryAttrib["DivideVolume"]:
cells_to_divide.append(cell)
for cell in cells_to_divide:
self.divideCellRandomOrientation(cell)
def step(self,mcs):
for cell in self.cellList:
#pyAttrib=cell.pyAttrib
pyAttrib=CompuCell.getPyAttrib(cell)
pyAttrib[0]=[cell.id*mcs,cell.id*(mcs-1)]
if not mcs % 20:
print "CELL ID modified=",pyAttrib," true=",cell.id,
print " ref count=",sys.getrefcount(pyAttrib),
print " ref count=",sys.getrefcount(pyAttrib)
def deleteSBMLFromCellTypes(self,_modelName,_types=[]):
import CompuCell
for cell in self.cellListByType(*_types):
dict_attrib=CompuCell.getPyAttrib(cell)
try:
sbmlDict=dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError,e:
pass
def step(self,mcs):
cells_to_divide=[]
for cell in self.cellList:
dictionaryAttrib = CompuCell.getPyAttrib( cell )
if cell.volume > dictionaryAttrib["DivideVolume"]:
cells_to_divide.append(cell)
for cell in cells_to_divide:
self.divideCellRandomOrientation(cell)
def grow_cell(self, cell):
cellDict = CompuCell.getPyAttrib(cell)
region = cellDict["region"]
r_grow = self.r_grow_list[region]
if cellDict["growth_timer"] >= 1:
if cell.targetVolume <= self.Vmax:
cell.targetVolume += int(cellDict["growth_timer"])
cellDict["growth_timer"] = 0
else:
cellDict["growth_timer"] += r_grow
def make_mitosis_list(self):
mitosis_list = []
for cell in self.cellList:
cellDict = CompuCell.getPyAttrib(cell)
region = cellDict["region"]
mitosis_probability = self.r_mitosis_list[region] / self.window
if mitosis_probability >= random():
if cell.volume >= self.Vmin_divide:
mitosis_list.append(cell)
return mitosis_list
def start(self):
self.y_EN_pos=self.find_posterior_EN_stripe()
self.y_EN_ant=self.find_anterior_EN_stripe()
self.y_GZ_border=self.find_y_GZ_mitosis_border()
for cell in self.cellList:
#region=self.assign_cell_region(cell)
self.assign_cell_region(cell)
cellDict = CompuCell.getPyAttrib(cell)
cellDict['divided']=0
cellDict['divided_GZ']=0
def grow_cell(self,cell):
cellDict=CompuCell.getPyAttrib(cell)
region=cellDict["region"]
r_grow=self.r_grow_list[region]
if cellDict["growth_timer"] >= 1:
if cell.targetVolume<=self.Vmax:
cell.targetVolume+=int(cellDict["growth_timer"])
cellDict["growth_timer"]=0
else:
cellDict["growth_timer"]+=r_grow
def step(self,mcs):
print "INSIDE Protein Expression STEPPABLE"
randommultiplier1=uniform(0.95,1.05)
randommultiplier2=uniform(0.95,1.05)
for cell in self.cellList:
vasculo_attributes=CompuCell.getPyAttrib(cell)
if cell.type==1:
vasculo_attributes['cell.receptor.VEGFR1']*=randommultiplier1
vasculo_attributes['cell.receptor.VEGFR2']*=randommultiplier2
def make_mitosis_list(self):
mitosis_list=[]
for cell in self.cellList:
cellDict=CompuCell.getPyAttrib(cell)
region=cellDict["region"]
mitosis_probability=self.r_mitosis_list[region]/self.window
if mitosis_probability>=random():
if cell.volume >= self.Vmin_divide:
mitosis_list.append(cell)
return mitosis_list
def start(self):
self.y_EN_pos = self.find_posterior_EN_stripe()
self.y_EN_ant = self.find_anterior_EN_stripe()
self.y_GZ_border = self.find_y_GZ_mitosis_border()
for cell in self.cellList:
region = self.assign_cell_region(cell)
# self.initiate_cell_volume(cell) ## Initiates cells with new volumes to distribute mitoses in time
cellDict = CompuCell.getPyAttrib(cell)
cellDict["growth_timer"] = self.attach_growth_timer(
cell) ## attached a countdown timer for cell growth
def updateAttributes(self):
self.parentCell.targetVolume /= 2.0 # reducing parent target volume
self.cloneParent2Child()
# for more control of what gets copied from parent to child use cloneAttributes function
# self.cloneAttributes(sourceCell=self.parentCell, targetCell=self.childCell, no_clone_key_dict_list = [attrib1, attrib2] )
if random() < 0.5:
self.childCell.type = self.parentCell.type
else:
self.childCell.type = self.DP
parentCellList = []
parentCellList = CompuCell.getPyAttrib(self.parentCell)
childCellList = []
childCellList = CompuCell.getPyAttrib(self.childCell)
mcs = self.simulator.getStep()
mitData = MitosisData(mcs, self.parentCell.id, self.parentCell.type,
self.childCell.id, self.childCell.type)
def copySBMLs(self,_fromCell,_toCell,_sbmlNames=[],_options=None):
sbmlNamesToCopy=[]
import CompuCell
if not(len(_sbmlNames)):
#if user does not specify _sbmlNames we copy all SBML networks
try:
dict_attrib=CompuCell.getPyAttrib(_fromCell)
sbmlDict=dict_attrib['SBMLSolver']
sbmlNamesToCopy=sbmlDict.keys()
except LookupError,e:
pass
def step(self,mcs):
self.scalarFieldD.clear()
self.scalarFieldN.clear()
self.scalarFieldB.clear()
self.scalarFieldR.clear()
for cell in self.cellListByType(1):
cellDict=CompuCell.getPyAttrib(cell)
self.scalarFieldD[cell]=cellDict['D']
self.scalarFieldN[cell]=cellDict['N']
self.scalarFieldB[cell]=cellDict['B']
self.scalarFieldR[cell]=cellDict['R']
def timestepCellSBML(self):
import CompuCell
#timestepping SBML attached to cells
for cell in self.cellList:
dict_attrib = CompuCell.getPyAttrib(cell)
if dict_attrib.has_key('SBMLSolver'):
sbmlDict = dict_attrib['SBMLSolver']
for modelName, rrTmp in sbmlDict.iteritems():
rrTmp.timestep() #integrating SBML
def timestepCellSBML(self):
import CompuCell
#timestepping SBML attached to cells
for cell in self.cellList:
dict_attrib=CompuCell.getPyAttrib(cell)
if dict_attrib.has_key('SBMLSolver'):
sbmlDict=dict_attrib['SBMLSolver']
for modelName, rrTmp in sbmlDict.iteritems():
rrTmp.timestep() #integrating SBML
def copySBMLs(self, _fromCell, _toCell, _sbmlNames=[], _options=None):
sbmlNamesToCopy = []
import CompuCell
if not (len(_sbmlNames)):
#if user does not specify _sbmlNames we copy all SBML networks
try:
dict_attrib = CompuCell.getPyAttrib(_fromCell)
sbmlDict = dict_attrib['SBMLSolver']
sbmlNamesToCopy = sbmlDict.keys()
except LookupError, e:
pass
def start(self):
self.y_EN_pos=self.find_posterior_EN_stripe()
self.y_EN_ant=self.find_anterior_EN_stripe()
self.y_GZ_border=self.find_y_GZ_mitosis_border()
for cell in self.cellList:
region=self.assign_cell_region(cell)
cellDict = CompuCell.getPyAttrib(cell)
cellDict['growth_timer']=self.attach_growth_timer(cell) ## attached a countdown timer for cell growth
cellDict['divided']=0
cellDict['divided_GZ']=0
cellDict['mitosis_times']=[]
cellDict['last_division_mcs']=0
def deleteSBMLFromCellIds(self, _modelName, _ids=[]):
import CompuCell
for id in _ids:
cell = self.inventory.attemptFetchingCellById(id)
if not cell:
continue
dict_attrib = CompuCell.getPyAttrib(cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def deleteSBMLFromCell(self, _modelName='', _cell=None):
"""
Deletes SBML from a particular cell
:param _modelName {str}: model name
:param _cell {obj}: CellG cell obj
:return: None
"""
import CompuCell
dict_attrib = CompuCell.getPyAttrib(_cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def timestepCellSBML(self):
"""
advances (integrats forward) models stored as attributes of cells
:return: None
"""
import CompuCell
# timestepping SBML attached to cells
for cell in self.cellList:
dict_attrib = CompuCell.getPyAttrib(cell)
if dict_attrib.has_key('SBMLSolver'):
sbmlDict = dict_attrib['SBMLSolver']
for modelName, rrTmp in sbmlDict.iteritems():
rrTmp.timestep() # integrating SBML
def step(self, mcs):
# ######### Update bionetwork integrator(s) for all cells ###########
bionetAPI.timestepBionetworks()
# ######## Implement cell growth by increasing target volume ##########
for cell in self.cellList:
if cell.id > self.initialNumberOfCells:
## All new cells are assigned a target volume of 0 to force cell death
cell.targetVolume = 0.
cell.lambdaVolume = 2.
cell.targetSurface = 0.
cell.lambdaSurface = 2.
else:
dictionaryAttrib = CompuCell.getPyAttrib(cell)
cell.targetVolume = cell.volume + 0.15 * dictionaryAttrib[
"InitialVolume"]
# ###### Retrieve delta values and set cell type according to delta concentration ########
for cell in self.cellList:
currentDeltaValue = bionetAPI.getBionetworkValue("DN_di", cell.id)
if (currentDeltaValue > 0.5):
if (self.cellTypeMap[cell.type] == "LowDelta"):
print "ID of cell to undergo type change %s" % cell.id
print "Type of cell to undergo type change %s" % bionetAPI.getBionetworkValue(
"TemplateLibrary", cell.id)
bionetAPI.setBionetworkValue("TemplateLibrary",
"HighDelta", cell.id)
else:
if (self.cellTypeMap[cell.type] == "HighDelta"):
bionetAPI.setBionetworkValue("TemplateLibrary", "LowDelta",
cell.id)
# ####### Set all cell dbari values as a function of neighbor delta values #########
for cell in self.cellList:
weightedSumOfNeighborDeltaValues = 0.0
neighborContactAreas = bionetAPI.getNeighborContactAreas(cell.id)
neighborDeltaValues = bionetAPI.getNeighborProperty(
"DN_di", cell.id)
for neighborID in neighborContactAreas.keys():
weightedSumOfNeighborDeltaValues += (
neighborContactAreas[neighborID] *
neighborDeltaValues[neighborID])
bionetAPI.setBionetworkValue(
"DN_dbari", weightedSumOfNeighborDeltaValues / cell.surface,
cell.id)
def deleteSBMLFromCellTypes(self, _modelName, _types=[]):
"""
Deletes SBML model from cells whose type match those stered int he _ids list
:param _modelName {str}: model name
:param _types: list of cell cell types
:return: None
"""
import CompuCell
for cell in self.cellListByType(*_types):
dict_attrib = CompuCell.getPyAttrib(cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def setStepSizeForCell(self, _modelName='', _cell=None, _stepSize=1.0):
"""
Sets integration step size for SBML model attached to _cell
:param _modelName {str}: model name
:param _cell {object}: CellG cell object
:param _stepSize {float}: integrtion step size
:return: None
"""
import CompuCell
dict_attrib = CompuCell.getPyAttrib(_cell)
try:
sbmlSolver = dict_attrib['SBMLSolver'][_modelName]
except LookupError, e:
return
def start(self):
for cell in self.cellList:
print " MODIFY ATTRIB CELL ID=",cell.id
#print "ref count=",sys.getrefcount(cell.pyAttrib)
#print "another ref count=",sys.getrefcount(cell.pyAttrib)
#pyAttrib=cell.pyAttrib
pyAttrib=CompuCell.getPyAttrib(cell)
print "ref count=",sys.getrefcount(pyAttrib)
#print " after assign ref count=",sys.getrefcount(cell.pyAttrib)
print "length=",len(pyAttrib)
pyAttrib[0:1]=[cell.id*4]
print "Cell attrib=",pyAttrib[0]
print "length=",len(pyAttrib)
pyAttrib.append(14)
print "Cell attrib=",pyAttrib[1]
print "length=",len(pyAttrib)
def start(self):
for cell in self.cellList:
if cell.type != self.MEDIUM:
cellDict = CompuCell.getPyAttrib(cell)
cellDict["Damage"] = 0
cellDict["ARF"] = random.gauss(
0.5,
0.17) # normally distributed within roughly within 0 and 1
if cellDict["ARF"] < 0:
cellDict["ARF"] = 0
elif cellDict["ARF"] > 1:
cellDict["ARF"] = 1
if cellDict["ARF"] >= 0.8:
cell.type = self.RESISTENTBACTERIA
else:
cell.type = self.REGULARBACTERIA
def deleteSBMLFromCellIds(self, _modelName, _ids=[]):
"""
Deletes SBML model from cells whose ids match those stered int he _ids list
:param _modelName {str}: model name
:param _ids {list}: list of cell ids
:return: None
"""
import CompuCell
for id in _ids:
cell = self.inventory.attemptFetchingCellById(id)
if not cell:
continue
dict_attrib = CompuCell.getPyAttrib(cell)
try:
sbmlDict = dict_attrib['SBMLSolver']
del sbmlDict[_modelName]
except LookupError, e:
pass
def copySBMLs(self, _fromCell, _toCell, _sbmlNames=[], _options=None):
"""
Copies SBML solvers (with their states - effectively clones the solver) from one cell to another
:param _fromCell {object}: source CellG cell
:param _toCell {object}: target CellG cell
:param _sbmlNames: list of SBML model name whose solver are to be copied
:param _options {dict}: - deprecated - list of SBML solver options
:return: None
"""
sbmlNamesToCopy = []
import CompuCell
if not (len(_sbmlNames)):
# if user does not specify _sbmlNames we copy all SBML networks
try:
dict_attrib = CompuCell.getPyAttrib(_fromCell)
sbmlDict = dict_attrib['SBMLSolver']
sbmlNamesToCopy = sbmlDict.keys()
except LookupError, e:
pass
def start(self):
# #################### Create SBML models ######################
sbmlModelName = "DeltaNotchModel"
sbmlModelKey = "DN"
sbmlModelPath = "Simulation/MinimalDeltaNotch.sbml"
timeStepOfIntegration = 0.1
bionetAPI.loadSBMLModel(sbmlModelName, sbmlModelPath, sbmlModelKey,
timeStepOfIntegration)
# ################ Add SBML models to cell types ##################
bionetAPI.addSBMLModelToTemplateLibrary("DeltaNotchModel", "LowDelta")
bionetAPI.addSBMLModelToTemplateLibrary("DeltaNotchModel", "HighDelta")
## Include this for a test
bionetAPI.addSBMLModelToTemplateLibrary("DeltaNotchModel", "External")
# ####### Set initial conditions for SBML properties #########
bionetAPI.setBionetworkInitialCondition("LowDelta", "DN_di", 0.2)
bionetAPI.setBionetworkInitialCondition("HighDelta", "DN_di", 0.8)
for cell in self.cellList:
cell.targetVolume = 32.0
cell.lambdaVolume = 1.0
cell.targetSurface = 32.0
cell.lambdaSurface = 1.0
# ######## Create bionetworks and initialize their states ##########
bionetAPI.initializeBionetworks()
# ######## Set cell initial conditions by individual cell ##########
for cell in self.cellList:
dictionaryAttrib = CompuCell.getPyAttrib(cell)
dictionaryAttrib["InitialVolume"] = cell.volume
dictionaryAttrib["DivideVolume"] = 2. * cell.volume
self.initialNumberOfCells = len(self.cellList)
print "\n\nNumber of cells: %s\n\n" % self.initialNumberOfCells
import CompuCellSetup
self.cellTypeMap = CompuCellSetup.ExtractTypeNamesAndIds()
del (self.cellTypeMap[0])
def step(self, mcs):
antibioticField = CompuCell.getConcentrationField(
self.simulator, 'Antibiotic')
for cell in self.cellList:
if cell.type != self.MEDIUM:
# get concentration at cells COM
cellCOM = CompuCell.Point3D()
cellCOM.x = int(round(cell.xCOM))
cellCOM.y = int(round(cell.yCOM))
cellCOM.z = int(round(cell.zCOM))
antibioticConcentration = antibioticField.get(cellCOM)
# calculate damage based on concentration and ARF
cellDict = CompuCell.getPyAttrib(cell)
cellDict["Damage"] += (
1 -
cellDict["ARF"]) * antibioticConcentration * DAMAGE_FACTOR
if cellDict["Damage"] >= 1: # too much damage -> die
cell.targetVolume = 0
cell.lambdaVolume = 100
def assign_cell_region(self, cell):
cellDict = CompuCell.getPyAttrib(cell)
yCM = cell.yCM / float(cell.volume)
if yCM > self.y_EN_ant: # if cell is anterior to EN stripes
cellDict["region"] = 0
# if (cell.type!=4 and cell.type!=2): # if cell is not En or mitosing
# cell.type=1 # AnteriorLobe
elif yCM > self.y_EN_pos: # if cell is in EN-striped region
cellDict["region"] = 1
if (cell.type != 2
and cell.type != 4): # if cell is not En or mitosing
cell.type = 5 # Segmented
elif yCM > self.y_GZ_border: # if cell is in anterior region of GZ
cellDict["region"] = 2
if (cell.type != 2
and cell.type != 4): # if cell is not En or mitosing
cell.type = 3 #GZ
else: # if cell is in posterior region of GZ
cellDict["region"] = 3
if cell.type != 4: #if cell is not mitosing
cell.type = 3 # GZ
