void TestWithCoarseSlightlyOutsideFine() throw(Exception)
{
// Fine mesh is has h=0.1, on unit cube (so 6000 elements)
TetrahedralMesh<3,3> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.1, 1.0,1.0,1.0);
// Coarse mesh is slightly bigger than in previous test
QuadraticMesh<3> coarse_mesh(1.0, 1.0, 1.0, 1.0); // xmax > 1.0
coarse_mesh.Scale(1.03, 1.0, 1.0);
FineCoarseMeshPair<3> mesh_pair(fine_mesh,coarse_mesh);
GaussianQuadratureRule<3> quad_rule(3);
// Need to call SetUpBoxesOnFineMesh first
TS_ASSERT_THROWS_CONTAINS(mesh_pair.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, true), "Call");
mesh_pair.SetUpBoxesOnFineMesh(0.3);
TS_ASSERT_EQUALS(mesh_pair.mpFineMeshBoxCollection->GetNumBoxes(), 4*4*4u);
mesh_pair.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, true);
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 2u); // hardcoded
TS_ASSERT_EQUALS(mesh_pair.mNotInMeshNearestElementWeights.size(), 2u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights().size(), 6*8u);
for (unsigned i=0; i<mesh_pair.rGetElementsAndWeights().size(); i++)
{
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].ElementNum, fine_mesh.GetNumElements());
// comment out this test as now some of the weights are negative/greater than one
//for (unsigned j=0; j<4; j++)
//{
// TS_ASSERT_LESS_THAN(-1e14, mesh_pair.rGetElementsAndWeights()[i].Weights(j));
// TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].Weights(j), 1.0+1e-14);
//}
}
/*
* For each quadrature point that was not found in the fine mesh, check
* that its x-value is greater than one - this is the only way it could
* be outside the fine mesh.
*/
QuadraturePointsGroup<3> quad_point_posns(coarse_mesh, quad_rule);
for (unsigned i=0; i<mesh_pair.mNotInMesh.size(); i++)
{
double x = quad_point_posns.rGet(mesh_pair.mNotInMesh[i])(0);
TS_ASSERT_LESS_THAN(1.0, x);
}
mesh_pair.PrintStatistics();
TS_ASSERT_EQUALS( Warnings::Instance()->GetNumWarnings(), 1u);
Warnings::Instance()->QuietDestroy();
}
/*
* Test when calling ComputeFineElementsAndWeightsForCoarseQuadPoints()
* in non-safe mode, but using the default value of box width. It is
* difficult to get the class to run incorrectly (ie fail without an
* assertion failing) in non-safe mode (ie we can't just specify boxes
* that are too small), so we just test we get the same results as in
* safe mode.
*/
void TestNonSafeMode() throw(Exception)
{
// Fine mesh is has h=0.1, on unit cube (so 6000 elements)
TetrahedralMesh<3,3> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.1, 1.0, 1.0, 1.0);
QuadraticMesh<3> coarse_mesh(1.0, 1.0, 1.0, 1.0); // xmax > 1.0
coarse_mesh.Scale(1.03, 1.0, 1.0);
FineCoarseMeshPair<3> mesh_pair(fine_mesh,coarse_mesh);
GaussianQuadratureRule<3> quad_rule(3);
// Call SetUpBoxesOnFineMesh() without providing a width
mesh_pair.SetUpBoxesOnFineMesh();
/*
* Whereas before 4 by 4 by 4 boxes were explicitly chosen, here it
* has been determined that 6 by 6 by 6 are needed.
*/
TS_ASSERT_EQUALS(mesh_pair.mpFineMeshBoxCollection->GetNumBoxes(), 6*6*6u);
mesh_pair.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, false /* non-safe mode*/);
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 2u); // hardcoded
TS_ASSERT_EQUALS(mesh_pair.mNotInMeshNearestElementWeights.size(), 2u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights().size(), 6*8u);
for (unsigned i=0; i<mesh_pair.rGetElementsAndWeights().size(); i++)
{
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].ElementNum, fine_mesh.GetNumElements());
}
/*
* For each quadrature point that was not found in the fine mesh, check
* that its x-value is greater than one - this is the only way it could
* be outside the fine mesh.
*/
QuadraturePointsGroup<3> quad_point_posns(coarse_mesh, quad_rule);
for (unsigned i=0; i<mesh_pair.mNotInMesh.size(); i++)
{
double x = quad_point_posns.rGet(mesh_pair.mNotInMesh[i])(0);
TS_ASSERT_LESS_THAN(1.0, x);
}
mesh_pair.PrintStatistics();
TS_ASSERT_EQUALS( Warnings::Instance()->GetNumWarnings(), 1u);
Warnings::Instance()->QuietDestroy();
}
void TestComputeFineElemsAndWeightsForCoarseNodes() throw(Exception)
{
TetrahedralMesh<2,2> fine_mesh;
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4_elements");
fine_mesh.ConstructFromMeshReader(mesh_reader);
QuadraticMesh<2> coarse_mesh(0.5, 0.5, 0.5);
coarse_mesh.Translate(0.2,0.1);
FineCoarseMeshPair<2> mesh_pair(fine_mesh,coarse_mesh);
// Need to call SetUpBoxesOnFineMesh first
TS_ASSERT_THROWS_CONTAINS(mesh_pair.ComputeFineElementsAndWeightsForCoarseNodes(true), "Call");
mesh_pair.SetUpBoxesOnFineMesh();
mesh_pair.ComputeFineElementsAndWeightsForCoarseNodes(true);
// All coarse quadrature points should have been found in the fine mesh
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 0u);
TS_ASSERT_EQUALS(mesh_pair.mNotInMeshNearestElementWeights.size(), 0u);
// Check the elements and weights have been set up correctly
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights().size(), 9u);
// Check the first four nodes against what they should be
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[0].ElementNum, 1u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[1].ElementNum, 1u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[2].ElementNum, 0u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[3].ElementNum, 2u);
for (unsigned i=0; i<mesh_pair.rGetElementsAndWeights().size(); i++)
{
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].ElementNum, fine_mesh.GetNumElements());
// All the weights should be between 0 and 1 as no coarse nodes are
// Note weights = (1-psi_x-psi_y-psi_z, psi_x, psi_y, psi_z), where psi is the position of the
// point in that element when transformed to the canonical element
for (unsigned j=0; j<3; j++)
{
TS_ASSERT_LESS_THAN(-1e14, mesh_pair.rGetElementsAndWeights()[i].Weights(j));
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].Weights(j), 1.0+1e-14);
}
}
TS_ASSERT_EQUALS(mesh_pair.mStatisticsCounters[0], 9u);
TS_ASSERT_EQUALS(mesh_pair.mStatisticsCounters[1], 0u);
}
// Covers some bits that aren't covered in the tests above,
void TestOtherCoverage() throw(Exception)
{
TetrahedralMesh<2,2> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.1, 1.0, 1.0);
QuadraticMesh<2> coarse_mesh(1.0, 1.0, 1.0);
/*
* Rotate the mesh by 45 degrees, makes it possible (since boxes no
* longer lined up with elements) for the containing element of a
* quad point to be in a *local* box, ie not an element contained
* in the box containing this point.
*/
c_matrix<double,2,2> rotation_mat;
rotation_mat(0,0) = 1.0/sqrt(2.0);
rotation_mat(1,0) = -1.0/sqrt(2.0);
rotation_mat(0,1) = 1.0/sqrt(2.0);
rotation_mat(1,1) = 1.0/sqrt(2.0);
fine_mesh.Rotate(rotation_mat);
coarse_mesh.Rotate(rotation_mat);
GaussianQuadratureRule<2> quad_rule(3);
FineCoarseMeshPair<2> mesh_pair(fine_mesh,coarse_mesh);
mesh_pair.SetUpBoxesOnFineMesh();
mesh_pair.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, true);
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 0u);
/*
* Repeat again with smaller boxes, covers the bit requiring the whole
* mesh to be searched to find an element for a particular quad point.
*/
FineCoarseMeshPair<2> mesh_pair2(fine_mesh,coarse_mesh);
mesh_pair2.SetUpBoxesOnFineMesh(0.01);
mesh_pair2.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, true);
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 0u);
}
void TestWithDefaultBoxWidth() throw(Exception)
{
TetrahedralMesh<2,2> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.1, 1.0, 1.0);
QuadraticMesh<2> coarse_mesh(1.0, 1.0, 1.0);
FineCoarseMeshPair<2> mesh_pair(fine_mesh,coarse_mesh);
mesh_pair.SetUpBoxesOnFineMesh();
/*
* With this mesh the proposed width - the width that would correspond to 20 boxes
* in the x-direction is:
* Proposed width = 0.0552632
* but
* max_edge_length = 0.141421
* and we want width > max_edge_length, so end up with
* box width = 0.155563
* (1.1 times max edge length)
*/
TS_ASSERT_EQUALS(mesh_pair.mpFineMeshBoxCollection->GetNumBoxes(), 64u);
// Now use a mesh with a smaller edge length
TetrahedralMesh<2,2> fine_mesh2;
fine_mesh2.ConstructRegularSlabMesh(0.01, 1.0,1.0);
/*
* Can use smaller boxes
* Proposed width = 0.0552632
* max_edge_length = 0.0141421
* box width = 0.0552632
*/
FineCoarseMeshPair<2> mesh_pair2(fine_mesh2,coarse_mesh);
mesh_pair2.SetUpBoxesOnFineMesh();
TS_ASSERT_EQUALS(mesh_pair2.mpFineMeshBoxCollection->GetNumBoxes(), 20*20u);
}
void TestComputeCoarseElementsForFineElementCentroids() throw(Exception)
{
TetrahedralMesh<2,2> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.2, 1.0, 1.0);
QuadraticMesh<2> coarse_mesh(1.0, 1.0, 1.0); // 2 triangular elements
FineCoarseMeshPair<2> mesh_pair(fine_mesh,coarse_mesh);
TS_ASSERT_THROWS_CONTAINS(mesh_pair.ComputeCoarseElementsForFineElementCentroids(true),"Call SetUpBoxesOnCoarseMesh()");
mesh_pair.SetUpBoxesOnCoarseMesh();
mesh_pair.ComputeCoarseElementsForFineElementCentroids(true);
//Check that the indices of the coarse mesh elements are as expected
unsigned lower_left_element_index=1u;
ChastePoint<2> lower_left(0.25, 0.25);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(lower_left), lower_left_element_index);
unsigned upper_right_element_index=0u;
ChastePoint<2> upper_right(0.75, 0.75);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(upper_right), upper_right_element_index);
TS_ASSERT_EQUALS( mesh_pair.rGetCoarseElementsForFineElementCentroids().size(), fine_mesh.GetNumElements());
for (unsigned i=0; i<fine_mesh.GetNumElements(); i++)
{
double x = fine_mesh.GetElement(i)->CalculateCentroid()(0);
double y = fine_mesh.GetElement(i)->CalculateCentroid()(1);
if (x+y < 1.0)
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineElementCentroids()[i], lower_left_element_index);
}
else
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineElementCentroids()[i], upper_right_element_index);
}
}
// Coverage
mesh_pair.DeleteCoarseBoxCollection();
mesh_pair.SetUpBoxesOnCoarseMesh(0.8); // force a point to be found in a neighbouring box
mesh_pair.ComputeCoarseElementsForFineElementCentroids(true);
mesh_pair.DeleteCoarseBoxCollection();
mesh_pair.SetUpBoxesOnCoarseMesh(0.1); // force a point to be found in a nonlocal box
mesh_pair.ComputeCoarseElementsForFineElementCentroids(true);
mesh_pair.DeleteCoarseBoxCollection();
mesh_pair.SetUpBoxesOnCoarseMesh(); // back to default
/*
* Translate the fine mesh in the (-1, -1) direction --> all fine elements
* nearest to (not contained in) element 0. We have to make the fine mesh
* tiny and then translate a small amount so that it is still in the box
* collection for the coarse (normally the two meshes should overlap).
*/
fine_mesh.Scale(1e-2, 1e-2);
fine_mesh.Translate(-1.1e-2, -1.1e-2);
mesh_pair.ComputeCoarseElementsForFineElementCentroids(true);
TS_ASSERT_EQUALS( mesh_pair.rGetCoarseElementsForFineElementCentroids().size(), fine_mesh.GetNumElements());
for (unsigned i=0; i<fine_mesh.GetNumElements(); i++)
{
TS_ASSERT_EQUALS( mesh_pair.rGetCoarseElementsForFineElementCentroids()[i], lower_left_element_index);
}
}
void TestComputeCoarseElementsForFineNodes() throw(Exception)
{
TetrahedralMesh<2,2> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.2, 1.0, 1.0);
QuadraticMesh<2> coarse_mesh(1.0, 1.0, 1.0); // 2 triangular elements
FineCoarseMeshPair<2> mesh_pair(fine_mesh,coarse_mesh);
TS_ASSERT_THROWS_CONTAINS(mesh_pair.ComputeCoarseElementsForFineNodes(true),"Call SetUpBoxesOnCoarseMesh()");
mesh_pair.SetUpBoxesOnCoarseMesh();
mesh_pair.ComputeCoarseElementsForFineNodes(true);
//Check that the indices of the coarse mesh elements are as expected
unsigned lower_left_element_index=1u;
ChastePoint<2> lower_left(0.25, 0.25);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(lower_left), lower_left_element_index);
ChastePoint<2> lower_left1(0.1, 0.25); //Double check that there is a `backslash`
ChastePoint<2> lower_left2(0.25, 0.1);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(lower_left1), lower_left_element_index);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(lower_left2), lower_left_element_index);
unsigned upper_right_element_index=0u;
ChastePoint<2> upper_right(0.75, 0.75);
TS_ASSERT_EQUALS(coarse_mesh.GetContainingElementIndex(upper_right), upper_right_element_index);
for (unsigned i=0; i<fine_mesh.GetNumNodes(); i++)
{
double x = fine_mesh.GetNode(i)->rGetLocation()[0];
double y = fine_mesh.GetNode(i)->rGetLocation()[1];
if ( x+y < 1.0 - 1e-5 ) // x+y < 1
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineNodes()[i], lower_left_element_index);
}
else if ( x+y > 1.0 + 1e-5 ) // x+y > 1
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineNodes()[i], upper_right_element_index);
}
else // x=1-y, so in both elements, result could be either. However, it should find 0 first
{
//TS_ASSERT_LESS_THAN(mesh_pair.rGetCoarseElementsForFineNodes()[i], 2u);
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineNodes()[i], 0u);
}
}
/*
* Translate the fine mesh in the (-1, -1) direction --> all fine nodes
* nearest to (not contained in) element 0. We have to make the fine mesh
* tiny and then translate a small amount so that it is still in the box
* collection for the coarse (normally the two meshes should overlap).
*/
fine_mesh.Scale(1e-2, 1e-2);
fine_mesh.Translate(-1.1e-2, -1.1e-2);
mesh_pair.ComputeCoarseElementsForFineNodes(true);
for (unsigned i=0; i<fine_mesh.GetNumNodes(); i++)
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineNodes()[i], lower_left_element_index);
}
// Call again with safeMode=false this time (same results, faster)
mesh_pair.rGetCoarseElementsForFineNodes()[0] = 189342958;
mesh_pair.ComputeCoarseElementsForFineNodes(false);
for (unsigned i=0; i<fine_mesh.GetNumNodes(); i++)
{
TS_ASSERT_EQUALS(mesh_pair.rGetCoarseElementsForFineNodes()[i], lower_left_element_index);
}
// Coverage:
// call again
mesh_pair.SetUpBoxesOnCoarseMesh();
// delete
mesh_pair.DeleteCoarseBoxCollection();
}
void TestWithCoarseContainedInFine() throw(Exception)
{
// Fine mesh is has h=0.1, on unit cube (so 6000 elements)
TetrahedralMesh<3,3> fine_mesh;
fine_mesh.ConstructRegularSlabMesh(0.1, 1.0, 1.0, 1.0);
// Coarse mesh is has h=1 on unit cube (so 6 elements)
QuadraticMesh<3> coarse_mesh(1.0, 1.0, 1.0, 1.0);
FineCoarseMeshPair<3> mesh_pair(fine_mesh,coarse_mesh);
mesh_pair.SetUpBoxesOnFineMesh(0.3);
TS_ASSERT_EQUALS(mesh_pair.mpFineMeshBoxCollection->GetNumBoxes(), 4*4*4u);
// For each node, find containing box. That box should contain any element that node is in.
for (unsigned i=0; i<fine_mesh.GetNumNodes(); i++)
{
unsigned box_index = mesh_pair.mpFineMeshBoxCollection->CalculateContainingBox(fine_mesh.GetNode(i));
assert(fine_mesh.GetNode(i)->rGetContainingElementIndices().size() > 0);
for (std::set<unsigned>::iterator iter = fine_mesh.GetNode(i)->rGetContainingElementIndices().begin();
iter != fine_mesh.GetNode(i)->rGetContainingElementIndices().end();
++iter)
{
Element<3,3>* p_element = fine_mesh.GetElement(*iter);
TS_ASSERT_DIFFERS( mesh_pair.mpFineMeshBoxCollection->rGetBox(box_index).rGetElementsContained().find(p_element), mesh_pair.mpFineMeshBoxCollection->rGetBox(box_index).rGetElementsContained().end() )
}
}
GaussianQuadratureRule<3> quad_rule(3);
mesh_pair.ComputeFineElementsAndWeightsForCoarseQuadPoints(quad_rule, true);
// All coarse quadrature points should have been found in the fine mesh
TS_ASSERT_EQUALS(mesh_pair.mNotInMesh.size(), 0u);
TS_ASSERT_EQUALS(mesh_pair.mNotInMeshNearestElementWeights.size(), 0u);
// Check the elements and weights have been set up correctly
// 6 elements, 8 quad points
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights().size(), 6*8u);
// Some hardcoded values, just to check element_nums not all zero
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[0].ElementNum, 3816u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[10].ElementNum, 217u);
TS_ASSERT_EQUALS(mesh_pair.rGetElementsAndWeights()[20].ElementNum, 1094u);
for (unsigned i=0; i<mesh_pair.rGetElementsAndWeights().size(); i++)
{
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].ElementNum, fine_mesh.GetNumElements());
/*
* As all the quadrature points should have been found in the fine mesh,
* all the weights should be between 0 and 1.
* Note weights = (1-psi_x-psi_y-psi_z, psi_x, psi_y, psi_z), where psi
* is the position of the point in that element when transformed to the
* canonical element.
*/
for (unsigned j=0; j<4; j++)
{
TS_ASSERT_LESS_THAN(-1e14, mesh_pair.rGetElementsAndWeights()[i].Weights(j));
TS_ASSERT_LESS_THAN(mesh_pair.rGetElementsAndWeights()[i].Weights(j), 1.0+1e-14);
}
}
TS_ASSERT_EQUALS(mesh_pair.mStatisticsCounters[0], 6*8u);
TS_ASSERT_EQUALS(mesh_pair.mStatisticsCounters[1], 0u);
mesh_pair.PrintStatistics();
mesh_pair.DeleteFineBoxCollection();
TS_ASSERT(mesh_pair.mpFineMeshBoxCollection==NULL);
}
VoltageInterpolaterOntoMechanicsMesh<DIM>::VoltageInterpolaterOntoMechanicsMesh(
TetrahedralMesh<DIM,DIM>& rElectricsMesh,
QuadraticMesh<DIM>& rMechanicsMesh,
std::vector<std::string>& rVariableNames,
std::string directory,
std::string inputFileNamePrefix)
{
// Read the data from the HDF5 file
Hdf5DataReader reader(directory,inputFileNamePrefix);
unsigned num_timesteps = reader.GetUnlimitedDimensionValues().size();
// set up the elements and weights for the coarse nodes in the fine mesh
FineCoarseMeshPair<DIM> mesh_pair(rElectricsMesh, rMechanicsMesh);
mesh_pair.SetUpBoxesOnFineMesh();
mesh_pair.ComputeFineElementsAndWeightsForCoarseNodes(true);
assert(mesh_pair.rGetElementsAndWeights().size()==rMechanicsMesh.GetNumNodes());
// create and setup a writer
Hdf5DataWriter* p_writer = new Hdf5DataWriter(*rMechanicsMesh.GetDistributedVectorFactory(),
directory,
"voltage_mechanics_mesh",
false, //don't clean
false);
std::vector<int> columns_id;
for (unsigned var_index = 0; var_index < rVariableNames.size(); var_index++)
{
std::string var_name = rVariableNames[var_index];
columns_id.push_back( p_writer->DefineVariable(var_name,"mV") );
}
p_writer->DefineUnlimitedDimension("Time","msecs", num_timesteps);
p_writer->DefineFixedDimension( rMechanicsMesh.GetNumNodes() );
p_writer->EndDefineMode();
assert(columns_id.size() == rVariableNames.size());
// set up a vector to read into
DistributedVectorFactory factory(rElectricsMesh.GetNumNodes());
Vec voltage = factory.CreateVec();
std::vector<double> interpolated_voltages(rMechanicsMesh.GetNumNodes());
Vec voltage_coarse = NULL;
for(unsigned time_step=0; time_step<num_timesteps; time_step++)
{
for (unsigned var_index = 0; var_index < rVariableNames.size(); var_index++)
{
std::string var_name = rVariableNames[var_index];
// read
reader.GetVariableOverNodes(voltage, var_name, time_step);
ReplicatableVector voltage_repl(voltage);
// interpolate
for(unsigned i=0; i<mesh_pair.rGetElementsAndWeights().size(); i++)
{
double interpolated_voltage = 0;
Element<DIM,DIM>& element = *(rElectricsMesh.GetElement(mesh_pair.rGetElementsAndWeights()[i].ElementNum));
for(unsigned node_index = 0; node_index<element.GetNumNodes(); node_index++)
{
unsigned global_node_index = element.GetNodeGlobalIndex(node_index);
interpolated_voltage += voltage_repl[global_node_index]*mesh_pair.rGetElementsAndWeights()[i].Weights(node_index);
}
interpolated_voltages[i] = interpolated_voltage;
}
if(voltage_coarse!=NULL)
{
PetscTools::Destroy(voltage_coarse);
}
voltage_coarse = PetscTools::CreateVec(interpolated_voltages);
// write
p_writer->PutVector(columns_id[var_index], voltage_coarse);
}
p_writer->PutUnlimitedVariable(time_step);
p_writer->AdvanceAlongUnlimitedDimension();
}
if(voltage_coarse!=NULL)
{
PetscTools::Destroy(voltage);
PetscTools::Destroy(voltage_coarse);
}
// delete to flush
delete p_writer;
// Convert the new data to CMGUI format.
// alter the directory in HeartConfig as that is where Hdf5ToCmguiConverter decides
// where to output
std::string config_directory = HeartConfig::Instance()->GetOutputDirectory();
HeartConfig::Instance()->SetOutputDirectory(directory);
Hdf5ToCmguiConverter<DIM,DIM> converter(FileFinder(directory, RelativeTo::ChasteTestOutput),
"voltage_mechanics_mesh",
&rMechanicsMesh,
false);
HeartConfig::Instance()->SetOutputDirectory(config_directory);
}
