void TestMirams2010WntOdeSystemSetup()
{
#ifdef CHASTE_CVODE
double wnt_level = 0.5;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
Mirams2010WntOdeSystem wnt_system(wnt_level, p_state);
// Solve system using CVODE solver
// Matlab's strictest bit uses 0.01 below and relaxes it on flatter bits.
double h_value = 0.1;
CvodeAdaptor cvode_solver;
OdeSolution solutions;
//OdeSolution solutions2;
std::vector<double> initial_conditions = wnt_system.GetInitialConditions();
std::cout << "Timings for 100 hours\n";
Timer::Reset();
solutions = cvode_solver.Solve(&wnt_system, initial_conditions, 0.0, 100.0, h_value, h_value);
Timer::Print("1. Cvode");
// Test solutions are OK for a small time increase...
int end = solutions.rGetSolutions().size() - 1;
// Tests the simulation is ending at the right time...(going into S phase at 7.8 hours)
TS_ASSERT_DELTA(solutions.rGetTimes()[end], 100, 1e-2);
// Decent results
TS_ASSERT_DELTA(solutions.rGetSolutions()[end][0], 67.5011, 1e-4);
TS_ASSERT_DELTA(solutions.rGetSolutions()[end][1], 67.5011, 1e-4);
TS_ASSERT_DELTA(solutions.rGetSolutions()[end][2], wnt_level, 1e-4);
#else
std::cout << "CVODE is not enabled. " << std::endl;
std::cout << "If required please install and alter your hostconfig settings to switch on chaste support." << std::endl;
#endif //CHASTE_CVODE
}
void CellsGenerator<CELL_CYCLE_MODEL,DIM>::GenerateGivenLocationIndices(std::vector<CellPtr>& rCells,
const std::vector<unsigned> locationIndices,
boost::shared_ptr<AbstractCellProperty> pCellProliferativeType)
{
assert(!locationIndices.empty());
unsigned num_cells = locationIndices.size();
rCells.clear();
rCells.reserve(num_cells);
CellPropertyRegistry::Instance()->Clear();
for (unsigned i=0; i<num_cells; i++)
{
CELL_CYCLE_MODEL* p_cell_cycle_model = new CELL_CYCLE_MODEL;
p_cell_cycle_model->SetDimension(DIM);
boost::shared_ptr<AbstractCellProperty> p_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
CellPtr p_cell(new Cell(p_state, p_cell_cycle_model));
if (!pCellProliferativeType)
{
p_cell->SetCellProliferativeType(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
}
else
{
p_cell->SetCellProliferativeType(pCellProliferativeType);
}
double birth_time = 0.0 - locationIndices[i];
p_cell->SetBirthTime(birth_time);
rCells.push_back(p_cell);
}
}
void TestArchiving()
{
EXIT_IF_PARALLEL;
#ifdef CHASTE_CVODE
OutputFileHandler handler("archive", false);
std::string archive_filename = handler.GetOutputDirectoryFullPath() + "mirams_ode.arch";
{
double wnt_level = 0.5;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
Mirams2010WntOdeSystem ode_system(wnt_level, p_state);
TS_ASSERT_DELTA(ode_system.GetWntLevel(), 0.50, 1e-6);
TS_ASSERT_EQUALS(ode_system.GetMutationState()->IsType<WildTypeCellMutationState>(), true);
std::vector<double> initial_conditions = ode_system.GetInitialConditions();
TS_ASSERT_EQUALS(initial_conditions.size(), 3u);
TS_ASSERT_DELTA(initial_conditions[0], 64.1863, 1e-4);
TS_ASSERT_DELTA(initial_conditions[1], 64.1863, 1e-4);
TS_ASSERT_DELTA(initial_conditions[2], 0.5, 1e-6);
// Create an output archive
std::ofstream ofs(archive_filename.c_str());
boost::archive::text_oarchive output_arch(ofs);
// Archive ODE system
AbstractOdeSystem* const p_const_ode_system = &ode_system;
output_arch << p_const_ode_system;
}
{
AbstractOdeSystem* p_ode_system;
// Create an input archive
std::ifstream ifs(archive_filename.c_str(), std::ios::binary);
boost::archive::text_iarchive input_arch(ifs);
// Restore from the archive
input_arch >> p_ode_system;
// Check that archiving worked correctly
TS_ASSERT_DELTA(static_cast<Mirams2010WntOdeSystem*>(p_ode_system)->GetWntLevel(), 0.50, 1e-6);
TS_ASSERT_EQUALS(static_cast<Mirams2010WntOdeSystem*>(p_ode_system)->GetMutationState()->IsType<WildTypeCellMutationState>(), true);
std::vector<double> initial_conditions = p_ode_system->GetInitialConditions();
TS_ASSERT_EQUALS(initial_conditions.size(), 3u);
TS_ASSERT_DELTA(initial_conditions[0], 64.1863, 1e-4);
TS_ASSERT_DELTA(initial_conditions[1], 64.1863, 1e-4);
TS_ASSERT_DELTA(initial_conditions[2], 0.5, 1e-6);
// Tidy up
delete p_ode_system;
}
#else
std::cout << "CVODE is not enabled. " << std::endl;
std::cout << "If required please install and alter your hostconfig settings to switch on chaste support." << std::endl;
#endif //CHASTE_CVODE
}
void TestVertexCryptBoundaryForceMethods() throw (Exception)
{
// Create a simple 2D VertexMesh
HoneycombVertexMeshGenerator generator(5, 5, false, 0.1, 0.5);
MutableVertexMesh<2,2>* p_mesh = generator.GetMesh();
// Translate mesh so that some points are below y=0
p_mesh->Translate(0.0, -3.0);
// Set up cells, one for each VertexElement. Give each cell
// a birth time of -elem_index, so its age is elem_index
std::vector<CellPtr> cells;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
boost::shared_ptr<AbstractCellProliferativeType> p_diff_type(new DifferentiatedCellProliferativeType);
for (unsigned elem_index=0; elem_index<p_mesh->GetNumElements(); elem_index++)
{
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_cell(new Cell(p_state, p_model));
p_cell->SetCellProliferativeType(p_diff_type);
double birth_time = 0.0 - elem_index;
p_cell->SetBirthTime(birth_time);
cells.push_back(p_cell);
}
// Create cell population
VertexBasedCellPopulation<2> cell_population(*p_mesh, cells);
// Create a force system
VertexCryptBoundaryForce<2> force(100);
for (unsigned i=0; i<cell_population.GetNumNodes(); i++)
{
cell_population.GetNode(i)->ClearAppliedForce();
}
force.AddForceContribution(cell_population);
// Check forces are correct
for (unsigned i=0; i<cell_population.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(cell_population.GetNode(i)->rGetAppliedForce()[0], 0.0, 1e-4);
double y = cell_population.GetNode(i)->rGetLocation()[1];
if (y >= 0.0)
{
// If y > 0, the force contribution should be zero...
TS_ASSERT_DELTA(cell_population.GetNode(i)->rGetAppliedForce()[1], 0.0, 1e-4);
}
else
{
// ...otherwise, the force contribution should be quadratic in y
double expected_force = force.GetForceStrength()*y*y;
TS_ASSERT_DELTA(cell_population.GetNode(i)->rGetAppliedForce()[1], expected_force, 1e-4);
}
}
}
void CellsGenerator<CELL_CYCLE_MODEL,DIM>::GenerateBasic(std::vector<CellPtr>& rCells,
unsigned numCells,
const std::vector<unsigned> locationIndices,
boost::shared_ptr<AbstractCellProperty> pCellProliferativeType)
{
rCells.clear();
if (!locationIndices.empty())
{
// If location indices is given, then it needs to match the number of output cells
if (numCells != locationIndices.size())
{
EXCEPTION("The size of the locationIndices vector must match the required number of output cells");
}
}
rCells.reserve(numCells);
// Create cells
for (unsigned i=0; i<numCells; i++)
{
CELL_CYCLE_MODEL* p_cell_cycle_model = new CELL_CYCLE_MODEL;
p_cell_cycle_model->SetDimension(DIM);
boost::shared_ptr<AbstractCellProperty> p_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
CellPtr p_cell(new Cell(p_state, p_cell_cycle_model));
if (!pCellProliferativeType)
{
p_cell->SetCellProliferativeType(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
}
else
{
p_cell->SetCellProliferativeType(pCellProliferativeType);
}
double birth_time;
if (!locationIndices.empty())
{
birth_time = 0.0 - locationIndices[i];
}
else
{
birth_time = 0.0 - i;
}
p_cell->SetBirthTime(birth_time);
rCells.push_back(p_cell);
}
}
void CellsGenerator<CELL_CYCLE_MODEL,DIM>::GenerateBasicRandom(std::vector<CellPtr>& rCells,
unsigned numCells,
boost::shared_ptr<AbstractCellProperty> pCellProliferativeType)
{
rCells.clear();
rCells.reserve(numCells);
// Create cells
for (unsigned i=0; i<numCells; i++)
{
CELL_CYCLE_MODEL* p_cell_cycle_model = new CELL_CYCLE_MODEL;
p_cell_cycle_model->SetDimension(DIM);
boost::shared_ptr<AbstractCellProperty> p_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
CellPtr p_cell(new Cell(p_state, p_cell_cycle_model));
if (!pCellProliferativeType)
{
p_cell->SetCellProliferativeType(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
}
else
{
p_cell->SetCellProliferativeType(pCellProliferativeType);
}
double birth_time = -p_cell_cycle_model->GetAverageStemCellCycleTime()*RandomNumberGenerator::Instance()->ranf();
if (p_cell->GetCellProliferativeType()->IsType<TransitCellProliferativeType>())
{
birth_time = -p_cell_cycle_model->GetAverageTransitCellCycleTime()*RandomNumberGenerator::Instance()->ranf();
}
p_cell->SetBirthTime(birth_time);
rCells.push_back(p_cell);
}
}
template <class PathType> inline
void LongstaffSchwartzPathPricer<PathType>::calibrate() {
const Size n = paths_.size();
Array prices(n), exercise(n);
std::vector<StateType> p_state(n);
std::vector<Real> p_price(n), p_exercise(n);
for (Size i=0; i<n; ++i) {
p_state[i] = pathPricer_->state(paths_[i],len_-1);
prices[i] = p_price[i] = (*pathPricer_)(paths_[i], len_-1);
p_exercise[i] = prices[i];
}
post_processing(len_ - 1, p_state, p_price, p_exercise);
std::vector<Real> y;
std::vector<StateType> x;
for (Size i=len_-2; i>0; --i) {
y.clear();
x.clear();
//roll back step
for (Size j=0; j<n; ++j) {
exercise[j]=(*pathPricer_)(paths_[j], i);
if (exercise[j]>0.0) {
x.push_back(pathPricer_->state(paths_[j], i));
y.push_back(dF_[i]*prices[j]);
}
}
if (v_.size() <= x.size()) {
coeff_[i-1] = GeneralLinearLeastSquares(x, y, v_).coefficients();
}
else {
// if number of itm paths is smaller then the number of
// calibration functions then early exercise if exerciseValue > 0
coeff_[i-1] = Array(v_.size(), 0.0);
}
for (Size j=0, k=0; j<n; ++j) {
prices[j]*=dF_[i];
if (exercise[j]>0.0) {
Real continuationValue = 0.0;
for (Size l=0; l<v_.size(); ++l) {
continuationValue += coeff_[i-1][l] * v_[l](x[k]);
}
if (continuationValue < exercise[j]) {
prices[j] = exercise[j];
}
++k;
}
p_state[j] = pathPricer_->state(paths_[j],i);
p_price[j] = prices[j];
p_exercise[j] = exercise[j];
}
post_processing(i, p_state, p_price, p_exercise);
}
// remove calibration paths and release memory
std::vector<PathType> empty;
paths_.swap(empty);
// entering the calculation phase
calibrationPhase_ = false;
}
void TestMeshBasedCryptWithMutations() throw(Exception)
{
EXIT_IF_PARALLEL;
double time_of_each_run = 10.0;
double end_simulations = 600.0;
CylindricalHoneycombMeshGenerator generator(10, 10, 2);
Cylindrical2dMesh* p_mesh = generator.GetCylindricalMesh();
std::vector<unsigned> location_indices = generator.GetCellLocationIndices();
std::vector<CellPtr> cells;
CryptCellsGenerator<StochasticWntCellCycleModel> cells_generator;
cells_generator.Generate(cells, p_mesh, location_indices, true);
boost::shared_ptr<AbstractCellProperty> p_state(CellPropertyRegistry::Instance()->Get<ApcTwoHitCellMutationState>());
MeshBasedCellPopulationWithGhostNodes<2> cell_population(*p_mesh, cells, location_indices);
cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>();
cell_population.SetCellAncestorsToLocationIndices();
double crypt_height = 8.0;
WntConcentration<2>::Instance()->SetType(LINEAR);
WntConcentration<2>::Instance()->SetCellPopulation(cell_population);
WntConcentration<2>::Instance()->SetCryptLength(crypt_height);
CryptSimulation2d simulator(cell_population);
simulator.SetOutputDirectory("MeshBasedCryptWithMutations");
simulator.SetSamplingTimestepMultiple(100);
simulator.SetEndTime(10);
//modify at end of timestep
MAKE_PTR(SimulationEndTimeModifier<2>, p_modifier);
simulator.AddSimulationModifier(p_modifier);
cell_population.AddCellWriter<CellAncestorWriter>();
MAKE_PTR(GeneralisedLinearSpringForce<2>, p_linear_force);
simulator.AddForce(p_linear_force);
MAKE_PTR_ARGS(SloughingCellKiller<2>, p_killer, (&cell_population, crypt_height));
simulator.AddCellKiller(p_killer);
simulator.Solve();
for (AbstractCellPopulation<2>::Iterator cell_iter = cell_population.Begin();
cell_iter != cell_population.End();
++cell_iter)
{
unsigned node_index = cell_population.GetLocationIndexUsingCell(*cell_iter);
if (node_index == 132) // Chosen from looking at the results from steady state
{
cell_iter->SetMutationState(p_state);
}
}
double normal_damping_constant = cell_population.GetDampingConstantNormal();
cell_population.SetDampingConstantMutant(10*normal_damping_constant);
CellBasedSimulationArchiver<2, CryptSimulation2d>::Save(&simulator);
simulator.SetEndTime(20);
for (double t = time_of_each_run; t<end_simulations+0.5; t += time_of_each_run)
{
CryptSimulation2d* p_simulator = CellBasedSimulationArchiver<2, CryptSimulation2d>::Load("MeshBasedCryptWithMutations",t);
p_simulator->SetEndTime(t+time_of_each_run);
p_simulator->Solve();
CellBasedSimulationArchiver<2, CryptSimulation2d>::Save(p_simulator);
delete p_simulator;
}
CellBasedEventHandler::Headings();
CellBasedEventHandler::Report();
WntConcentration<2>::Destroy();
}
void TestCryptProjectionForceMethods() throw (Exception)
{
EXIT_IF_PARALLEL; // HoneycombMeshGenerator doesnt work in parallel.
// Create a mesh
unsigned num_cells_width = 10;
unsigned num_cells_depth = 10;
unsigned thickness_of_ghost_layer = 0;
SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0,1);
HoneycombMeshGenerator generator(num_cells_width, num_cells_depth, thickness_of_ghost_layer);
MutableMesh<2,2>* p_mesh = generator.GetMesh();
// Centre the mesh at (0,0)
ChasteCuboid<2> bounding_box=p_mesh->CalculateBoundingBox();
double width_of_mesh = (num_cells_width/(num_cells_width+2.0*thickness_of_ghost_layer))*(bounding_box.GetWidth(0));
double height_of_mesh = (num_cells_depth/(num_cells_depth+2.0*thickness_of_ghost_layer))*(bounding_box.GetWidth(1));
p_mesh->Translate(-width_of_mesh/2, -height_of_mesh/2);
// Create some cells
std::vector<CellPtr> cells;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
boost::shared_ptr<AbstractCellProperty> p_stem_type(new StemCellProliferativeType);
for (unsigned i=0; i<p_mesh->GetNumNodes(); i++)
{
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_cell(new Cell(p_state, p_model));
if (i==4 || i==5)
{
p_cell->SetBirthTime(-0.5);
}
else
{
p_cell->SetBirthTime(-10.0);
}
p_cell->SetCellProliferativeType(p_stem_type);
cells.push_back(p_cell);
}
// Create a cell population
MeshBasedCellPopulation<2> cell_population(*p_mesh, cells);
std::pair<CellPtr,CellPtr> cell_pair_4_5 = cell_population.CreateCellPair(cell_population.GetCellUsingLocationIndex(4), cell_population.GetCellUsingLocationIndex(5));
cell_population.MarkSpring(cell_pair_4_5);
// Create a spring system with crypt surface z = 2*r
WntConcentration<2>::Instance()->SetCryptProjectionParameterA(2.0);
WntConcentration<2>::Instance()->SetCryptProjectionParameterB(1.0);
CryptProjectionForce crypt_projection_force;
// Test get methods
TS_ASSERT_DELTA(crypt_projection_force.GetA(), 2.0, 1e-12);
TS_ASSERT_DELTA(crypt_projection_force.GetB(), 1.0, 1e-12);
// Test crypt height and gradient calculations
c_vector<double, 2> node_location_2d = p_mesh->GetNode(0)->rGetLocation();
TS_ASSERT_DELTA(crypt_projection_force.CalculateCryptSurfaceHeightAtPoint(node_location_2d), 2.0*pow(norm_2(node_location_2d),1.0), 1e-12);
TS_ASSERT_DELTA(crypt_projection_force.CalculateCryptSurfaceDerivativeAtPoint(node_location_2d), 2.0, 1e-12);
// Test updating of mNode3dLocationMap
crypt_projection_force.UpdateNode3dLocationMap(cell_population);
// Move a node slightly
ChastePoint<2> new_point;
new_point.rGetLocation()[0] = node_location_2d[0]+0.05;
new_point.rGetLocation()[1] = node_location_2d[1];
p_mesh->SetNode(0, new_point, false);
// Test UpdateNode3dLocationMap()
c_vector<double, 2> new_node_location_2d;
new_node_location_2d[0] = new_point.rGetLocation()[0];
new_node_location_2d[1] = new_point.rGetLocation()[1];
crypt_projection_force.UpdateNode3dLocationMap(cell_population);
// Check the map updates correctly (note that we have used no ghost nodes, so the map does contain 0)
c_vector<double, 3> calculated_new_node_location_3d = crypt_projection_force.mNode3dLocationMap[0];
c_vector<double, 3> correct_new_node_location_3d;
correct_new_node_location_3d[0] = new_node_location_2d[0];
correct_new_node_location_3d[1] = new_node_location_2d[1];
correct_new_node_location_3d[2] = crypt_projection_force.CalculateCryptSurfaceHeightAtPoint(new_node_location_2d);
TS_ASSERT_DELTA(calculated_new_node_location_3d[0], correct_new_node_location_3d[0], 1e-12);
TS_ASSERT_DELTA(calculated_new_node_location_3d[1], correct_new_node_location_3d[1], 1e-12);
TS_ASSERT_DELTA(calculated_new_node_location_3d[2], correct_new_node_location_3d[2], 1e-12);
// Test force calculation on a normal spring
c_vector<double,2> force_on_spring; // between nodes 0 and 1
// Find one of the elements that nodes 0 and 1 live on
ChastePoint<2> new_point2;
new_point2.rGetLocation()[0] = new_point[0] + 0.01;
new_point2.rGetLocation()[1] = new_point[1] + 0.01;
unsigned elem_index = p_mesh->GetContainingElementIndex(new_point2, false);
Element<2,2>* p_element = p_mesh->GetElement(elem_index);
force_on_spring = crypt_projection_force.CalculateForceBetweenNodes(p_element->GetNodeGlobalIndex(1),
p_element->GetNodeGlobalIndex(0),
cell_population);
TS_ASSERT_DELTA(force_on_spring[0], -5.7594, 1e-4);
TS_ASSERT_DELTA(force_on_spring[1], 0.0230, 1e-4);
// Test force calculation with a cutoff
double dist = norm_2(p_mesh->GetVectorFromAtoB(p_element->GetNode(0)->rGetLocation(),
p_element->GetNode(1)->rGetLocation()));
crypt_projection_force.SetCutOffLength(dist - 0.1);
force_on_spring = crypt_projection_force.CalculateForceBetweenNodes(p_element->GetNodeGlobalIndex(1),
p_element->GetNodeGlobalIndex(0),
cell_population);
TS_ASSERT_DELTA(force_on_spring[0], 0.0, 1e-4);
TS_ASSERT_DELTA(force_on_spring[1], 0.0, 1e-4);
// Test force calculation for a pair of newly born neighbouring cells
force_on_spring = crypt_projection_force.CalculateForceBetweenNodes(4, 5, cell_population);
TS_ASSERT_DELTA(force_on_spring[0], 0.0, 1e-4);
TS_ASSERT_DELTA(force_on_spring[1], 0.0, 1e-4);
cell_population.UnmarkSpring(cell_pair_4_5);
// For coverage, test force calculation for a pair of neighbouring apoptotic cells
cell_population.GetCellUsingLocationIndex(6)->StartApoptosis();
cell_population.GetCellUsingLocationIndex(7)->StartApoptosis();
force_on_spring = crypt_projection_force.CalculateForceBetweenNodes(6, 7, cell_population);
TS_ASSERT_DELTA(force_on_spring[0], 0.0, 1e-4);
TS_ASSERT_DELTA(force_on_spring[1], 0.0, 1e-4);
// Test force calculation for a particular node
for (unsigned i=0; i<cell_population.GetNumNodes(); i++)
{
cell_population.GetNode(i)->ClearAppliedForce();
}
crypt_projection_force.AddForceContribution(cell_population);
TS_ASSERT_DELTA(cell_population.GetNode(0)->rGetAppliedForce()[0], 0.0, 1e-4);
TS_ASSERT_DELTA(cell_population.GetNode(0)->rGetAppliedForce()[1], 0.0, 1e-4);
// Test that in the case of a flat crypt surface (mA=mB=0), the results are the same as for Meineke2001SpringSystem
WntConcentration<2>::Instance()->SetCryptProjectionParameterA(0.001);
WntConcentration<2>::Instance()->SetCryptProjectionParameterB(0.001);
CryptProjectionForce flat_crypt_projection_force;
GeneralisedLinearSpringForce<2> linear_force;
// Normally this would be set up at the start of rCalculateforcesOfEachNode
flat_crypt_projection_force.UpdateNode3dLocationMap(cell_population);
for (MeshBasedCellPopulation<2>::SpringIterator spring_iterator = cell_population.SpringsBegin();
spring_iterator != cell_population.SpringsEnd();
++spring_iterator)
{
unsigned nodeA_global_index = spring_iterator.GetNodeA()->GetIndex();
unsigned nodeB_global_index = spring_iterator.GetNodeB()->GetIndex();
c_vector<double, 2> force_flat = flat_crypt_projection_force.CalculateForceBetweenNodes(nodeA_global_index, nodeB_global_index, cell_population);
c_vector<double, 2> force_meineke = linear_force.CalculateForceBetweenNodes(nodeA_global_index, nodeB_global_index, cell_population);
TS_ASSERT_DELTA(force_flat[0], force_meineke[0], 1e-3);
TS_ASSERT_DELTA(force_flat[1], force_meineke[1], 1e-3);
}
WntConcentration<2>::Destroy();
}
void TestCryptProjectionForceWithArchiving() throw (Exception)
{
EXIT_IF_PARALLEL; // Cell-based archiving doesn't work in parallel.
OutputFileHandler handler("archive", false); // don't erase contents of folder
std::string archive_filename = handler.GetOutputDirectoryFullPath() + "crypt_projection_spring_system.arch";
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
MutableMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0,1);
std::vector<CellPtr> cells;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
boost::shared_ptr<AbstractCellProperty> p_stem_type(new StemCellProliferativeType);
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_cell(new Cell(p_state, p_model));
p_cell->SetCellProliferativeType(p_stem_type);
p_cell->SetBirthTime(-50.0);
cells.push_back(p_cell);
}
MeshBasedCellPopulation<2> crypt(mesh, cells);
WntConcentration<2>::Instance()->SetCryptProjectionParameterA(1.0);
WntConcentration<2>::Instance()->SetCryptProjectionParameterB(2.0);
// Create force object
CryptProjectionForce crypt_projection_force;
TS_ASSERT_DELTA(crypt_projection_force.GetWntChemotaxisStrength(), 100.0, 1e-6);
crypt_projection_force.SetWntChemotaxisStrength(15.0);
std::ofstream ofs(archive_filename.c_str());
boost::archive::text_oarchive output_arch(ofs);
// Serialize via pointer
CryptProjectionForce* const p_crypt_projection_force = &crypt_projection_force;
p_crypt_projection_force->SetCutOffLength(1.1);
output_arch << p_crypt_projection_force;
WntConcentration<2>::Destroy();
}
{
ArchiveLocationInfo::SetMeshPathname("mesh/test/data/", "square_2_elements");
// Create an input archive
std::ifstream ifs(archive_filename.c_str(), std::ios::binary);
boost::archive::text_iarchive input_arch(ifs);
CryptProjectionForce* p_crypt_projection_force;
// Restore from the archive
input_arch >> p_crypt_projection_force;
// Test the member data
TS_ASSERT_EQUALS(p_crypt_projection_force->mUseCutOffLength, true);
TS_ASSERT_DELTA(p_crypt_projection_force->GetA(), 1.0, 1e-12);
TS_ASSERT_DELTA(p_crypt_projection_force->GetB(), 2.0, 1e-12);
TS_ASSERT_DELTA(p_crypt_projection_force->GetWntChemotaxisStrength(), 15.0, 1e-6);
delete p_crypt_projection_force;
}
}
/**
* \todo WntBasedChemotaxis should be possible in other force laws. If/when
* this is implemented, this test should be moved to somewhere more appropriate.
*/
void TestCryptProjectionForceWithWntBasedChemotaxis() throw (Exception)
{
EXIT_IF_PARALLEL; // HoneycombMeshGenerator doesnt work in parallel.
double crypt_length = 22.0;
// Create a mesh
unsigned num_cells_width = 10;
unsigned num_cells_depth = 10;
unsigned thickness_of_ghost_layer = 0;
SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0,1);
HoneycombMeshGenerator generator(num_cells_width, num_cells_depth, thickness_of_ghost_layer);
MutableMesh<2,2>* p_mesh = generator.GetMesh();
// Centre the mesh at (0,0)
ChasteCuboid<2> bounding_box=p_mesh->CalculateBoundingBox();
double width_of_mesh = (num_cells_width/(num_cells_width+2.0*thickness_of_ghost_layer))*(bounding_box.GetWidth(0));
double height_of_mesh = (num_cells_depth/(num_cells_depth+2.0*thickness_of_ghost_layer))*(bounding_box.GetWidth(1));
p_mesh->Translate(-width_of_mesh/2, -height_of_mesh/2);
// Create some cells
std::vector<CellPtr> cells;
boost::shared_ptr<AbstractCellMutationState> p_state(new WildTypeCellMutationState);
boost::shared_ptr<AbstractCellProperty> p_stem_type(new StemCellProliferativeType);
for (unsigned i=0; i<p_mesh->GetNumNodes(); i++)
{
FixedDurationGenerationBasedCellCycleModel* p_model = new FixedDurationGenerationBasedCellCycleModel();
CellPtr p_cell(new Cell(p_state, p_model));
p_cell->SetCellProliferativeType(p_stem_type);
p_cell->SetBirthTime(-10.0);
cells.push_back(p_cell);
}
// Create a cell population
MeshBasedCellPopulation<2> cell_population(*p_mesh, cells);
std::pair<CellPtr,CellPtr> cell_pair_4_5 = cell_population.CreateCellPair(cell_population.GetCellUsingLocationIndex(4), cell_population.GetCellUsingLocationIndex(5));
cell_population.MarkSpring(cell_pair_4_5);
WntConcentration<2>::Instance()->SetType(RADIAL);
WntConcentration<2>::Instance()->SetCellPopulation(cell_population);
WntConcentration<2>::Instance()->SetCryptLength(crypt_length);
// Create a spring system with crypt surface z = 2*r
WntConcentration<2>::Instance()->SetCryptProjectionParameterA(2.0);
WntConcentration<2>::Instance()->SetCryptProjectionParameterB(1.0);
CryptProjectionForce crypt_projection_force;
crypt_projection_force.SetWntChemotaxis(false);
for (unsigned i=0; i<cell_population.GetNumNodes(); i++)
{
cell_population.GetNode(i)->ClearAppliedForce();
}
// Calculate node forces
crypt_projection_force.AddForceContribution(cell_population);
// Store the force of a particular node without Wnt-chemotaxis
c_vector<double,2> old_force;
old_force[0] = cell_population.GetNode(11)->rGetAppliedForce()[0];
old_force[1] = cell_population.GetNode(11)->rGetAppliedForce()[1];
// Now turn on Wnt-chemotaxis
crypt_projection_force.SetWntChemotaxis(true);
for (unsigned i=0; i<cell_population.GetNumNodes(); i++)
{
cell_population.GetNode(i)->ClearAppliedForce();
}
// Calculate node forces
crypt_projection_force.AddForceContribution(cell_population);
// Store the force of the same node, but now with Wnt-chemotaxis
c_vector<double,2> new_force = cell_population.GetNode(11)->rGetAppliedForce();
double wnt_chemotaxis_strength = crypt_projection_force.GetWntChemotaxisStrength();
CellPtr p_cell = cell_population.GetCellUsingLocationIndex(11u);
c_vector<double,2> wnt_component = wnt_chemotaxis_strength*WntConcentration<2>::Instance()->GetWntGradient(p_cell);
TS_ASSERT_DELTA(new_force[0], old_force[0]+wnt_component[0], 1e-4);
TS_ASSERT_DELTA(new_force[1], old_force[1]+wnt_component[1], 1e-4);
WntConcentration<2>::Destroy();
}