std::ostream& operator<<(std::ostream &o, const Sawyer::Container::Graph<V, E> &graph) {
typedef const typename Sawyer::Container::Graph<V, E> Graph;
typedef typename Graph::ConstVertexIterator VertexIterator;
typedef typename Graph::ConstEdgeIterator EdgeIterator;
typedef typename Graph::Vertex Vertex;
typedef typename Graph::Edge Edge;
o <<" vertices:\n";
for (size_t id=0; id<graph.nVertices(); ++id) {
VertexIterator vertex = graph.findVertex(id);
o <<" [" <<vertex->id() <<"] = " <<vertex->value() <<"\n";
BOOST_FOREACH (const Edge &edge, vertex->outEdges())
o <<" out edge #" <<edge.id() <<" to node #" <<edge.target()->id() <<" = " <<edge.value() <<"\n";
BOOST_FOREACH (const Edge &edge, vertex->inEdges())
o <<" in edge #" <<edge.id() <<" from node #" <<edge.source()->id() <<" = " <<edge.value() <<"\n";
}
o <<" edges:\n";
for (size_t id=0; id<graph.nEdges(); ++id) {
EdgeIterator edge = graph.findEdge(id);
o <<" [" <<edge->id() <<"] = " <<edge->value() <<"\n";
o <<" from vertex [" <<edge->source()->id() <<"] = " <<edge->source()->value() <<"\n";
o <<" to vertex [" <<edge->target()->id() <<"] = " <<edge->target()->value() <<"\n";
}
return o;
}
void GlobalFun::computeEigenWithTheta(CMesh* _samples, double radius)
{
vector<vector<int> > neighborMap;
typedef vector<CVertex>::iterator VertexIterator;
VertexIterator begin = _samples->vert.begin();
VertexIterator end = _samples->vert.end();
neighborMap.assign(end - begin, vector<int>());
int curr_index = 0;
for (VertexIterator iter=begin; iter!=end; iter++, curr_index++)
{
if(iter->neighbors.size() <= 3)
{
iter->eigen_confidence = 0.5;
continue;
}
for(int j = 0; j < iter->neighbors.size(); j++)
{
neighborMap[curr_index].push_back(iter->neighbors[j]);
}
}
double radius2 = radius*radius;
double iradius16 = -1/radius2;
int currIndex = 0;
for (VertexIterator iter=begin; iter!=end; iter++, currIndex++)
{
if(iter->neighbors.size() <= 3)
{
iter->eigen_confidence = 0.5;
continue;
}
Matrix33d covariance_matrix;
Point3f diff;
covariance_matrix.SetZero();
int neighborIndex = -1;
int neighbor_size = iter->neighbors.size();
for (unsigned int n=0; n<neighbor_size; n++)
{
neighborIndex = neighborMap[currIndex][n];
if(neighborIndex < 0)
break;
VertexIterator neighborIter = begin + neighborIndex;
diff = iter->P() - neighborIter->P();
Point3f vm = iter->N();
Point3f tm = neighborIter->N();
double dist2 = diff.SquaredNorm();
double theta = exp(dist2*iradius16);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
covariance_matrix[i][j] += diff[i]*diff[j] * theta;
}
Point3f eigenvalues;
Matrix33d eigenvectors;
int required_rotations;
vcg::Jacobi< Matrix33d, Point3f >(covariance_matrix, eigenvalues, eigenvectors, required_rotations);
vcg::SortEigenvaluesAndEigenvectors< Matrix33d, Point3f >(eigenvalues, eigenvectors);
double sum_eigen_value = (eigenvalues[0] + eigenvalues[1] + eigenvalues[2]);
iter->eigen_confidence = eigenvalues[0] / sum_eigen_value;
for (int d=0; d<3; d++)
iter->eigen_vector0[d] = eigenvectors[d][0];
for (int d=0; d<3; d++)
iter->eigen_vector1[d] = eigenvectors[d][1];
for (int d=0; d<3; d++)
iter->N()[d] = eigenvectors[d][2];
iter->eigen_vector0.Normalize();
iter->eigen_vector1.Normalize();
iter->N().Normalize();
}
}
void GlobalFun::computeEigenIgnoreBranchedPoints(CMesh* _samples)
{
vector<vector<int> > neighborMap;
typedef vector<CVertex>::iterator VertexIterator;
VertexIterator begin = _samples->vert.begin();
VertexIterator end = _samples->vert.end();
neighborMap.assign(end - begin, vector<int>());
int curr_index = 0;
for (VertexIterator iter=begin; iter!=end; ++iter, curr_index++)
{
if(iter->neighbors.size() <= 3)
{
iter->eigen_confidence = 0.5;
continue;
}
//neighborMap[curr_index].push_back(curr_index);
for(int j = 0; j < iter->neighbors.size(); j++)
{
CVertex& t = _samples->vert[iter->neighbors[j]];
if (t.is_skel_branch || t.is_skel_ignore)
{
continue;
}
neighborMap[curr_index].push_back(iter->neighbors[j]);
}
}
int currIndex = 0;
for (VertexIterator iter=begin; iter!=end; iter++, currIndex++)
{
int neighbor_size = neighborMap[currIndex].size();
if (neighbor_size < 3)
{
iter->eigen_confidence = 0.95;
iter->eigen_vector0 = Point3f(0, 0, 0);
continue;
}
Matrix33d covariance_matrix;
Point3f diff;
covariance_matrix.SetZero();
int neighborIndex = -1;
for (unsigned int n=0; n<neighbor_size; n++)
{
neighborIndex = neighborMap[currIndex][n];
if(neighborIndex < 0)
break;
VertexIterator neighborIter = begin + neighborIndex;
diff = iter->P() - neighborIter->P();
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
covariance_matrix[i][j] += diff[i]*diff[j];
}
Point3f eigenvalues;
Matrix33d eigenvectors;
int required_rotations;
vcg::Jacobi< Matrix33d, Point3f >(covariance_matrix, eigenvalues, eigenvectors, required_rotations);
vcg::SortEigenvaluesAndEigenvectors< Matrix33d, Point3f >(eigenvalues, eigenvectors);
double sum_eigen_value = (eigenvalues[0] + eigenvalues[1] + eigenvalues[2]);
iter->eigen_confidence = eigenvalues[0] / sum_eigen_value;
for (int d=0; d<3; d++)
iter->eigen_vector0[d] = eigenvectors[d][0];
for (int d=0; d<3; d++)
iter->eigen_vector1[d] = eigenvectors[d][1];
for (int d=0; d<3; d++)
iter->N()[d] = eigenvectors[d][2];
iter->eigen_vector0.Normalize();
iter->eigen_vector1.Normalize();
iter->N().Normalize();
}
}
ColoringMove MonteCarloSelection::selectMove() {
//synchro avec le vrai graphe
//recuperation du coup de l'adversaire
vertex v;
color c=-1;
bool found;
VertexIterator it = game.getGraph().getVertices();
while(it.hasNext()) {
if(game.getGraph().getVertexProperties(it.getCurrent()).getColor() !=
tree->getGame()->getGraph().getVertexProperties(it.getCurrent()).getColor()) {
v = it.getCurrent();
c = game.getGraph().getVertexProperties(v).getColor();
found = true;
break;
}
it.moveNext();
}
if(found) {
//synchro de l'arbre
std::vector<MonteCarloNode*> children = tree->getChildren();
for(std::vector<MonteCarloNode*>::iterator it=children.begin() ;
it != children.end() ; ++it) {
ColoringMove* move = (*it)->getMove();
if(move->getVertex()==v && move->getColor()==c) {
(*it)->playMove();
tree=(*it);
tree->deleteParent();
break;
}
}
}
//simulations
simulate(tree, nb_simu, minimize, UCB1);
//selection du coup
std::vector<MonteCarloNode*> children = tree->getChildren();
MonteCarloNode* best(children.at(0));
int nbWon = best->gamesWon;
for(std::vector<MonteCarloNode*>::iterator it=children.begin() ;
it != children.end() ; ++it) {
switch(minimize) {
case false:
if((*it)->gamesWon > nbWon) {
nbWon = (*it)->gamesWon;
best = (*it);
}
break;
case true:
if((*it)->gamesWon < nbWon) {
nbWon = (*it)->gamesWon;
best = (*it);
}
break;
}
}
best->playMove();
tree = best;
tree->deleteParent();
return *(tree->getMove());
}
void test(ReaderType & my_reader, std::string const & infile, std::string const & outfile)
{
typedef typename viennagrid::result_of::segmentation<MeshType>::type SegmentationType;
typedef typename viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef typename viennagrid::result_of::cell<MeshType>::type CellType;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::cell_range<MeshType>::type CellRange;
typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
MeshType mesh;
SegmentationType segmentation(mesh);
try
{
my_reader(mesh, segmentation, infile);
}
catch (std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
exit(EXIT_FAILURE);
}
std::vector<double> vtk_vertex_double_data;
std::vector<double> vtk_vertex_long_data;
std::vector< std::vector<double> > vtk_vertex_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_double_accessor( vtk_vertex_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_long_accessor( vtk_vertex_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, VertexType >::type vtk_vertex_vector_accessor( vtk_vertex_vector_data );
//write some dummy data:
VertexContainer vertices(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
vtk_vertex_double_accessor(*vit) = viennagrid::point(*vit)[0];
vtk_vertex_long_accessor(*vit) = vit->id().get();
vtk_vertex_vector_accessor(*vit).resize(3);
vtk_vertex_vector_accessor(*vit)[0] = viennagrid::point(*vit)[0];
vtk_vertex_vector_accessor(*vit)[1] = viennagrid::point(*vit)[1];
}
std::vector<double> vtk_cell_double_data;
std::vector<double> vtk_cell_long_data;
std::vector< std::vector<double> > vtk_cell_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_double_accessor( vtk_cell_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_long_accessor( vtk_cell_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, CellType >::type vtk_cell_vector_accessor( vtk_cell_vector_data );
int index = 0;
CellRange cells(mesh);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit, ++index)
{
vtk_cell_double_accessor(*cit) = viennagrid::centroid(*cit)[0];
vtk_cell_long_accessor(*cit) = cit->id().get();
vtk_cell_vector_accessor(*cit).resize(3);
vtk_cell_vector_accessor(*cit)[0] = viennagrid::centroid(*cit)[0];
vtk_cell_vector_accessor(*cit)[1] = viennagrid::centroid(*cit)[1];
}
//test writers:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_vertices(my_vtk_writer, vtk_vertex_vector_accessor, "data_point");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_vtk_writer, vtk_cell_vector_accessor, "data_point");
my_vtk_writer(mesh, segmentation, outfile);
viennagrid::io::opendx_writer<MeshType> my_dx_writer;
my_dx_writer(mesh, outfile + ".odx");
}
void test_vtk(ReaderType & my_reader, std::string const & infile, std::string const & outfile)
{
typedef typename viennagrid::result_of::segmentation<MeshType>::type SegmentationType;
typedef typename viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef typename viennagrid::result_of::cell<MeshType>::type CellType;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::cell_range<MeshType>::type CellRange;
typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
MeshType mesh;
SegmentationType segmentation(mesh);
std::vector<double> vtk_vertex_double_data;
std::vector<double> vtk_vertex_long_data;
std::vector< std::vector<double> > vtk_vertex_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_double_accessor( vtk_vertex_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_long_accessor( vtk_vertex_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, VertexType >::type vtk_vertex_vector_accessor( vtk_vertex_vector_data );
std::vector<double> vtk_cell_double_data;
std::vector<double> vtk_cell_long_data;
std::vector< std::vector<double> > vtk_cell_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_double_accessor( vtk_cell_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_long_accessor( vtk_cell_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, CellType >::type vtk_cell_vector_accessor( vtk_cell_vector_data );
viennagrid::io::add_scalar_data_on_vertices(my_reader, vtk_vertex_double_accessor, "data_double" );
viennagrid::io::add_scalar_data_on_vertices(my_reader, vtk_vertex_long_accessor, "data_long" );
viennagrid::io::add_vector_data_on_vertices(my_reader, vtk_vertex_vector_accessor, "data_point" );
viennagrid::io::add_scalar_data_on_cells(my_reader, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_reader, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_reader, vtk_cell_vector_accessor, "data_point");
try
{
my_reader(mesh, segmentation, infile);
}
catch (std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
exit(EXIT_FAILURE);
}
//write some dummy data:
VertexContainer vertices(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
double data_double = vtk_vertex_double_accessor(*vit);
long data_long = static_cast<long>(vtk_vertex_long_accessor(*vit));
std::vector<double> data_point = vtk_vertex_vector_accessor(*vit);
assert( fabs(data_double - viennagrid::point(*vit)[0]) < 1e-4 && "Vertex check failed: data_double!");
assert( (data_long == vit->id().get()) && "Vertex check failed: data_long!");
assert( fabs(data_point[0] - viennagrid::point(*vit)[0]) < 1e-4
&& fabs(data_point[1] - viennagrid::point(*vit)[1]) < 1e-4
&& "Vertex check failed: data_point!");
}
CellRange cells(mesh);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit)
{
double data_double = vtk_cell_double_accessor(*cit);
long data_long = static_cast<long>(vtk_cell_long_accessor(*cit));
std::vector<double> data_point = vtk_cell_vector_accessor(*cit);
assert( fabs(data_double - viennagrid::centroid(*cit)[0]) < 1e-4 && "Cell check failed: data_double!");
assert( (data_long == cit->id().get()) && "Cell check failed: data_long!");
assert( fabs(data_point[0] - viennagrid::centroid(*cit)[0]) < 1e-4
&& fabs(data_point[1] - viennagrid::centroid(*cit)[1]) < 1e-4
&& "Cell check failed: data_point!");
}
//test writers:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_vertices(my_vtk_writer, vtk_vertex_vector_accessor, "data_point");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_vtk_writer, vtk_cell_vector_accessor, "data_point");
my_vtk_writer(mesh, segmentation, outfile);
viennagrid::io::opendx_writer<MeshType> my_dx_writer;
my_dx_writer(mesh, outfile + ".odx");
}
void ArrayMeshTest::test_vertex_iterator_one_based()
{
MsqPrintError err(std::cerr);
VertexIterator* iter = oneBased3D->vertex_iterator( err );
CPPUNIT_ASSERT( !err );
std::auto_ptr<VertexIterator> deleter(iter);
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)1, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)2, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)3, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)4, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)5, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)6, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)7, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(!iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)8, (size_t)iter->operator*() );
iter->operator++();
CPPUNIT_ASSERT(iter->is_at_end());
CPPUNIT_ASSERT_EQUAL( (size_t)9, (size_t)iter->operator*() );
iter->restart();
CPPUNIT_ASSERT_EQUAL( (size_t)1, (size_t)iter->operator*() );
}
void assemble(MeshType & mesh,
MatrixType & system_matrix,
VectorType & load_vector)
{
typedef typename viennagrid::result_of::cell<MeshType>::type CellType;
typedef typename viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef typename viennagrid::result_of::line<MeshType>::type EdgeType;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::coboundary_range<MeshType, viennagrid::vertex_tag, viennagrid::line_tag>::type EdgeOnVertexContainer;
typedef typename viennagrid::result_of::iterator<EdgeOnVertexContainer>::type EdgeOnVertexIterator;
std::size_t current_dof = 0;
//
// Compute Voronoi info
//
typedef typename viennagrid::result_of::const_cell_handle<MeshType>::type ConstCellHandleType;
std::deque<double> interface_areas;
std::deque< typename viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > interface_contributions;
std::deque<double> vertex_box_volumes;
std::deque< typename viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > vertex_box_volume_contributions;
std::deque<double> edge_box_volumes;
std::deque< typename viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > edge_box_volume_contributions;
// Write Voronoi info to default ViennaData keys:
viennagrid::apply_voronoi<CellType>(
mesh,
viennagrid::make_accessor<EdgeType>(interface_areas),
viennagrid::make_accessor<EdgeType>(interface_contributions),
viennagrid::make_accessor<VertexType>(vertex_box_volumes),
viennagrid::make_accessor<VertexType>(vertex_box_volume_contributions),
viennagrid::make_accessor<EdgeType>(edge_box_volumes),
viennagrid::make_accessor<EdgeType>(edge_box_volume_contributions)
);
typename viennagrid::result_of::accessor< std::deque<double>, EdgeType >::type interface_area_accessor( interface_areas );
typename viennagrid::result_of::accessor< std::deque<double>, EdgeType >::type edge_box_volume_accessor( edge_box_volumes );
std::deque<long> dof_container;
typename viennagrid::result_of::accessor< std::deque<long>, VertexType >::type dof_accessor( dof_container );
//
// Iterate over all vertices in the mesh and enumerate degrees of freedom (aka. unknown indices)
//
VertexContainer vertices = viennagrid::elements<viennagrid::vertex_tag>(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
//boundary condition: Assuming homogeneous Dirichlet boundary conditions at x=0 and x=1
//if ( (vit->point()[0] == 0) || (vit->point()[0] == 1) )
if ( (viennagrid::point(mesh, *vit)[0] == 0) || (viennagrid::point(mesh, *vit)[0] == 1) )
dof_accessor(*vit) = -1;
else
{
dof_accessor(*vit) = current_dof;
++current_dof;
}
}
std::cout << "Assigned degrees of freedom: " << current_dof << std::endl;
//resize global system matrix and load vector to the number of unknowns:
system_matrix.resize(current_dof, current_dof);
load_vector.resize(current_dof);
//
// Poisson equation assembly: div( grad(psi) ) = 1
//
for (VertexIterator vhit = vertices.begin();
vhit != vertices.end();
++vhit)
{
VertexType & vertex = *vhit;
long row_index = dof_accessor(vertex);
//std::cout << vertex << " " << row_index << std::endl;
if (row_index < 0) //this is a Dirichlet boundary condition
continue;
//EdgeOnVertexContainer edges = viennagrid::ncells<1>(*vit, mesh);
EdgeOnVertexContainer edges = viennagrid::coboundary_elements<viennagrid::vertex_tag, viennagrid::line_tag>(mesh, vhit.handle());
for (EdgeOnVertexIterator eovit = edges.begin();
eovit != edges.end();
++eovit)
{
VertexType const * other_vertex_ptr = &(viennagrid::elements<viennagrid::vertex_tag>(*eovit)[0]);
if (other_vertex_ptr == &(vertex)) //one of the two vertices of the edge is different from *vit
other_vertex_ptr = &(viennagrid::elements<viennagrid::vertex_tag>(*eovit)[1]);
long col_index = dof_accessor(*other_vertex_ptr);
double edge_len = viennagrid::volume(*eovit);
double interface_area = interface_area_accessor(*eovit);
//std::cout << " " << *other_vertex_ptr << std::endl;
//std::cout << " " << col_index << " " << edge_len << " " << interface_area << std::endl;
if (col_index >= 0)
system_matrix(row_index, col_index) = - interface_area / edge_len;
system_matrix(row_index, row_index) += interface_area / edge_len;
//std::cout << " " << system_matrix(row_index, col_index) << " " << system_matrix(row_index, row_index) << std::endl;
//std::cout << std::endl;
//Note: volume stored on edges consists of volumes of both adjacent boxes.
load_vector[row_index] += edge_box_volume_accessor(*eovit) / 2.0;
} //for edges
} //for vertices
} //assemble()
