struct cells_t *apply_rule(cell_state rule[8], struct cells_t *cells) {
struct cells_t *new_cells = cells_copy(cells);
for(size_t i = 1; i < cells_length(cells) - 1; i++) {
cell_state newval = lookup_rule_table(rule, cells, i);
cells_set_state(new_cells, i, newval);
}
return new_cells;
}
/*
* Here we set up a test with 5 nodes, make a cell for each. We then set cell
* 0 to be associated with node 1 instead of node 0, and Validate() throws an
* exception. We then set node 0 to be a particle node, and Validate() passes.
*/
void TestValidateNodeBasedCellPopulationWithParticles() throw(Exception)
{
EXIT_IF_PARALLEL; // This test doesn't work in parallel.
// Create a simple mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4_elements");
TetrahedralMesh<2,2> generating_mesh;
generating_mesh.ConstructFromMeshReader(mesh_reader);
// Convert this to a NodesOnlyMesh
NodesOnlyMesh<2> mesh;
mesh.ConstructNodesWithoutMesh(generating_mesh, 1.5);
// Create cells
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, mesh.GetNumNodes()-1);
std::vector<unsigned> cell_location_indices;
for (unsigned i=0; i<cells.size(); i++)
{
cell_location_indices.push_back(i);
}
// Fails as the cell population constructor is not given the location indices
// corresponding to real cells, so cannot work out which nodes are
// particles
std::vector<CellPtr> cells_copy(cells);
TS_ASSERT_THROWS_THIS(NodeBasedCellPopulationWithParticles<2> dodgy_cell_population(mesh, cells_copy),
"Node 4 does not appear to be a particle or has a cell associated with it");
// Passes as the cell population constructor automatically works out which
// cells are particles using the mesh and cell_location_indices
NodeBasedCellPopulationWithParticles<2> cell_population(mesh, cells, cell_location_indices);
// Here we set the particles to what they already are
std::set<unsigned> particle_indices;
particle_indices.insert(mesh.GetNumNodes()-1);
cell_population.SetParticles(particle_indices);
// So validate passes at the moment
cell_population.Validate();
// Test GetCellUsingLocationIndex()
TS_ASSERT_THROWS_NOTHING(cell_population.GetCellUsingLocationIndex(0)); // real cell
TS_ASSERT_THROWS_THIS(cell_population.GetCellUsingLocationIndex(mesh.GetNumNodes()-1u),"Location index input argument does not correspond to a Cell"); // particles
// Now we label a real cell's node as particle
particle_indices.insert(1);
// Validate detects this inconsistency
TS_ASSERT_THROWS_THIS(cell_population.SetParticles(particle_indices),"Node 1 is labelled as a particle and has a cell attached");
}
void TestValidate() throw (Exception)
{
// Create a simple Potts mesh
PottsMeshGenerator<2> generator(4, 2, 2, 4, 2, 2);
PottsMesh<2>* p_mesh = generator.GetMesh();
// Create cells
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, p_mesh->GetNumElements()-1);
std::vector<unsigned> cell_location_indices;
for (unsigned i=0; i<cells.size(); i++)
{
cell_location_indices.push_back(i);
}
// This should throw an exception as the number of cells does not equal the number of elements
std::vector<CellPtr> cells_copy(cells);
TS_ASSERT_THROWS_THIS(PottsBasedCellPopulation<2> cell_population(*p_mesh, cells_copy),
"At time 0, Element 3 does not appear to have a cell associated with it");
MAKE_PTR(WildTypeCellMutationState, p_state);
MAKE_PTR(StemCellProliferativeType, p_stem_type);
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_cell1(new Cell(p_state, p_model));
p_cell1->SetCellProliferativeType(p_stem_type);
double birth_time = 0.0 - p_mesh->GetNumElements()-1;
p_cell1->SetBirthTime(birth_time);
cells.push_back(p_cell1);
cell_location_indices.push_back(p_mesh->GetNumElements()-1);
// This should pass as the number of cells equals the number of elements
std::vector<CellPtr> cells_copy2(cells);
TS_ASSERT_THROWS_NOTHING(PottsBasedCellPopulation<2> cell_population(*p_mesh, cells_copy2));
// Create cell population
PottsBasedCellPopulation<2> cell_population(*p_mesh, cells);
// Check correspondence between elements and cells
for (PottsMesh<2>::PottsElementIterator iter = p_mesh->GetElementIteratorBegin();
iter != p_mesh->GetElementIteratorEnd();
++iter)
{
std::set<unsigned> expected_node_indices;
unsigned expected_index = iter->GetIndex();
for (unsigned i=0; i<iter->GetNumNodes(); i++)
{
expected_node_indices.insert(iter->GetNodeGlobalIndex(i));
}
std::set<unsigned> actual_node_indices;
unsigned elem_index = iter->GetIndex();
CellPtr p_cell = cell_population.GetCellUsingLocationIndex(elem_index);
PottsElement<2>* p_actual_element = cell_population.GetElementCorrespondingToCell(p_cell);
unsigned actual_index = p_actual_element->GetIndex();
for (unsigned i=0; i<p_actual_element->GetNumNodes(); i++)
{
actual_node_indices.insert(p_actual_element->GetNodeGlobalIndex(i));
}
TS_ASSERT_EQUALS(actual_index, expected_index);
TS_ASSERT_EQUALS(actual_node_indices, expected_node_indices);
}
// Create another simple potts-based mesh
PottsMeshGenerator<2> generator2(4, 2, 2, 4, 2, 2);
PottsMesh<2>* p_mesh2 = generator2.GetMesh();
// Create cells
std::vector<CellPtr> cells2;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator2;
cells_generator2.GenerateBasic(cells2, p_mesh2->GetNumElements()+1);
std::vector<unsigned> cell_location_indices2;
for (unsigned i=0; i<cells2.size(); i++)
{
cell_location_indices2.push_back(i%p_mesh2->GetNumElements()); // Element 0 will have 2 cells
}
// This should throw a never-reached exception as the number of cells
// does not equal the number of elements
TS_ASSERT_THROWS_THIS(PottsBasedCellPopulation<2> cell_population2(*p_mesh2, cells2, false, true, cell_location_indices2),
"At time 0, Element 0 appears to have 2 cells associated with it");
}
