/*
* ReadyToDivide() now calls UpdateCellProliferativeType() where appropriate.
* (at the moment in Wnt-dependent cells).
*/
void TestUpdateCellProliferativeTypes() throw (Exception)
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(200, 20);
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_stem_type(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
boost::shared_ptr<AbstractCellProperty> p_transit_type(CellPropertyRegistry::Instance()->Get<TransitCellProliferativeType>());
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_stem_cell(new Cell(p_healthy_state, p_model));
p_stem_cell->SetCellProliferativeType(p_stem_type);
p_stem_cell->InitialiseCellCycleModel();
p_stem_cell->ReadyToDivide();
TS_ASSERT_EQUALS(p_stem_cell->GetCellProliferativeType()->IsType<StemCellProliferativeType>(), true);
p_stem_cell->SetCellProliferativeType(p_transit_type);
p_stem_cell->ReadyToDivide();
TS_ASSERT_EQUALS(p_stem_cell->GetCellProliferativeType()->IsType<TransitCellProliferativeType>(), true);
// Test a Wnt dependent cell
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(0.0);
WntCellCycleModel* p_cell_cycle_model1 = new WntCellCycleModel();
p_cell_cycle_model1->SetDimension(2);
CellPtr p_wnt_cell(new Cell(p_healthy_state, p_cell_cycle_model1));
p_wnt_cell->SetCellProliferativeType(p_transit_type);
TS_ASSERT_EQUALS(p_wnt_cell->GetCellProliferativeType()->IsType<TransitCellProliferativeType>(), true);
p_wnt_cell->InitialiseCellCycleModel();
TS_ASSERT_EQUALS(p_wnt_cell->GetCellProliferativeType()->IsType<DifferentiatedCellProliferativeType>(), true);
p_wnt_cell->ReadyToDivide();
TS_ASSERT_EQUALS(p_wnt_cell->GetCellProliferativeType()->IsType<DifferentiatedCellProliferativeType>(), true);
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(1.0);
// Go forward through time
for (unsigned i=0; i<20; i++)
{
p_simulation_time->IncrementTimeOneStep();
}
p_wnt_cell->ReadyToDivide();
TS_ASSERT_EQUALS(p_wnt_cell->GetCellProliferativeType()->IsType<TransitCellProliferativeType>(), true);
// Tidy up
WntConcentration<2>::Destroy();
}
void TestGoldbeter1991OdeSteadyState()
{
// Keep running until we reach steady state
SimulationTime* p_simulation_time = SimulationTime::Instance();
// run until 100, with dt=0.01
double t1=100;
double dt=0.01;
unsigned num_steps=(unsigned) t1/dt;
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(t1, num_steps+1);
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_transit_type(CellPropertyRegistry::Instance()->Get<TransitCellProliferativeType>());
// Create a cell-cycle model
FixedDurationGenerationBasedCellCycleModel* p_cell_model = new FixedDurationGenerationBasedCellCycleModel();
Goldbeter1991SrnModel* p_srn_model = new Goldbeter1991SrnModel();
CellPtr p_tn_cell(new Cell(p_healthy_state, p_cell_model, p_srn_model, false, CellPropertyCollection()));
p_tn_cell->SetCellProliferativeType(p_transit_type);
p_tn_cell->InitialiseCellCycleModel();
p_tn_cell->InitialiseSrnModel();
// Run the cell simulation until t1
while (!p_simulation_time->IsFinished())
{
p_simulation_time->IncrementTimeOneStep();
if (p_tn_cell->ReadyToDivide())
{
p_tn_cell->Divide();
}
}
// Get final state variables
double current_time = SimulationTime::Instance()->GetTime();
std::cout << "Finished ODE - " << "mSimulatedToTime : " << p_srn_model->GetSimulatedToTime() << ", current_time : " << current_time << std::endl;
// Direct access to state variables
double C = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetC();
TS_ASSERT_DELTA(C, 0.5470, 1e-4);
double M = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetM();
TS_ASSERT_DELTA(M, 0.2936, 1e-4);
double X = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetX();
TS_ASSERT_DELTA(X, 0.0067, 1e-4);
// Indirect access to state vector
C = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetProteinConcentrations()[0];
TS_ASSERT_DELTA(C, 0.5470, 1e-4);
M = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetProteinConcentrations()[1];
TS_ASSERT_DELTA(M, 0.2936, 1e-4);
X = dynamic_cast<Goldbeter1991SrnModel*>(p_tn_cell->GetSrnModel())->GetProteinConcentrations()[2];
TS_ASSERT_DELTA(X, 0.0067, 1e-4);
std::cout << "Finished ODE - " << "C : " << C << ", M : " << M << ", X : " << X << std::endl;
}
void TestArchivingOfCell() throw(Exception)
{
OutputFileHandler handler("archive", false);
handler.SetArchiveDirectory();
std::string archive_filename = handler.GetOutputDirectoryFullPath() + "cell.arch";
// Archive a cell
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(2.0, 4);
// Create mutation state
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_type(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
// Create cell-cycle model
FixedDurationGenerationBasedCellCycleModel* p_cell_model = new FixedDurationGenerationBasedCellCycleModel();
// Create SRN
Goldbeter1991SrnModel* p_srn_model = new Goldbeter1991SrnModel();
// Create cell property collection
CellPropertyCollection collection;
MAKE_PTR(CellLabel, p_label);
collection.AddProperty(p_label);
// Create cell
CellPtr p_cell(new Cell(p_healthy_state, p_cell_model, p_srn_model, false, collection));
p_cell->SetCellProliferativeType(p_type);
p_cell->InitialiseCellCycleModel();
p_cell->InitialiseSrnModel();
p_simulation_time->IncrementTimeOneStep();
TS_ASSERT_EQUALS(p_cell->GetAge(), 0.5);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), UNSIGNED_UNSET);
// Set ancestor
MAKE_PTR_ARGS(CellAncestor, p_cell_ancestor, (2u));
p_cell->SetAncestor(p_cell_ancestor);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
// Set CellVecData with some actual content
boost::shared_ptr<AbstractCellProperty> p_vec_data(CellPropertyRegistry::Instance()->Get<CellVecData>());
p_cell->AddCellProperty(p_vec_data);
Vec item_1 = PetscTools::CreateAndSetVec(2, -17.3); // <-17.3, -17.3>
p_cell->GetCellVecData()->SetItem("item 1", item_1);
// Check properties set correctly
CellPropertyCollection& final_collection = p_cell->rGetCellPropertyCollection();
TS_ASSERT_EQUALS(final_collection.GetSize(), 7u);
TS_ASSERT_EQUALS(final_collection.HasProperty<WildTypeCellMutationState>(), true);
TS_ASSERT_EQUALS(final_collection.HasProperty<ApcOneHitCellMutationState>(), false);
TS_ASSERT_EQUALS(final_collection.HasProperty<ApcTwoHitCellMutationState>(), false);
TS_ASSERT_EQUALS(final_collection.HasProperty<CellLabel>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<AbstractCellMutationState>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<CellAncestor>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<CellId>(), true);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
for (CellPropertyCollection::Iterator it = final_collection.Begin(); it != final_collection.End(); ++it)
{
TS_ASSERT_EQUALS(final_collection.HasProperty(*it), true);
bool is_wildtype = (*it)->IsType<WildTypeCellMutationState>();
bool is_label = (*it)->IsType<CellLabel>();
bool is_ancestor = (*it)->IsType<CellAncestor>();
bool is_cellid = (*it)->IsType<CellId>();
bool is_data = (*it)->IsType<CellData>();
bool is_vec_data = (*it)->IsType<CellVecData>();
bool is_stem = (*it)->IsType<StemCellProliferativeType>();
bool is_any_of_above = is_wildtype || is_label || is_ancestor || is_cellid || is_data || is_vec_data || is_stem;
TS_ASSERT_EQUALS(is_any_of_above, true);
}
// Create another cell
boost::shared_ptr<AbstractCellProperty> p_another_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
FixedDurationGenerationBasedCellCycleModel* p_another_cell_model = new FixedDurationGenerationBasedCellCycleModel();
Goldbeter1991SrnModel* p_another_srn_model = new Goldbeter1991SrnModel();
CellPtr p_another_cell(new Cell(p_another_healthy_state, p_another_cell_model, p_another_srn_model, false, collection));
boost::shared_ptr<AbstractCellProperty> p_another_vec_data(new CellVecData);
p_another_cell->AddCellProperty(p_another_vec_data);
TS_ASSERT_EQUALS(p_cell->GetCellVecData()->GetNumItems(), 1u);
TS_ASSERT_EQUALS(p_another_cell->GetCellVecData()->GetNumItems(), 0u);
Vec another_item_1 = PetscTools::CreateAndSetVec(2, 42.0); // <42, 42>
p_another_cell->GetCellVecData()->SetItem("item 1", another_item_1);
// Create an output archive
std::ofstream ofs(archive_filename.c_str());
boost::archive::text_oarchive output_arch(ofs);
CellPtr const p_const_cell = p_cell;
// Write the cell to the archive
output_arch << static_cast<const SimulationTime&> (*p_simulation_time);
output_arch << p_const_cell;
// Write the second cell also
CellPtr const p_another_const_cell = p_another_cell;
output_arch << p_another_const_cell;
// Tidy up
SimulationTime::Destroy();
PetscTools::Destroy(item_1);
PetscTools::Destroy(another_item_1);
}
// Restore CellPtr
{
// Need to set up time to initialize a cell
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetStartTime(1.0);
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(2.0, 1); // will be restored
// Initialize a cell
CellPtr p_cell;
// Restore the cell
std::ifstream ifs(archive_filename.c_str(), std::ios::binary);
boost::archive::text_iarchive input_arch(ifs);
input_arch >> *p_simulation_time;
input_arch >> p_cell;
// Check the simulation time has been restored (through the cell)
TS_ASSERT_EQUALS(p_simulation_time->GetTime(), 0.5);
TS_ASSERT_EQUALS(p_simulation_time->GetTimeStep(), 0.5);
TS_ASSERT_EQUALS(p_cell->GetAge(), 0.5);
TS_ASSERT_EQUALS(static_cast<FixedDurationGenerationBasedCellCycleModel*>(p_cell->GetCellCycleModel())->GetGeneration(), 0u);
TS_ASSERT(dynamic_cast<Goldbeter1991SrnModel*>(p_cell->GetSrnModel()));
TS_ASSERT_EQUALS(p_cell->GetCellProliferativeType()->IsType<StemCellProliferativeType>(), true);
AbstractCellCycleModel* p_cc_model = p_cell->GetCellCycleModel();
TS_ASSERT_EQUALS(p_cc_model->GetCell(), p_cell);
AbstractSrnModel* p_srn_model = p_cell->GetSrnModel();
TS_ASSERT_EQUALS(p_srn_model->GetCell(), p_cell);
CellPropertyCollection& collection = p_cell->rGetCellPropertyCollection();
TS_ASSERT_EQUALS(collection.GetSize(), 7u);
TS_ASSERT_EQUALS(collection.HasProperty<WildTypeCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcOneHitCellMutationState>(), false);
TS_ASSERT_EQUALS(collection.HasProperty<ApcTwoHitCellMutationState>(), false);
TS_ASSERT_EQUALS(collection.HasProperty<CellLabel>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<CellAncestor>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<CellId>(), true);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
// Check explicitly for CellVecData as it is not available by default as CellData
TS_ASSERT_EQUALS(collection.HasPropertyType<CellVecData>(), true);
// Check that the Vec stored in CellVecData was unarchived correctly
boost::shared_ptr<CellVecData> p_cell_vec_data = boost::static_pointer_cast<CellVecData>(collection.GetPropertiesType<CellVecData>().GetProperty());
PetscInt vec_size;
VecGetSize(p_cell_vec_data->GetItem("item 1"), &vec_size);
TS_ASSERT_EQUALS(vec_size, 2);
ReplicatableVector rep_item_1(p_cell_vec_data->GetItem("item 1"));
TS_ASSERT_DELTA(rep_item_1[0], -17.3, 2e-14);
for (CellPropertyCollection::Iterator it = collection.Begin(); it != collection.End(); ++it)
{
TS_ASSERT_EQUALS(collection.HasProperty(*it), true);
bool is_wildtype = (*it)->IsType<WildTypeCellMutationState>();
bool is_label = (*it)->IsType<CellLabel>();
bool is_ancestor = (*it)->IsType<CellAncestor>();
bool is_cellid = (*it)->IsType<CellId>();
bool is_data = (*it)->IsType<CellData>();
bool is_vec_data = (*it)->IsType<CellVecData>();
bool is_stem = (*it)->IsType<StemCellProliferativeType>();
bool is_any_of_above = is_wildtype || is_label || is_ancestor || is_cellid || is_data || is_vec_data || is_stem;
TS_ASSERT_EQUALS(is_any_of_above, true);
}
// Try another cell
CellPtr p_another_cell;
input_arch >> p_another_cell;
ReplicatableVector rep_another_item_1(p_another_cell->GetCellVecData()->GetItem("item 1"));
TS_ASSERT_DELTA(rep_another_item_1[0], 42.0, 2e-14);
}
}
/*
* We are checking that the CellPtrs work with the StochasticWnt cell-cycle models here
* That division of wnt cells and stuff works OK.
*
* It checks that the cell division thing works nicely too.
*/
void TestWithStochasticWntCellCycleModel() throw(Exception)
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
unsigned num_steps = 101;
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(50.0, num_steps+1);
double wnt_stimulus = 1.0;
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(wnt_stimulus);
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_transit_type(CellPropertyRegistry::Instance()->Get<TransitCellProliferativeType>());
StochasticWntCellCycleModel* p_cell_model = new StochasticWntCellCycleModel();
p_cell_model->SetDimension(2);
CellPtr p_wnt_cell(new Cell(p_healthy_state, p_cell_model));
p_wnt_cell->SetCellProliferativeType(p_transit_type);
p_wnt_cell->InitialiseCellCycleModel();
// These are the first three normal random with mean of usual G2 Duration (4hrs), s.d. 0.9 and this seed (0)
double SG2MDuration1 = p_cell_model->GetSDuration() + 2.98536 + p_cell_model->GetMDuration();
double SG2MDuration2 = p_cell_model->GetSDuration() + 3.63573 + p_cell_model->GetMDuration();
double SG2MDuration3 = p_cell_model->GetSDuration() + 3.62339 + p_cell_model->GetMDuration();
double g1_duration = 5.971;
for (unsigned i=0; i<num_steps/2; i++)
{
p_simulation_time->IncrementTimeOneStep();
double time = p_simulation_time->GetTime();
if (time >= g1_duration+SG2MDuration1)
{
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), true);
}
else
{
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), false);
}
}
p_simulation_time->IncrementTimeOneStep();
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), true);
CellPtr p_wnt_cell2 = p_wnt_cell->Divide();
double time_of_birth = p_wnt_cell->GetBirthTime();
double time_of_birth2 = p_wnt_cell2->GetBirthTime();
TS_ASSERT_DELTA(time_of_birth, time_of_birth2, 1e-9);
for (unsigned i=0; i<num_steps/2; i++)
{
p_simulation_time->IncrementTimeOneStep();
double time = p_simulation_time->GetTime();
bool parent_ready = p_wnt_cell->ReadyToDivide();
bool daughter_ready = p_wnt_cell2->ReadyToDivide();
if (time >= g1_duration+SG2MDuration2+time_of_birth)
{
TS_ASSERT_EQUALS(parent_ready, true);
}
else
{
TS_ASSERT_EQUALS(parent_ready, false);
}
if (time >= g1_duration+SG2MDuration3+time_of_birth2)
{
TS_ASSERT_EQUALS(daughter_ready, true);
}
else
{
TS_ASSERT_EQUALS(daughter_ready, false);
}
}
// Tidy up
WntConcentration<2>::Destroy();
}
/*
* We are checking that the CellPtrs work with the Wnt cell-cycle models here
* That division of wnt cells and stuff works OK.
*
* It checks that the cell division thing works nicely too.
*/
void TestWithWntCellCycleModel() throw(Exception)
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
unsigned num_steps = 100;
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(50.0, num_steps+1);
double wnt_stimulus = 1.0;
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(wnt_stimulus);
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_transit_type(CellPropertyRegistry::Instance()->Get<TransitCellProliferativeType>());
WntCellCycleModel* p_cell_cycle_model1 = new WntCellCycleModel();
p_cell_cycle_model1->SetDimension(2);
CellPtr p_wnt_cell(new Cell(p_healthy_state, p_cell_cycle_model1));
p_wnt_cell->SetCellProliferativeType(p_transit_type);
p_wnt_cell->InitialiseCellCycleModel();
double SG2MDuration = p_cell_cycle_model1->GetSG2MDuration();
#ifdef CHASTE_CVODE
const double expected_g1_duration = 5.96441;
#else
const double expected_g1_duration = 5.971;
#endif //CHASTE_CVODE
for (unsigned i=0; i<num_steps/2; i++)
{
p_simulation_time->IncrementTimeOneStep();
double time = p_simulation_time->GetTime();
if (time >= expected_g1_duration+SG2MDuration)
{
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), true);
}
else
{
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), false);
}
}
p_simulation_time->IncrementTimeOneStep();
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(wnt_stimulus);
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), true);
CellPtr p_wnt_cell2 = p_wnt_cell->Divide();
double time_of_birth = p_wnt_cell->GetBirthTime();
double time_of_birth2 = p_wnt_cell2->GetBirthTime();
TS_ASSERT_DELTA(time_of_birth, time_of_birth2, 1e-9);
for (unsigned i=0; i<num_steps/2; i++)
{
p_simulation_time->IncrementTimeOneStep();
double time = p_simulation_time->GetTime();
bool result1 = p_wnt_cell->ReadyToDivide();
bool result2 = p_wnt_cell2->ReadyToDivide();
if (time >= expected_g1_duration + SG2MDuration + time_of_birth)
{
TS_ASSERT_EQUALS(result1, true);
TS_ASSERT_EQUALS(result2, true);
}
else
{
TS_ASSERT_EQUALS(result1, false);
TS_ASSERT_EQUALS(result2, false);
}
}
// Tidy up
WntConcentration<2>::Destroy();
}
