/* * 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(); }
/* * EMPTYLINE * * In this test, we demonstrate how to simulate a heterotypic monolayer that incorporates * differential adhesion, using a vertex-based approach. This may be compared with the * second test in the TestRunningPottsBasedSimulationsTutorial, which implements a similar * simulation using a cellular Potts model. */ void TestVertexBasedDifferentialAdhesionSimulation() throw (Exception) { /* First we create a regular vertex mesh. Here we choose to set the value of the cell rearrangement threshold. */ HoneycombVertexMeshGenerator generator(5, 5); MutableVertexMesh<2,2>* p_mesh = generator.GetMesh(); p_mesh->SetCellRearrangementThreshold(0.1); /* We then create some cells using the helper class {{{CellsGenerator}}}. Note that in this simulation * the cells are all differentiated, and thus no cell division occurs; if we wished, we could modify * the three lines below in a straightforward manner to incorporate cell proliferation and investigate * the effect of this on the cell sorting process. */ std::vector<CellPtr> cells; MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type); CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator; cells_generator.GenerateBasic(cells, p_mesh->GetNumElements(), std::vector<unsigned>(), p_diff_type); /* Using the vertex mesh and cells, we create a cell-based population object, and specify which results to * output to file. */ VertexBasedCellPopulation<2> cell_population(*p_mesh, cells); cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>(); cell_population.AddCellPopulationCountWriter<CellProliferativeTypesCountWriter>(); cell_population.AddCellPopulationCountWriter<CellProliferativePhasesCountWriter>(); cell_population.AddCellWriter<CellProliferativePhasesWriter>(); cell_population.AddCellWriter<CellAgesWriter>(); cell_population.AddCellWriter<CellVolumesWriter>(); /* We randomly label some cells using the cell property {{{CellLabel}}}. We begin by creating a shared pointer to * this cell property using the helper singleton {{{CellPropertyRegistry}}}. We then loop over the cells and label * each cell independently with probability 0.5. Note that since the cells have been passed to the * {{{VertexBasedCellPopulation}}} object, the vector {{{cells}}} above is now empty, so we must use the * {{{Iterator}}} to loop over cells. */ boost::shared_ptr<AbstractCellProperty> p_label(CellPropertyRegistry::Instance()->Get<CellLabel>()); for (AbstractCellPopulation<2>::Iterator cell_iter = cell_population.Begin(); cell_iter != cell_population.End(); ++cell_iter) { if (RandomNumberGenerator::Instance()->ranf() < 0.5) { cell_iter->AddCellProperty(p_label); } } /* We are now in a position to create and configure the cell-based simulation object. * We can make the simulation run for longer to see more cell sorting by increasing the end time. */ OffLatticeSimulation<2> simulator(cell_population); simulator.SetOutputDirectory("TestVertexBasedDifferentialAdhesionSimulation"); simulator.SetSamplingTimestepMultiple(10); simulator.SetEndTime(1.0); /* Next we create the differential adhesion force law. This builds upon the model of Nagai, Honda and co-workers * encounted in the TestRunningVertexBasedSimulationsTutorial by allowing different values of the adhesion * energy parameters depending on the types of two neighbouring cells. Here we interpret the 'type' of a cell * as whether or not it has the cell property {{{CellLabel}}}; it would be straightforward to create a similar * force law that took account of a cell's mutation state, for example. Having created the force law, we set the * values of the parameters. If the adhesion energy for two neighbouring homotypic cells is less than that of two * heterotypic cells, then we may expect cell sorting to occur, in which the cells of each type will tend to locally * aggregate over time. */ MAKE_PTR(NagaiHondaDifferentialAdhesionForce<2>, p_force); p_force->SetNagaiHondaDeformationEnergyParameter(55.0); p_force->SetNagaiHondaMembraneSurfaceEnergyParameter(0.0); p_force->SetNagaiHondaCellCellAdhesionEnergyParameter(1.0); p_force->SetNagaiHondaLabelledCellCellAdhesionEnergyParameter(6.0); p_force->SetNagaiHondaLabelledCellLabelledCellAdhesionEnergyParameter(3.0); p_force->SetNagaiHondaCellBoundaryAdhesionEnergyParameter(12.0); p_force->SetNagaiHondaLabelledCellBoundaryAdhesionEnergyParameter(40.0); simulator.AddForce(p_force); /* A {{{NagaiHondaForceDifferentialAdhesionForce}}} assumes that each cell has been assigned a target area. * The {{{SimpleTargetAreaModifier}}} will assign and update the target areas of all cells. */ MAKE_PTR(SimpleTargetAreaModifier<2>, p_growth_modifier); simulator.AddSimulationModifier(p_growth_modifier); /* Finally, we run the simulation. */ simulator.Solve(); }
Parser::stmt_t Parser::p_stmt_toks(Lexer &lex,const Context &ctx,std::vector<Lexer::Token> *toks){ Lexer::Token tok,tok1,tok2; lex >> tok; stmt_t res_stmt = stmt_t::nop(); std::vector<Lexer::Token> mytoks; switch(tok.type){ case Lexer::NOP: ppush(&mytoks,tok); res_stmt = stmt_t::nop(tok.pos,mytoks); break; case Lexer::READ: { ppush(&mytoks,tok); force_toks(lex,Lexer::COLON,&mytoks); lex >> tok1; if(tok1.type == Lexer::REG){ ppush(&mytoks,tok1); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); res_stmt = resolve_pointer(ml,[&tok1,&tok](const memloc_t &ml){ return stmt_t::read_assign(tok1.value,ml,tok.pos); },ctx,mytoks); }else{ lex.putback(tok1); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::EQ,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = resolve_pointer(ml,[&e,&tok](const memloc_t &ml){ return stmt_t::read_assert(ml,e,tok.pos); },ctx,mytoks); } break; } case Lexer::SYNCRD: { ppush(&mytoks,tok); force_toks(lex,Lexer::COLON,&mytoks); lex >> tok1; if(tok1.type == Lexer::REG){ ppush(&mytoks,tok1); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); res_stmt = resolve_pointer(ml,[&tok1,&tok](const memloc_t &ml){ return stmt_t::syncrd_assign(tok1.value,ml,tok.pos); },ctx,mytoks); }else{ lex.putback(tok1); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::EQ,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = resolve_pointer(ml,[&e,&tok](const memloc_t &ml){ return stmt_t::syncrd_assert(ml,e,tok.pos); },ctx,mytoks); } break; } case Lexer::WRITE: { ppush(&mytoks,tok); force_toks(lex,Lexer::COLON,&mytoks); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = resolve_pointer(ml,[&e,&tok](const memloc_t &ml){ return stmt_t::write(ml,e,tok.pos); },ctx,mytoks); break; } case Lexer::SYNCWR: { ppush(&mytoks,tok); force_toks(lex,Lexer::COLON,&mytoks); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = resolve_pointer(ml,[&e,&tok](const memloc_t &ml){ return stmt_t::syncwr(ml,e,tok.pos); },ctx,mytoks); break; } case Lexer::FENCE: { ppush(&mytoks,tok); res_stmt = stmt_t::full_fence(tok.pos,mytoks); break; } case Lexer::SSFENCE: { ppush(&mytoks,tok); res_stmt = stmt_t::ss_fence(tok.pos,mytoks); break; } case Lexer::LLFENCE: { ppush(&mytoks,tok); res_stmt = stmt_t::ll_fence(tok.pos,mytoks); break; } case Lexer::CAS: { ppush(&mytoks,tok); force_toks(lex,Lexer::LPAREN,&mytoks); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::COMMA,&mytoks); expr_t v0(p_expr_toks(lex,&mytoks)); force_toks(lex,Lexer::COMMA,&mytoks); expr_t v1(p_expr_toks(lex,&mytoks)); force_toks(lex,Lexer::RPAREN,&mytoks); res_stmt = resolve_pointer(ml,[&v0,&v1,&tok](const memloc_t &ml){ return stmt_t::cas(ml,v0,v1,tok.pos); },ctx,mytoks); break; } case Lexer::REG: { ppush(&mytoks,tok); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = stmt_t::assignment(tok.value,e,tok.pos,mytoks); break; } case Lexer::IF: { ppush(&mytoks,tok); bexpr_t b(p_bexpr_toks(lex,&mytoks)); force_toks(lex,Lexer::THEN,&mytoks); stmt_t::labeled_stmt_t s0 = p_lstmt(lex,ctx,&mytoks); lex >> tok1; if(tok1.type == Lexer::ELSE){ ppush(&mytoks,tok1); stmt_t::labeled_stmt_t s1 = p_lstmt(lex,ctx,&mytoks); res_stmt = stmt_t::if_stmt(b,s0,s1,tok.pos,mytoks); }else{ lex.putback(tok1); res_stmt = stmt_t::if_stmt(b,s0,tok.pos,mytoks); } break; } case Lexer::WHILE: { ppush(&mytoks,tok); bexpr_t b(p_bexpr_toks(lex,&mytoks)); force_toks(lex,Lexer::DO,&mytoks); stmt_t::labeled_stmt_t s = p_lstmt(lex,ctx,&mytoks); res_stmt = stmt_t::while_stmt(b,s,tok.pos,mytoks); break; } case Lexer::GOTO: { ppush(&mytoks,tok); Lang::label_t lbl = p_label(lex,&mytoks); res_stmt = stmt_t::goto_stmt(lbl,tok.pos,mytoks); break; } case Lexer::EITHER: { ppush(&mytoks,tok); Lexer::TokenPos pos0 = tok.pos; std::vector<stmt_t> seq; Lexer::Token lctok; Lexer::Token tok; lex >> lctok; lex.putback(lctok); force_toks(lex,Lexer::LCURL,&mytoks); seq.push_back(p_stmt_list(lex,ctx,&mytoks)); lex >> tok; while(tok.type == Lexer::EITHER_OR){ ppush(&mytoks,tok); seq.push_back(p_stmt_list(lex,ctx,&mytoks)); lex >> tok; } lex.putback(tok); force_toks(lex,Lexer::RCURL,&mytoks,"Expected '}' at "," to match '{' at "+ lctok.pos.to_long_string()+"."); res_stmt = stmt_t::either(seq,pos0); break; } case Lexer::LOCKED: { ppush(&mytoks,tok); Lexer::TokenPos pos0 = tok.pos; std::vector<stmt_t> seq; Lexer::Token lctok; Lexer::Token tok; lex >> lctok; if(lctok.type == Lexer::WRITE){ ppush(&mytoks,lctok); force_toks(lex,Lexer::COLON,&mytoks); Parser::memloc_or_pointer_t ml = p_memloc_toks(lex,ctx,&mytoks); force_toks(lex,Lexer::ASSIGNMENT,&mytoks); expr_t e = p_expr_toks(lex,&mytoks); res_stmt = resolve_pointer(ml,[&e,&pos0](const memloc_t &ml){ return stmt_t::locked_write(ml,e,pos0); },ctx,mytoks); }else{ lex.putback(lctok); force_toks(lex,Lexer::LCURL,&mytoks); stmt_t s = p_stmt_list(lex,ctx,&mytoks); std::string cmt; if(!stmt_t::check_locked_invariant(s,&cmt)){ throw new SyntaxError("Error in locked block at "+lctok.pos.to_long_string()+": "+cmt,lctok.pos); } seq.push_back(s); lex >> tok; while(tok.type == Lexer::EITHER_OR){ ppush(&mytoks,tok); s = p_stmt_list(lex,ctx,&mytoks); if(!stmt_t::check_locked_invariant(s,&cmt)){ throw new SyntaxError("Error in locked block at "+tok.pos.to_long_string()+": "+cmt,tok.pos); } seq.push_back(s); lex >> tok; } lex.putback(tok); force_toks(lex,Lexer::RCURL,&mytoks,"Expected '}' at "," to match '{' at "+ lctok.pos.to_long_string()+"."); res_stmt = stmt_t::locked_block(seq,pos0); } break; } case Lexer::SLOCKED: { Lexer::TokenPos pos0 = tok.pos; force(lex,Lexer::WRITE); force(lex,Lexer::COLON); Parser::memloc_or_pointer_t ml = p_memloc(lex,ctx); force(lex,Lexer::ASSIGNMENT); expr_t e = p_expr(lex); return resolve_pointer(ml,[&e,&pos0](const memloc_t &ml){ return stmt_t::slocked_write(ml,e,pos0); },ctx,mytoks); } case Lexer::LCURL: { ppush(&mytoks,tok); stmt_t sl = p_stmt_list(lex,ctx,&mytoks); force_toks(lex,Lexer::RCURL,&mytoks,"Expected '}' at "," to match '{' at "+ tok.pos.to_long_string()+"."); res_stmt = sl; break; } case Lexer::ASSUME: { ppush(&mytoks,tok); force_toks(lex,Lexer::COLON,&mytoks); bexpr_t cnd = p_bexpr_toks(lex,&mytoks); res_stmt = stmt_t::assume(cnd,tok.pos,mytoks); break; } default: throw new SyntaxError("Expected statement at "+tok.pos.to_long_string()+".",tok.pos); } if(toks) toks->insert(toks->end(),mytoks.begin(),mytoks.end()); return res_stmt; }
void TestWriteResultsToFileAndOutputCellPopulationParameters() { EXIT_IF_PARALLEL; // Copying in parallel uses parallel NodesOnlyMesh and will therefore cause unexpected errors. // Resetting the maximum cell ID to zero (to account for previous tests) CellId::ResetMaxCellId(); std::string output_directory = "TestPottsBasedCellPopulationWriters"; OutputFileHandler output_file_handler(output_directory, false); // Create a simple 2D PottsMesh PottsMeshGenerator<2> generator(6, 2, 2, 6, 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()); // Create cell population PottsBasedCellPopulation<2> cell_population(*p_mesh, cells); // For coverage, label one cell boost::shared_ptr<AbstractCellProperty> p_label(cell_population.GetCellPropertyRegistry()->Get<CellLabel>()); cell_population.GetCellUsingLocationIndex(0)->AddCellProperty(p_label); TS_ASSERT_EQUALS(cell_population.GetIdentifier(), "PottsBasedCellPopulation-2"); cell_population.SetCellAncestorsToLocationIndices(); cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>(); cell_population.AddCellPopulationCountWriter<CellProliferativeTypesCountWriter>(); cell_population.AddCellPopulationCountWriter<CellProliferativePhasesCountWriter>(); cell_population.AddCellWriter<CellProliferativePhasesWriter>(); cell_population.AddCellWriter<CellAncestorWriter>(); cell_population.AddCellWriter<CellAgesWriter>(); cell_population.AddCellWriter<CellVolumesWriter>(); cell_population.SetNumSweepsPerTimestep(5); TS_ASSERT_EQUALS(cell_population.GetNumSweepsPerTimestep(), 5u); // VTK writing needs a simulation time SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0, 1); cell_population.OpenWritersFiles(output_file_handler); cell_population.WriteResultsToFiles(output_directory); cell_population.CloseWritersFiles(); // Compare output with saved files of what they should look like std::string results_dir = output_file_handler.GetOutputDirectoryFullPath(); FileComparison(results_dir + "results.viznodes", "cell_based/test/data/TestPottsBasedCellPopulationWriters/results.viznodes").CompareFiles(); FileComparison(results_dir + "results.vizcelltypes", "cell_based/test/data/TestPottsBasedCellPopulationWriters/results.vizcelltypes").CompareFiles(); FileComparison(results_dir + "results.vizancestors", "cell_based/test/data/TestPottsBasedCellPopulationWriters/results.vizancestors").CompareFiles(); FileComparison(results_dir + "cellmutationstates.dat", "cell_based/test/data/TestPottsBasedCellPopulationWriters/cellmutationstates.dat").CompareFiles(); FileComparison(results_dir + "cellages.dat", "cell_based/test/data/TestPottsBasedCellPopulationWriters/cellages.dat").CompareFiles(); FileComparison(results_dir + "cellareas.dat", "cell_based/test/data/TestPottsBasedCellPopulationWriters/cellareas.dat").CompareFiles(); // Test that the cell population parameters are output correctly out_stream parameter_file = output_file_handler.OpenOutputFile("results.parameters"); // Write cell population parameters to file cell_population.OutputCellPopulationParameters(parameter_file); parameter_file->close(); // Compare output with saved files of what they should look like FileComparison( results_dir + "results.parameters", "cell_based/test/data/TestPottsBasedCellPopulationWriters/results.parameters").CompareFiles(); }
void TestPottsSpheroidCellSorting() throw (Exception) { EXIT_IF_PARALLEL; // Potts simulations don't work in parallel because they depend on NodesOnlyMesh for writing. // Create a simple 3D PottsMesh unsigned domain_size = 10; unsigned element_number = 4; unsigned element_size = 2; PottsMeshGenerator<3> generator(domain_size, element_number, element_size, domain_size, element_number, element_size, domain_size, element_number, element_size); PottsMesh<3>* p_mesh = generator.GetMesh(); // Create cells std::vector<CellPtr> cells; MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type); CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 3> cells_generator; cells_generator.GenerateBasicRandom(cells, p_mesh->GetNumElements(), p_diff_type); // Randomly label some cells boost::shared_ptr<AbstractCellProperty> p_label(CellPropertyRegistry::Instance()->Get<CellLabel>()); RandomlyLabelCells(cells, p_label, 0.5); // Create cell population PottsBasedCellPopulation<3> cell_population(*p_mesh, cells); cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>(); // So outputs the labelled cells // Set up cell-based simulation OnLatticeSimulation<3> simulator(cell_population); simulator.SetOutputDirectory("TestPotts3DCellSorting"); simulator.SetDt(0.1); simulator.SetEndTime(1.0); // Create update rules and pass to the simulation MAKE_PTR(VolumeConstraintPottsUpdateRule<3>, p_volume_constraint_update_rule); p_volume_constraint_update_rule->SetMatureCellTargetVolume(element_size*element_size*element_size); p_volume_constraint_update_rule->SetDeformationEnergyParameter(0.2); simulator.AddPottsUpdateRule(p_volume_constraint_update_rule); MAKE_PTR(DifferentialAdhesionPottsUpdateRule<3>, p_differential_adhesion_update_rule); p_differential_adhesion_update_rule->SetLabelledCellLabelledCellAdhesionEnergyParameter(0.16); p_differential_adhesion_update_rule->SetLabelledCellCellAdhesionEnergyParameter(0.11); p_differential_adhesion_update_rule->SetCellCellAdhesionEnergyParameter(0.02); p_differential_adhesion_update_rule->SetLabelledCellBoundaryAdhesionEnergyParameter(0.16); p_differential_adhesion_update_rule->SetCellBoundaryAdhesionEnergyParameter(0.16); simulator.AddPottsUpdateRule(p_differential_adhesion_update_rule); // Run simulation simulator.Solve(); // Check that the same number of cells TS_ASSERT_EQUALS(simulator.rGetCellPopulation().GetNumRealCells(), 64u); // Test no births or deaths TS_ASSERT_EQUALS(simulator.GetNumBirths(), 0u); TS_ASSERT_EQUALS(simulator.GetNumDeaths(), 0u); #ifdef CHASTE_VTK // Test that VTK writer has produced some files OutputFileHandler handler("TestPotts3DCellSorting", false); std::string results_dir = handler.GetOutputDirectoryFullPath(); // Initial condition file FileFinder vtk_file(results_dir + "results_from_time_0/results_0.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file.Exists()); // Final file FileFinder vtk_file2(results_dir + "results_from_time_0/results_10.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file2.Exists()); // Check that the second VTK file for Potts specific data (element IDs) VtkMeshReader<3,3> vtk_reader(results_dir + "results_from_time_0/results_10.vtu"); std::vector<double> cell_types; vtk_reader.GetPointData("Cell types", cell_types); TS_ASSERT_EQUALS(cell_types.size(), 1000u); // The cell types are between -1 and 5. Check the maximum TS_ASSERT_DELTA(*max_element(cell_types.begin(), cell_types.end()), 5.0, 1e-12); std::vector<double> cell_ids; vtk_reader.GetPointData("Cell IDs", cell_ids); // Prior to release 3.2 this was called "Element index". // It is changed to cell_id as this is preferable for VTK output. TS_ASSERT_EQUALS(cell_ids.size(), 1000u); TS_ASSERT_DELTA(*max_element(cell_ids.begin(), cell_ids.end()), 63.0, 1e-12); #endif //CHASTE_VTK }
void TestPottsMonolayerCellSortingPeriodic() throw (Exception) { EXIT_IF_PARALLEL; // Potts simulations don't work in parallel because they depend on NodesOnlyMesh for writing. // Create a simple 2D PottsMesh PottsMeshGenerator<2> generator(20, 5, 4, 20, 5, 4, 1, 1, 1, false, true, true); // Periodic in x and y PottsMesh<2>* p_mesh = generator.GetMesh(); // Create cells std::vector<CellPtr> cells; MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type); CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator; cells_generator.GenerateBasicRandom(cells, p_mesh->GetNumElements(), p_diff_type); // Randomly label some cells boost::shared_ptr<AbstractCellProperty> p_label(CellPropertyRegistry::Instance()->Get<CellLabel>()); RandomlyLabelCells(cells, p_label, 0.5); // Create cell population PottsBasedCellPopulation<2> cell_population(*p_mesh, cells); cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>(); // So outputs the labelled cells // Set up cell-based simulation OnLatticeSimulation<2> simulator(cell_population); simulator.SetOutputDirectory("TestPottsCellSortingPeriodic"); simulator.SetDt(0.1); simulator.SetEndTime(1.0); // Create update rules and pass to the simulation MAKE_PTR(VolumeConstraintPottsUpdateRule<2>, p_volume_constraint_update_rule); p_volume_constraint_update_rule->SetMatureCellTargetVolume(16); p_volume_constraint_update_rule->SetDeformationEnergyParameter(0.2); simulator.AddPottsUpdateRule(p_volume_constraint_update_rule); MAKE_PTR(DifferentialAdhesionPottsUpdateRule<2>, p_differential_adhesion_update_rule); p_differential_adhesion_update_rule->SetLabelledCellLabelledCellAdhesionEnergyParameter(0.16); p_differential_adhesion_update_rule->SetLabelledCellCellAdhesionEnergyParameter(0.11); p_differential_adhesion_update_rule->SetCellCellAdhesionEnergyParameter(0.02); p_differential_adhesion_update_rule->SetLabelledCellBoundaryAdhesionEnergyParameter(0.16); p_differential_adhesion_update_rule->SetCellBoundaryAdhesionEnergyParameter(0.16); simulator.AddPottsUpdateRule(p_differential_adhesion_update_rule); // Run simulation simulator.Solve(); // Check that the same number of cells TS_ASSERT_EQUALS(simulator.rGetCellPopulation().GetNumRealCells(), 25u); // Test no births or deaths TS_ASSERT_EQUALS(simulator.GetNumBirths(), 0u); TS_ASSERT_EQUALS(simulator.GetNumDeaths(), 0u); #ifdef CHASTE_VTK //Test that VTK writer has produced some files OutputFileHandler handler("TestPottsCellSortingPeriodic", false); std::string results_dir = handler.GetOutputDirectoryFullPath(); // Initial condition file FileFinder vtk_file_1(results_dir + "results_from_time_0/results_0.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file_1.Exists()); FileFinder vtk_file_2(results_dir + "results_from_time_0/outlines_0.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file_2.Exists()); // Final file FileFinder vtk_file_3(results_dir + "results_from_time_0/results_10.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file_3.Exists()); FileFinder vtk_file_4(results_dir + "results_from_time_0/outlines_10.vtu", RelativeTo::Absolute); TS_ASSERT(vtk_file_4.Exists()); #endif //CHASTE_VTK }