void TestOtherExceptions() throw(Exception)
{
TS_ASSERT_THROWS_THIS(READER_2D mesh_reader("mesh/test/data/nonexistent_file"),
"Could not open data file: mesh/test/data/nonexistent_file.node");
TS_ASSERT_THROWS_THIS(READER_2D mesh_reader("mesh/test/data/baddata/vertex_mesh_without_element_file"),
"Could not open data file: mesh/test/data/baddata/vertex_mesh_without_element_file.cell");
}
/**
* Check that the elements are read correctly. Checks that the output vector
* for a given input file is the correct length and that if the input file
* is corrupted (missing elements) then an exception is thrown.
*/
void TestElementsDataRead() throw(Exception)
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/disk_984_elements_indexed_from_1");
TS_ASSERT_EQUALS( mesh_reader.GetNumElements(), 984u);
ElementData data1 = mesh_reader.GetNextElementData();
TS_ASSERT_EQUALS(data1.NodeIndices.size(), 3u);
TS_ASSERT_EQUALS(data1.NodeIndices[0], 309u);
TS_ASSERT_EQUALS(data1.NodeIndices[1], 144u);
TS_ASSERT_EQUALS(data1.NodeIndices[2], 310u);
TS_ASSERT_EQUALS( mesh_reader.GetNumElementAttributes(), 0u);
for (unsigned i=1; i<mesh_reader.GetNumElements(); i++)
{
ElementData data = mesh_reader.GetNextElementData();
TS_ASSERT_EQUALS(data.AttributeValue, 0u);
}
TrianglesMeshReader<2,2> mesh_reader2("mesh/test/data/baddata/bad_elements_disk_522_elements");
// Reads element 0 from file
TS_ASSERT_THROWS_NOTHING(mesh_reader2.GetNextElementData());
// Reads element 2 from file when expecting number 1
TS_ASSERT_THROWS_THIS(mesh_reader2.GetNextElementData(),"Data for item 1 missing");
}
/**
* Check that GetNextNode() returns the coordinates of the correct node and the correct node attributes.
* Compares the coordinates of the first two nodes with their known
* values, checks that no errors are thrown for the remaining nodes and
* that an error is thrown if we try to call the function too many times.
*/
void TestGetNextNode() throw(Exception)
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/disk_984_elements");
std::vector<double> first_node;
first_node = mesh_reader.GetNextNode();
TS_ASSERT_DELTA(first_node[0], 0.9980267283, 1e-6);
TS_ASSERT_DELTA(first_node[1], -0.0627905195, 1e-6);
// This mesh has zero attributes and one marker in the node file (as the header specifies).
// we have to ensure that in such situation the last number in each node line is not mistakenly
// read and interpreted as a node attribute (it is a node marker instead).
TS_ASSERT_EQUALS(mesh_reader.GetNodeAttributes().size(), 0u);
std::vector<double> next_node;
next_node = mesh_reader.GetNextNode();
TS_ASSERT_DELTA(next_node[0], 1.0, 1e-6);
TS_ASSERT_DELTA(next_node[1], 0.0, 1e-6);
for (int i=0; i<541; i++)
{
TS_ASSERT_THROWS_NOTHING(next_node = mesh_reader.GetNextNode());
}
TS_ASSERT_EQUALS(mesh_reader.GetNodeAttributes().size(), 0u);
TS_ASSERT_THROWS_THIS(next_node = mesh_reader.GetNextNode(),
"File contains incomplete data: unexpected end of file.");
}
void TestSetLogInfo() throw (Exception)
{
TrianglesMeshReader<3,3> mesh_reader("heart/test/data/box_shaped_heart/box_heart");
std::string epi_face_file = "heart/test/data/box_shaped_heart/epi.tri";
std::string rv_face_file = "heart/test/data/box_shaped_heart/rv.tri";
std::string lv_face_file = "heart/test/data/box_shaped_heart/lv.tri";
DistributedTetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
StreeterFibreGenerator<3> fibre_generator(mesh);
fibre_generator.SetSurfaceFiles(epi_face_file, rv_face_file, lv_face_file, false);
fibre_generator.SetApexToBase(0);
OutputFileHandler handler("shorter_streeter_loginfo");
fibre_generator.WriteData(handler, "box_heart.ortho");
FileFinder node_regions_file = handler.FindFile("node_regions.data");
FileFinder wall_thickness_file = handler.FindFile("wall_thickness.data");
FileFinder averaged_thickness_file = handler.FindFile("averaged_thickness.data");
TS_ASSERT_EQUALS(node_regions_file.IsFile(), false);
TS_ASSERT_EQUALS(wall_thickness_file.IsFile(), false);
TS_ASSERT_EQUALS(averaged_thickness_file.IsFile(), false);
fibre_generator.SetLogInfo(true);
fibre_generator.WriteData(handler, "box_heart.ortho");
TS_ASSERT_EQUALS(node_regions_file.IsFile(), true);
TS_ASSERT_EQUALS(wall_thickness_file.IsFile(), true);
TS_ASSERT_EQUALS(averaged_thickness_file.IsFile(), true);
}
void TestCellwiseDataGradientVerySmallMesh() throw(Exception)
{
// Create a simple mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
MutableMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Create a cell population
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, mesh.GetNumNodes());
MeshBasedCellPopulation<2> cell_population(mesh, cells);
// Set up data: C(x,y) = x^2
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
double x = mesh.GetNode(i)->rGetLocation()[0];
CellPtr p_cell = cell_population.GetCellUsingLocationIndex(mesh.GetNode(i)->GetIndex());
p_cell->GetCellData()->SetItem("x^2", x*x);
}
CellwiseDataGradient<2> gradient;
gradient.SetupGradients(cell_population, "x^2");
// With the algorithm being used, the numerical gradient is (1,0)
// for each of the nodes
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 1.0, 1e-9);
TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), 0.0, 1e-9);
}
}
void TestGenerateBasicRandomWithFixedDurationGenerationBasedCellCycleModel() throw(Exception)
{
// Create mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Create cells
MAKE_PTR(TransitCellProliferativeType, p_transit_type);
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasicRandom(cells, mesh.GetNumNodes(), p_transit_type);
// Test that cells were generated correctly
TS_ASSERT_EQUALS(cells.size(), mesh.GetNumNodes());
for (unsigned i=0; i<cells.size(); i++)
{
// Should lie between -24 and 0
TS_ASSERT_LESS_THAN_EQUALS(cells[i]->GetBirthTime(), 0.0);
TS_ASSERT_LESS_THAN_EQUALS(-24.0, cells[i]->GetBirthTime());
TS_ASSERT_EQUALS(cells[i]->GetCellCycleModel()->GetDimension(), 2u);
TS_ASSERT_EQUALS(cells[i]->GetCellProliferativeType(), p_transit_type);
}
// Test exact random numbers as test re-seeds random number generator.
TS_ASSERT_DELTA(cells[0]->GetBirthTime(), -7.1141, 1e-4);
TS_ASSERT_DELTA(cells[1]->GetBirthTime(), -10.1311, 1e-4);
TS_ASSERT_DELTA(cells[2]->GetBirthTime(), -10.2953, 1e-4);
}
void TestReadingElementAttributes() throw(Exception)
{
VertexMeshReader<2,2> mesh_reader("mesh/test/data/TestVertexMeshReader2d/vertex_mesh_with_element_attributes");
TS_ASSERT_EQUALS(mesh_reader.GetNumElements(), 2u);
TS_ASSERT_EQUALS(mesh_reader.GetNumElementAttributes(), 1u);
ElementData next_element_info = mesh_reader.GetNextElementData();
std::vector<unsigned> nodes = next_element_info.NodeIndices;
TS_ASSERT_EQUALS(nodes.size(), 5u);
TS_ASSERT_EQUALS(next_element_info.AttributeValue, 97u);
next_element_info = mesh_reader.GetNextElementData();
nodes = next_element_info.NodeIndices;
TS_ASSERT_EQUALS(nodes.size(), 3u);
TS_ASSERT_EQUALS(next_element_info.AttributeValue, 152u);
/*
* Coverage
*
* \todo The methods GetNextFaceData() and GetNumFaces() are not
* fully implemented for VertexMeshReader, but must be overridden
* as they are pure virtual in the base class. When they are
* implemented, these lines need to be replaced by proper tests.
*
* See also #1001.
*/
ElementData face_data = mesh_reader.GetNextFaceData();
TS_ASSERT_EQUALS(face_data.NodeIndices.empty(), true);
TS_ASSERT_EQUALS(face_data.AttributeValue, 0u);
TS_ASSERT_EQUALS(mesh_reader.GetNumFaces(), 0u);
TS_ASSERT_EQUALS(mesh_reader.GetNumEdges(), 0u);
}
void TestTranslationMethod() throw (Exception)
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Pick a random node and store spatial position
Node<3>* p_node = mesh.GetNode(10);
ChastePoint<3> original_coordinate = p_node->GetPoint();
double mesh_volume = mesh.GetVolume();
const double x_movement = 1.0;
const double y_movement = 2.5;
const double z_movement = -3.75;
mesh.Translate(x_movement, y_movement, z_movement);
ChastePoint<3> new_coordinate = p_node->GetPoint();
double new_mesh_volume = mesh.GetVolume();
TS_ASSERT_DELTA(mesh_volume, new_mesh_volume, 1e-6);
TS_ASSERT_DELTA(original_coordinate[0], new_coordinate[0]-x_movement, 1e-6);
TS_ASSERT_DELTA(original_coordinate[1], new_coordinate[1]-y_movement, 1e-6);
TS_ASSERT_DELTA(original_coordinate[2], new_coordinate[2]-z_movement, 1e-6);
}
void TestSimpleOrthotropic() throw (Exception)
{
TrianglesMeshReader<3,3> mesh_reader("heart/test/data/box_shaped_heart/box_heart");
std::string epi_face_file = "heart/test/data/box_shaped_heart/epi.tri";
std::string rv_face_file = "heart/test/data/box_shaped_heart/rv.tri";
std::string lv_face_file = "heart/test/data/box_shaped_heart/lv.tri";
DistributedTetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
StreeterFibreGenerator<3> fibre_generator(mesh);
fibre_generator.SetSurfaceFiles(epi_face_file, rv_face_file, lv_face_file, false);
fibre_generator.SetApexToBase(0);
OutputFileHandler handler("shorter_streeter", false);
fibre_generator.WriteData(handler, "box_heart.ortho");
FileFinder fibre_file_ascii = handler.FindFile("box_heart.ortho");
FileFinder fibre_file_reference("heart/test/data/box_shaped_heart/box_heart.ortho", RelativeTo::ChasteSourceRoot);
CompareGeneratedWithReferenceFile(fibre_file_ascii, ORTHO, fibre_file_reference, ORTHO);
fibre_generator.SetWriteFileAsBinary();
fibre_generator.WriteData(handler, "box_heart_binary.ortho");
FileFinder fibre_file_binary = handler.FindFile("box_heart_binary.ortho");
CompareGeneratedWithReferenceFile(fibre_file_binary, ORTHO, fibre_file_reference, ORTHO);
}
void TestTranslation3DWithUblas()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
double volume = mesh.GetVolume();
double surface_area = mesh.GetSurfaceArea();
Node<3>* p_node1 = mesh.GetNode(36);
ChastePoint<3> point1 = p_node1->GetPoint();
Node<3>* p_node2 = mesh.GetNode(23);
ChastePoint<3> point2 = p_node2->GetPoint();
c_vector<double, 3> old_location1 = point1.rGetLocation();
c_vector<double, 3> old_location2 = point2.rGetLocation();
// Set translation Vector
c_vector<double, 3> trans_vec;
trans_vec(0) = 2.0;
trans_vec(1) = 2.0;
trans_vec(2) = 2.0;
// Translate
mesh.Translate(trans_vec);
c_vector<double, 3> new_location1 = point1.rGetLocation();
c_vector<double, 3> new_location2 = point2.rGetLocation();
// Check Volume and Surface Area are invariant
TS_ASSERT_DELTA(mesh.GetVolume(), volume, 1e-6);
TS_ASSERT_DELTA(mesh.GetSurfaceArea(), surface_area, 1e-6);
// Spot check a couple of nodes
TS_ASSERT_DELTA(inner_prod(new_location1-old_location1, trans_vec), 0, 1e-6);
TS_ASSERT_DELTA(inner_prod(new_location2-old_location2, trans_vec), 0, 1e-6);
}
void TestRefreshMeshByScaling()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_DELTA(mesh.GetVolume(), 1.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetSurfaceArea(), 6.0, 1e-6);
// Change coordinates
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
Node<3>* p_node = mesh.GetNode(i);
ChastePoint<3> point = p_node->GetPoint();
point.SetCoordinate(0, point[0]*2.0);
point.SetCoordinate(1, point[1]*2.0);
point.SetCoordinate(2, point[2]*2.0);
p_node->SetPoint(point);
}
mesh.RefreshMesh();
TS_ASSERT_DELTA(mesh.GetVolume(), 8.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetSurfaceArea(), 24.0, 1e-6);
}
void failsInParallelTestDistributedRigidBodyMethods()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
DistributedTetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
c_matrix<double, 3, 3> dummy;
double jacobian_det = 0.0;
double scaled_volume = 0.0;
for (AbstractTetrahedralMesh<3, 3>::ElementIterator iter = mesh.GetElementIteratorBegin();
iter != mesh.GetElementIteratorEnd();
++iter)
{
iter->CalculateJacobian(dummy, jacobian_det);
scaled_volume += jacobian_det;
}
TS_ASSERT_DELTA(scaled_volume, 1.0*6, 1e-6);
mesh.RotateX(M_PI);
//mesh.Translate(100.0, 0.0, 0.0);
double scaled_volume_after = 0.0;
for (AbstractTetrahedralMesh<3, 3>::ElementIterator iter = mesh.GetElementIteratorBegin();
iter != mesh.GetElementIteratorEnd();
++iter)
{
iter->CalculateJacobian(dummy, jacobian_det);
scaled_volume_after += jacobian_det;
}
TS_ASSERT_DELTA(scaled_volume_after, 1.0*6, 1e-6);
}
void Test2DMeshRotation()
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/2D_0_to_1mm_200_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
double angle = M_PI;
mesh.Rotate(angle);
TetrahedralMesh<2,2> original_mesh;
original_mesh.ConstructFromMeshReader(mesh_reader);
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
// Find new coordinates of the translated node
Node<2>* p_node = mesh.GetNode(i);
ChastePoint<2> new_coordinate = p_node->GetPoint();
// Get original node
Node<2>* p_original_node = original_mesh.GetNode(i);
ChastePoint<2> original_coordinate = p_original_node->GetPoint();
// Run a test to make sure the node has gone to the correct place
TS_ASSERT_DELTA(original_coordinate[0], -new_coordinate[0], 1e-5);
TS_ASSERT_DELTA(original_coordinate[1], -new_coordinate[1], 1e-5);
}
// Check volume conservation
double mesh_volume = mesh.GetVolume();
double original_mesh_volume = original_mesh.GetVolume();
TS_ASSERT_DELTA(mesh_volume, original_mesh_volume, 1e-5);
}
void TestScalingWithMethod()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
double mesh_volume = mesh.GetVolume();
mesh.Scale(1.0);
TS_ASSERT_DELTA(mesh_volume, mesh.GetVolume(), 1e-6);
mesh.Scale(2.0, 3.0, 4.0);
TS_ASSERT_DELTA(24.0*mesh_volume, mesh.GetVolume(), 1e-6);
ChastePoint<3> corner_after = mesh.GetNode(6)->GetPoint();
TS_ASSERT_DELTA(corner_after[0], 2.0, 1e-7);
TS_ASSERT_DELTA(corner_after[1], 3.0, 1e-7);
TS_ASSERT_DELTA(corner_after[2], 4.0, 1e-7);
mesh.Scale(0.5, 1.0/3.0, 0.25);
TS_ASSERT_DELTA(mesh_volume,mesh.GetVolume(),1e-6);
corner_after = mesh.GetNode(6)->GetPoint();
TS_ASSERT_DELTA(corner_after[0], 1.0, 1e-7);
TS_ASSERT_DELTA(corner_after[1], 1.0, 1e-7);
TS_ASSERT_DELTA(corner_after[2], 1.0, 1e-7);
}
/**
* This tests the HDF5 to XDMF converter
*/
void TestHdf5ToXdmfConverter() throw(Exception)
{
#ifndef _MSC_VER
std::string working_directory = "TestHdf5Converters_TestHdf5ToXdmfConverter";
CopyToTestOutputDirectory("pde/test/data/cube_2mm_12_elements.h5",
working_directory);
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_2mm_12_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Convert
Hdf5ToXdmfConverter<3,3> converter(FileFinder(working_directory, RelativeTo::ChasteTestOutput),
"cube_2mm_12_elements",
&mesh);
std::vector<std::string> files_to_compare;
files_to_compare.push_back("cube_2mm_12_elements.xdmf");
files_to_compare.push_back("cube_2mm_12_elements_geometry_0.xml");
files_to_compare.push_back("cube_2mm_12_elements_topology_0.xml");
for (unsigned i=0; i<files_to_compare.size(); i++)
{
std::cout << "Comparing generated and reference " << files_to_compare[i] << std::endl;
FileFinder generated_file(working_directory +"/xdmf_output/" + files_to_compare[i], RelativeTo::ChasteTestOutput);
FileFinder reference_file("pde/test/data/xdmf_output/" + files_to_compare[i], RelativeTo::ChasteSourceRoot);
FileComparison comparer(generated_file, reference_file);
TS_ASSERT(comparer.CompareFiles());
}
#endif // _MSC_VER
}
// see also TestPapillaryFibreCalculatorLong() for bigger test of the main method on a cylinder.
void TestGetFibreOrientationsOnSimpleCube(void) throw(Exception)
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/simple_cube");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
PapillaryFibreCalculator calculator(mesh);
std::vector<c_vector<double,3> > fibre_orientations = calculator.CalculateFibreOrientations();
// Not very well defined for a cube (since it's so well structured that there are zero
// eigenvectors in the smoothed tensors) but necessary to test coverage.
// Nightly test TestPapillaryFibreCalculatorLong.hpp is a better one if you want to understand it!
///\todo There may still be a sign issue between flapack and MKL
///\todo THIS TEST IS KNOWN TO STALL IN LAPACK (dgeev_)
// ON THIS CONFIGURATION :
// * 32-bit virtual machine on Ubuntu 8.04 LTS
// * build=GccOpt
// * PETSc: petsc-2.3.2-p10 with f2cblaslapack
TS_ASSERT_DELTA(fabs(fibre_orientations[0](0)), 0.7056, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[0](1)), 0.0641, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[0](2)), 0.7056, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[4](0)), 0.0455, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[4](1)), 0.5005, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[4](2)), 0.8645, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[5](0)), 0.6704, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[5](1)), 0.3176, 1e-4);
TS_ASSERT_DELTA(fabs(fibre_orientations[5](2)), 0.6704, 1e-4);
}
void TestDeleteOrderSimpleMesh() throw(Exception)
{
TrianglesMeshReader<1,3> mesh_reader("lung/test/airway_generation/data/test_major_airways_mesh");
MutableMesh<1,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
//Assign valid radii
for(unsigned node_index = 0; node_index < mesh.GetNumNodes(); ++node_index)
{
mesh.GetNode(node_index)->rGetNodeAttributes()[0] = 1.0;
}
TS_ASSERT_EQUALS(mesh.GetNumNodes(), 6u);
TS_ASSERT_EQUALS(mesh.GetNumElements(), 5u);
MajorAirwaysCentreLinesCleaner cleaner(mesh, 0u);
cleaner.CleanUsingHorsfieldOrder(1u);
NodeMap node_map(mesh.GetNumAllNodes());
mesh.ReIndex(node_map);
TS_ASSERT_EQUALS(mesh.GetNumNodes(), 2u);
TS_ASSERT_EQUALS(mesh.GetNumElements(), 1u);
TS_ASSERT_DELTA(mesh.GetNode(0u)->rGetLocation()[0], 0.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetNode(0u)->rGetLocation()[1], 0.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetNode(0u)->rGetLocation()[2], -2.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetNode(1u)->rGetLocation()[0], 0.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetNode(1u)->rGetLocation()[1], 0.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetNode(1u)->rGetLocation()[2], 0.0, 1e-6);
}
void TestDeleteFirstOrder() throw(Exception)
{
#ifdef CHASTE_VTK
VtkMeshReader<1,3> mesh_reader("lung/test/data/TestSubject002MajorAirways.vtu");
MutableMesh<1,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
//Assign valid radii
for(unsigned node_index = 0; node_index < mesh.GetNumNodes(); ++node_index)
{
mesh.GetNode(node_index)->AddNodeAttribute(1.0);
}
TS_ASSERT_EQUALS(mesh.GetNumNodes(), 12065u);
TS_ASSERT_EQUALS(mesh.GetNumElements(), 12064u);
MajorAirwaysCentreLinesCleaner cleaner(mesh, 0u);
cleaner.CleanUsingHorsfieldOrder(1u);
NodeMap node_map(mesh.GetNumAllNodes());
mesh.ReIndex(node_map);
//Confirmed visually to be correct
TS_ASSERT_EQUALS(mesh.GetNumNodes(), 3683u);
TS_ASSERT_EQUALS(mesh.GetNumElements(), 3682u);
// Uncomment to visualise
// VtkMeshWriter<1,3> mesh_writer("TestMajorAirwaysCentreLinesCleaner", "Novartis002Trimmed");
// mesh_writer.WriteFilesUsingMesh(mesh);
#endif //CHASTE_VTK
}
void TestGenerateBasicRandomWithNoSpecifiedProliferativeCellType() throw(Exception)
{
// Create mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Create cells
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasicRandom(cells, mesh.GetNumNodes());
// Test that cells were generated correctly
TS_ASSERT_EQUALS(cells.size(), mesh.GetNumNodes());
for (unsigned i=0; i<cells.size(); i++)
{
TS_ASSERT_EQUALS(cells[i]->GetCellCycleModel()->GetDimension(), 2u);
TS_ASSERT_EQUALS(cells[i]->GetCellProliferativeType()->IsType<StemCellProliferativeType>(), true);
// Should lie between -24 and 0
double birth_time=cells[i]->GetBirthTime();
///\todo Breaks Intel 10? TS_ASSERT_LESS_THAN_EQUALS(birth_time, 0.0);
TS_ASSERT_LESS_THAN_EQUALS(-24.0, birth_time);
}
}
void TestConstructStreeterOnRightWedge() throw(Exception)
{
TrianglesMeshReader<3,3> mesh_reader("heart/test/data/human_wedge_mesh/HumanWedgeMesh");
std::string epi_face_file = "heart/test/data/human_wedge_mesh/epi.tri";
std::string endo_face_file = "heart/test/data/human_wedge_mesh/endo.tri";
DistributedTetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
StreeterFibreGenerator<3> fibre_generator(mesh);
//Assume we are in the left ventricle
fibre_generator.SetSurfaceFiles(epi_face_file, endo_face_file, "", true);
fibre_generator.SetApexToBase(0);
fibre_generator.SetWriteFileAsBinary();
OutputFileHandler handler("human_wedge_mesh", false);
fibre_generator.WriteData(handler, "HumanWedgeMeshRight.ortho");
FileFinder fibre_file1 = handler.FindFile("HumanWedgeMeshRight.ortho");
FileFinder fibre_file2("heart/test/data/human_wedge_mesh/HumanWedgeMeshRight.ortho", RelativeTo::ChasteSourceRoot);
CompareGeneratedWithReferenceFile(fibre_file1, ORTHO, fibre_file2, ORTHO);
}
void TestMeshWriterWithDeletedNode() throw (Exception)
{
// Create mesh
VertexMeshReader<2,2> mesh_reader("mesh/test/data/TestVertexMesh/honeycomb_vertex_mesh_3_by_3");
MutableVertexMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_EQUALS(mesh.GetNumNodes(), 30u);
TS_ASSERT_EQUALS(mesh.GetNumElements(), 9u);
/*
* Delete element 0. This element contains 3 nodes that are
* not contained in any other element and so will be marked
* as deleted.
*/
mesh.DeleteElementPriorToReMesh(0);
// Write mesh to file
VertexMeshWriter<2,2> mesh_writer("TestMeshWriterWithDeletedNode", "vertex_mesh");
TS_ASSERT_THROWS_NOTHING(mesh_writer.WriteFilesUsingMesh(mesh));
// Read mesh back in from file
std::string output_dir = mesh_writer.GetOutputDirectory();
VertexMeshReader<2,2> mesh_reader2(output_dir + "vertex_mesh");
// We should have one less element and three less nodes
TS_ASSERT_EQUALS(mesh_reader2.GetNumNodes(), 27u);
TS_ASSERT_EQUALS(mesh_reader2.GetNumElements(), 8u);
}
void TestValidate()
{
// Load a 2D square mesh with 1 central non-boundary node
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
BoundaryConditionsContainer<2,2,1> bcc;
// No BCs yet, so shouldn't validate
TS_ASSERT(!bcc.Validate(&mesh));
// Add some BCs
ConstBoundaryCondition<2> *bc = new ConstBoundaryCondition<2>(0.0);
bcc.AddDirichletBoundaryCondition(mesh.GetNode(0), bc);
bcc.AddDirichletBoundaryCondition(mesh.GetNode(1), bc);
bcc.AddDirichletBoundaryCondition(mesh.GetNode(3), bc);
TetrahedralMesh<2,2>::BoundaryElementIterator iter
= mesh.GetBoundaryElementIteratorEnd();
iter--;
bcc.AddNeumannBoundaryCondition(*iter, bc); // 2 to 3
iter--;
bcc.AddNeumannBoundaryCondition(*iter, bc); // 1 to 2
TS_ASSERT(bcc.Validate(&mesh));
}
void TestAnyNonZeroNeumannConditionsAndApplyNeumannToMeshBoundary()
{
// Load a 2D square mesh with 1 central non-boundary node
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
BoundaryConditionsContainer<2,2,1> bcc;
BoundaryConditionsContainer<2,2,2> bcc_2unknowns;
TS_ASSERT_EQUALS(bcc.AnyNonZeroNeumannConditions(), false);
bcc.DefineZeroNeumannOnMeshBoundary(&mesh);
TetrahedralMesh<2,2>::BoundaryElementIterator iter;
iter = mesh.GetBoundaryElementIteratorBegin();
while (iter != mesh.GetBoundaryElementIteratorEnd())
{
TS_ASSERT(bcc.HasNeumannBoundaryCondition(*iter));
double value = bcc.GetNeumannBCValue(*iter, (*iter)->GetNode(0)->GetPoint());
TS_ASSERT_DELTA(value, 0.0, 1e-8);
iter++;
}
TS_ASSERT_EQUALS(bcc.AnyNonZeroNeumannConditions(), false);
iter = mesh.GetBoundaryElementIteratorBegin();
ConstBoundaryCondition<2>* p_boundary_condition2 = new ConstBoundaryCondition<2>(-1);
bcc_2unknowns.AddNeumannBoundaryCondition(*iter, p_boundary_condition2);
TS_ASSERT_EQUALS(bcc_2unknowns.AnyNonZeroNeumannConditions(), true);
}
/**
* This tests the HDF5 to .txt converter using a 3D example
* taken from a bidomain simulation.
*/
void TestBidomainTxtConversion3D() throw(Exception)
{
std::string working_directory = "TestHdf5ToTxtConverter_bidomain";
/*
* Firstly, copy the .h5 file to CHASTE_TEST_OUTPUT/TestHdf5ToTxtConverter_bidomain,
* as that is where the reader reads from.
*/
CopyToTestOutputDirectory("pde/test/data/cube_2mm_12_elements.h5",
working_directory);
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_2mm_12_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Convert
Hdf5ToTxtConverter<3,3> converter(FileFinder(working_directory, RelativeTo::ChasteTestOutput),
"cube_2mm_12_elements", &mesh);
std::vector<std::string> files_to_compare;
files_to_compare.push_back("cube_2mm_12_elements_V_0.txt");
files_to_compare.push_back("cube_2mm_12_elements_V_1.txt");
files_to_compare.push_back("cube_2mm_12_elements_Phi_e_0.txt");
files_to_compare.push_back("cube_2mm_12_elements_Phi_e_1.txt");
for (unsigned i=0; i<files_to_compare.size(); i++)
{
std::cout << "Comparing generated and reference " << files_to_compare[i] << std::endl;
FileFinder generated_file(working_directory +"/txt_output/" + files_to_compare[i], RelativeTo::ChasteTestOutput);
FileFinder reference_file("pde/test/data/" + files_to_compare[i], RelativeTo::ChasteSourceRoot);
NumericFileComparison comparer(generated_file, reference_file);
TS_ASSERT(comparer.CompareFiles());
}
}
void TestAllCases()
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
MutableMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_DELTA(mesh.GetAngleBetweenNodes(2,0), -0.75*M_PI, 1e-12);
TS_ASSERT_DELTA(mesh.GetAngleBetweenNodes(2,1), -0.5*M_PI, 1e-12);
CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator;
std::vector<CellPtr> cells;
cells_generator.GenerateBasic(cells, mesh.GetNumNodes());
MeshBasedCellPopulation<2> cell_population(mesh, cells);
MAKE_PTR(GeneralisedLinearSpringForce<2>, p_force);
std::vector<boost::shared_ptr<AbstractTwoBodyInteractionForce<2> > > force_collection;
force_collection.push_back(p_force);
DiscreteSystemForceCalculator calculator(cell_population, force_collection);
double epsilon = 0.5*M_PI;
calculator.SetEpsilon(epsilon);
TS_ASSERT_THROWS_NOTHING(calculator.GetSamplingAngles(2));
}
// This test covers the case when the hdf5 file contains 3 variables (e.g., after solving a problem with PROBLEM_DIM=3)
void TestMeshalyzerConversion3Variables() throw(Exception)
{
/*
* Firstly, copy the .h5 file to CHASTE_TEST_OUTPUT/TestHdf5ToMeshalyzerConverter,
* as that is where the reader reads from.
*/
std::string output_folder("TestHdf5Converters_TestMeshalyzerConversion3Variables");
CopyToTestOutputDirectory("heart/test/data/three_variables/3_vars.h5", output_folder);
TrianglesMeshReader<1,1> mesh_reader("mesh/test/data/1D_0_to_1_100_elements");
TetrahedralMesh<1,1> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Convert
Hdf5ToMeshalyzerConverter<1,1> converter(FileFinder(output_folder, RelativeTo::ChasteTestOutput),
"3_vars", &mesh, true);
// Compare the first voltage file
std::string test_output_directory = OutputFileHandler::GetChasteTestOutputDirectory();
NumericFileComparison(test_output_directory + output_folder + "/output/3_vars_Vm_1.dat",
"heart/test/data/three_variables/extended_bidomain_Vm_1.dat").CompareFiles();
// Compare the second voltage file
NumericFileComparison(test_output_directory + output_folder +"/output/3_vars_Vm_2.dat",
"heart/test/data/three_variables/extended_bidomain_Vm_2.dat").CompareFiles();
// Compare the Phi_e file
NumericFileComparison(test_output_directory + output_folder + "/output/3_vars_Phi_e.dat",
"heart/test/data/three_variables/extended_bidomain_Phi_e.dat").CompareFiles();
// Compare the time information file
FileComparison(test_output_directory + output_folder + "/output/3_vars_times.info",
"heart/test/data/three_variables/extended_bidomain_times.info").CompareFiles();
}
void TestCellPopulationIteratorWithNoCells() throw(Exception)
{
EXIT_IF_PARALLEL; // This test doesn't work in parallel.
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(10.0, 1);
// Create a simple mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_128_elements");
TetrahedralMesh<2,2> generating_mesh;
generating_mesh.ConstructFromMeshReader(mesh_reader);
// Convert this to a NodesOnlyMesh
NodesOnlyMesh<2> mesh;
mesh.ConstructNodesWithoutMesh(generating_mesh, 1.2);
// Create vector of cell location indices
std::vector<unsigned> cell_location_indices;
cell_location_indices.push_back(80);
// Create a single cell
std::vector<CellPtr> cells;
CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, cell_location_indices.size());
cells[0]->StartApoptosis();
// Create a cell population
NodeBasedCellPopulationWithParticles<2> cell_population(mesh, cells, cell_location_indices);
// Iterate over cell population and check there is a single cell
unsigned counter = 0;
for (AbstractCellPopulation<2>::Iterator cell_iter = cell_population.Begin();
cell_iter != cell_population.End();
++cell_iter)
{
counter++;
}
TS_ASSERT_EQUALS(counter, 1u);
TS_ASSERT_EQUALS(cell_population.rGetCells().empty(), false);
// Increment simulation time and update cell population
p_simulation_time->IncrementTimeOneStep();
unsigned num_cells_removed = cell_population.RemoveDeadCells();
TS_ASSERT_EQUALS(num_cells_removed, 1u);
cell_population.Update();
// Iterate over cell population and check there are now no cells
counter = 0;
for (AbstractCellPopulation<2>::Iterator cell_iter = cell_population.Begin();
cell_iter != cell_population.End();
++cell_iter)
{
counter++;
}
TS_ASSERT_EQUALS(counter, 0u);
TS_ASSERT_EQUALS(cell_population.rGetCells().empty(), true);
}
/**
* Check that the 1D data are read correctly. Check that the output vector
* for a given input file is the correct length.
*/
void Test1DMeshRead() throw(Exception)
{
TrianglesMeshReader<1,1> mesh_reader("mesh/test/data/trivial_1d_mesh");
TS_ASSERT_EQUALS(mesh_reader.GetNumNodes(), 11u);
TS_ASSERT_EQUALS(mesh_reader.GetNumElements(), 10u);
TS_ASSERT_EQUALS(mesh_reader.GetNumFaces(), 2u);
}
void TestXaxisRotation3DWithHomogeneousUblas()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_DELTA(mesh.GetVolume(), 1.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetSurfaceArea(), 6.0, 1e-6);
// Change coordinates
c_matrix<double, 4, 4> x_rotation_matrix = identity_matrix<double>(4);
double theta = M_PI/2;
x_rotation_matrix(1,1) = cos(theta);
x_rotation_matrix(1,2) = sin(theta);
x_rotation_matrix(2,1) = -sin(theta);
x_rotation_matrix(2,2) = cos(theta);
ChastePoint<3> corner_before = mesh.GetNode(6)->GetPoint();
TS_ASSERT_EQUALS(corner_before[0], 1.0);
TS_ASSERT_EQUALS(corner_before[1], 1.0);
TS_ASSERT_EQUALS(corner_before[2], 1.0);
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
Node<3>* p_node = mesh.GetNode(i);
ChastePoint<3> point = p_node->GetPoint();
c_vector<double, 4> point_location;
point_location[0] = point[0];
point_location[1] = point[1];
point_location[2] = point[2];
point_location[3] = 1.0;
c_vector<double, 4> new_point_location = prod(x_rotation_matrix, point_location);
TS_ASSERT_EQUALS(new_point_location[3], 1.0);
point.SetCoordinate(0, new_point_location[0]);
point.SetCoordinate(1, new_point_location[1]);
point.SetCoordinate(2, new_point_location[2]);
p_node->SetPoint(point);
}
ChastePoint<3> corner_after = mesh.GetNode(6)->GetPoint();
TS_ASSERT_EQUALS(corner_after[0], 1.0);
TS_ASSERT_EQUALS(corner_after[1], 1.0);
TS_ASSERT_DELTA(corner_after[2], -1.0, 1e-7);
mesh.RefreshMesh();
TS_ASSERT_DELTA(mesh.GetVolume(), 1.0, 1e-6);
TS_ASSERT_DELTA(mesh.GetSurfaceArea(), 6.0, 1e-6);
}
void TestReadingAndWritingElementAttributes() throw(Exception)
{
// Read in a mesh with element attributes
VertexMeshReader<2,2> mesh_reader("mesh/test/data/TestVertexMeshReader2d/vertex_mesh_with_element_attributes");
TS_ASSERT_EQUALS(mesh_reader.GetNumElements(), 2u);
TS_ASSERT_EQUALS(mesh_reader.GetNumElementAttributes(), 1u);
// Construct the mesh
VertexMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_EQUALS(mesh.GetElement(0)->GetUnsignedAttribute(), 97u);
TS_ASSERT_EQUALS(mesh.GetElement(1)->GetUnsignedAttribute(), 152u);
// Write the mesh to file
// Nested scope so the reader is destroyed before we try writing to the folder again
{
VertexMeshWriter<2,2> mesh_writer("TestReadingAndWritingElementAttributes", "vertex_mesh_with_element_attributes");
mesh_writer.WriteFilesUsingMesh(mesh);
// Now read in the mesh that was written
OutputFileHandler handler("TestReadingAndWritingElementAttributes", false);
VertexMeshReader<2,2> mesh_reader2(handler.GetOutputDirectoryFullPath() + "vertex_mesh_with_element_attributes");
TS_ASSERT_EQUALS(mesh_reader2.GetNumElements(), 2u);
TS_ASSERT_EQUALS(mesh_reader2.GetNumElementAttributes(), 1u);
// Construct the mesh again
VertexMesh<2,2> mesh2;
mesh2.ConstructFromMeshReader(mesh_reader);
TS_ASSERT_EQUALS(mesh2.GetElement(0)->GetUnsignedAttribute(), 97u);
TS_ASSERT_EQUALS(mesh2.GetElement(1)->GetUnsignedAttribute(), 152u);
}
// For coverage, repeat this test for a vertex mesh whose elements have faces
VertexMeshReader<3,3> mesh_reader3d("mesh/test/data/TestVertexMeshWriter/vertex_mesh_3d_with_faces_and_attributes");
TS_ASSERT_EQUALS(mesh_reader3d.GetNumElements(), 1u);
TS_ASSERT_EQUALS(mesh_reader3d.GetNumElementAttributes(), 1u);
// Construct the mesh
VertexMesh<3,3> mesh3d;
mesh3d.ConstructFromMeshReader(mesh_reader3d);
TS_ASSERT_EQUALS(mesh3d.GetElement(0)->GetUnsignedAttribute(), 49u);
// Write the mesh to file
VertexMeshWriter<3,3> mesh_writer3d("TestReadingAndWritingElementAttributes", "vertex_mesh_3d_with_faces_and_attributes");
mesh_writer3d.WriteFilesUsingMesh(mesh3d);
// Now read in the mesh that was written
OutputFileHandler handler3d("TestReadingAndWritingElementAttributes", false);
VertexMeshReader<3,3> mesh_reader3d2(handler3d.GetOutputDirectoryFullPath() + "vertex_mesh_3d_with_faces_and_attributes");
TS_ASSERT_EQUALS(mesh_reader3d2.GetNumElements(), 1u);
TS_ASSERT_EQUALS(mesh_reader3d2.GetNumElementAttributes(), 1u);
// Construct the mesh again
VertexMesh<3,3> mesh3d2;
mesh3d2.ConstructFromMeshReader(mesh_reader3d2);
TS_ASSERT_EQUALS(mesh3d2.GetElement(0)->GetUnsignedAttribute(), 49u);
}