CellPropertyCollection GetPropertiesType() const
{
CellPropertyCollection result;
for (ConstIteratorType it = mProperties.begin(); it != mProperties.end(); ++it)
{
if ((*it)->IsSubType<BASECLASS>())
{
result.AddProperty(*it);
}
}
return result;
}
/*
* We are checking that the CellPtrs work with the Wnt
* cell-cycle models here. This just tests the set-up and checks that
* the functions can all be called (not what they return).
*
* For more in depth tests see TestNightlyCellPtr.hpp
* (these test that the cell cycle times are correct for the
* various mutant cells)
*/
void TestWntMutantVariantsAndLabelling() throw(Exception)
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
unsigned num_steps = 10;
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(1.0, num_steps+1);
double wnt_stimulus = 1.0;
WntConcentration<2>::Instance()->SetConstantWntValueForTesting(wnt_stimulus);
boost::shared_ptr<AbstractCellProperty> p_wt_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_apc_one_hit_state(CellPropertyRegistry::Instance()->Get<ApcOneHitCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_apc_two_hit_state(CellPropertyRegistry::Instance()->Get<ApcTwoHitCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_bcat_one_hit_state(CellPropertyRegistry::Instance()->Get<BetaCateninOneHitCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_label(CellPropertyRegistry::Instance()->Get<CellLabel>());
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_apc_one_hit_state, p_cell_cycle_model1));
p_wnt_cell->SetCellProliferativeType(p_transit_type);
p_wnt_cell->InitialiseCellCycleModel();
WntCellCycleModel* p_cell_cycle_model2 = new WntCellCycleModel();
p_cell_cycle_model2->SetDimension(2);
CellPtr p_wnt_cell2(new Cell(p_bcat_one_hit_state, p_cell_cycle_model2));
p_wnt_cell2->SetCellProliferativeType(p_transit_type);
p_wnt_cell2->InitialiseCellCycleModel();
WntCellCycleModel* p_cell_cycle_model3 = new WntCellCycleModel();
p_cell_cycle_model3->SetDimension(2);
CellPtr p_wnt_cell3(new Cell(p_apc_two_hit_state, p_cell_cycle_model3));
p_wnt_cell3->SetCellProliferativeType(p_transit_type);
p_wnt_cell3->InitialiseCellCycleModel();
WntCellCycleModel* p_cell_cycle_model4 = new WntCellCycleModel();
p_cell_cycle_model4->SetDimension(2);
CellPropertyCollection collection;
collection.AddProperty(p_label);
CellPtr p_wnt_cell4(new Cell(p_wt_state, p_cell_cycle_model4, false, collection));
p_wnt_cell4->SetCellProliferativeType(p_transit_type);
p_wnt_cell4->InitialiseCellCycleModel();
TS_ASSERT_EQUALS(p_wnt_cell->ReadyToDivide(), false);
TS_ASSERT_EQUALS(p_wnt_cell2->ReadyToDivide(), false);
TS_ASSERT_EQUALS(p_wnt_cell3->ReadyToDivide(), false);
TS_ASSERT_EQUALS(p_wnt_cell4->ReadyToDivide(), false);
//Tidy up
WntConcentration<2>::Destroy();
}
void TestArchiveCellPropertyCollection() throw (Exception)
{
OutputFileHandler handler("archive", false);
std::string archive_filename = handler.GetOutputDirectoryFullPath() + "properties.arch";
// Archive a cell property collection
{
// Create a cell property collection
CellPropertyCollection collection;
NEW_PROP(BetaCateninOneHitCellMutationState, p_bcat1_mutation);
collection.AddProperty(p_bcat1_mutation);
NEW_PROP(ApcOneHitCellMutationState, p_apc1_mutation);
collection.AddProperty(p_apc1_mutation);
// Create an output archive
std::ofstream ofs(archive_filename.c_str());
boost::archive::text_oarchive output_arch(ofs);
// Write the cell to the archive
output_arch << static_cast<const CellPropertyCollection>(collection);
}
// Restore cell property collection
{
CellPropertyCollection collection;
// Restore the cell property collection
std::ifstream ifs(archive_filename.c_str());
boost::archive::text_iarchive input_arch(ifs);
input_arch >> collection;
// Test that the collection was archived correctly
TS_ASSERT_EQUALS(collection.GetSize(), 2u);
TS_ASSERT_EQUALS(collection.HasProperty<BetaCateninOneHitCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcOneHitCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcTwoHitCellMutationState>(), false);
NEW_PROP(ApcOneHitCellMutationState, p_apc1_mutation_2);
TS_ASSERT_EQUALS(collection.HasProperty(p_apc1_mutation_2), false);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellMutationState>(), true);
for (CellPropertyCollection::Iterator it = collection.Begin(); it != collection.End(); ++it)
{
TS_ASSERT_EQUALS(collection.HasProperty(*it), true);
TS_ASSERT((*it)->IsType<BetaCateninOneHitCellMutationState>() || (*it)->IsType<ApcOneHitCellMutationState>());
TS_ASSERT_EQUALS((*it)->IsSubType<AbstractCellMutationState>(), true);
}
}
}
/*
* === Using the cell property in a cell-based simulation ===
*
* We conclude with a brief test demonstrating how {{{MotileCellProperty}}} can be used
* in a cell-based simulation.
*/
void TestOffLatticeSimulationWithMotileCellProperty() throw(Exception)
{
/* Note that HoneycombMeshGenerator, used in this test, is not
* yet implemented in parallel. */
/* We use the {{{HoneycombMeshGenerator}}} to create a honeycomb mesh covering a
* circular domain of given radius, and use this to generate a {{{NodesOnlyMesh}}}
* as follows. */
HoneycombMeshGenerator generator(10, 10);
MutableMesh<2,2>* p_generating_mesh = generator.GetCircularMesh(5);
NodesOnlyMesh<2> mesh;
/* We construct the mesh using the generating mesh and a cut-off 1.5 which defines the
* connectivity in the mesh.
*/
mesh.ConstructNodesWithoutMesh(*p_generating_mesh, 1.5);
/* We now create a shared pointer to our new property, as follows. */
MAKE_PTR(MotileCellProperty, p_motile);
/*
* Also create a shared pointer to a cell label so we can visualize the
* different cell types. Note that this is also a {{{CellProperty}}}.
*/
MAKE_PTR(CellLabel, p_label);
/* Next, we create some cells. We don't use a Generator as we want to give some cells the new cell property, therefore
* we create the cells in a loop, as follows.*/
MAKE_PTR(WildTypeCellMutationState, p_state);
MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type);
std::vector<CellPtr> cells;
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
/* For each node we create a cell with our cell-cycle model and the wild-type cell mutation state.
* We then add the property {{{MotileCellProperty}}} to a random selection of the cells, as follows. */
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPropertyCollection collection;
if (RandomNumberGenerator::Instance()->ranf() < 0.2)
{
collection.AddProperty(p_motile);
collection.AddProperty(p_label);
}
CellPtr p_cell(new Cell(p_state, p_model, false, collection));
p_cell->SetCellProliferativeType(p_diff_type);
/* Now, we define a random birth time, chosen from [-T,0], where
* T = t,,1,, + t,,2,,, where t,,1,, is a parameter representing the G,,1,, duration
* of a stem cell, and t,,2,, is the basic S+G,,2,,+M phases duration.
*/
double birth_time = - RandomNumberGenerator::Instance()->ranf() *
(p_model->GetStemCellG1Duration()
+ p_model->GetSG2MDuration());
/* Finally, we set the birth time and push the cell back into the vector of cells. */
p_cell->SetBirthTime(birth_time);
cells.push_back(p_cell);
}
/* Now that we have defined the mesh and cells, we can define the cell population. The constructor
* takes in the mesh and the cells vector. */
NodeBasedCellPopulation<2> cell_population(mesh, cells);
/* In order to visualize labelled cells we need to use the following command.*/
cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>();
/* We then pass in the cell population into an {{{OffLatticeSimulation}}},
* and set the output directory, output multiple, and end time. */
OffLatticeSimulation<2> simulator(cell_population);
simulator.SetOutputDirectory("TestOffLatticeSimulationWithMotileCellProperty");
simulator.SetSamplingTimestepMultiple(12);
simulator.SetEndTime(10.0);
/* We create a force law and pass it to the {{{OffLatticeSimulation}}}. */
MAKE_PTR(GeneralisedLinearSpringForce<2>, p_linear_force);
p_linear_force->SetCutOffLength(1.5);
simulator.AddForce(p_linear_force);
/* Now create a {{{MotlieForce}}} and pass it to the {{{OffLatticeSimulation}}}. */
MAKE_PTR(MyMotiveForce, p_motive_force);
simulator.AddForce(p_motive_force);
/* To run the simulation, we call {{{Solve()}}}. */
simulator.Solve();
}
void TestPropertyCollection() throw (Exception)
{
CellPropertyCollection collection;
TS_ASSERT_EQUALS(collection.GetSize(), 0u);
// Test that the CellPropertyRegistry assigned to the CellPropertyCollection defaults to CellPropertyRegistry::Instance().
TS_ASSERT_EQUALS(collection.GetCellPropertyRegistry(),CellPropertyRegistry::Instance());
// Add some properties
NEW_PROP(WildTypeCellMutationState, p_wt_mutation);
TS_ASSERT_EQUALS(p_wt_mutation->GetIdentifier(), "WildTypeCellMutationState");
collection.AddProperty(p_wt_mutation);
NEW_PROP(ApcOneHitCellMutationState, p_apc1_mutation);
collection.AddProperty(p_apc1_mutation);
// Test we can't add the same *object* twice
TS_ASSERT_THROWS_THIS(collection.AddProperty(p_wt_mutation),
"That property object is already in the collection.");
NEW_PROP(WildTypeCellMutationState, p_wt_mutation_2);
collection.AddProperty(p_wt_mutation_2);
collection.RemoveProperty(p_wt_mutation_2);
// Check the contents
TS_ASSERT_EQUALS(collection.GetSize(), 2u);
// ...by object
TS_ASSERT_EQUALS(collection.HasProperty(p_wt_mutation), true);
TS_ASSERT_EQUALS(collection.HasProperty(p_apc1_mutation), true);
NEW_PROP(ApcOneHitCellMutationState, p_apc1_mutation_2);
TS_ASSERT_EQUALS(collection.HasProperty(p_apc1_mutation_2), false);
// ...by type
TS_ASSERT_EQUALS(collection.HasProperty<WildTypeCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcOneHitCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcTwoHitCellMutationState>(), false);
// ..by subclass
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellMutationState>(), true);
//TS_ASSERT_EQUALS(!collection.HasProperty<AbstractCellMutationState>(), false); <-- This won't compile (yet)
// ..by iteration
for (CellPropertyCollection::Iterator it = collection.Begin(); it != collection.End(); ++it)
{
TS_ASSERT_EQUALS(collection.HasProperty(*it), true);
TS_ASSERT((*it)->IsType<WildTypeCellMutationState>() || (*it)->IsType<ApcOneHitCellMutationState>());
TS_ASSERT_EQUALS((*it)->IsSubType<AbstractCellMutationState>(), true);
}
// Remove property
collection.RemoveProperty<WildTypeCellMutationState>();
TS_ASSERT_EQUALS(collection.HasProperty<WildTypeCellMutationState>(), false);
collection.RemoveProperty(p_apc1_mutation);
TS_ASSERT_EQUALS(collection.HasProperty<ApcOneHitCellMutationState>(), false);
TS_ASSERT_THROWS_THIS(collection.RemoveProperty<WildTypeCellMutationState>(),
"Collection does not contain the given property type.");
TS_ASSERT_THROWS_THIS(collection.RemoveProperty(p_apc1_mutation),
"Collection does not contain the given property.");
TS_ASSERT_EQUALS(collection.GetSize(), 0u);
// Get matching properties
collection.AddProperty(p_wt_mutation);
collection.AddProperty(p_apc1_mutation);
CellPropertyCollection mutations = collection.GetPropertiesType<AbstractCellMutationState>();
TS_ASSERT_EQUALS(mutations.GetSize(), 2u);
CellPropertyCollection::Iterator it = mutations.Begin();
TS_ASSERT_EQUALS(collection.HasProperty(*it), true);
TS_ASSERT_EQUALS((*it)->IsSubType<AbstractCellMutationState>(), true);
TS_ASSERT( (*it)->IsType<WildTypeCellMutationState>() || (*(++it))->IsType<WildTypeCellMutationState>() );
CellPropertyCollection wild_types = collection.GetProperties<WildTypeCellMutationState>();
TS_ASSERT_EQUALS(wild_types.GetSize(), 1u);
it = wild_types.Begin();
TS_ASSERT_EQUALS((*it)->IsType<WildTypeCellMutationState>(), true);
TS_ASSERT( *it == wild_types.GetProperty() );
TS_ASSERT_THROWS_THIS(collection.GetProperty(),
"Can only call GetProperty on a collection of size 1.");
}
void TestOffLatticeSimulationWithMotileCellPropertyAndWriters() throw(Exception)
{
/*
* We begin by creating a {{{NodeBasedCellPopulation}}}, just as in [wiki:UserTutorials/CreatingAndUsingANewCellProperty].
* We add the {{{MotileCellProperty}}} to a random selection of cells.
* We also add the {{{CellLabel}}} to these cells so that we can easily visualize the different cell types.
*/
EXIT_IF_PARALLEL;
HoneycombMeshGenerator generator(10, 10);
MutableMesh<2,2>* p_generating_mesh = generator.GetCircularMesh(5);
NodesOnlyMesh<2> mesh;
mesh.ConstructNodesWithoutMesh(*p_generating_mesh, 1.5);
MAKE_PTR(MotileCellProperty, p_motile);
MAKE_PTR(CellLabel, p_label);
MAKE_PTR(WildTypeCellMutationState, p_state);
MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type);
std::vector<CellPtr> cells;
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPropertyCollection collection;
if (RandomNumberGenerator::Instance()->ranf() < 0.2)
{
collection.AddProperty(p_motile);
collection.AddProperty(p_label);
}
CellPtr p_cell(new Cell(p_state, p_model, false, collection));
p_cell->SetCellProliferativeType(p_diff_type);
double birth_time = - RandomNumberGenerator::Instance()->ranf() *
(p_model->GetStemCellG1Duration() + p_model->GetSG2MDuration());
p_cell->SetBirthTime(birth_time);
cells.push_back(p_cell);
}
NodeBasedCellPopulation<2> cell_population(mesh, cells);
/* In order to write cell motility data using our writer, we must add it to the list of writers
* used by the population. This is achieved using the {{{AddCellWriter()}}} method,
* which is templated. */
cell_population.AddCellWriter<CellMotilityWriter>();
/* We then pass in the cell population into an {{{OffLatticeSimulation}}},
* and set the output directory, output multiple, and end time. */
OffLatticeSimulation<2> simulator(cell_population);
simulator.SetOutputDirectory("TestOffLatticeSimulationWithMotileCellPropertyAndWriters");
simulator.SetSamplingTimestepMultiple(12);
simulator.SetEndTime(10.0);
/* Next we create a force law and pass it to the {{{OffLatticeSimulation}}}, and call {{{Solve()}}} to run the simulation. */
MAKE_PTR(GeneralisedLinearSpringForce<2>, p_linear_force);
p_linear_force->SetCutOffLength(1.5);
simulator.AddForce(p_linear_force);
simulator.Solve();
}
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);
}
}
