chaste.cell_based package

Module contents

Cell Based Module

class chaste.cell_based.Identifiable

GetIdentifier((Identifiable)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetIdentifier(Identifiable {lvalue})

class chaste.cell_based.Cell

AddCellProperty((Cell)arg1, (object)rProperty) → None :

C++ signature :

void AddCellProperty(Cell {lvalue},boost::shared_ptr<AbstractCellProperty>)

Divide((Cell)arg1) → Cell :

C++ signature :

boost::shared_ptr<Cell> Divide(Cell {lvalue})

GetAge((Cell)arg1) → float :

C++ signature :

double GetAge(Cell {lvalue})

GetAncestor((Cell)arg1) → int :

C++ signature :

unsigned int GetAncestor(Cell {lvalue})

GetApoptosisTime((Cell)arg1) → float :

C++ signature :

double GetApoptosisTime(Cell {lvalue})

GetBirthTime((Cell)arg1) → float :

C++ signature :

double GetBirthTime(Cell {lvalue})

GetCellCycleModel((Cell)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* GetCellCycleModel(Cell {lvalue})

GetCellData((Cell)arg1) → CellData :

C++ signature :

boost::shared_ptr<CellData> GetCellData(Cell {lvalue})

GetCellId((Cell)arg1) → int :

C++ signature :

unsigned int GetCellId(Cell {lvalue})

GetCellProliferativeType((Cell)arg1) → AbstractCellProliferativeType :

C++ signature :

boost::shared_ptr<AbstractCellProliferativeType> GetCellProliferativeType(Cell {lvalue})

GetCellVecData((Cell)arg1) → object :

C++ signature :

boost::shared_ptr<CellVecData> GetCellVecData(Cell {lvalue})

GetMutationState((Cell)arg1) → AbstractCellMutationState :

C++ signature :

boost::shared_ptr<AbstractCellMutationState> GetMutationState(Cell {lvalue})

GetStartOfApoptosisTime((Cell)arg1) → float :

C++ signature :

double GetStartOfApoptosisTime(Cell {lvalue})

GetTimeUntilDeath((Cell)arg1) → float :

C++ signature :

double GetTimeUntilDeath(Cell {lvalue})

HasApoptosisBegun((Cell)arg1) → bool :

C++ signature :

bool HasApoptosisBegun(Cell {lvalue})

HasCellVecData((Cell)arg1) → bool :

C++ signature :

bool HasCellVecData(Cell {lvalue})

InitialiseCellCycleModel((Cell)arg1) → None :

C++ signature :

void InitialiseCellCycleModel(Cell {lvalue})

InitialiseSrnModel((Cell)arg1) → None :

C++ signature :

void InitialiseSrnModel(Cell {lvalue})

IsDead((Cell)arg1) → bool :

C++ signature :

bool IsDead(Cell {lvalue})

IsLogged((Cell)arg1) → bool :

C++ signature :

bool IsLogged(Cell {lvalue})

Kill((Cell)arg1) → None :

C++ signature :

void Kill(Cell {lvalue})

ReadyToDivide((Cell)arg1) → bool :

C++ signature :

bool ReadyToDivide(Cell {lvalue})

SetAncestor((Cell)arg1, (object)pCellAncestor) → None :

C++ signature :

void SetAncestor(Cell {lvalue},boost::shared_ptr<AbstractCellProperty>)

SetApoptosisTime((Cell)arg1, (float)apoptosisTime) → None :

C++ signature :

void SetApoptosisTime(Cell {lvalue},double)

SetBirthTime((Cell)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(Cell {lvalue},double)

SetCellCycleModel((Cell)arg1, (AbstractCellCycleModel)pCellCycleModel) → None :

C++ signature :

void SetCellCycleModel(Cell {lvalue},AbstractCellCycleModel*)

SetCellProliferativeType((Cell)arg1, (object)pProliferativeType) → None :

C++ signature :

void SetCellProliferativeType(Cell {lvalue},boost::shared_ptr<AbstractCellProperty>)

SetLogged((Cell)arg1) → None :

C++ signature :

void SetLogged(Cell {lvalue})

SetMutationState((Cell)arg1, (object)pMutationState) → None :

C++ signature :

void SetMutationState(Cell {lvalue},boost::shared_ptr<AbstractCellProperty>)

SetSrnModel((Cell)arg1, (object)pSrnModel) → None :

C++ signature :

void SetSrnModel(Cell {lvalue},AbstractSrnModel*)

StartApoptosis((Cell)arg1[, (bool)setDeathTime=True]) → None :

C++ signature :

void StartApoptosis(Cell {lvalue} [,bool=True])

class chaste.cell_based.CellPropertyCollection

AddProperty((CellPropertyCollection)arg1, (object)rProp) → None :

C++ signature :

void AddProperty(CellPropertyCollection {lvalue},boost::shared_ptr<AbstractCellProperty>)

Begin((CellPropertyCollection)arg1) → object :

C++ signature :

std::_Rb_tree_const_iterator<boost::shared_ptr<AbstractCellProperty> > Begin(CellPropertyCollection {lvalue})

End((CellPropertyCollection)arg1) → object :

C++ signature :

std::_Rb_tree_const_iterator<boost::shared_ptr<AbstractCellProperty> > End(CellPropertyCollection {lvalue})

GetProperty((CellPropertyCollection)arg1) → AbstractCellProperty :

C++ signature :

boost::shared_ptr<AbstractCellProperty> GetProperty(CellPropertyCollection {lvalue})

GetSize((CellPropertyCollection)arg1) → int :

C++ signature :

unsigned int GetSize(CellPropertyCollection {lvalue})

HasProperty((CellPropertyCollection)arg1, (object)rProp) → bool :

C++ signature :

bool HasProperty(CellPropertyCollection {lvalue},boost::shared_ptr<AbstractCellProperty>)

RemoveProperty((CellPropertyCollection)arg1, (object)rProp) → None :

C++ signature :

void RemoveProperty(CellPropertyCollection {lvalue},boost::shared_ptr<AbstractCellProperty>)

SetCellPropertyRegistry((CellPropertyCollection)arg1, (CellPropertyRegistry)pRegistry) → None :

C++ signature :

void SetCellPropertyRegistry(CellPropertyCollection {lvalue},CellPropertyRegistry*)

class chaste.cell_based.CellId

AssignCellId((CellId)arg1) → None :

C++ signature :

void AssignCellId(CellId {lvalue})

GetCellId((CellId)arg1) → int :

C++ signature :

unsigned int GetCellId(CellId {lvalue})

GetMaxCellId((CellId)arg1) → int :

C++ signature :

unsigned int GetMaxCellId(CellId {lvalue})

static ResetMaxCellId() → None :

C++ signature :

void ResetMaxCellId()

class chaste.cell_based.CellLabel

GetColour((CellLabel)arg1) → int :

C++ signature :

unsigned int GetColour(CellLabel {lvalue})

class chaste.cell_based.CellData

GetItem((CellData)arg1, (str)rVariableName) → float :

C++ signature :

double GetItem(CellData {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

GetKeys((CellData)arg1) → object :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetKeys(CellData {lvalue})

GetNumItems((CellData)arg1) → int :

C++ signature :

unsigned int GetNumItems(CellData {lvalue})

SetItem((CellData)arg1, (str)rVariableName, (float)data) → None :

C++ signature :

void SetItem(CellData {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,double)

class chaste.cell_based.CellAncestor

GetAncestor((CellAncestor)arg1) → int :

C++ signature :

unsigned int GetAncestor(CellAncestor {lvalue})

class chaste.cell_based.CellPropertyRegistry

Clear((CellPropertyRegistry)arg1) → None :

C++ signature :

void Clear(CellPropertyRegistry {lvalue})

HasOrderingBeenSpecified((CellPropertyRegistry)arg1) → bool :

C++ signature :

bool HasOrderingBeenSpecified(CellPropertyRegistry {lvalue})

static Instance() → CellPropertyRegistry :

C++ signature :

CellPropertyRegistry* Instance()

SpecifyOrdering((CellPropertyRegistry)arg1, (VecAbstractCellProperty)rOrdering) → None :

C++ signature :

void SpecifyOrdering(CellPropertyRegistry {lvalue},std::vector<boost::shared_ptr<AbstractCellProperty>, std::allocator<boost::shared_ptr<AbstractCellProperty> > >)

class chaste.cell_based.SimulationTime

static Destroy() → None :

C++ signature :

void Destroy()

GetTime((SimulationTime)arg1) → float :

C++ signature :

double GetTime(SimulationTime {lvalue})

GetTimeStep((SimulationTime)arg1) → float :

C++ signature :

double GetTimeStep(SimulationTime {lvalue})

GetTimeStepsElapsed((SimulationTime)arg1) → int :

C++ signature :

unsigned int GetTimeStepsElapsed(SimulationTime {lvalue})

IncrementTimeOneStep((SimulationTime)arg1) → None :

C++ signature :

void IncrementTimeOneStep(SimulationTime {lvalue})

static Instance() → SimulationTime :

C++ signature :

SimulationTime* Instance()

IsEndTimeAndNumberOfTimeStepsSetUp((SimulationTime)arg1) → bool :

C++ signature :

bool IsEndTimeAndNumberOfTimeStepsSetUp(SimulationTime {lvalue})

IsFinished((SimulationTime)arg1) → bool :

C++ signature :

bool IsFinished(SimulationTime {lvalue})

IsStartTimeSetUp((SimulationTime)arg1) → bool :

C++ signature :

bool IsStartTimeSetUp(SimulationTime {lvalue})

ResetEndTimeAndNumberOfTimeSteps((SimulationTime)arg1, (float)rEndTime, (int)rNumberOfTimeStepsInThisRun) → None :

C++ signature :

void ResetEndTimeAndNumberOfTimeSteps(SimulationTime {lvalue},double,unsigned int)

SetEndTimeAndNumberOfTimeSteps((SimulationTime)arg1, (float)endTime, (int)totalTimeStepsInSimulation) → None :

C++ signature :

void SetEndTimeAndNumberOfTimeSteps(SimulationTime {lvalue},double,unsigned int)

SetStartTime((SimulationTime)arg1, (float)startTime) → None :

C++ signature :

void SetStartTime(SimulationTime {lvalue},double)

class chaste.cell_based.OnLatticeSimulation2

AddUpdateRule((OnLatticeSimulation2)arg1, (object)pUpdateRule) → None :

C++ signature :

void AddUpdateRule(OnLatticeSimulation<2u> {lvalue},boost::shared_ptr<AbstractUpdateRule<2u> >)

DoCellBirth((OnLatticeSimulation2)arg1) → int :

C++ signature :

unsigned int DoCellBirth(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

DoCellRemoval((OnLatticeSimulation2)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

OutputAdditionalSimulationSetup((OnLatticeSimulation2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(OnLatticeSimulation<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputAdditionalSimulationSetup( (OnLatticeSimulation2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputAdditionalSimulationSetup(OnLatticeSimulation_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((OnLatticeSimulation2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(OnLatticeSimulation<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (OnLatticeSimulation2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationParameters(OnLatticeSimulation_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((OnLatticeSimulation2)arg1) → None :

C++ signature :

void OutputSimulationSetup(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

RemoveAllUpdateRules((OnLatticeSimulation2)arg1) → None :

C++ signature :

void RemoveAllUpdateRules(OnLatticeSimulation<2u> {lvalue})

SetupSolve((OnLatticeSimulation2)arg1) → None :

C++ signature :

void SetupSolve(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

StoppingEventHasOccurred((OnLatticeSimulation2)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((OnLatticeSimulation2)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

UpdateCellPopulation((OnLatticeSimulation2)arg1) → None :

C++ signature :

void UpdateCellPopulation(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

WriteVisualizerSetupFile((OnLatticeSimulation2)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(OnLatticeSimulation_less__2__greater__wrapper {lvalue})

class chaste.cell_based.OnLatticeSimulation3

AddUpdateRule((OnLatticeSimulation3)arg1, (object)pUpdateRule) → None :

C++ signature :

void AddUpdateRule(OnLatticeSimulation<3u> {lvalue},boost::shared_ptr<AbstractUpdateRule<3u> >)

DoCellBirth((OnLatticeSimulation3)arg1) → int :

C++ signature :

unsigned int DoCellBirth(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

DoCellRemoval((OnLatticeSimulation3)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

OutputAdditionalSimulationSetup((OnLatticeSimulation3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(OnLatticeSimulation<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputAdditionalSimulationSetup( (OnLatticeSimulation3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputAdditionalSimulationSetup(OnLatticeSimulation_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((OnLatticeSimulation3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(OnLatticeSimulation<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (OnLatticeSimulation3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationParameters(OnLatticeSimulation_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((OnLatticeSimulation3)arg1) → None :

C++ signature :

void OutputSimulationSetup(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

RemoveAllUpdateRules((OnLatticeSimulation3)arg1) → None :

C++ signature :

void RemoveAllUpdateRules(OnLatticeSimulation<3u> {lvalue})

SetupSolve((OnLatticeSimulation3)arg1) → None :

C++ signature :

void SetupSolve(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

StoppingEventHasOccurred((OnLatticeSimulation3)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((OnLatticeSimulation3)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

UpdateCellPopulation((OnLatticeSimulation3)arg1) → None :

C++ signature :

void UpdateCellPopulation(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

WriteVisualizerSetupFile((OnLatticeSimulation3)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(OnLatticeSimulation_less__3__greater__wrapper {lvalue})

class chaste.cell_based.DiffusionCaUpdateRule2

EvaluateProbability((DiffusionCaUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation2)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) → float :

C++ signature :

double EvaluateProbability(DiffusionCaUpdateRule<2u> {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<2u> {lvalue},double,double,boost::shared_ptr<Cell>)

EvaluateProbability( (DiffusionCaUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation2)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) -> float :

C++ signature :

double EvaluateProbability(DiffusionCaUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<2u> {lvalue},double,double,boost::shared_ptr<Cell>)

GetDiffusionParameter((DiffusionCaUpdateRule2)arg1) → float :

C++ signature :

double GetDiffusionParameter(DiffusionCaUpdateRule<2u> {lvalue})

OutputUpdateRuleParameters((DiffusionCaUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(DiffusionCaUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (DiffusionCaUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(DiffusionCaUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDiffusionParameter((DiffusionCaUpdateRule2)arg1, (float)diffusionParameter) → None :

C++ signature :

void SetDiffusionParameter(DiffusionCaUpdateRule<2u> {lvalue},double)

class chaste.cell_based.DiffusionCaUpdateRule3

EvaluateProbability((DiffusionCaUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation3)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) → float :

C++ signature :

double EvaluateProbability(DiffusionCaUpdateRule<3u> {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<3u> {lvalue},double,double,boost::shared_ptr<Cell>)

EvaluateProbability( (DiffusionCaUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation3)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) -> float :

C++ signature :

double EvaluateProbability(DiffusionCaUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<3u> {lvalue},double,double,boost::shared_ptr<Cell>)

GetDiffusionParameter((DiffusionCaUpdateRule3)arg1) → float :

C++ signature :

double GetDiffusionParameter(DiffusionCaUpdateRule<3u> {lvalue})

OutputUpdateRuleParameters((DiffusionCaUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(DiffusionCaUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (DiffusionCaUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(DiffusionCaUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDiffusionParameter((DiffusionCaUpdateRule3)arg1, (float)diffusionParameter) → None :

C++ signature :

void SetDiffusionParameter(DiffusionCaUpdateRule<3u> {lvalue},double)

class chaste.cell_based.AbstractCaUpdateRule2

EvaluateProbability((AbstractCaUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation2)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) → float :

C++ signature :

double EvaluateProbability(AbstractCaUpdateRule<2u> {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<2u> {lvalue},double,double,boost::shared_ptr<Cell>)

EvaluateProbability( (AbstractCaUpdateRule2)arg1, (int)arg2, (int)arg3, (CaBasedCellPopulation2)arg4, (float)arg5, (float)arg6, (Cell)arg7) -> None :

C++ signature :

void EvaluateProbability(AbstractCaUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<2u> {lvalue},double,double,boost::shared_ptr<Cell>)

OutputUpdateRuleParameters((AbstractCaUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractCaUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractCaUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractCaUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractCaUpdateRule3

EvaluateProbability((AbstractCaUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (CaBasedCellPopulation3)rCellPopulation, (float)dt, (float)deltaX, (Cell)cell) → float :

C++ signature :

double EvaluateProbability(AbstractCaUpdateRule<3u> {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<3u> {lvalue},double,double,boost::shared_ptr<Cell>)

EvaluateProbability( (AbstractCaUpdateRule3)arg1, (int)arg2, (int)arg3, (CaBasedCellPopulation3)arg4, (float)arg5, (float)arg6, (Cell)arg7) -> None :

C++ signature :

void EvaluateProbability(AbstractCaUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,CaBasedCellPopulation<3u> {lvalue},double,double,boost::shared_ptr<Cell>)

OutputUpdateRuleParameters((AbstractCaUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractCaUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractCaUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractCaUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractUpdateRule2

OutputUpdateRuleInfo((AbstractUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleInfo(AbstractUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters((AbstractUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractUpdateRule2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractUpdateRule3

OutputUpdateRuleInfo((AbstractUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleInfo(AbstractUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters((AbstractUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractUpdateRule3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.VtkSceneModifier2

GetVtkScene((VtkSceneModifier2)arg1) → object :

C++ signature :

boost::shared_ptr<VtkScene<2u> > GetVtkScene(VtkSceneModifier<2u> {lvalue})

OutputSimulationModifierParameters((VtkSceneModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(VtkSceneModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (VtkSceneModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(VtkSceneModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetUpdateFrequency((VtkSceneModifier2)arg1, (int)frequency) → None :

C++ signature :

void SetUpdateFrequency(VtkSceneModifier<2u> {lvalue},unsigned int)

SetVtkScene((VtkSceneModifier2)arg1, (object)pScene) → None :

C++ signature :

void SetVtkScene(VtkSceneModifier<2u> {lvalue},boost::shared_ptr<VtkScene<2u> >)

SetupSolve((VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(VtkSceneModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(VtkSceneModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(VtkSceneModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(VtkSceneModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(VtkSceneModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(VtkSceneModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(VtkSceneModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(VtkSceneModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateCellData((VtkSceneModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateCellData(VtkSceneModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.VtkSceneModifier3

GetVtkScene((VtkSceneModifier3)arg1) → object :

C++ signature :

boost::shared_ptr<VtkScene<3u> > GetVtkScene(VtkSceneModifier<3u> {lvalue})

OutputSimulationModifierParameters((VtkSceneModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(VtkSceneModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (VtkSceneModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(VtkSceneModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetUpdateFrequency((VtkSceneModifier3)arg1, (int)frequency) → None :

C++ signature :

void SetUpdateFrequency(VtkSceneModifier<3u> {lvalue},unsigned int)

SetVtkScene((VtkSceneModifier3)arg1, (object)pScene) → None :

C++ signature :

void SetVtkScene(VtkSceneModifier<3u> {lvalue},boost::shared_ptr<VtkScene<3u> >)

SetupSolve((VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(VtkSceneModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(VtkSceneModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(VtkSceneModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(VtkSceneModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(VtkSceneModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(VtkSceneModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(VtkSceneModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(VtkSceneModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateCellData((VtkSceneModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateCellData(VtkSceneModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.AbstractTargetAreaModifier2

GetReferenceTargetArea((AbstractTargetAreaModifier2)arg1) → float :

C++ signature :

double GetReferenceTargetArea(AbstractTargetAreaModifier<2u> {lvalue})

OutputSimulationModifierParameters((AbstractTargetAreaModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractTargetAreaModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractTargetAreaModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetReferenceTargetArea((AbstractTargetAreaModifier2)arg1, (float)referenceTargetArea) → None :

C++ signature :

void SetReferenceTargetArea(AbstractTargetAreaModifier<2u> {lvalue},double)

SetupSolve((AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateTargetAreaOfCell((AbstractTargetAreaModifier2)arg1, (Cell)pCell) → None :

C++ signature :

void UpdateTargetAreaOfCell(AbstractTargetAreaModifier<2u> {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreaOfCell( (AbstractTargetAreaModifier2)arg1, (Cell)arg2) -> None :

C++ signature :

void UpdateTargetAreaOfCell(AbstractTargetAreaModifier_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreas((AbstractTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateTargetAreas(AbstractTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.AbstractTargetAreaModifier3

GetReferenceTargetArea((AbstractTargetAreaModifier3)arg1) → float :

C++ signature :

double GetReferenceTargetArea(AbstractTargetAreaModifier<3u> {lvalue})

OutputSimulationModifierParameters((AbstractTargetAreaModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractTargetAreaModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractTargetAreaModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetReferenceTargetArea((AbstractTargetAreaModifier3)arg1, (float)referenceTargetArea) → None :

C++ signature :

void SetReferenceTargetArea(AbstractTargetAreaModifier<3u> {lvalue},double)

SetupSolve((AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateTargetAreaOfCell((AbstractTargetAreaModifier3)arg1, (Cell)pCell) → None :

C++ signature :

void UpdateTargetAreaOfCell(AbstractTargetAreaModifier<3u> {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreaOfCell( (AbstractTargetAreaModifier3)arg1, (Cell)arg2) -> None :

C++ signature :

void UpdateTargetAreaOfCell(AbstractTargetAreaModifier_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreas((AbstractTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateTargetAreas(AbstractTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.SimpleTargetAreaModifier2

GetGrowthDuration((SimpleTargetAreaModifier2)arg1) → float :

C++ signature :

double GetGrowthDuration(SimpleTargetAreaModifier<2u> {lvalue})

OutputSimulationModifierParameters((SimpleTargetAreaModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(SimpleTargetAreaModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (SimpleTargetAreaModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetGrowthDuration((SimpleTargetAreaModifier2)arg1, (float)growthDuration) → None :

C++ signature :

void SetGrowthDuration(SimpleTargetAreaModifier<2u> {lvalue},double)

SetupSolve((SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(SimpleTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(SimpleTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(SimpleTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(SimpleTargetAreaModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (SimpleTargetAreaModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateTargetAreaOfCell((SimpleTargetAreaModifier2)arg1, (Cell)pCell) → None :

C++ signature :

void UpdateTargetAreaOfCell(SimpleTargetAreaModifier<2u> {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreaOfCell( (SimpleTargetAreaModifier2)arg1, (Cell)pCell) -> None :

C++ signature :

void UpdateTargetAreaOfCell(SimpleTargetAreaModifier_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

class chaste.cell_based.SimpleTargetAreaModifier3

GetGrowthDuration((SimpleTargetAreaModifier3)arg1) → float :

C++ signature :

double GetGrowthDuration(SimpleTargetAreaModifier<3u> {lvalue})

OutputSimulationModifierParameters((SimpleTargetAreaModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(SimpleTargetAreaModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (SimpleTargetAreaModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetGrowthDuration((SimpleTargetAreaModifier3)arg1, (float)growthDuration) → None :

C++ signature :

void SetGrowthDuration(SimpleTargetAreaModifier<3u> {lvalue},double)

SetupSolve((SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(SimpleTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(SimpleTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(SimpleTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(SimpleTargetAreaModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (SimpleTargetAreaModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateTargetAreaOfCell((SimpleTargetAreaModifier3)arg1, (Cell)pCell) → None :

C++ signature :

void UpdateTargetAreaOfCell(SimpleTargetAreaModifier<3u> {lvalue},boost::shared_ptr<Cell>)

UpdateTargetAreaOfCell( (SimpleTargetAreaModifier3)arg1, (Cell)pCell) -> None :

C++ signature :

void UpdateTargetAreaOfCell(SimpleTargetAreaModifier_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

class chaste.cell_based.NagaiHondaForce2

AddForceContribution((NagaiHondaForce2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void AddForceContribution(NagaiHondaForce<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

AddForceContribution( (NagaiHondaForce2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(NagaiHondaForce_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

GetAdhesionParameter((NagaiHondaForce2)arg1, (object)pNodeA, (object)pNodeB, (VertexBasedCellPopulation2)rVertexCellPopulation) → float :

C++ signature :

double GetAdhesionParameter(NagaiHondaForce<2u> {lvalue},Node<2u>*,Node<2u>*,VertexBasedCellPopulation<2u> {lvalue})

GetAdhesionParameter( (NagaiHondaForce2)arg1, (object)pNodeA, (object)pNodeB, (VertexBasedCellPopulation2)rVertexCellPopulation) -> float :

C++ signature :

double GetAdhesionParameter(NagaiHondaForce_less__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*,VertexBasedCellPopulation<2u> {lvalue})

GetNagaiHondaCellBoundaryAdhesionEnergyParameter((NagaiHondaForce2)arg1) → float :

C++ signature :

double GetNagaiHondaCellBoundaryAdhesionEnergyParameter(NagaiHondaForce<2u> {lvalue})

GetNagaiHondaCellCellAdhesionEnergyParameter((NagaiHondaForce2)arg1) → float :

C++ signature :

double GetNagaiHondaCellCellAdhesionEnergyParameter(NagaiHondaForce<2u> {lvalue})

GetNagaiHondaDeformationEnergyParameter((NagaiHondaForce2)arg1) → float :

C++ signature :

double GetNagaiHondaDeformationEnergyParameter(NagaiHondaForce<2u> {lvalue})

GetNagaiHondaMembraneSurfaceEnergyParameter((NagaiHondaForce2)arg1) → float :

C++ signature :

double GetNagaiHondaMembraneSurfaceEnergyParameter(NagaiHondaForce<2u> {lvalue})

OutputForceParameters((NagaiHondaForce2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(NagaiHondaForce<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (NagaiHondaForce2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(NagaiHondaForce_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetNagaiHondaCellBoundaryAdhesionEnergyParameter((NagaiHondaForce2)arg1, (float)nagaiHondaCellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetNagaiHondaCellBoundaryAdhesionEnergyParameter(NagaiHondaForce<2u> {lvalue},double)

SetNagaiHondaCellCellAdhesionEnergyParameter((NagaiHondaForce2)arg1, (float)nagaiHondaCellCellAdhesionEnergyEnergyParameter) → None :

C++ signature :

void SetNagaiHondaCellCellAdhesionEnergyParameter(NagaiHondaForce<2u> {lvalue},double)

SetNagaiHondaDeformationEnergyParameter((NagaiHondaForce2)arg1, (float)nagaiHondaDeformationEnergyParameter) → None :

C++ signature :

void SetNagaiHondaDeformationEnergyParameter(NagaiHondaForce<2u> {lvalue},double)

SetNagaiHondaMembraneSurfaceEnergyParameter((NagaiHondaForce2)arg1, (float)nagaiHondaMembraneSurfaceEnergyParameter) → None :

C++ signature :

void SetNagaiHondaMembraneSurfaceEnergyParameter(NagaiHondaForce<2u> {lvalue},double)

WriteDataToVisualizerSetupFile((NagaiHondaForce2)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(NagaiHondaForce<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (NagaiHondaForce2)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(NagaiHondaForce_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.NagaiHondaForce3

AddForceContribution((NagaiHondaForce3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void AddForceContribution(NagaiHondaForce<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

AddForceContribution( (NagaiHondaForce3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(NagaiHondaForce_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

GetAdhesionParameter((NagaiHondaForce3)arg1, (object)pNodeA, (object)pNodeB, (VertexBasedCellPopulation3)rVertexCellPopulation) → float :

C++ signature :

double GetAdhesionParameter(NagaiHondaForce<3u> {lvalue},Node<3u>*,Node<3u>*,VertexBasedCellPopulation<3u> {lvalue})

GetAdhesionParameter( (NagaiHondaForce3)arg1, (object)pNodeA, (object)pNodeB, (VertexBasedCellPopulation3)rVertexCellPopulation) -> float :

C++ signature :

double GetAdhesionParameter(NagaiHondaForce_less__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*,VertexBasedCellPopulation<3u> {lvalue})

GetNagaiHondaCellBoundaryAdhesionEnergyParameter((NagaiHondaForce3)arg1) → float :

C++ signature :

double GetNagaiHondaCellBoundaryAdhesionEnergyParameter(NagaiHondaForce<3u> {lvalue})

GetNagaiHondaCellCellAdhesionEnergyParameter((NagaiHondaForce3)arg1) → float :

C++ signature :

double GetNagaiHondaCellCellAdhesionEnergyParameter(NagaiHondaForce<3u> {lvalue})

GetNagaiHondaDeformationEnergyParameter((NagaiHondaForce3)arg1) → float :

C++ signature :

double GetNagaiHondaDeformationEnergyParameter(NagaiHondaForce<3u> {lvalue})

GetNagaiHondaMembraneSurfaceEnergyParameter((NagaiHondaForce3)arg1) → float :

C++ signature :

double GetNagaiHondaMembraneSurfaceEnergyParameter(NagaiHondaForce<3u> {lvalue})

OutputForceParameters((NagaiHondaForce3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(NagaiHondaForce<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (NagaiHondaForce3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(NagaiHondaForce_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetNagaiHondaCellBoundaryAdhesionEnergyParameter((NagaiHondaForce3)arg1, (float)nagaiHondaCellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetNagaiHondaCellBoundaryAdhesionEnergyParameter(NagaiHondaForce<3u> {lvalue},double)

SetNagaiHondaCellCellAdhesionEnergyParameter((NagaiHondaForce3)arg1, (float)nagaiHondaCellCellAdhesionEnergyEnergyParameter) → None :

C++ signature :

void SetNagaiHondaCellCellAdhesionEnergyParameter(NagaiHondaForce<3u> {lvalue},double)

SetNagaiHondaDeformationEnergyParameter((NagaiHondaForce3)arg1, (float)nagaiHondaDeformationEnergyParameter) → None :

C++ signature :

void SetNagaiHondaDeformationEnergyParameter(NagaiHondaForce<3u> {lvalue},double)

SetNagaiHondaMembraneSurfaceEnergyParameter((NagaiHondaForce3)arg1, (float)nagaiHondaMembraneSurfaceEnergyParameter) → None :

C++ signature :

void SetNagaiHondaMembraneSurfaceEnergyParameter(NagaiHondaForce<3u> {lvalue},double)

WriteDataToVisualizerSetupFile((NagaiHondaForce3)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(NagaiHondaForce<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (NagaiHondaForce3)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(NagaiHondaForce_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractPottsUpdateRule2

EvaluateHamiltonianContribution((AbstractPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(AbstractPottsUpdateRule<2u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

EvaluateHamiltonianContribution( (AbstractPottsUpdateRule2)arg1, (int)arg2, (int)arg3, (PottsBasedCellPopulation2)arg4) -> None :

C++ signature :

void EvaluateHamiltonianContribution(AbstractPottsUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

OutputUpdateRuleParameters((AbstractPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractPottsUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractPottsUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractPottsUpdateRule3

EvaluateHamiltonianContribution((AbstractPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(AbstractPottsUpdateRule<3u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

EvaluateHamiltonianContribution( (AbstractPottsUpdateRule3)arg1, (int)arg2, (int)arg3, (PottsBasedCellPopulation3)arg4) -> None :

C++ signature :

void EvaluateHamiltonianContribution(AbstractPottsUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

OutputUpdateRuleParameters((AbstractPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AbstractPottsUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AbstractPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AbstractPottsUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.VolumeConstraintPottsUpdateRule2

EvaluateHamiltonianContribution((VolumeConstraintPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(VolumeConstraintPottsUpdateRule<2u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

EvaluateHamiltonianContribution( (VolumeConstraintPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(VolumeConstraintPottsUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

GetDeformationEnergyParameter((VolumeConstraintPottsUpdateRule2)arg1) → float :

C++ signature :

double GetDeformationEnergyParameter(VolumeConstraintPottsUpdateRule<2u> {lvalue})

GetMatureCellTargetVolume((VolumeConstraintPottsUpdateRule2)arg1) → float :

C++ signature :

double GetMatureCellTargetVolume(VolumeConstraintPottsUpdateRule<2u> {lvalue})

OutputUpdateRuleParameters((VolumeConstraintPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(VolumeConstraintPottsUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (VolumeConstraintPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(VolumeConstraintPottsUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDeformationEnergyParameter((VolumeConstraintPottsUpdateRule2)arg1, (float)deformationEnergyParameter) → None :

C++ signature :

void SetDeformationEnergyParameter(VolumeConstraintPottsUpdateRule<2u> {lvalue},double)

SetMatureCellTargetVolume((VolumeConstraintPottsUpdateRule2)arg1, (float)matureCellTargetVolume) → None :

C++ signature :

void SetMatureCellTargetVolume(VolumeConstraintPottsUpdateRule<2u> {lvalue},double)

class chaste.cell_based.VolumeConstraintPottsUpdateRule3

EvaluateHamiltonianContribution((VolumeConstraintPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(VolumeConstraintPottsUpdateRule<3u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

EvaluateHamiltonianContribution( (VolumeConstraintPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(VolumeConstraintPottsUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

GetDeformationEnergyParameter((VolumeConstraintPottsUpdateRule3)arg1) → float :

C++ signature :

double GetDeformationEnergyParameter(VolumeConstraintPottsUpdateRule<3u> {lvalue})

GetMatureCellTargetVolume((VolumeConstraintPottsUpdateRule3)arg1) → float :

C++ signature :

double GetMatureCellTargetVolume(VolumeConstraintPottsUpdateRule<3u> {lvalue})

OutputUpdateRuleParameters((VolumeConstraintPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(VolumeConstraintPottsUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (VolumeConstraintPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(VolumeConstraintPottsUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDeformationEnergyParameter((VolumeConstraintPottsUpdateRule3)arg1, (float)deformationEnergyParameter) → None :

C++ signature :

void SetDeformationEnergyParameter(VolumeConstraintPottsUpdateRule<3u> {lvalue},double)

SetMatureCellTargetVolume((VolumeConstraintPottsUpdateRule3)arg1, (float)matureCellTargetVolume) → None :

C++ signature :

void SetMatureCellTargetVolume(VolumeConstraintPottsUpdateRule<3u> {lvalue},double)

class chaste.cell_based.SurfaceAreaConstraintPottsUpdateRule2

EvaluateHamiltonianContribution((SurfaceAreaConstraintPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

EvaluateHamiltonianContribution( (SurfaceAreaConstraintPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(SurfaceAreaConstraintPottsUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

GetDeformationEnergyParameter((SurfaceAreaConstraintPottsUpdateRule2)arg1) → float :

C++ signature :

double GetDeformationEnergyParameter(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue})

GetMatureCellTargetSurfaceArea((SurfaceAreaConstraintPottsUpdateRule2)arg1) → float :

C++ signature :

double GetMatureCellTargetSurfaceArea(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue})

OutputUpdateRuleParameters((SurfaceAreaConstraintPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (SurfaceAreaConstraintPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(SurfaceAreaConstraintPottsUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDeformationEnergyParameter((SurfaceAreaConstraintPottsUpdateRule2)arg1, (float)deformationEnergyParameter) → None :

C++ signature :

void SetDeformationEnergyParameter(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue},double)

SetMatureCellTargetSurfaceArea((SurfaceAreaConstraintPottsUpdateRule2)arg1, (float)matureCellTargetSurfaceArea) → None :

C++ signature :

void SetMatureCellTargetSurfaceArea(SurfaceAreaConstraintPottsUpdateRule<2u> {lvalue},double)

class chaste.cell_based.SurfaceAreaConstraintPottsUpdateRule3

EvaluateHamiltonianContribution((SurfaceAreaConstraintPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

EvaluateHamiltonianContribution( (SurfaceAreaConstraintPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(SurfaceAreaConstraintPottsUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

GetDeformationEnergyParameter((SurfaceAreaConstraintPottsUpdateRule3)arg1) → float :

C++ signature :

double GetDeformationEnergyParameter(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue})

GetMatureCellTargetSurfaceArea((SurfaceAreaConstraintPottsUpdateRule3)arg1) → float :

C++ signature :

double GetMatureCellTargetSurfaceArea(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue})

OutputUpdateRuleParameters((SurfaceAreaConstraintPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (SurfaceAreaConstraintPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(SurfaceAreaConstraintPottsUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDeformationEnergyParameter((SurfaceAreaConstraintPottsUpdateRule3)arg1, (float)deformationEnergyParameter) → None :

C++ signature :

void SetDeformationEnergyParameter(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue},double)

SetMatureCellTargetSurfaceArea((SurfaceAreaConstraintPottsUpdateRule3)arg1, (float)matureCellTargetSurfaceArea) → None :

C++ signature :

void SetMatureCellTargetSurfaceArea(SurfaceAreaConstraintPottsUpdateRule<3u> {lvalue},double)

class chaste.cell_based.DifferentialAdhesionPottsUpdateRule2

EvaluateHamiltonianContribution((DifferentialAdhesionPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

EvaluateHamiltonianContribution( (DifferentialAdhesionPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(DifferentialAdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

GetCellBoundaryAdhesionEnergy((DifferentialAdhesionPottsUpdateRule2)arg1, (Cell)pCell) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergy( (DifferentialAdhesionPottsUpdateRule2)arg1, (Cell)pCell) -> float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(DifferentialAdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy((DifferentialAdhesionPottsUpdateRule2)arg1, (Cell)pCellA, (Cell)pCellB) → float :

C++ signature :

double GetCellCellAdhesionEnergy(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy( (DifferentialAdhesionPottsUpdateRule2)arg1, (Cell)pCellA, (Cell)pCellB) -> float :

C++ signature :

double GetCellCellAdhesionEnergy(DifferentialAdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetLabelledCellBoundaryAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1) → float :

C++ signature :

double GetLabelledCellBoundaryAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue})

GetLabelledCellCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1) → float :

C++ signature :

double GetLabelledCellCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue})

GetLabelledCellLabelledCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1) → float :

C++ signature :

double GetLabelledCellLabelledCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue})

OutputUpdateRuleParameters((DifferentialAdhesionPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (DifferentialAdhesionPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(DifferentialAdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetLabelledCellBoundaryAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1, (float)labelledCellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellBoundaryAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},double)

SetLabelledCellCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1, (float)labelledCellCellAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},double)

SetLabelledCellLabelledCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule2)arg1, (float)labelledCellLabelledCellAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellLabelledCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<2u> {lvalue},double)

class chaste.cell_based.DifferentialAdhesionPottsUpdateRule3

EvaluateHamiltonianContribution((DifferentialAdhesionPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

EvaluateHamiltonianContribution( (DifferentialAdhesionPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(DifferentialAdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

GetCellBoundaryAdhesionEnergy((DifferentialAdhesionPottsUpdateRule3)arg1, (Cell)pCell) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergy( (DifferentialAdhesionPottsUpdateRule3)arg1, (Cell)pCell) -> float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(DifferentialAdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy((DifferentialAdhesionPottsUpdateRule3)arg1, (Cell)pCellA, (Cell)pCellB) → float :

C++ signature :

double GetCellCellAdhesionEnergy(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy( (DifferentialAdhesionPottsUpdateRule3)arg1, (Cell)pCellA, (Cell)pCellB) -> float :

C++ signature :

double GetCellCellAdhesionEnergy(DifferentialAdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetLabelledCellBoundaryAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1) → float :

C++ signature :

double GetLabelledCellBoundaryAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue})

GetLabelledCellCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1) → float :

C++ signature :

double GetLabelledCellCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue})

GetLabelledCellLabelledCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1) → float :

C++ signature :

double GetLabelledCellLabelledCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue})

OutputUpdateRuleParameters((DifferentialAdhesionPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (DifferentialAdhesionPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(DifferentialAdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetLabelledCellBoundaryAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1, (float)labelledCellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellBoundaryAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},double)

SetLabelledCellCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1, (float)labelledCellCellAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},double)

SetLabelledCellLabelledCellAdhesionEnergyParameter((DifferentialAdhesionPottsUpdateRule3)arg1, (float)labelledCellLabelledCellAdhesionEnergyParameter) → None :

C++ signature :

void SetLabelledCellLabelledCellAdhesionEnergyParameter(DifferentialAdhesionPottsUpdateRule<3u> {lvalue},double)

class chaste.cell_based.AdhesionPottsUpdateRule2

EvaluateHamiltonianContribution((AdhesionPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(AdhesionPottsUpdateRule<2u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

EvaluateHamiltonianContribution( (AdhesionPottsUpdateRule2)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation2)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(AdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<2u> {lvalue})

GetCellBoundaryAdhesionEnergy((AdhesionPottsUpdateRule2)arg1, (Cell)pCell) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(AdhesionPottsUpdateRule<2u> {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergy( (AdhesionPottsUpdateRule2)arg1, (Cell)pCell) -> float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(AdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergyParameter((AdhesionPottsUpdateRule2)arg1) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergyParameter(AdhesionPottsUpdateRule<2u> {lvalue})

GetCellCellAdhesionEnergy((AdhesionPottsUpdateRule2)arg1, (Cell)pCellA, (Cell)pCellB) → float :

C++ signature :

double GetCellCellAdhesionEnergy(AdhesionPottsUpdateRule<2u> {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy( (AdhesionPottsUpdateRule2)arg1, (Cell)pCellA, (Cell)pCellB) -> float :

C++ signature :

double GetCellCellAdhesionEnergy(AdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergyParameter((AdhesionPottsUpdateRule2)arg1) → float :

C++ signature :

double GetCellCellAdhesionEnergyParameter(AdhesionPottsUpdateRule<2u> {lvalue})

OutputUpdateRuleParameters((AdhesionPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AdhesionPottsUpdateRule<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AdhesionPottsUpdateRule2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AdhesionPottsUpdateRule_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetCellBoundaryAdhesionEnergyParameter((AdhesionPottsUpdateRule2)arg1, (float)cellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetCellBoundaryAdhesionEnergyParameter(AdhesionPottsUpdateRule<2u> {lvalue},double)

SetCellCellAdhesionEnergyParameter((AdhesionPottsUpdateRule2)arg1, (float)cellCellAdhesionEnergyEnergyParameter) → None :

C++ signature :

void SetCellCellAdhesionEnergyParameter(AdhesionPottsUpdateRule<2u> {lvalue},double)

class chaste.cell_based.AdhesionPottsUpdateRule3

EvaluateHamiltonianContribution((AdhesionPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) → float :

C++ signature :

double EvaluateHamiltonianContribution(AdhesionPottsUpdateRule<3u> {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

EvaluateHamiltonianContribution( (AdhesionPottsUpdateRule3)arg1, (int)currentNodeIndex, (int)targetNodeIndex, (PottsBasedCellPopulation3)rCellPopulation) -> float :

C++ signature :

double EvaluateHamiltonianContribution(AdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,PottsBasedCellPopulation<3u> {lvalue})

GetCellBoundaryAdhesionEnergy((AdhesionPottsUpdateRule3)arg1, (Cell)pCell) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(AdhesionPottsUpdateRule<3u> {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergy( (AdhesionPottsUpdateRule3)arg1, (Cell)pCell) -> float :

C++ signature :

double GetCellBoundaryAdhesionEnergy(AdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>)

GetCellBoundaryAdhesionEnergyParameter((AdhesionPottsUpdateRule3)arg1) → float :

C++ signature :

double GetCellBoundaryAdhesionEnergyParameter(AdhesionPottsUpdateRule<3u> {lvalue})

GetCellCellAdhesionEnergy((AdhesionPottsUpdateRule3)arg1, (Cell)pCellA, (Cell)pCellB) → float :

C++ signature :

double GetCellCellAdhesionEnergy(AdhesionPottsUpdateRule<3u> {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergy( (AdhesionPottsUpdateRule3)arg1, (Cell)pCellA, (Cell)pCellB) -> float :

C++ signature :

double GetCellCellAdhesionEnergy(AdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},boost::shared_ptr<Cell>,boost::shared_ptr<Cell>)

GetCellCellAdhesionEnergyParameter((AdhesionPottsUpdateRule3)arg1) → float :

C++ signature :

double GetCellCellAdhesionEnergyParameter(AdhesionPottsUpdateRule<3u> {lvalue})

OutputUpdateRuleParameters((AdhesionPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputUpdateRuleParameters(AdhesionPottsUpdateRule<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputUpdateRuleParameters( (AdhesionPottsUpdateRule3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputUpdateRuleParameters(AdhesionPottsUpdateRule_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetCellBoundaryAdhesionEnergyParameter((AdhesionPottsUpdateRule3)arg1, (float)cellBoundaryAdhesionEnergyParameter) → None :

C++ signature :

void SetCellBoundaryAdhesionEnergyParameter(AdhesionPottsUpdateRule<3u> {lvalue},double)

SetCellCellAdhesionEnergyParameter((AdhesionPottsUpdateRule3)arg1, (float)cellCellAdhesionEnergyEnergyParameter) → None :

C++ signature :

void SetCellCellAdhesionEnergyParameter(AdhesionPottsUpdateRule<3u> {lvalue},double)

class chaste.cell_based.SphereGeometryBoundaryCondition2

GetRadiusOfSphere((SphereGeometryBoundaryCondition2)arg1) → float :

C++ signature :

double GetRadiusOfSphere(SphereGeometryBoundaryCondition<2u> {lvalue})

ImposeBoundaryCondition((SphereGeometryBoundaryCondition2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(SphereGeometryBoundaryCondition<2u> {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

ImposeBoundaryCondition( (SphereGeometryBoundaryCondition2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(SphereGeometryBoundaryCondition_less__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

OutputCellPopulationBoundaryConditionParameters((SphereGeometryBoundaryCondition2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(SphereGeometryBoundaryCondition<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (SphereGeometryBoundaryCondition2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(SphereGeometryBoundaryCondition_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

VerifyBoundaryCondition((SphereGeometryBoundaryCondition2)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(SphereGeometryBoundaryCondition<2u> {lvalue})

VerifyBoundaryCondition( (SphereGeometryBoundaryCondition2)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(SphereGeometryBoundaryCondition_less__2__greater__wrapper {lvalue})

rGetCentreOfSphere((SphereGeometryBoundaryCondition2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetCentreOfSphere(SphereGeometryBoundaryCondition<2u> {lvalue})

class chaste.cell_based.SphereGeometryBoundaryCondition3

GetRadiusOfSphere((SphereGeometryBoundaryCondition3)arg1) → float :

C++ signature :

double GetRadiusOfSphere(SphereGeometryBoundaryCondition<3u> {lvalue})

ImposeBoundaryCondition((SphereGeometryBoundaryCondition3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(SphereGeometryBoundaryCondition<3u> {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

ImposeBoundaryCondition( (SphereGeometryBoundaryCondition3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(SphereGeometryBoundaryCondition_less__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

OutputCellPopulationBoundaryConditionParameters((SphereGeometryBoundaryCondition3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(SphereGeometryBoundaryCondition<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (SphereGeometryBoundaryCondition3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(SphereGeometryBoundaryCondition_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

VerifyBoundaryCondition((SphereGeometryBoundaryCondition3)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(SphereGeometryBoundaryCondition<3u> {lvalue})

VerifyBoundaryCondition( (SphereGeometryBoundaryCondition3)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(SphereGeometryBoundaryCondition_less__3__greater__wrapper {lvalue})

rGetCentreOfSphere((SphereGeometryBoundaryCondition3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetCentreOfSphere(SphereGeometryBoundaryCondition<3u> {lvalue})

class chaste.cell_based.AbstractCellKiller2

CheckAndLabelCellsForApoptosisOrDeath((AbstractCellKiller2)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(AbstractCellKiller<2u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (AbstractCellKiller2)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(AbstractCellKiller_less__2__greater__wrapper {lvalue})

GetCellPopulation((AbstractCellKiller2)arg1) → AbstractCellPopulation2_2 :

C++ signature :

AbstractCellPopulation<2u, 2u> const* GetCellPopulation(AbstractCellKiller<2u> {lvalue})

OutputCellKillerInfo((AbstractCellKiller2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerInfo(AbstractCellKiller<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters((AbstractCellKiller2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(AbstractCellKiller<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (AbstractCellKiller2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellKillerParameters(AbstractCellKiller_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractCellKiller3

CheckAndLabelCellsForApoptosisOrDeath((AbstractCellKiller3)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(AbstractCellKiller<3u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (AbstractCellKiller3)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(AbstractCellKiller_less__3__greater__wrapper {lvalue})

GetCellPopulation((AbstractCellKiller3)arg1) → AbstractCellPopulation3_3 :

C++ signature :

AbstractCellPopulation<3u, 3u> const* GetCellPopulation(AbstractCellKiller<3u> {lvalue})

OutputCellKillerInfo((AbstractCellKiller3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerInfo(AbstractCellKiller<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters((AbstractCellKiller3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(AbstractCellKiller<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (AbstractCellKiller3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellKillerParameters(AbstractCellKiller_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.PlaneBasedCellKiller2

CheckAndLabelCellsForApoptosisOrDeath((PlaneBasedCellKiller2)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(PlaneBasedCellKiller<2u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (PlaneBasedCellKiller2)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(PlaneBasedCellKiller_less__2__greater__wrapper {lvalue})

OutputCellKillerParameters((PlaneBasedCellKiller2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(PlaneBasedCellKiller<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (PlaneBasedCellKiller2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(PlaneBasedCellKiller_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

rGetNormalToPlane((PlaneBasedCellKiller2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetNormalToPlane(PlaneBasedCellKiller<2u> {lvalue})

rGetPointOnPlane((PlaneBasedCellKiller2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetPointOnPlane(PlaneBasedCellKiller<2u> {lvalue})

class chaste.cell_based.PlaneBasedCellKiller3

CheckAndLabelCellsForApoptosisOrDeath((PlaneBasedCellKiller3)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(PlaneBasedCellKiller<3u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (PlaneBasedCellKiller3)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(PlaneBasedCellKiller_less__3__greater__wrapper {lvalue})

OutputCellKillerParameters((PlaneBasedCellKiller3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(PlaneBasedCellKiller<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (PlaneBasedCellKiller3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(PlaneBasedCellKiller_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

rGetNormalToPlane((PlaneBasedCellKiller3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetNormalToPlane(PlaneBasedCellKiller<3u> {lvalue})

rGetPointOnPlane((PlaneBasedCellKiller3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetPointOnPlane(PlaneBasedCellKiller<3u> {lvalue})

class chaste.cell_based.ApoptoticCellKiller2

CheckAndLabelCellsForApoptosisOrDeath((ApoptoticCellKiller2)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(ApoptoticCellKiller<2u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (ApoptoticCellKiller2)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(ApoptoticCellKiller_less__2__greater__wrapper {lvalue})

CheckAndLabelSingleCellForApoptosis((ApoptoticCellKiller2)arg1, (Cell)pCell) → None :

C++ signature :

void CheckAndLabelSingleCellForApoptosis(ApoptoticCellKiller<2u> {lvalue},boost::shared_ptr<Cell>)

OutputCellKillerParameters((ApoptoticCellKiller2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(ApoptoticCellKiller<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (ApoptoticCellKiller2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(ApoptoticCellKiller_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.ApoptoticCellKiller3

CheckAndLabelCellsForApoptosisOrDeath((ApoptoticCellKiller3)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(ApoptoticCellKiller<3u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (ApoptoticCellKiller3)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(ApoptoticCellKiller_less__3__greater__wrapper {lvalue})

CheckAndLabelSingleCellForApoptosis((ApoptoticCellKiller3)arg1, (Cell)pCell) → None :

C++ signature :

void CheckAndLabelSingleCellForApoptosis(ApoptoticCellKiller<3u> {lvalue},boost::shared_ptr<Cell>)

OutputCellKillerParameters((ApoptoticCellKiller3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(ApoptoticCellKiller<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (ApoptoticCellKiller3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(ApoptoticCellKiller_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.RandomCellKiller2

CheckAndLabelCellsForApoptosisOrDeath((RandomCellKiller2)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(RandomCellKiller<2u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (RandomCellKiller2)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(RandomCellKiller_less__2__greater__wrapper {lvalue})

CheckAndLabelSingleCellForApoptosis((RandomCellKiller2)arg1, (Cell)pCell) → None :

C++ signature :

void CheckAndLabelSingleCellForApoptosis(RandomCellKiller<2u> {lvalue},boost::shared_ptr<Cell>)

GetDeathProbabilityInAnHour((RandomCellKiller2)arg1) → float :

C++ signature :

double GetDeathProbabilityInAnHour(RandomCellKiller<2u> {lvalue})

OutputCellKillerParameters((RandomCellKiller2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(RandomCellKiller<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (RandomCellKiller2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(RandomCellKiller_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.RandomCellKiller3

CheckAndLabelCellsForApoptosisOrDeath((RandomCellKiller3)arg1) → None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(RandomCellKiller<3u> {lvalue})

CheckAndLabelCellsForApoptosisOrDeath( (RandomCellKiller3)arg1) -> None :

C++ signature :

void CheckAndLabelCellsForApoptosisOrDeath(RandomCellKiller_less__3__greater__wrapper {lvalue})

CheckAndLabelSingleCellForApoptosis((RandomCellKiller3)arg1, (Cell)pCell) → None :

C++ signature :

void CheckAndLabelSingleCellForApoptosis(RandomCellKiller<3u> {lvalue},boost::shared_ptr<Cell>)

GetDeathProbabilityInAnHour((RandomCellKiller3)arg1) → float :

C++ signature :

double GetDeathProbabilityInAnHour(RandomCellKiller<3u> {lvalue})

OutputCellKillerParameters((RandomCellKiller3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellKillerParameters(RandomCellKiller<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellKillerParameters( (RandomCellKiller3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellKillerParameters(RandomCellKiller_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.CellwiseSourceEllipticPde2

ComputeConstantInUSourceTerm((CellwiseSourceEllipticPde2)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeConstantInUSourceTerm(CellwiseSourceEllipticPde<2u> {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeConstantInUSourceTerm( (CellwiseSourceEllipticPde2)arg1, (object)rX, (object)pElement) -> float :

C++ signature :

double ComputeConstantInUSourceTerm(CellwiseSourceEllipticPde_less__2__greater__wrapper {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeConstantInUSourceTermAtNode((CellwiseSourceEllipticPde2)arg1, (object)rNode) → float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(CellwiseSourceEllipticPde<2u> {lvalue},Node<2u>)

ComputeConstantInUSourceTermAtNode( (CellwiseSourceEllipticPde2)arg1, (object)rNode) -> float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(CellwiseSourceEllipticPde_less__2__greater__wrapper {lvalue},Node<2u>)

ComputeDiffusionTerm((CellwiseSourceEllipticPde2)arg1, (object)rX) → object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 2ul, 2ul> ComputeDiffusionTerm(CellwiseSourceEllipticPde<2u> {lvalue},ChastePoint<2u>)

ComputeDiffusionTerm( (CellwiseSourceEllipticPde2)arg1, (object)rX) -> object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 2ul, 2ul> ComputeDiffusionTerm(CellwiseSourceEllipticPde_less__2__greater__wrapper {lvalue},ChastePoint<2u>)

ComputeLinearInUCoeffInSourceTerm((CellwiseSourceEllipticPde2)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(CellwiseSourceEllipticPde<2u> {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeLinearInUCoeffInSourceTerm( (CellwiseSourceEllipticPde2)arg1, (object)rX, (object)pElement) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(CellwiseSourceEllipticPde_less__2__greater__wrapper {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeLinearInUCoeffInSourceTermAtNode((CellwiseSourceEllipticPde2)arg1, (object)rNode) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(CellwiseSourceEllipticPde<2u> {lvalue},Node<2u>)

ComputeLinearInUCoeffInSourceTermAtNode( (CellwiseSourceEllipticPde2)arg1, (object)rNode) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(CellwiseSourceEllipticPde_less__2__greater__wrapper {lvalue},Node<2u>)

GetCoefficient((CellwiseSourceEllipticPde2)arg1) → float :

C++ signature :

double GetCoefficient(CellwiseSourceEllipticPde<2u> {lvalue})

rGetCellPopulation((CellwiseSourceEllipticPde2)arg1) → AbstractCellPopulation2_2 :

C++ signature :

AbstractCellPopulation<2u, 2u> rGetCellPopulation(CellwiseSourceEllipticPde<2u> {lvalue})

class chaste.cell_based.CellwiseSourceEllipticPde3

ComputeConstantInUSourceTerm((CellwiseSourceEllipticPde3)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeConstantInUSourceTerm(CellwiseSourceEllipticPde<3u> {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeConstantInUSourceTerm( (CellwiseSourceEllipticPde3)arg1, (object)rX, (object)pElement) -> float :

C++ signature :

double ComputeConstantInUSourceTerm(CellwiseSourceEllipticPde_less__3__greater__wrapper {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeConstantInUSourceTermAtNode((CellwiseSourceEllipticPde3)arg1, (object)rNode) → float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(CellwiseSourceEllipticPde<3u> {lvalue},Node<3u>)

ComputeConstantInUSourceTermAtNode( (CellwiseSourceEllipticPde3)arg1, (object)rNode) -> float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(CellwiseSourceEllipticPde_less__3__greater__wrapper {lvalue},Node<3u>)

ComputeDiffusionTerm((CellwiseSourceEllipticPde3)arg1, (object)rX) → object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 3ul, 3ul> ComputeDiffusionTerm(CellwiseSourceEllipticPde<3u> {lvalue},ChastePoint<3u>)

ComputeDiffusionTerm( (CellwiseSourceEllipticPde3)arg1, (object)rX) -> object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 3ul, 3ul> ComputeDiffusionTerm(CellwiseSourceEllipticPde_less__3__greater__wrapper {lvalue},ChastePoint<3u>)

ComputeLinearInUCoeffInSourceTerm((CellwiseSourceEllipticPde3)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(CellwiseSourceEllipticPde<3u> {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeLinearInUCoeffInSourceTerm( (CellwiseSourceEllipticPde3)arg1, (object)rX, (object)pElement) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(CellwiseSourceEllipticPde_less__3__greater__wrapper {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeLinearInUCoeffInSourceTermAtNode((CellwiseSourceEllipticPde3)arg1, (object)rNode) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(CellwiseSourceEllipticPde<3u> {lvalue},Node<3u>)

ComputeLinearInUCoeffInSourceTermAtNode( (CellwiseSourceEllipticPde3)arg1, (object)rNode) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(CellwiseSourceEllipticPde_less__3__greater__wrapper {lvalue},Node<3u>)

GetCoefficient((CellwiseSourceEllipticPde3)arg1) → float :

C++ signature :

double GetCoefficient(CellwiseSourceEllipticPde<3u> {lvalue})

rGetCellPopulation((CellwiseSourceEllipticPde3)arg1) → AbstractCellPopulation3_3 :

C++ signature :

AbstractCellPopulation<3u, 3u> rGetCellPopulation(CellwiseSourceEllipticPde<3u> {lvalue})

class chaste.cell_based.AbstractPdeModifier2

GetBoundaryCondition((AbstractPdeModifier2)arg1) → object :

C++ signature :

boost::shared_ptr<AbstractBoundaryCondition<2u> > GetBoundaryCondition(AbstractPdeModifier<2u> {lvalue})

GetOutputGradient((AbstractPdeModifier2)arg1) → bool :

C++ signature :

bool GetOutputGradient(AbstractPdeModifier<2u> {lvalue})

GetPde((AbstractPdeModifier2)arg1) → AbstractLinearPde2_2 :

C++ signature :

boost::shared_ptr<AbstractLinearPde<2u, 2u> > GetPde(AbstractPdeModifier<2u> {lvalue})

HasAveragedSourcePde((AbstractPdeModifier2)arg1) → bool :

C++ signature :

bool HasAveragedSourcePde(AbstractPdeModifier<2u> {lvalue})

IsNeumannBoundaryCondition((AbstractPdeModifier2)arg1) → bool :

C++ signature :

bool IsNeumannBoundaryCondition(AbstractPdeModifier<2u> {lvalue})

OutputSimulationModifierParameters((AbstractPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractPdeModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractPdeModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDependentVariableName((AbstractPdeModifier2)arg1, (str)rName) → None :

C++ signature :

void SetDependentVariableName(AbstractPdeModifier<2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetOutputGradient((AbstractPdeModifier2)arg1, (bool)outputGradient) → None :

C++ signature :

void SetOutputGradient(AbstractPdeModifier<2u> {lvalue},bool)

SetOutputSolutionAtPdeNodes((AbstractPdeModifier2)arg1, (bool)outputSolutionAtPdeNodes) → None :

C++ signature :

void SetOutputSolutionAtPdeNodes(AbstractPdeModifier<2u> {lvalue},bool)

SetUpSourceTermsForAveragedSourcePde((AbstractPdeModifier2)arg1, (object)pMesh, (MapCellUnsigned)pCellPdeElementMap) → None :

C++ signature :

void SetUpSourceTermsForAveragedSourcePde(AbstractPdeModifier<2u> {lvalue},TetrahedralMesh<2u, 2u>*,std::map<boost::shared_ptr<Cell>, unsigned int, std::less<boost::shared_ptr<Cell> >, std::allocator<std::pair<boost::shared_ptr<Cell> const, unsigned int> > >*)

SetupSolve((AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractPdeModifier2)arg1, (AbstractCellPopulation2_2)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.AbstractPdeModifier3

GetBoundaryCondition((AbstractPdeModifier3)arg1) → object :

C++ signature :

boost::shared_ptr<AbstractBoundaryCondition<3u> > GetBoundaryCondition(AbstractPdeModifier<3u> {lvalue})

GetOutputGradient((AbstractPdeModifier3)arg1) → bool :

C++ signature :

bool GetOutputGradient(AbstractPdeModifier<3u> {lvalue})

GetPde((AbstractPdeModifier3)arg1) → AbstractLinearPde3_3 :

C++ signature :

boost::shared_ptr<AbstractLinearPde<3u, 3u> > GetPde(AbstractPdeModifier<3u> {lvalue})

HasAveragedSourcePde((AbstractPdeModifier3)arg1) → bool :

C++ signature :

bool HasAveragedSourcePde(AbstractPdeModifier<3u> {lvalue})

IsNeumannBoundaryCondition((AbstractPdeModifier3)arg1) → bool :

C++ signature :

bool IsNeumannBoundaryCondition(AbstractPdeModifier<3u> {lvalue})

OutputSimulationModifierParameters((AbstractPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractPdeModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractPdeModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetDependentVariableName((AbstractPdeModifier3)arg1, (str)rName) → None :

C++ signature :

void SetDependentVariableName(AbstractPdeModifier<3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetOutputGradient((AbstractPdeModifier3)arg1, (bool)outputGradient) → None :

C++ signature :

void SetOutputGradient(AbstractPdeModifier<3u> {lvalue},bool)

SetOutputSolutionAtPdeNodes((AbstractPdeModifier3)arg1, (bool)outputSolutionAtPdeNodes) → None :

C++ signature :

void SetOutputSolutionAtPdeNodes(AbstractPdeModifier<3u> {lvalue},bool)

SetUpSourceTermsForAveragedSourcePde((AbstractPdeModifier3)arg1, (object)pMesh, (MapCellUnsigned)pCellPdeElementMap) → None :

C++ signature :

void SetUpSourceTermsForAveragedSourcePde(AbstractPdeModifier<3u> {lvalue},TetrahedralMesh<3u, 3u>*,std::map<boost::shared_ptr<Cell>, unsigned int, std::less<boost::shared_ptr<Cell> >, std::allocator<std::pair<boost::shared_ptr<Cell> const, unsigned int> > >*)

SetupSolve((AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractPdeModifier3)arg1, (AbstractCellPopulation3_3)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.AbstractGrowingDomainPdeModifier2

GenerateFeMesh((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void GenerateFeMesh(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

OutputSimulationModifierParameters((AbstractGrowingDomainPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractGrowingDomainPdeModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractGrowingDomainPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateCellData((AbstractGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateCellData(AbstractGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.AbstractGrowingDomainPdeModifier3

GenerateFeMesh((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void GenerateFeMesh(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

OutputSimulationModifierParameters((AbstractGrowingDomainPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractGrowingDomainPdeModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractGrowingDomainPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(AbstractGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateCellData((AbstractGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateCellData(AbstractGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.EllipticGrowingDomainPdeModifier2

OutputSimulationModifierParameters((EllipticGrowingDomainPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(EllipticGrowingDomainPdeModifier<2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (EllipticGrowingDomainPdeModifier2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(EllipticGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(EllipticGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(EllipticGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(EllipticGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(EllipticGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(EllipticGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(EllipticGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(EllipticGrowingDomainPdeModifier<2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (EllipticGrowingDomainPdeModifier2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(EllipticGrowingDomainPdeModifier_less__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.EllipticGrowingDomainPdeModifier3

OutputSimulationModifierParameters((EllipticGrowingDomainPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(EllipticGrowingDomainPdeModifier<3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (EllipticGrowingDomainPdeModifier3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationModifierParameters(EllipticGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(EllipticGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) -> None :

C++ signature :

void SetupSolve(EllipticGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(EllipticGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(EllipticGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(EllipticGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(EllipticGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(EllipticGrowingDomainPdeModifier<3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (EllipticGrowingDomainPdeModifier3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(EllipticGrowingDomainPdeModifier_less__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.AbstractCellBasedSimulation2_2

AddCellKiller((AbstractCellBasedSimulation2_2)arg1, (object)pCellKiller) → None :

C++ signature :

void AddCellKiller(AbstractCellBasedSimulation<2u, 2u> {lvalue},boost::shared_ptr<AbstractCellKiller<2u> >)

AddSimulationModifier((AbstractCellBasedSimulation2_2)arg1, (object)pSimulationModifier) → None :

C++ signature :

void AddSimulationModifier(AbstractCellBasedSimulation<2u, 2u> {lvalue},boost::shared_ptr<AbstractCellBasedSimulationModifier<2u, 2u> >)

DoCellBirth((AbstractCellBasedSimulation2_2)arg1) → int :

C++ signature :

unsigned int DoCellBirth(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

DoCellRemoval((AbstractCellBasedSimulation2_2)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

GetDt((AbstractCellBasedSimulation2_2)arg1) → float :

C++ signature :

double GetDt(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetNodeLocation((AbstractCellBasedSimulation2_2)arg1, (int)rNodeIndex) → VecDouble :

C++ signature :

std::vector<double, std::allocator<double> > GetNodeLocation(AbstractCellBasedSimulation<2u, 2u> {lvalue},unsigned int)

GetNumBirths((AbstractCellBasedSimulation2_2)arg1) → int :

C++ signature :

unsigned int GetNumBirths(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetNumDeaths((AbstractCellBasedSimulation2_2)arg1) → int :

C++ signature :

unsigned int GetNumDeaths(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetOutputCellVelocities((AbstractCellBasedSimulation2_2)arg1) → bool :

C++ signature :

bool GetOutputCellVelocities(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetOutputDirectory((AbstractCellBasedSimulation2_2)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetOutputDirectory(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetOutputDivisionLocations((AbstractCellBasedSimulation2_2)arg1) → bool :

C++ signature :

bool GetOutputDivisionLocations(AbstractCellBasedSimulation<2u, 2u> {lvalue})

GetUpdateCellPopulationRule((AbstractCellBasedSimulation2_2)arg1) → bool :

C++ signature :

bool GetUpdateCellPopulationRule(AbstractCellBasedSimulation<2u, 2u> {lvalue})

OutputAdditionalSimulationSetup((AbstractCellBasedSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((AbstractCellBasedSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(AbstractCellBasedSimulation<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (AbstractCellBasedSimulation2_2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputSimulationParameters(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void OutputSimulationSetup(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

RemoveAllCellKillers((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void RemoveAllCellKillers(AbstractCellBasedSimulation<2u, 2u> {lvalue})

SetDt((AbstractCellBasedSimulation2_2)arg1, (float)dt) → None :

C++ signature :

void SetDt(AbstractCellBasedSimulation<2u, 2u> {lvalue},double)

SetEndTime((AbstractCellBasedSimulation2_2)arg1, (float)endTime) → None :

C++ signature :

void SetEndTime(AbstractCellBasedSimulation<2u, 2u> {lvalue},double)

SetNoBirth((AbstractCellBasedSimulation2_2)arg1, (bool)noBirth) → None :

C++ signature :

void SetNoBirth(AbstractCellBasedSimulation<2u, 2u> {lvalue},bool)

SetOutputCellVelocities((AbstractCellBasedSimulation2_2)arg1, (bool)outputCellVelocities) → None :

C++ signature :

void SetOutputCellVelocities(AbstractCellBasedSimulation<2u, 2u> {lvalue},bool)

SetOutputDirectory((AbstractCellBasedSimulation2_2)arg1, (str)outputDirectory) → None :

C++ signature :

void SetOutputDirectory(AbstractCellBasedSimulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetOutputDivisionLocations((AbstractCellBasedSimulation2_2)arg1, (bool)outputDivisionLocations) → None :

C++ signature :

void SetOutputDivisionLocations(AbstractCellBasedSimulation<2u, 2u> {lvalue},bool)

SetSamplingTimestepMultiple((AbstractCellBasedSimulation2_2)arg1, (int)samplingTimestepMultiple) → None :

C++ signature :

void SetSamplingTimestepMultiple(AbstractCellBasedSimulation<2u, 2u> {lvalue},unsigned int)

SetUpdateCellPopulationRule((AbstractCellBasedSimulation2_2)arg1, (bool)updateCellPopulation) → None :

C++ signature :

void SetUpdateCellPopulationRule(AbstractCellBasedSimulation<2u, 2u> {lvalue},bool)

SetupSolve((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

Solve((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void Solve(AbstractCellBasedSimulation<2u, 2u> {lvalue})

StoppingEventHasOccurred((AbstractCellBasedSimulation2_2)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

UpdateCellPopulation((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void UpdateCellPopulation(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

WriteVisualizerSetupFile((AbstractCellBasedSimulation2_2)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(AbstractCellBasedSimulation_less__2_comma__2__greater__wrapper {lvalue})

rGetCellPopulation((AbstractCellBasedSimulation2_2)arg1) → AbstractCellPopulation2_2 :

C++ signature :

AbstractCellPopulation<2u, 2u> rGetCellPopulation(AbstractCellBasedSimulation<2u, 2u> {lvalue})

class chaste.cell_based.AbstractCellBasedSimulation3_3

AddCellKiller((AbstractCellBasedSimulation3_3)arg1, (object)pCellKiller) → None :

C++ signature :

void AddCellKiller(AbstractCellBasedSimulation<3u, 3u> {lvalue},boost::shared_ptr<AbstractCellKiller<3u> >)

AddSimulationModifier((AbstractCellBasedSimulation3_3)arg1, (object)pSimulationModifier) → None :

C++ signature :

void AddSimulationModifier(AbstractCellBasedSimulation<3u, 3u> {lvalue},boost::shared_ptr<AbstractCellBasedSimulationModifier<3u, 3u> >)

DoCellBirth((AbstractCellBasedSimulation3_3)arg1) → int :

C++ signature :

unsigned int DoCellBirth(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

DoCellRemoval((AbstractCellBasedSimulation3_3)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

GetDt((AbstractCellBasedSimulation3_3)arg1) → float :

C++ signature :

double GetDt(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetNodeLocation((AbstractCellBasedSimulation3_3)arg1, (int)rNodeIndex) → VecDouble :

C++ signature :

std::vector<double, std::allocator<double> > GetNodeLocation(AbstractCellBasedSimulation<3u, 3u> {lvalue},unsigned int)

GetNumBirths((AbstractCellBasedSimulation3_3)arg1) → int :

C++ signature :

unsigned int GetNumBirths(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetNumDeaths((AbstractCellBasedSimulation3_3)arg1) → int :

C++ signature :

unsigned int GetNumDeaths(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetOutputCellVelocities((AbstractCellBasedSimulation3_3)arg1) → bool :

C++ signature :

bool GetOutputCellVelocities(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetOutputDirectory((AbstractCellBasedSimulation3_3)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetOutputDirectory(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetOutputDivisionLocations((AbstractCellBasedSimulation3_3)arg1) → bool :

C++ signature :

bool GetOutputDivisionLocations(AbstractCellBasedSimulation<3u, 3u> {lvalue})

GetUpdateCellPopulationRule((AbstractCellBasedSimulation3_3)arg1) → bool :

C++ signature :

bool GetUpdateCellPopulationRule(AbstractCellBasedSimulation<3u, 3u> {lvalue})

OutputAdditionalSimulationSetup((AbstractCellBasedSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((AbstractCellBasedSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(AbstractCellBasedSimulation<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (AbstractCellBasedSimulation3_3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputSimulationParameters(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void OutputSimulationSetup(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

RemoveAllCellKillers((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void RemoveAllCellKillers(AbstractCellBasedSimulation<3u, 3u> {lvalue})

SetDt((AbstractCellBasedSimulation3_3)arg1, (float)dt) → None :

C++ signature :

void SetDt(AbstractCellBasedSimulation<3u, 3u> {lvalue},double)

SetEndTime((AbstractCellBasedSimulation3_3)arg1, (float)endTime) → None :

C++ signature :

void SetEndTime(AbstractCellBasedSimulation<3u, 3u> {lvalue},double)

SetNoBirth((AbstractCellBasedSimulation3_3)arg1, (bool)noBirth) → None :

C++ signature :

void SetNoBirth(AbstractCellBasedSimulation<3u, 3u> {lvalue},bool)

SetOutputCellVelocities((AbstractCellBasedSimulation3_3)arg1, (bool)outputCellVelocities) → None :

C++ signature :

void SetOutputCellVelocities(AbstractCellBasedSimulation<3u, 3u> {lvalue},bool)

SetOutputDirectory((AbstractCellBasedSimulation3_3)arg1, (str)outputDirectory) → None :

C++ signature :

void SetOutputDirectory(AbstractCellBasedSimulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetOutputDivisionLocations((AbstractCellBasedSimulation3_3)arg1, (bool)outputDivisionLocations) → None :

C++ signature :

void SetOutputDivisionLocations(AbstractCellBasedSimulation<3u, 3u> {lvalue},bool)

SetSamplingTimestepMultiple((AbstractCellBasedSimulation3_3)arg1, (int)samplingTimestepMultiple) → None :

C++ signature :

void SetSamplingTimestepMultiple(AbstractCellBasedSimulation<3u, 3u> {lvalue},unsigned int)

SetUpdateCellPopulationRule((AbstractCellBasedSimulation3_3)arg1, (bool)updateCellPopulation) → None :

C++ signature :

void SetUpdateCellPopulationRule(AbstractCellBasedSimulation<3u, 3u> {lvalue},bool)

SetupSolve((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

Solve((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void Solve(AbstractCellBasedSimulation<3u, 3u> {lvalue})

StoppingEventHasOccurred((AbstractCellBasedSimulation3_3)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

UpdateCellPopulation((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void UpdateCellPopulation(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

WriteVisualizerSetupFile((AbstractCellBasedSimulation3_3)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(AbstractCellBasedSimulation_less__3_comma__3__greater__wrapper {lvalue})

rGetCellPopulation((AbstractCellBasedSimulation3_3)arg1) → AbstractCellPopulation3_3 :

C++ signature :

AbstractCellPopulation<3u, 3u> rGetCellPopulation(AbstractCellBasedSimulation<3u, 3u> {lvalue})

class chaste.cell_based.OffLatticeSimulation2_2

AddCellPopulationBoundaryCondition((OffLatticeSimulation2_2)arg1, (object)pBoundaryCondition) → None :

C++ signature :

void AddCellPopulationBoundaryCondition(OffLatticeSimulation<2u, 2u> {lvalue},boost::shared_ptr<AbstractCellPopulationBoundaryCondition<2u, 2u> >)

AddForce((OffLatticeSimulation2_2)arg1, (object)pForce) → None :

C++ signature :

void AddForce(OffLatticeSimulation<2u, 2u> {lvalue},boost::shared_ptr<AbstractForce<2u, 2u> >)

ApplyBoundaries((OffLatticeSimulation2_2)arg1, (MapNodePtr2CVectorDouble_2)oldNodeLoctions) → None :

C++ signature :

void ApplyBoundaries(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

DoCellBirth((OffLatticeSimulation2_2)arg1) → int :

C++ signature :

unsigned int DoCellBirth(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

DoCellRemoval((OffLatticeSimulation2_2)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

GetNumericalMethod((OffLatticeSimulation2_2)arg1) → object :

C++ signature :

boost::shared_ptr<AbstractNumericalMethod<2u, 2u> > GetNumericalMethod(OffLatticeSimulation<2u, 2u> {lvalue})

OutputAdditionalSimulationSetup((OffLatticeSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(OffLatticeSimulation<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputAdditionalSimulationSetup( (OffLatticeSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputAdditionalSimulationSetup(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((OffLatticeSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(OffLatticeSimulation<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (OffLatticeSimulation2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationParameters(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void OutputSimulationSetup(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

RemoveAllCellPopulationBoundaryConditions((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void RemoveAllCellPopulationBoundaryConditions(OffLatticeSimulation<2u, 2u> {lvalue})

RemoveAllForces((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void RemoveAllForces(OffLatticeSimulation<2u, 2u> {lvalue})

RevertToOldLocations((OffLatticeSimulation2_2)arg1, (MapNodePtr2CVectorDouble_2)oldNodeLoctions) → None :

C++ signature :

void RevertToOldLocations(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

SetNumericalMethod((OffLatticeSimulation2_2)arg1, (object)pNumericalMethod) → None :

C++ signature :

void SetNumericalMethod(OffLatticeSimulation<2u, 2u> {lvalue},boost::shared_ptr<AbstractNumericalMethod<2u, 2u> >)

SetupSolve((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void SetupSolve(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

StoppingEventHasOccurred((OffLatticeSimulation2_2)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

UpdateCellPopulation((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void UpdateCellPopulation(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

WriteVisualizerSetupFile((OffLatticeSimulation2_2)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(OffLatticeSimulation_less__2_comma__2__greater__wrapper {lvalue})

class chaste.cell_based.OffLatticeSimulation3_3

AddCellPopulationBoundaryCondition((OffLatticeSimulation3_3)arg1, (object)pBoundaryCondition) → None :

C++ signature :

void AddCellPopulationBoundaryCondition(OffLatticeSimulation<3u, 3u> {lvalue},boost::shared_ptr<AbstractCellPopulationBoundaryCondition<3u, 3u> >)

AddForce((OffLatticeSimulation3_3)arg1, (object)pForce) → None :

C++ signature :

void AddForce(OffLatticeSimulation<3u, 3u> {lvalue},boost::shared_ptr<AbstractForce<3u, 3u> >)

ApplyBoundaries((OffLatticeSimulation3_3)arg1, (MapNodePtr2CVectorDouble_3)oldNodeLoctions) → None :

C++ signature :

void ApplyBoundaries(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

DoCellBirth((OffLatticeSimulation3_3)arg1) → int :

C++ signature :

unsigned int DoCellBirth(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

DoCellRemoval((OffLatticeSimulation3_3)arg1) → int :

C++ signature :

unsigned int DoCellRemoval(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

GetNumericalMethod((OffLatticeSimulation3_3)arg1) → object :

C++ signature :

boost::shared_ptr<AbstractNumericalMethod<3u, 3u> > GetNumericalMethod(OffLatticeSimulation<3u, 3u> {lvalue})

OutputAdditionalSimulationSetup((OffLatticeSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputAdditionalSimulationSetup(OffLatticeSimulation<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputAdditionalSimulationSetup( (OffLatticeSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputAdditionalSimulationSetup(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters((OffLatticeSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationParameters(OffLatticeSimulation<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationParameters( (OffLatticeSimulation3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputSimulationParameters(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationSetup((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void OutputSimulationSetup(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

RemoveAllCellPopulationBoundaryConditions((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void RemoveAllCellPopulationBoundaryConditions(OffLatticeSimulation<3u, 3u> {lvalue})

RemoveAllForces((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void RemoveAllForces(OffLatticeSimulation<3u, 3u> {lvalue})

RevertToOldLocations((OffLatticeSimulation3_3)arg1, (MapNodePtr2CVectorDouble_3)oldNodeLoctions) → None :

C++ signature :

void RevertToOldLocations(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

SetNumericalMethod((OffLatticeSimulation3_3)arg1, (object)pNumericalMethod) → None :

C++ signature :

void SetNumericalMethod(OffLatticeSimulation<3u, 3u> {lvalue},boost::shared_ptr<AbstractNumericalMethod<3u, 3u> >)

SetupSolve((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void SetupSolve(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

StoppingEventHasOccurred((OffLatticeSimulation3_3)arg1) → bool :

C++ signature :

bool StoppingEventHasOccurred(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

UpdateCellLocationsAndTopology((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void UpdateCellLocationsAndTopology(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

UpdateCellPopulation((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void UpdateCellPopulation(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

WriteVisualizerSetupFile((OffLatticeSimulation3_3)arg1) → None :

C++ signature :

void WriteVisualizerSetupFile(OffLatticeSimulation_less__3_comma__3__greater__wrapper {lvalue})

class chaste.cell_based.AbstractCellBasedSimulationModifier2_2

OutputSimulationModifierInfo((AbstractCellBasedSimulationModifier2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierInfo(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters((AbstractCellBasedSimulationModifier2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractCellBasedSimulationModifier2_2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractCellBasedSimulationModifier_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)arg2, (str)arg3) -> None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulationModifier_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractCellBasedSimulationModifier_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve((AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfSolve( (AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractCellBasedSimulationModifier_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep((AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractCellBasedSimulationModifier<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractCellBasedSimulationModifier2_2)arg1, (AbstractCellPopulation2_2)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractCellBasedSimulationModifier_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

class chaste.cell_based.AbstractCellBasedSimulationModifier3_3

OutputSimulationModifierInfo((AbstractCellBasedSimulationModifier3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierInfo(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters((AbstractCellBasedSimulationModifier3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputSimulationModifierParameters(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputSimulationModifierParameters( (AbstractCellBasedSimulationModifier3_3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputSimulationModifierParameters(AbstractCellBasedSimulationModifier_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetupSolve((AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation, (str)outputDirectory) → None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

SetupSolve( (AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)arg2, (str)arg3) -> None :

C++ signature :

void SetupSolve(AbstractCellBasedSimulationModifier_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

UpdateAtEndOfOutputTimeStep((AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfOutputTimeStep( (AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfOutputTimeStep(AbstractCellBasedSimulationModifier_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve((AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfSolve(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfSolve( (AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void UpdateAtEndOfSolve(AbstractCellBasedSimulationModifier_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep((AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractCellBasedSimulationModifier<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

UpdateAtEndOfTimeStep( (AbstractCellBasedSimulationModifier3_3)arg1, (AbstractCellPopulation3_3)arg2) -> None :

C++ signature :

void UpdateAtEndOfTimeStep(AbstractCellBasedSimulationModifier_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

class chaste.cell_based.AbstractTwoBodyInteractionForce2_2

AddForceContribution((AbstractTwoBodyInteractionForce2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void AddForceContribution(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

AddForceContribution( (AbstractTwoBodyInteractionForce2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(AbstractTwoBodyInteractionForce_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

CalculateForceBetweenNodes((AbstractTwoBodyInteractionForce2_2)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation2_2)rCellPopulation) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateForceBetweenNodes(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue})

CalculateForceBetweenNodes( (AbstractTwoBodyInteractionForce2_2)arg1, (int)arg2, (int)arg3, (AbstractCellPopulation2_2)arg4) -> None :

C++ signature :

void CalculateForceBetweenNodes(AbstractTwoBodyInteractionForce_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue})

GetCutOffLength((AbstractTwoBodyInteractionForce2_2)arg1) → float :

C++ signature :

double GetCutOffLength(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue})

GetUseCutOffLength((AbstractTwoBodyInteractionForce2_2)arg1) → bool :

C++ signature :

bool GetUseCutOffLength(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue})

OutputForceParameters((AbstractTwoBodyInteractionForce2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (AbstractTwoBodyInteractionForce2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(AbstractTwoBodyInteractionForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetCutOffLength((AbstractTwoBodyInteractionForce2_2)arg1, (float)cutOffLength) → None :

C++ signature :

void SetCutOffLength(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue},double)

WriteDataToVisualizerSetupFile((AbstractTwoBodyInteractionForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractTwoBodyInteractionForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (AbstractTwoBodyInteractionForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractTwoBodyInteractionForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractTwoBodyInteractionForce3_3

AddForceContribution((AbstractTwoBodyInteractionForce3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void AddForceContribution(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

AddForceContribution( (AbstractTwoBodyInteractionForce3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(AbstractTwoBodyInteractionForce_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

CalculateForceBetweenNodes((AbstractTwoBodyInteractionForce3_3)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation3_3)rCellPopulation) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateForceBetweenNodes(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue})

CalculateForceBetweenNodes( (AbstractTwoBodyInteractionForce3_3)arg1, (int)arg2, (int)arg3, (AbstractCellPopulation3_3)arg4) -> None :

C++ signature :

void CalculateForceBetweenNodes(AbstractTwoBodyInteractionForce_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue})

GetCutOffLength((AbstractTwoBodyInteractionForce3_3)arg1) → float :

C++ signature :

double GetCutOffLength(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue})

GetUseCutOffLength((AbstractTwoBodyInteractionForce3_3)arg1) → bool :

C++ signature :

bool GetUseCutOffLength(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue})

OutputForceParameters((AbstractTwoBodyInteractionForce3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (AbstractTwoBodyInteractionForce3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(AbstractTwoBodyInteractionForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetCutOffLength((AbstractTwoBodyInteractionForce3_3)arg1, (float)cutOffLength) → None :

C++ signature :

void SetCutOffLength(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue},double)

WriteDataToVisualizerSetupFile((AbstractTwoBodyInteractionForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractTwoBodyInteractionForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (AbstractTwoBodyInteractionForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractTwoBodyInteractionForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractForce2_2

AddForceContribution((AbstractForce2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void AddForceContribution(AbstractForce<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

AddForceContribution( (AbstractForce2_2)arg1, (AbstractCellPopulation2_2)arg2) -> None :

C++ signature :

void AddForceContribution(AbstractForce_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

OutputForceInfo((AbstractForce2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceInfo(AbstractForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters((AbstractForce2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(AbstractForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (AbstractForce2_2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputForceParameters(AbstractForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile((AbstractForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (AbstractForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractForce3_3

AddForceContribution((AbstractForce3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void AddForceContribution(AbstractForce<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

AddForceContribution( (AbstractForce3_3)arg1, (AbstractCellPopulation3_3)arg2) -> None :

C++ signature :

void AddForceContribution(AbstractForce_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

OutputForceInfo((AbstractForce3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceInfo(AbstractForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters((AbstractForce3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(AbstractForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (AbstractForce3_3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputForceParameters(AbstractForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile((AbstractForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (AbstractForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(AbstractForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.GeneralisedLinearSpringForce2_2

AddForceContribution((GeneralisedLinearSpringForce2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) → None :

C++ signature :

void AddForceContribution(GeneralisedLinearSpringForce<2u, 2u> {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

AddForceContribution( (GeneralisedLinearSpringForce2_2)arg1, (AbstractCellPopulation2_2)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(GeneralisedLinearSpringForce_less__2_comma__2__greater__wrapper {lvalue},AbstractCellPopulation<2u, 2u> {lvalue})

CalculateForceBetweenNodes((GeneralisedLinearSpringForce2_2)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation2_2)rCellPopulation) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateForceBetweenNodes(GeneralisedLinearSpringForce<2u, 2u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue})

CalculateForceBetweenNodes( (GeneralisedLinearSpringForce2_2)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation2_2)rCellPopulation) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateForceBetweenNodes(GeneralisedLinearSpringForce_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue})

GetMeinekeDivisionRestingSpringLength((GeneralisedLinearSpringForce2_2)arg1) → float :

C++ signature :

double GetMeinekeDivisionRestingSpringLength(GeneralisedLinearSpringForce<2u, 2u> {lvalue})

GetMeinekeSpringGrowthDuration((GeneralisedLinearSpringForce2_2)arg1) → float :

C++ signature :

double GetMeinekeSpringGrowthDuration(GeneralisedLinearSpringForce<2u, 2u> {lvalue})

GetMeinekeSpringStiffness((GeneralisedLinearSpringForce2_2)arg1) → float :

C++ signature :

double GetMeinekeSpringStiffness(GeneralisedLinearSpringForce<2u, 2u> {lvalue})

OutputForceParameters((GeneralisedLinearSpringForce2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(GeneralisedLinearSpringForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (GeneralisedLinearSpringForce2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(GeneralisedLinearSpringForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetMeinekeDivisionRestingSpringLength((GeneralisedLinearSpringForce2_2)arg1, (float)divisionRestingSpringLength) → None :

C++ signature :

void SetMeinekeDivisionRestingSpringLength(GeneralisedLinearSpringForce<2u, 2u> {lvalue},double)

SetMeinekeSpringGrowthDuration((GeneralisedLinearSpringForce2_2)arg1, (float)springGrowthDuration) → None :

C++ signature :

void SetMeinekeSpringGrowthDuration(GeneralisedLinearSpringForce<2u, 2u> {lvalue},double)

SetMeinekeSpringStiffness((GeneralisedLinearSpringForce2_2)arg1, (float)springStiffness) → None :

C++ signature :

void SetMeinekeSpringStiffness(GeneralisedLinearSpringForce<2u, 2u> {lvalue},double)

VariableSpringConstantMultiplicationFactor((GeneralisedLinearSpringForce2_2)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation2_2)rCellPopulation, (bool)isCloserThanRestLength) → float :

C++ signature :

double VariableSpringConstantMultiplicationFactor(GeneralisedLinearSpringForce<2u, 2u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue},bool)

VariableSpringConstantMultiplicationFactor( (GeneralisedLinearSpringForce2_2)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation2_2)rCellPopulation, (bool)isCloserThanRestLength) -> float :

C++ signature :

double VariableSpringConstantMultiplicationFactor(GeneralisedLinearSpringForce_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<2u, 2u> {lvalue},bool)

WriteDataToVisualizerSetupFile((GeneralisedLinearSpringForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(GeneralisedLinearSpringForce<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (GeneralisedLinearSpringForce2_2)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(GeneralisedLinearSpringForce_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.GeneralisedLinearSpringForce3_3

AddForceContribution((GeneralisedLinearSpringForce3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) → None :

C++ signature :

void AddForceContribution(GeneralisedLinearSpringForce<3u, 3u> {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

AddForceContribution( (GeneralisedLinearSpringForce3_3)arg1, (AbstractCellPopulation3_3)rCellPopulation) -> None :

C++ signature :

void AddForceContribution(GeneralisedLinearSpringForce_less__3_comma__3__greater__wrapper {lvalue},AbstractCellPopulation<3u, 3u> {lvalue})

CalculateForceBetweenNodes((GeneralisedLinearSpringForce3_3)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation3_3)rCellPopulation) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateForceBetweenNodes(GeneralisedLinearSpringForce<3u, 3u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue})

CalculateForceBetweenNodes( (GeneralisedLinearSpringForce3_3)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation3_3)rCellPopulation) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateForceBetweenNodes(GeneralisedLinearSpringForce_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue})

GetMeinekeDivisionRestingSpringLength((GeneralisedLinearSpringForce3_3)arg1) → float :

C++ signature :

double GetMeinekeDivisionRestingSpringLength(GeneralisedLinearSpringForce<3u, 3u> {lvalue})

GetMeinekeSpringGrowthDuration((GeneralisedLinearSpringForce3_3)arg1) → float :

C++ signature :

double GetMeinekeSpringGrowthDuration(GeneralisedLinearSpringForce<3u, 3u> {lvalue})

GetMeinekeSpringStiffness((GeneralisedLinearSpringForce3_3)arg1) → float :

C++ signature :

double GetMeinekeSpringStiffness(GeneralisedLinearSpringForce<3u, 3u> {lvalue})

OutputForceParameters((GeneralisedLinearSpringForce3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputForceParameters(GeneralisedLinearSpringForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputForceParameters( (GeneralisedLinearSpringForce3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputForceParameters(GeneralisedLinearSpringForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetMeinekeDivisionRestingSpringLength((GeneralisedLinearSpringForce3_3)arg1, (float)divisionRestingSpringLength) → None :

C++ signature :

void SetMeinekeDivisionRestingSpringLength(GeneralisedLinearSpringForce<3u, 3u> {lvalue},double)

SetMeinekeSpringGrowthDuration((GeneralisedLinearSpringForce3_3)arg1, (float)springGrowthDuration) → None :

C++ signature :

void SetMeinekeSpringGrowthDuration(GeneralisedLinearSpringForce<3u, 3u> {lvalue},double)

SetMeinekeSpringStiffness((GeneralisedLinearSpringForce3_3)arg1, (float)springStiffness) → None :

C++ signature :

void SetMeinekeSpringStiffness(GeneralisedLinearSpringForce<3u, 3u> {lvalue},double)

VariableSpringConstantMultiplicationFactor((GeneralisedLinearSpringForce3_3)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation3_3)rCellPopulation, (bool)isCloserThanRestLength) → float :

C++ signature :

double VariableSpringConstantMultiplicationFactor(GeneralisedLinearSpringForce<3u, 3u> {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue},bool)

VariableSpringConstantMultiplicationFactor( (GeneralisedLinearSpringForce3_3)arg1, (int)nodeAGlobalIndex, (int)nodeBGlobalIndex, (AbstractCellPopulation3_3)rCellPopulation, (bool)isCloserThanRestLength) -> float :

C++ signature :

double VariableSpringConstantMultiplicationFactor(GeneralisedLinearSpringForce_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,AbstractCellPopulation<3u, 3u> {lvalue},bool)

WriteDataToVisualizerSetupFile((GeneralisedLinearSpringForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) → None :

C++ signature :

void WriteDataToVisualizerSetupFile(GeneralisedLinearSpringForce<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

WriteDataToVisualizerSetupFile( (GeneralisedLinearSpringForce3_3)arg1, (StdOutputFileStream)pVizSetupFile) -> None :

C++ signature :

void WriteDataToVisualizerSetupFile(GeneralisedLinearSpringForce_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

class chaste.cell_based.AbstractCellPopulationBoundaryCondition2_2

GetCellPopulation((AbstractCellPopulationBoundaryCondition2_2)arg1) → AbstractCellPopulation2_2 :

C++ signature :

AbstractCellPopulation<2u, 2u> const* GetCellPopulation(AbstractCellPopulationBoundaryCondition<2u, 2u> {lvalue})

ImposeBoundaryCondition((AbstractCellPopulationBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(AbstractCellPopulationBoundaryCondition<2u, 2u> {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

ImposeBoundaryCondition( (AbstractCellPopulationBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)arg2) -> None :

C++ signature :

void ImposeBoundaryCondition(AbstractCellPopulationBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

OutputCellPopulationBoundaryConditionInfo((AbstractCellPopulationBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionInfo(AbstractCellPopulationBoundaryCondition<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters((AbstractCellPopulationBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AbstractCellPopulationBoundaryCondition<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (AbstractCellPopulationBoundaryCondition2_2)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AbstractCellPopulationBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

VerifyBoundaryCondition((AbstractCellPopulationBoundaryCondition2_2)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(AbstractCellPopulationBoundaryCondition<2u, 2u> {lvalue})

VerifyBoundaryCondition( (AbstractCellPopulationBoundaryCondition2_2)arg1) -> None :

C++ signature :

void VerifyBoundaryCondition(AbstractCellPopulationBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue})

class chaste.cell_based.AbstractCellPopulationBoundaryCondition3_3

GetCellPopulation((AbstractCellPopulationBoundaryCondition3_3)arg1) → AbstractCellPopulation3_3 :

C++ signature :

AbstractCellPopulation<3u, 3u> const* GetCellPopulation(AbstractCellPopulationBoundaryCondition<3u, 3u> {lvalue})

ImposeBoundaryCondition((AbstractCellPopulationBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(AbstractCellPopulationBoundaryCondition<3u, 3u> {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

ImposeBoundaryCondition( (AbstractCellPopulationBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)arg2) -> None :

C++ signature :

void ImposeBoundaryCondition(AbstractCellPopulationBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

OutputCellPopulationBoundaryConditionInfo((AbstractCellPopulationBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionInfo(AbstractCellPopulationBoundaryCondition<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters((AbstractCellPopulationBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AbstractCellPopulationBoundaryCondition<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (AbstractCellPopulationBoundaryCondition3_3)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AbstractCellPopulationBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

VerifyBoundaryCondition((AbstractCellPopulationBoundaryCondition3_3)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(AbstractCellPopulationBoundaryCondition<3u, 3u> {lvalue})

VerifyBoundaryCondition( (AbstractCellPopulationBoundaryCondition3_3)arg1) -> None :

C++ signature :

void VerifyBoundaryCondition(AbstractCellPopulationBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue})

class chaste.cell_based.PlaneBoundaryCondition2_2

GetUseJiggledNodesOnPlane((PlaneBoundaryCondition2_2)arg1) → bool :

C++ signature :

bool GetUseJiggledNodesOnPlane(PlaneBoundaryCondition<2u, 2u> {lvalue})

ImposeBoundaryCondition((PlaneBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(PlaneBoundaryCondition<2u, 2u> {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

ImposeBoundaryCondition( (PlaneBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(PlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

OutputCellPopulationBoundaryConditionParameters((PlaneBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(PlaneBoundaryCondition<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (PlaneBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(PlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetUseJiggledNodesOnPlane((PlaneBoundaryCondition2_2)arg1, (bool)useJiggledNodesOnPlane) → None :

C++ signature :

void SetUseJiggledNodesOnPlane(PlaneBoundaryCondition<2u, 2u> {lvalue},bool)

VerifyBoundaryCondition((PlaneBoundaryCondition2_2)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(PlaneBoundaryCondition<2u, 2u> {lvalue})

VerifyBoundaryCondition( (PlaneBoundaryCondition2_2)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(PlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue})

rGetNormalToPlane((PlaneBoundaryCondition2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetNormalToPlane(PlaneBoundaryCondition<2u, 2u> {lvalue})

rGetPointOnPlane((PlaneBoundaryCondition2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetPointOnPlane(PlaneBoundaryCondition<2u, 2u> {lvalue})

class chaste.cell_based.PlaneBoundaryCondition3_3

GetUseJiggledNodesOnPlane((PlaneBoundaryCondition3_3)arg1) → bool :

C++ signature :

bool GetUseJiggledNodesOnPlane(PlaneBoundaryCondition<3u, 3u> {lvalue})

ImposeBoundaryCondition((PlaneBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(PlaneBoundaryCondition<3u, 3u> {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

ImposeBoundaryCondition( (PlaneBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(PlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

OutputCellPopulationBoundaryConditionParameters((PlaneBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(PlaneBoundaryCondition<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (PlaneBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(PlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetUseJiggledNodesOnPlane((PlaneBoundaryCondition3_3)arg1, (bool)useJiggledNodesOnPlane) → None :

C++ signature :

void SetUseJiggledNodesOnPlane(PlaneBoundaryCondition<3u, 3u> {lvalue},bool)

VerifyBoundaryCondition((PlaneBoundaryCondition3_3)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(PlaneBoundaryCondition<3u, 3u> {lvalue})

VerifyBoundaryCondition( (PlaneBoundaryCondition3_3)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(PlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue})

rGetNormalToPlane((PlaneBoundaryCondition3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetNormalToPlane(PlaneBoundaryCondition<3u, 3u> {lvalue})

rGetPointOnPlane((PlaneBoundaryCondition3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetPointOnPlane(PlaneBoundaryCondition<3u, 3u> {lvalue})

class chaste.cell_based.AttractingPlaneBoundaryCondition2_2

GetUseJiggledNodesOnPlane((AttractingPlaneBoundaryCondition2_2)arg1) → bool :

C++ signature :

bool GetUseJiggledNodesOnPlane(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue})

ImposeBoundaryCondition((AttractingPlaneBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

ImposeBoundaryCondition( (AttractingPlaneBoundaryCondition2_2)arg1, (MapNodePtr2CVectorDouble_2)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(AttractingPlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::map<Node<2u>*, boost::numeric::ublas::c_vector<double, 2ul>, std::less<Node<2u>*>, std::allocator<std::pair<Node<2u>* const, boost::numeric::ublas::c_vector<double, 2ul> > > >)

OutputCellPopulationBoundaryConditionParameters((AttractingPlaneBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (AttractingPlaneBoundaryCondition2_2)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AttractingPlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetAttractionThreshold((AttractingPlaneBoundaryCondition2_2)arg1, (float)attractionThreshold) → None :

C++ signature :

void SetAttractionThreshold(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue},double)

SetPointOnPlane((AttractingPlaneBoundaryCondition2_2)arg1, (object)rPoint) → None :

C++ signature :

void SetPointOnPlane(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

SetUseJiggledNodesOnPlane((AttractingPlaneBoundaryCondition2_2)arg1, (bool)useJiggledNodesOnPlane) → None :

C++ signature :

void SetUseJiggledNodesOnPlane(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue},bool)

VerifyBoundaryCondition((AttractingPlaneBoundaryCondition2_2)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue})

VerifyBoundaryCondition( (AttractingPlaneBoundaryCondition2_2)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(AttractingPlaneBoundaryCondition_less__2_comma__2__greater__wrapper {lvalue})

rGetNormalToPlane((AttractingPlaneBoundaryCondition2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetNormalToPlane(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue})

rGetPointOnPlane((AttractingPlaneBoundaryCondition2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetPointOnPlane(AttractingPlaneBoundaryCondition<2u, 2u> {lvalue})

class chaste.cell_based.AttractingPlaneBoundaryCondition3_3

GetUseJiggledNodesOnPlane((AttractingPlaneBoundaryCondition3_3)arg1) → bool :

C++ signature :

bool GetUseJiggledNodesOnPlane(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue})

ImposeBoundaryCondition((AttractingPlaneBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) → None :

C++ signature :

void ImposeBoundaryCondition(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

ImposeBoundaryCondition( (AttractingPlaneBoundaryCondition3_3)arg1, (MapNodePtr2CVectorDouble_3)rOldLocations) -> None :

C++ signature :

void ImposeBoundaryCondition(AttractingPlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::map<Node<3u>*, boost::numeric::ublas::c_vector<double, 3ul>, std::less<Node<3u>*>, std::allocator<std::pair<Node<3u>* const, boost::numeric::ublas::c_vector<double, 3ul> > > >)

OutputCellPopulationBoundaryConditionParameters((AttractingPlaneBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellPopulationBoundaryConditionParameters( (AttractingPlaneBoundaryCondition3_3)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellPopulationBoundaryConditionParameters(AttractingPlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

SetAttractionThreshold((AttractingPlaneBoundaryCondition3_3)arg1, (float)attractionThreshold) → None :

C++ signature :

void SetAttractionThreshold(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue},double)

SetPointOnPlane((AttractingPlaneBoundaryCondition3_3)arg1, (object)rPoint) → None :

C++ signature :

void SetPointOnPlane(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

SetUseJiggledNodesOnPlane((AttractingPlaneBoundaryCondition3_3)arg1, (bool)useJiggledNodesOnPlane) → None :

C++ signature :

void SetUseJiggledNodesOnPlane(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue},bool)

VerifyBoundaryCondition((AttractingPlaneBoundaryCondition3_3)arg1) → bool :

C++ signature :

bool VerifyBoundaryCondition(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue})

VerifyBoundaryCondition( (AttractingPlaneBoundaryCondition3_3)arg1) -> bool :

C++ signature :

bool VerifyBoundaryCondition(AttractingPlaneBoundaryCondition_less__3_comma__3__greater__wrapper {lvalue})

rGetNormalToPlane((AttractingPlaneBoundaryCondition3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetNormalToPlane(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue})

rGetPointOnPlane((AttractingPlaneBoundaryCondition3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetPointOnPlane(AttractingPlaneBoundaryCondition<3u, 3u> {lvalue})

class chaste.cell_based.AbstractLinearEllipticPde2_2

ComputeConstantInUSourceTerm((AbstractLinearEllipticPde2_2)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeConstantInUSourceTerm(AbstractLinearEllipticPde<2u, 2u> {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeConstantInUSourceTerm( (AbstractLinearEllipticPde2_2)arg1, (object)arg2, (object)arg3) -> None :

C++ signature :

void ComputeConstantInUSourceTerm(AbstractLinearEllipticPde_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeConstantInUSourceTermAtNode((AbstractLinearEllipticPde2_2)arg1, (object)rNode) → float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(AbstractLinearEllipticPde<2u, 2u> {lvalue},Node<2u>)

ComputeConstantInUSourceTermAtNode( (AbstractLinearEllipticPde2_2)arg1, (object)rNode) -> float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(AbstractLinearEllipticPde_less__2_comma__2__greater__wrapper {lvalue},Node<2u>)

ComputeDiffusionTerm((AbstractLinearEllipticPde2_2)arg1, (object)rX) → object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 2ul, 2ul> ComputeDiffusionTerm(AbstractLinearEllipticPde<2u, 2u> {lvalue},ChastePoint<2u>)

ComputeDiffusionTerm( (AbstractLinearEllipticPde2_2)arg1, (object)arg2) -> None :

C++ signature :

void ComputeDiffusionTerm(AbstractLinearEllipticPde_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

ComputeLinearInUCoeffInSourceTerm((AbstractLinearEllipticPde2_2)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(AbstractLinearEllipticPde<2u, 2u> {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeLinearInUCoeffInSourceTerm( (AbstractLinearEllipticPde2_2)arg1, (object)arg2, (object)arg3) -> None :

C++ signature :

void ComputeLinearInUCoeffInSourceTerm(AbstractLinearEllipticPde_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>,Element<2u, 2u>*)

ComputeLinearInUCoeffInSourceTermAtNode((AbstractLinearEllipticPde2_2)arg1, (object)rNode) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(AbstractLinearEllipticPde<2u, 2u> {lvalue},Node<2u>)

ComputeLinearInUCoeffInSourceTermAtNode( (AbstractLinearEllipticPde2_2)arg1, (object)rNode) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(AbstractLinearEllipticPde_less__2_comma__2__greater__wrapper {lvalue},Node<2u>)

class chaste.cell_based.AbstractLinearEllipticPde3_3

ComputeConstantInUSourceTerm((AbstractLinearEllipticPde3_3)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeConstantInUSourceTerm(AbstractLinearEllipticPde<3u, 3u> {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeConstantInUSourceTerm( (AbstractLinearEllipticPde3_3)arg1, (object)arg2, (object)arg3) -> None :

C++ signature :

void ComputeConstantInUSourceTerm(AbstractLinearEllipticPde_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeConstantInUSourceTermAtNode((AbstractLinearEllipticPde3_3)arg1, (object)rNode) → float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(AbstractLinearEllipticPde<3u, 3u> {lvalue},Node<3u>)

ComputeConstantInUSourceTermAtNode( (AbstractLinearEllipticPde3_3)arg1, (object)rNode) -> float :

C++ signature :

double ComputeConstantInUSourceTermAtNode(AbstractLinearEllipticPde_less__3_comma__3__greater__wrapper {lvalue},Node<3u>)

ComputeDiffusionTerm((AbstractLinearEllipticPde3_3)arg1, (object)rX) → object :

C++ signature :

boost::numeric::ublas::c_matrix<double, 3ul, 3ul> ComputeDiffusionTerm(AbstractLinearEllipticPde<3u, 3u> {lvalue},ChastePoint<3u>)

ComputeDiffusionTerm( (AbstractLinearEllipticPde3_3)arg1, (object)arg2) -> None :

C++ signature :

void ComputeDiffusionTerm(AbstractLinearEllipticPde_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

ComputeLinearInUCoeffInSourceTerm((AbstractLinearEllipticPde3_3)arg1, (object)rX, (object)pElement) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTerm(AbstractLinearEllipticPde<3u, 3u> {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeLinearInUCoeffInSourceTerm( (AbstractLinearEllipticPde3_3)arg1, (object)arg2, (object)arg3) -> None :

C++ signature :

void ComputeLinearInUCoeffInSourceTerm(AbstractLinearEllipticPde_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>,Element<3u, 3u>*)

ComputeLinearInUCoeffInSourceTermAtNode((AbstractLinearEllipticPde3_3)arg1, (object)rNode) → float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(AbstractLinearEllipticPde<3u, 3u> {lvalue},Node<3u>)

ComputeLinearInUCoeffInSourceTermAtNode( (AbstractLinearEllipticPde3_3)arg1, (object)rNode) -> float :

C++ signature :

double ComputeLinearInUCoeffInSourceTermAtNode(AbstractLinearEllipticPde_less__3_comma__3__greater__wrapper {lvalue},Node<3u>)

class chaste.cell_based.AbstractLinearPde2_2

class chaste.cell_based.AbstractLinearPde3_3

class chaste.cell_based.AbstractCellProperty

DecrementCellCount((AbstractCellProperty)arg1) → None :

C++ signature :

void DecrementCellCount(AbstractCellProperty {lvalue})

GetCellCount((AbstractCellProperty)arg1) → int :

C++ signature :

unsigned int GetCellCount(AbstractCellProperty {lvalue})

IncrementCellCount((AbstractCellProperty)arg1) → None :

C++ signature :

void IncrementCellCount(AbstractCellProperty {lvalue})

IsSame((AbstractCellProperty)arg1, (AbstractCellProperty)pOther) → bool :

C++ signature :

bool IsSame(AbstractCellProperty {lvalue},AbstractCellProperty const*)

IsSame( (AbstractCellProperty)arg1, (object)pOther) -> bool :

C++ signature :

bool IsSame(AbstractCellProperty {lvalue},boost::shared_ptr<AbstractCellProperty const>)

class chaste.cell_based.AbstractCellProliferativeType

GetColour((AbstractCellProliferativeType)arg1) → int :

C++ signature :

unsigned int GetColour(AbstractCellProliferativeType {lvalue})

class chaste.cell_based.StemCellProliferativeType

class chaste.cell_based.DefaultCellProliferativeType

class chaste.cell_based.TransitCellProliferativeType

class chaste.cell_based.DifferentiatedCellProliferativeType

class chaste.cell_based.AbstractCellMutationState

GetColour((AbstractCellMutationState)arg1) → int :

C++ signature :

unsigned int GetColour(AbstractCellMutationState {lvalue})

class chaste.cell_based.ApcOneHitCellMutationState

class chaste.cell_based.ApcTwoHitCellMutationState

class chaste.cell_based.BetaCateninOneHitCellMutationState

class chaste.cell_based.WildTypeCellMutationState

class chaste.cell_based.AbstractCellCycleModel

CanCellTerminallyDifferentiate((AbstractCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (AbstractCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((AbstractCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(AbstractCellCycleModel {lvalue})

CreateCellCycleModel( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void CreateCellCycleModel(AbstractCellCycleModel_wrapper {lvalue})

GetAge((AbstractCellCycleModel)arg1) → float :

C++ signature :

double GetAge(AbstractCellCycleModel {lvalue})

GetAverageStemCellCycleTime((AbstractCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void GetAverageStemCellCycleTime(AbstractCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((AbstractCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void GetAverageTransitCellCycleTime(AbstractCellCycleModel_wrapper {lvalue})

GetBirthTime((AbstractCellCycleModel)arg1) → float :

C++ signature :

double GetBirthTime(AbstractCellCycleModel {lvalue})

GetCell((AbstractCellCycleModel)arg1) → Cell :

C++ signature :

boost::shared_ptr<Cell> GetCell(AbstractCellCycleModel {lvalue})

GetDimension((AbstractCellCycleModel)arg1) → int :

C++ signature :

unsigned int GetDimension(AbstractCellCycleModel {lvalue})

Initialise((AbstractCellCycleModel)arg1) → None :

C++ signature :

void Initialise(AbstractCellCycleModel {lvalue})

Initialise( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(AbstractCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((AbstractCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(AbstractCellCycleModel {lvalue})

InitialiseDaughterCell( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(AbstractCellCycleModel_wrapper {lvalue})

OutputCellCycleModelInfo((AbstractCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelInfo(AbstractCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters((AbstractCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(AbstractCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (AbstractCellCycleModel)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellCycleModelParameters(AbstractCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((AbstractCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(AbstractCellCycleModel {lvalue})

ReadyToDivide( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void ReadyToDivide(AbstractCellCycleModel_wrapper {lvalue})

ResetForDivision((AbstractCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(AbstractCellCycleModel {lvalue})

ResetForDivision( (AbstractCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(AbstractCellCycleModel_wrapper {lvalue})

SetBirthTime((AbstractCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(AbstractCellCycleModel {lvalue},double)

SetBirthTime( (AbstractCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(AbstractCellCycleModel_wrapper {lvalue},double)

SetCell((AbstractCellCycleModel)arg1, (Cell)pCell) → None :

C++ signature :

void SetCell(AbstractCellCycleModel {lvalue},boost::shared_ptr<Cell>)

SetDimension((AbstractCellCycleModel)arg1, (int)dimension) → None :

C++ signature :

void SetDimension(AbstractCellCycleModel {lvalue},unsigned int)

class chaste.cell_based.AbstractPhaseBasedCellCycleModel

CanCellTerminallyDifferentiate((AbstractPhaseBasedCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractPhaseBasedCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (AbstractPhaseBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((AbstractPhaseBasedCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(AbstractPhaseBasedCellCycleModel {lvalue})

CreateCellCycleModel( (AbstractPhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void CreateCellCycleModel(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractPhaseBasedCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractPhaseBasedCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetCurrentCellCyclePhase((AbstractPhaseBasedCellCycleModel)arg1) → object :

C++ signature :

CellCyclePhase_ GetCurrentCellCyclePhase(AbstractPhaseBasedCellCycleModel {lvalue})

GetG1Duration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG1Duration(AbstractPhaseBasedCellCycleModel {lvalue})

GetG1Duration( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG1Duration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetG2Duration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG2Duration(AbstractPhaseBasedCellCycleModel {lvalue})

GetG2Duration( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG2Duration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetMDuration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetMDuration(AbstractPhaseBasedCellCycleModel {lvalue})

GetMDuration( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetMDuration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetMinimumGapDuration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetMinimumGapDuration(AbstractPhaseBasedCellCycleModel {lvalue})

GetSDuration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetSDuration(AbstractPhaseBasedCellCycleModel {lvalue})

GetSDuration( (AbstractPhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetSDuration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

GetSG2MDuration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetSG2MDuration(AbstractPhaseBasedCellCycleModel {lvalue})

GetStemCellG1Duration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetStemCellG1Duration(AbstractPhaseBasedCellCycleModel {lvalue})

GetTransitCellG1Duration((AbstractPhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetTransitCellG1Duration(AbstractPhaseBasedCellCycleModel {lvalue})

Initialise((AbstractPhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void Initialise(AbstractPhaseBasedCellCycleModel {lvalue})

Initialise( (AbstractPhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((AbstractPhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(AbstractPhaseBasedCellCycleModel {lvalue})

InitialiseDaughterCell( (AbstractPhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((AbstractPhaseBasedCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(AbstractPhaseBasedCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (AbstractPhaseBasedCellCycleModel)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellCycleModelParameters(AbstractPhaseBasedCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((AbstractPhaseBasedCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(AbstractPhaseBasedCellCycleModel {lvalue})

ReadyToDivide( (AbstractPhaseBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

ResetForDivision((AbstractPhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(AbstractPhaseBasedCellCycleModel {lvalue})

ResetForDivision( (AbstractPhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

SetBirthTime((AbstractPhaseBasedCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetBirthTime( (AbstractPhaseBasedCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(AbstractPhaseBasedCellCycleModel_wrapper {lvalue},double)

SetG2Duration((AbstractPhaseBasedCellCycleModel)arg1, (float)g2Duration) → None :

C++ signature :

void SetG2Duration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetMDuration((AbstractPhaseBasedCellCycleModel)arg1, (float)mDuration) → None :

C++ signature :

void SetMDuration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetMinimumGapDuration((AbstractPhaseBasedCellCycleModel)arg1, (float)minimumGapDuration) → None :

C++ signature :

void SetMinimumGapDuration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetSDuration((AbstractPhaseBasedCellCycleModel)arg1, (float)sDuration) → None :

C++ signature :

void SetSDuration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetStemCellG1Duration((AbstractPhaseBasedCellCycleModel)arg1, (float)stemCellG1Duration) → None :

C++ signature :

void SetStemCellG1Duration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetStemCellG1Duration( (AbstractPhaseBasedCellCycleModel)arg1, (float)stemCellG1Duration) -> None :

C++ signature :

void SetStemCellG1Duration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue},double)

SetTransitCellG1Duration((AbstractPhaseBasedCellCycleModel)arg1, (float)transitCellG1Duration) → None :

C++ signature :

void SetTransitCellG1Duration(AbstractPhaseBasedCellCycleModel {lvalue},double)

SetTransitCellG1Duration( (AbstractPhaseBasedCellCycleModel)arg1, (float)transitCellG1Duration) -> None :

C++ signature :

void SetTransitCellG1Duration(AbstractPhaseBasedCellCycleModel_wrapper {lvalue},double)

UpdateCellCyclePhase((AbstractPhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void UpdateCellCyclePhase(AbstractPhaseBasedCellCycleModel {lvalue})

UpdateCellCyclePhase( (AbstractPhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void UpdateCellCyclePhase(AbstractPhaseBasedCellCycleModel_wrapper {lvalue})

class chaste.cell_based.AbstractSimpleCellCycleModel

CanCellTerminallyDifferentiate((AbstractSimpleCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimpleCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (AbstractSimpleCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimpleCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((AbstractSimpleCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(AbstractSimpleCellCycleModel {lvalue})

CreateCellCycleModel( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void CreateCellCycleModel(AbstractSimpleCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((AbstractSimpleCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractSimpleCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void GetAverageStemCellCycleTime(AbstractSimpleCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((AbstractSimpleCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractSimpleCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void GetAverageTransitCellCycleTime(AbstractSimpleCellCycleModel_wrapper {lvalue})

GetCellCycleDuration((AbstractSimpleCellCycleModel)arg1) → float :

C++ signature :

double GetCellCycleDuration(AbstractSimpleCellCycleModel {lvalue})

Initialise((AbstractSimpleCellCycleModel)arg1) → None :

C++ signature :

void Initialise(AbstractSimpleCellCycleModel {lvalue})

Initialise( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(AbstractSimpleCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((AbstractSimpleCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(AbstractSimpleCellCycleModel {lvalue})

InitialiseDaughterCell( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(AbstractSimpleCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((AbstractSimpleCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimpleCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (AbstractSimpleCellCycleModel)arg1, (StdOutputFileStream)arg2) -> None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimpleCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((AbstractSimpleCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(AbstractSimpleCellCycleModel {lvalue})

ReadyToDivide( (AbstractSimpleCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(AbstractSimpleCellCycleModel_wrapper {lvalue})

ResetForDivision((AbstractSimpleCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(AbstractSimpleCellCycleModel {lvalue})

ResetForDivision( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(AbstractSimpleCellCycleModel_wrapper {lvalue})

SetBirthTime((AbstractSimpleCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(AbstractSimpleCellCycleModel {lvalue},double)

SetBirthTime( (AbstractSimpleCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(AbstractSimpleCellCycleModel_wrapper {lvalue},double)

SetCellCycleDuration((AbstractSimpleCellCycleModel)arg1) → None :

C++ signature :

void SetCellCycleDuration(AbstractSimpleCellCycleModel {lvalue})

SetCellCycleDuration( (AbstractSimpleCellCycleModel)arg1) -> None :

C++ signature :

void SetCellCycleDuration(AbstractSimpleCellCycleModel_wrapper {lvalue})

class chaste.cell_based.AbstractSimplePhaseBasedCellCycleModel

CanCellTerminallyDifferentiate((AbstractSimplePhaseBasedCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimplePhaseBasedCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((AbstractSimplePhaseBasedCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(AbstractSimplePhaseBasedCellCycleModel {lvalue})

CreateCellCycleModel( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void CreateCellCycleModel(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetG1Duration((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG1Duration(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetG1Duration( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG1Duration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetG2Duration((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG2Duration(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetG2Duration( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG2Duration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetMDuration((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetMDuration(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetMDuration( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetMDuration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

GetSDuration((AbstractSimplePhaseBasedCellCycleModel)arg1) → float :

C++ signature :

double GetSDuration(AbstractSimplePhaseBasedCellCycleModel {lvalue})

GetSDuration( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetSDuration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

Initialise((AbstractSimplePhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void Initialise(AbstractSimplePhaseBasedCellCycleModel {lvalue})

Initialise( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((AbstractSimplePhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(AbstractSimplePhaseBasedCellCycleModel {lvalue})

InitialiseDaughterCell( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((AbstractSimplePhaseBasedCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimplePhaseBasedCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (AbstractSimplePhaseBasedCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((AbstractSimplePhaseBasedCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(AbstractSimplePhaseBasedCellCycleModel {lvalue})

ReadyToDivide( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

ResetForDivision((AbstractSimplePhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(AbstractSimplePhaseBasedCellCycleModel {lvalue})

ResetForDivision( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

SetBirthTime((AbstractSimplePhaseBasedCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(AbstractSimplePhaseBasedCellCycleModel {lvalue},double)

SetBirthTime( (AbstractSimplePhaseBasedCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue},double)

SetG1Duration((AbstractSimplePhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void SetG1Duration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

SetStemCellG1Duration((AbstractSimplePhaseBasedCellCycleModel)arg1, (float)stemCellG1Duration) → None :

C++ signature :

void SetStemCellG1Duration(AbstractSimplePhaseBasedCellCycleModel {lvalue},double)

SetStemCellG1Duration( (AbstractSimplePhaseBasedCellCycleModel)arg1, (float)stemCellG1Duration) -> None :

C++ signature :

void SetStemCellG1Duration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue},double)

SetTransitCellG1Duration((AbstractSimplePhaseBasedCellCycleModel)arg1, (float)transitCellG1Duration) → None :

C++ signature :

void SetTransitCellG1Duration(AbstractSimplePhaseBasedCellCycleModel {lvalue},double)

SetTransitCellG1Duration( (AbstractSimplePhaseBasedCellCycleModel)arg1, (float)transitCellG1Duration) -> None :

C++ signature :

void SetTransitCellG1Duration(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue},double)

UpdateCellCyclePhase((AbstractSimplePhaseBasedCellCycleModel)arg1) → None :

C++ signature :

void UpdateCellCyclePhase(AbstractSimplePhaseBasedCellCycleModel {lvalue})

UpdateCellCyclePhase( (AbstractSimplePhaseBasedCellCycleModel)arg1) -> None :

C++ signature :

void UpdateCellCyclePhase(AbstractSimplePhaseBasedCellCycleModel_wrapper {lvalue})

class chaste.cell_based.AbstractSimpleGenerationalCellCycleModel

CanCellTerminallyDifferentiate((AbstractSimpleGenerationalCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimpleGenerationalCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (AbstractSimpleGenerationalCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((AbstractSimpleGenerationalCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(AbstractSimpleGenerationalCellCycleModel {lvalue})

CreateCellCycleModel( (AbstractSimpleGenerationalCellCycleModel)arg1) -> None :

C++ signature :

void CreateCellCycleModel(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetG1Duration((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetG1Duration(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetG1Duration( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetG1Duration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetG2Duration((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetG2Duration(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetG2Duration( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetG2Duration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetGeneration((AbstractSimpleGenerationalCellCycleModel)arg1) → int :

C++ signature :

unsigned int GetGeneration(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetMDuration((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetMDuration(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetMDuration( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetMDuration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

GetMaxTransitGenerations((AbstractSimpleGenerationalCellCycleModel)arg1) → int :

C++ signature :

unsigned int GetMaxTransitGenerations(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetSDuration((AbstractSimpleGenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetSDuration(AbstractSimpleGenerationalCellCycleModel {lvalue})

GetSDuration( (AbstractSimpleGenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetSDuration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

Initialise((AbstractSimpleGenerationalCellCycleModel)arg1) → None :

C++ signature :

void Initialise(AbstractSimpleGenerationalCellCycleModel {lvalue})

Initialise( (AbstractSimpleGenerationalCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((AbstractSimpleGenerationalCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(AbstractSimpleGenerationalCellCycleModel {lvalue})

InitialiseDaughterCell( (AbstractSimpleGenerationalCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((AbstractSimpleGenerationalCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimpleGenerationalCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (AbstractSimpleGenerationalCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((AbstractSimpleGenerationalCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(AbstractSimpleGenerationalCellCycleModel {lvalue})

ReadyToDivide( (AbstractSimpleGenerationalCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

ResetForDivision((AbstractSimpleGenerationalCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(AbstractSimpleGenerationalCellCycleModel {lvalue})

ResetForDivision( (AbstractSimpleGenerationalCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

SetBirthTime((AbstractSimpleGenerationalCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(AbstractSimpleGenerationalCellCycleModel {lvalue},double)

SetBirthTime( (AbstractSimpleGenerationalCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue},double)

SetG1Duration((AbstractSimpleGenerationalCellCycleModel)arg1) → None :

C++ signature :

void SetG1Duration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

SetGeneration((AbstractSimpleGenerationalCellCycleModel)arg1, (int)generation) → None :

C++ signature :

void SetGeneration(AbstractSimpleGenerationalCellCycleModel {lvalue},unsigned int)

SetMaxTransitGenerations((AbstractSimpleGenerationalCellCycleModel)arg1, (int)maxTransitGenerations) → None :

C++ signature :

void SetMaxTransitGenerations(AbstractSimpleGenerationalCellCycleModel {lvalue},unsigned int)

SetStemCellG1Duration((AbstractSimpleGenerationalCellCycleModel)arg1, (float)stemCellG1Duration) → None :

C++ signature :

void SetStemCellG1Duration(AbstractSimpleGenerationalCellCycleModel {lvalue},double)

SetStemCellG1Duration( (AbstractSimpleGenerationalCellCycleModel)arg1, (float)stemCellG1Duration) -> None :

C++ signature :

void SetStemCellG1Duration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue},double)

SetTransitCellG1Duration((AbstractSimpleGenerationalCellCycleModel)arg1, (float)transitCellG1Duration) → None :

C++ signature :

void SetTransitCellG1Duration(AbstractSimpleGenerationalCellCycleModel {lvalue},double)

SetTransitCellG1Duration( (AbstractSimpleGenerationalCellCycleModel)arg1, (float)transitCellG1Duration) -> None :

C++ signature :

void SetTransitCellG1Duration(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue},double)

UpdateCellCyclePhase((AbstractSimpleGenerationalCellCycleModel)arg1) → None :

C++ signature :

void UpdateCellCyclePhase(AbstractSimpleGenerationalCellCycleModel {lvalue})

UpdateCellCyclePhase( (AbstractSimpleGenerationalCellCycleModel)arg1) -> None :

C++ signature :

void UpdateCellCyclePhase(AbstractSimpleGenerationalCellCycleModel_wrapper {lvalue})

class chaste.cell_based.UniformCellCycleModel

CanCellTerminallyDifferentiate((UniformCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(UniformCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (UniformCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(UniformCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((UniformCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(UniformCellCycleModel {lvalue})

CreateCellCycleModel( (UniformCellCycleModel)arg1) -> AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(UniformCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((UniformCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(UniformCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (UniformCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(UniformCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((UniformCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(UniformCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (UniformCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(UniformCellCycleModel_wrapper {lvalue})

GetMaxCellCycleDuration((UniformCellCycleModel)arg1) → float :

C++ signature :

double GetMaxCellCycleDuration(UniformCellCycleModel {lvalue})

GetMinCellCycleDuration((UniformCellCycleModel)arg1) → float :

C++ signature :

double GetMinCellCycleDuration(UniformCellCycleModel {lvalue})

Initialise((UniformCellCycleModel)arg1) → None :

C++ signature :

void Initialise(UniformCellCycleModel {lvalue})

Initialise( (UniformCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(UniformCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((UniformCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(UniformCellCycleModel {lvalue})

InitialiseDaughterCell( (UniformCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(UniformCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((UniformCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(UniformCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (UniformCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(UniformCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((UniformCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(UniformCellCycleModel {lvalue})

ReadyToDivide( (UniformCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(UniformCellCycleModel_wrapper {lvalue})

ResetForDivision((UniformCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(UniformCellCycleModel {lvalue})

ResetForDivision( (UniformCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(UniformCellCycleModel_wrapper {lvalue})

SetBirthTime((UniformCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(UniformCellCycleModel {lvalue},double)

SetBirthTime( (UniformCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(UniformCellCycleModel_wrapper {lvalue},double)

SetCellCycleDuration((UniformCellCycleModel)arg1) → None :

C++ signature :

void SetCellCycleDuration(UniformCellCycleModel {lvalue})

SetCellCycleDuration( (UniformCellCycleModel)arg1) -> None :

C++ signature :

void SetCellCycleDuration(UniformCellCycleModel_wrapper {lvalue})

SetMaxCellCycleDuration((UniformCellCycleModel)arg1, (float)maxCellCycleDuration) → None :

C++ signature :

void SetMaxCellCycleDuration(UniformCellCycleModel {lvalue},double)

SetMinCellCycleDuration((UniformCellCycleModel)arg1, (float)minCellCycleDuration) → None :

C++ signature :

void SetMinCellCycleDuration(UniformCellCycleModel {lvalue},double)

class chaste.cell_based.SimpleOxygenBasedCellCycleModel

CanCellTerminallyDifferentiate((SimpleOxygenBasedCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(SimpleOxygenBasedCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (SimpleOxygenBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((SimpleOxygenBasedCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(SimpleOxygenBasedCellCycleModel {lvalue})

CreateCellCycleModel( (SimpleOxygenBasedCellCycleModel)arg1) -> AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(SimpleOxygenBasedCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(SimpleOxygenBasedCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetCriticalHypoxicDuration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetCriticalHypoxicDuration(SimpleOxygenBasedCellCycleModel {lvalue})

GetCurrentHypoxiaOnsetTime((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetCurrentHypoxiaOnsetTime(SimpleOxygenBasedCellCycleModel {lvalue})

GetCurrentHypoxicDuration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetCurrentHypoxicDuration(SimpleOxygenBasedCellCycleModel {lvalue})

GetG1Duration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG1Duration(SimpleOxygenBasedCellCycleModel {lvalue})

GetG1Duration( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG1Duration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetG2Duration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetG2Duration(SimpleOxygenBasedCellCycleModel {lvalue})

GetG2Duration( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetG2Duration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetHypoxicConcentration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetHypoxicConcentration(SimpleOxygenBasedCellCycleModel {lvalue})

GetMDuration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetMDuration(SimpleOxygenBasedCellCycleModel {lvalue})

GetMDuration( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetMDuration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

GetQuiescentConcentration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetQuiescentConcentration(SimpleOxygenBasedCellCycleModel {lvalue})

GetSDuration((SimpleOxygenBasedCellCycleModel)arg1) → float :

C++ signature :

double GetSDuration(SimpleOxygenBasedCellCycleModel {lvalue})

GetSDuration( (SimpleOxygenBasedCellCycleModel)arg1) -> float :

C++ signature :

double GetSDuration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

Initialise((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void Initialise(SimpleOxygenBasedCellCycleModel {lvalue})

Initialise( (SimpleOxygenBasedCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(SimpleOxygenBasedCellCycleModel {lvalue})

InitialiseDaughterCell( (SimpleOxygenBasedCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((SimpleOxygenBasedCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(SimpleOxygenBasedCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (SimpleOxygenBasedCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(SimpleOxygenBasedCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((SimpleOxygenBasedCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(SimpleOxygenBasedCellCycleModel {lvalue})

ReadyToDivide( (SimpleOxygenBasedCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

ResetForDivision((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(SimpleOxygenBasedCellCycleModel {lvalue})

ResetForDivision( (SimpleOxygenBasedCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

SetBirthTime((SimpleOxygenBasedCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetBirthTime( (SimpleOxygenBasedCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(SimpleOxygenBasedCellCycleModel_wrapper {lvalue},double)

SetCriticalHypoxicDuration((SimpleOxygenBasedCellCycleModel)arg1, (float)criticalHypoxicDuration) → None :

C++ signature :

void SetCriticalHypoxicDuration(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetCurrentHypoxiaOnsetTime((SimpleOxygenBasedCellCycleModel)arg1, (float)currentHypoxiaOnsetTime) → None :

C++ signature :

void SetCurrentHypoxiaOnsetTime(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetG1Duration((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void SetG1Duration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

SetHypoxicConcentration((SimpleOxygenBasedCellCycleModel)arg1, (float)hypoxicConcentration) → None :

C++ signature :

void SetHypoxicConcentration(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetQuiescentConcentration((SimpleOxygenBasedCellCycleModel)arg1, (float)quiescentConcentration) → None :

C++ signature :

void SetQuiescentConcentration(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetStemCellG1Duration((SimpleOxygenBasedCellCycleModel)arg1, (float)stemCellG1Duration) → None :

C++ signature :

void SetStemCellG1Duration(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetStemCellG1Duration( (SimpleOxygenBasedCellCycleModel)arg1, (float)stemCellG1Duration) -> None :

C++ signature :

void SetStemCellG1Duration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue},double)

SetTransitCellG1Duration((SimpleOxygenBasedCellCycleModel)arg1, (float)transitCellG1Duration) → None :

C++ signature :

void SetTransitCellG1Duration(SimpleOxygenBasedCellCycleModel {lvalue},double)

SetTransitCellG1Duration( (SimpleOxygenBasedCellCycleModel)arg1, (float)transitCellG1Duration) -> None :

C++ signature :

void SetTransitCellG1Duration(SimpleOxygenBasedCellCycleModel_wrapper {lvalue},double)

UpdateCellCyclePhase((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void UpdateCellCyclePhase(SimpleOxygenBasedCellCycleModel {lvalue})

UpdateCellCyclePhase( (SimpleOxygenBasedCellCycleModel)arg1) -> None :

C++ signature :

void UpdateCellCyclePhase(SimpleOxygenBasedCellCycleModel_wrapper {lvalue})

UpdateHypoxicDuration((SimpleOxygenBasedCellCycleModel)arg1) → None :

C++ signature :

void UpdateHypoxicDuration(SimpleOxygenBasedCellCycleModel {lvalue})

class chaste.cell_based.UniformG1GenerationalCellCycleModel

CanCellTerminallyDifferentiate((UniformG1GenerationalCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(UniformG1GenerationalCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (UniformG1GenerationalCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((UniformG1GenerationalCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(UniformG1GenerationalCellCycleModel {lvalue})

CreateCellCycleModel( (UniformG1GenerationalCellCycleModel)arg1) -> AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(UniformG1GenerationalCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(UniformG1GenerationalCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetG1Duration((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetG1Duration(UniformG1GenerationalCellCycleModel {lvalue})

GetG1Duration( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetG1Duration(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetG2Duration((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetG2Duration(UniformG1GenerationalCellCycleModel {lvalue})

GetG2Duration( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetG2Duration(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetMDuration((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetMDuration(UniformG1GenerationalCellCycleModel {lvalue})

GetMDuration( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetMDuration(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

GetSDuration((UniformG1GenerationalCellCycleModel)arg1) → float :

C++ signature :

double GetSDuration(UniformG1GenerationalCellCycleModel {lvalue})

GetSDuration( (UniformG1GenerationalCellCycleModel)arg1) -> float :

C++ signature :

double GetSDuration(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

Initialise((UniformG1GenerationalCellCycleModel)arg1) → None :

C++ signature :

void Initialise(UniformG1GenerationalCellCycleModel {lvalue})

Initialise( (UniformG1GenerationalCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((UniformG1GenerationalCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(UniformG1GenerationalCellCycleModel {lvalue})

InitialiseDaughterCell( (UniformG1GenerationalCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((UniformG1GenerationalCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(UniformG1GenerationalCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (UniformG1GenerationalCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(UniformG1GenerationalCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((UniformG1GenerationalCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(UniformG1GenerationalCellCycleModel {lvalue})

ReadyToDivide( (UniformG1GenerationalCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

ResetForDivision((UniformG1GenerationalCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(UniformG1GenerationalCellCycleModel {lvalue})

ResetForDivision( (UniformG1GenerationalCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

SetBirthTime((UniformG1GenerationalCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(UniformG1GenerationalCellCycleModel {lvalue},double)

SetBirthTime( (UniformG1GenerationalCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(UniformG1GenerationalCellCycleModel_wrapper {lvalue},double)

SetG1Duration((UniformG1GenerationalCellCycleModel)arg1) → None :

C++ signature :

void SetG1Duration(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

SetStemCellG1Duration((UniformG1GenerationalCellCycleModel)arg1, (float)stemCellG1Duration) → None :

C++ signature :

void SetStemCellG1Duration(UniformG1GenerationalCellCycleModel {lvalue},double)

SetStemCellG1Duration( (UniformG1GenerationalCellCycleModel)arg1, (float)stemCellG1Duration) -> None :

C++ signature :

void SetStemCellG1Duration(UniformG1GenerationalCellCycleModel_wrapper {lvalue},double)

SetTransitCellG1Duration((UniformG1GenerationalCellCycleModel)arg1, (float)transitCellG1Duration) → None :

C++ signature :

void SetTransitCellG1Duration(UniformG1GenerationalCellCycleModel {lvalue},double)

SetTransitCellG1Duration( (UniformG1GenerationalCellCycleModel)arg1, (float)transitCellG1Duration) -> None :

C++ signature :

void SetTransitCellG1Duration(UniformG1GenerationalCellCycleModel_wrapper {lvalue},double)

UpdateCellCyclePhase((UniformG1GenerationalCellCycleModel)arg1) → None :

C++ signature :

void UpdateCellCyclePhase(UniformG1GenerationalCellCycleModel {lvalue})

UpdateCellCyclePhase( (UniformG1GenerationalCellCycleModel)arg1) -> None :

C++ signature :

void UpdateCellCyclePhase(UniformG1GenerationalCellCycleModel_wrapper {lvalue})

class chaste.cell_based.NoCellCycleModel

CanCellTerminallyDifferentiate((NoCellCycleModel)arg1) → bool :

C++ signature :

bool CanCellTerminallyDifferentiate(NoCellCycleModel {lvalue})

CanCellTerminallyDifferentiate( (NoCellCycleModel)arg1) -> bool :

C++ signature :

bool CanCellTerminallyDifferentiate(NoCellCycleModel_wrapper {lvalue})

CreateCellCycleModel((NoCellCycleModel)arg1) → AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(NoCellCycleModel {lvalue})

CreateCellCycleModel( (NoCellCycleModel)arg1) -> AbstractCellCycleModel :

C++ signature :

AbstractCellCycleModel* CreateCellCycleModel(NoCellCycleModel_wrapper {lvalue})

GetAverageStemCellCycleTime((NoCellCycleModel)arg1) → float :

C++ signature :

double GetAverageStemCellCycleTime(NoCellCycleModel {lvalue})

GetAverageStemCellCycleTime( (NoCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageStemCellCycleTime(NoCellCycleModel_wrapper {lvalue})

GetAverageTransitCellCycleTime((NoCellCycleModel)arg1) → float :

C++ signature :

double GetAverageTransitCellCycleTime(NoCellCycleModel {lvalue})

GetAverageTransitCellCycleTime( (NoCellCycleModel)arg1) -> float :

C++ signature :

double GetAverageTransitCellCycleTime(NoCellCycleModel_wrapper {lvalue})

Initialise((NoCellCycleModel)arg1) → None :

C++ signature :

void Initialise(NoCellCycleModel {lvalue})

Initialise( (NoCellCycleModel)arg1) -> None :

C++ signature :

void Initialise(NoCellCycleModel_wrapper {lvalue})

InitialiseDaughterCell((NoCellCycleModel)arg1) → None :

C++ signature :

void InitialiseDaughterCell(NoCellCycleModel {lvalue})

InitialiseDaughterCell( (NoCellCycleModel)arg1) -> None :

C++ signature :

void InitialiseDaughterCell(NoCellCycleModel_wrapper {lvalue})

OutputCellCycleModelParameters((NoCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) → None :

C++ signature :

void OutputCellCycleModelParameters(NoCellCycleModel {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

OutputCellCycleModelParameters( (NoCellCycleModel)arg1, (StdOutputFileStream)rParamsFile) -> None :

C++ signature :

void OutputCellCycleModelParameters(NoCellCycleModel_wrapper {lvalue},std::auto_ptr<std::basic_ofstream<char, std::char_traits<char> > > {lvalue})

ReadyToDivide((NoCellCycleModel)arg1) → bool :

C++ signature :

bool ReadyToDivide(NoCellCycleModel {lvalue})

ReadyToDivide( (NoCellCycleModel)arg1) -> bool :

C++ signature :

bool ReadyToDivide(NoCellCycleModel_wrapper {lvalue})

ResetForDivision((NoCellCycleModel)arg1) → None :

C++ signature :

void ResetForDivision(NoCellCycleModel {lvalue})

ResetForDivision( (NoCellCycleModel)arg1) -> None :

C++ signature :

void ResetForDivision(NoCellCycleModel_wrapper {lvalue})

SetBirthTime((NoCellCycleModel)arg1, (float)birthTime) → None :

C++ signature :

void SetBirthTime(NoCellCycleModel {lvalue},double)

SetBirthTime( (NoCellCycleModel)arg1, (float)birthTime) -> None :

C++ signature :

void SetBirthTime(NoCellCycleModel_wrapper {lvalue},double)