ComputeIntersections.h File Reference

#include <vtkType.h>
#include <vtkUnstructuredGrid.h>
#include <Eigen/Core>
#include <range/v3/view/enumerate.hpp>
#include <vector>
#include "ComputeNaturalCoordsResult.h"

Include dependency graph for ComputeIntersections.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	IntersectionResult
	Result of an intersection of a line with a cell. More...

Functions
std::vector< std::vector< IntersectionResult > >	getOrderedAnchorCoords (vtkUnstructuredGrid *grid, Eigen::MatrixX3d const &realcoords, Eigen::VectorXd const &free_fraction, double const tol)
	Finds intersection points of a line segment with the cells of a vtkUnstructuredGrid. The line segment is defined by consecutive entries in realcoords.
AU::ComputeNaturalCoordsResult	setPhysicalPropertiesForIntersectionPoints (std::vector< std::vector< IntersectionResult > > const &anchor_coords, AU::ComputeNaturalCoordsResult const &original_anchor_data)
	fills the physical properties of the intersection points based on the original anchor data.

Function Documentation

getOrderedAnchorCoords()

std::vector< std::vector< IntersectionResult > > getOrderedAnchorCoords	(	vtkUnstructuredGrid *	grid,
		Eigen::MatrixX3d const &	realcoords,
		Eigen::VectorXd const &	free_fraction,
		double const	tol )

Finds intersection points of a line segment with the cells of a vtkUnstructuredGrid. The line segment is defined by consecutive entries in realcoords.

Parameters

grid	The vtkUnstructuredGrid to intersect with.
realcoords	original coordinates of the anchor start and end points.
free_fraction	The fraction of the line segment to consider for intersections.
tol	Tolerance for considering points as identical.

Returns

a vector of vectors containing the intersection results which need to be converted using setPhysicalPropertiesForIntersectionPoints() to fill in physical properties and to obtain the final anchor format

Definition at line 130 of file ComputeIntersections.cpp.

{
    std::vector<std::vector<IntersectionResult>> ordered_intersections(
        realcoords.rows() / 2);
    assert(realcoords.rows() % 2 == 0);
    assert(free_fraction.size() == realcoords.rows() / 2);
    for (int i = 0; i < realcoords.rows(); i += 2)
    {
        ordered_intersections[i / 2] = findOrderedIntersections(
            grid, realcoords.row(i), realcoords.row(i + 1),
            free_fraction(i / 2), tol);
    }
    return ordered_intersections;
}

References findOrderedIntersections().

Referenced by main().

setPhysicalPropertiesForIntersectionPoints()

AU::ComputeNaturalCoordsResult setPhysicalPropertiesForIntersectionPoints	(	std::vector< std::vector< IntersectionResult > > const &	anchor_coords,
		AU::ComputeNaturalCoordsResult const &	original_anchor_data )

fills the physical properties of the intersection points based on the original anchor data.

Parameters

anchor_coords	The intersection points of the anchors with the bulk mesh.
original_anchor_data	The original anchor data read from the JSON file.

Returns

struct containing the anchor data which will be stored in the unstructured grid

Definition at line 149 of file ComputeIntersections.cpp.

{
    std::vector<IntersectionResult> all_intersections;
    std::vector<int> anchorids;
    for (auto&& [anchor_id, intersections] :
         ranges::views::enumerate(anchor_coords))
    {
        for (auto&& [index, result] : ranges::views::enumerate(intersections))
        {
            if (index > 0 && index < intersections.size() - 1)
            {
                anchorids.push_back(anchor_id);
                all_intersections.push_back(result);
            }
            anchorids.push_back(anchor_id);
            all_intersections.push_back(result);
        }
    }
    assert(all_intersections.size() == anchorids.size());
    assert(all_intersections.size() % 2 == 0);
    Eigen::MatrixXd realcoords(anchorids.size(), 3);
    auto const number_of_anchors = anchorids.size() / 2;
    Eigen::VectorXd initial_stress(number_of_anchors);
    Eigen::VectorXd maximum_stress(number_of_anchors);
    Eigen::VectorXd residual_stress(number_of_anchors);
    Eigen::VectorXd cross_sectional_area(number_of_anchors);
    Eigen::VectorXd stiffness(number_of_anchors);
    for (std::size_t i = 0; i < all_intersections.size(); ++i)
    {
        realcoords.row(i).noalias() = all_intersections[i].point;
        if (i % 2 == 0)
        {
            initial_stress(i / 2) =
                original_anchor_data.initial_anchor_stress(anchorids[i]);
            maximum_stress(i / 2) =
                original_anchor_data.maximum_anchor_stress(anchorids[i]);
            residual_stress(i / 2) =
                original_anchor_data.residual_anchor_stress(anchorids[i]);
            cross_sectional_area(i / 2) =
                original_anchor_data.anchor_cross_sectional_area(anchorids[i]);
            stiffness(i / 2) =
                original_anchor_data.anchor_stiffness(anchorids[i]);
        }
    }
    AU::ComputeNaturalCoordsResult anchor_data;
    anchor_data.real_coords = realcoords;
    anchor_data.initial_anchor_stress = initial_stress;
    anchor_data.maximum_anchor_stress = maximum_stress;
    anchor_data.residual_anchor_stress = residual_stress;
    anchor_data.anchor_cross_sectional_area = cross_sectional_area;
    anchor_data.anchor_stiffness = stiffness;
    return anchor_data;
}

References ApplicationUtils::ComputeNaturalCoordsResult::anchor_cross_sectional_area, ApplicationUtils::ComputeNaturalCoordsResult::anchor_stiffness, ApplicationUtils::ComputeNaturalCoordsResult::initial_anchor_stress, ApplicationUtils::ComputeNaturalCoordsResult::maximum_anchor_stress, ApplicationUtils::ComputeNaturalCoordsResult::real_coords, and ApplicationUtils::ComputeNaturalCoordsResult::residual_anchor_stress.

Referenced by main().