Polyhedron Class Reference

A polyhedron, implementation class for use in IFormFactorPolyhedron. More...

Public Member Functions
	Polyhedron ()=delete
	Polyhedron (const PolyhedralTopology &topology, double z_bottom, const std::vector< kvector_t > &vertices)
	Polyhedron (const Polyhedron &)=delete
	~Polyhedron ()
void	assert_platonic () const
complex_t	evaluate_centered (const cvector_t &q) const
	Returns the form factor F(q) of this polyhedron, with origin at z=0. More...
complex_t	evaluate_for_q (const cvector_t &q) const
	needed for topZ, bottomZ computation More...
double	radius () const
const std::vector< kvector_t > &	vertices ()
double	volume () const

Private Attributes
std::vector< PolyhedralFace >	m_faces
double	m_radius
bool	m_sym_Ci
	if true, then faces obtainable by inversion are not provided More...
std::vector< kvector_t >	m_vertices
double	m_volume
double	m_z_bottom

Detailed Description

A polyhedron, implementation class for use in IFormFactorPolyhedron.

Definition at line 30 of file Polyhedron.h.

Constructor & Destructor Documentation

Polyhedron() [1/3]

Polyhedron::Polyhedron ( )

delete

Polyhedron() [2/3]

Polyhedron::Polyhedron ( const Polyhedron &  )

delete

Polyhedron() [3/3]

Polyhedron::Polyhedron	(	const PolyhedralTopology &	topology,
		double	z_bottom,
		const std::vector< kvector_t > &	vertices
	)

Definition at line 33 of file Polyhedron.cpp.

{
 
    m_vertices.clear();
    for (const kvector_t& vertex : vertices)
        m_vertices.push_back(vertex - kvector_t{0, 0, z_bottom});
 
    try {
        m_z_bottom = z_bottom;
        m_sym_Ci = topology.symmetry_Ci;
 
        double diameter = 0;
        for (size_t j = 0; j < vertices.size(); ++j)
            for (size_t jj = j + 1; jj < vertices.size(); ++jj)
                diameter = std::max(diameter, (vertices[j] - vertices[jj]).mag());
 
        m_faces.clear();
        for (const PolygonalTopology& tf : topology.faces) {
            std::vector<kvector_t> corners; // of one face
            for (int i : tf.vertexIndices)
                corners.push_back(vertices[i]);
            if (PolyhedralFace::diameter(corners) <= 1e-14 * diameter)
                continue; // skip ridiculously small face
            m_faces.push_back(PolyhedralFace(corners, tf.symmetry_S2));
        }
        if (m_faces.size() < 4)
            throw std::logic_error("Less than four non-vanishing faces");
 
        m_radius = 0;
        m_volume = 0;
        for (const PolyhedralFace& Gk : m_faces) {
            m_radius = std::max(m_radius, Gk.radius3d());
            m_volume += Gk.pyramidalVolume();
        }
        if (m_sym_Ci) {
            if (m_faces.size() & 1)
                throw std::logic_error("Odd #faces violates symmetry Ci");
            size_t N = m_faces.size() / 2;
            // for this tests, m_faces must be in a specific order
            for (size_t k = 0; k < N; ++k)
                m_faces[k].assert_Ci(m_faces[2 * N - 1 - k]);
            // keep only half of the faces
            m_faces.erase(m_faces.begin() + N, m_faces.end());
        }
    } catch (std::invalid_argument& e) {
        throw std::invalid_argument(std::string("Invalid parameterization of Polyhedron: ")
                                    + e.what());
    } catch (std::logic_error& e) {
        throw std::logic_error(std::string("Bug in Polyhedron: ") + e.what()
                               + " [please report to the maintainers]");
    } catch (std::exception& e) {
        throw std::runtime_error(std::string("Unexpected exception in Polyhedron: ") + e.what()
                                 + " [please report to the maintainers]");
    }
}

References PolyhedralFace::diameter(), PolyhedralTopology::faces, m_faces, m_radius, m_sym_Ci, m_vertices, m_volume, m_z_bottom, PolyhedralTopology::symmetry_Ci, PolygonalTopology::symmetry_S2, PolygonalTopology::vertexIndices, and vertices().

Here is the call graph for this function:

~Polyhedron()

Polyhedron::~Polyhedron ( )

default

Member Function Documentation

assert_platonic()

void Polyhedron::assert_platonic

(

)

const

Definition at line 92 of file Polyhedron.cpp.

{
    // just one test; one could do much more ...
    double pyramidal_volume = 0;
    for (const auto& Gk : m_faces)
        pyramidal_volume += Gk.pyramidalVolume();
    pyramidal_volume /= m_faces.size();
    for (const auto& Gk : m_faces)
        if (std::abs(Gk.pyramidalVolume() - pyramidal_volume) > 160 * eps * pyramidal_volume) {
            std::cerr << std::setprecision(16)
                      << "Bug: pyr_volume(this face)=" << Gk.pyramidalVolume()
                      << " vs pyr_volume(avge)=" << pyramidal_volume << "\n";
            throw std::runtime_error("Deviant pyramidal volume in Platonic Polyhedron");
        }
}

References m_faces.

evaluate_centered()

complex_t Polyhedron::evaluate_centered

(

const cvector_t &

q

)

const

Returns the form factor F(q) of this polyhedron, with origin at z=0.

Definition at line 142 of file Polyhedron.cpp.

{
    double q_red = m_radius * q.mag();
#ifdef ALGORITHM_DIAGNOSTIC
    polyhedralDiagnosis.reset();
#endif
    if (q_red == 0) {
        return m_volume;
    } else if (q_red < q_limit_series) {
        // summation of power series
#ifdef ALGORITHM_DIAGNOSTIC
        polyhedralDiagnosis.algo = 100;
#endif
        complex_t sum = 0;
        complex_t n_fac = (m_sym_Ci ? -2 : -1) / q.mag2();
        int count_return_condition = 0;
        for (int n = 2; n < n_limit_series; ++n) {
            if (m_sym_Ci && n & 1)
                continue;
#ifdef ALGORITHM_DIAGNOSTIC
            polyhedralDiagnosis.order = std::max(polyhedralDiagnosis.order, n);
#endif
            complex_t term = 0;
            for (const PolyhedralFace& Gk : m_faces) {
                complex_t tmp = Gk.ff_n(n + 1, q);
                term += tmp;
            }
            term *= n_fac;
#ifdef ALGORITHM_DIAGNOSTIC_LEVEL2
            polyhedralDiagnosis.msg +=
                boost::str(boost::format("  + term(n=%2i) = %23.17e+i*%23.17e\n") % n % term.real()
                           % term.imag());
#endif
            sum += term;
            if (std::abs(term) <= eps * std::abs(sum) || std::abs(sum) < eps * m_volume)
                ++count_return_condition;
            else
                count_return_condition = 0;
            if (count_return_condition > 2)
                return m_volume + sum; // regular exit
            n_fac = m_sym_Ci ? -n_fac : mul_I(n_fac);
        }
        throw std::runtime_error("Series F(q) not converged");
    } else {
        // direct evaluation of analytic formula (coefficients may involve series)
#ifdef ALGORITHM_DIAGNOSTIC
        polyhedralDiagnosis.algo = 200;
#endif
        complex_t sum = 0;
        for (const PolyhedralFace& Gk : m_faces) {
            complex_t qn = Gk.normalProjectionConj(q); // conj(q)*normal
            if (std::abs(qn) < eps * q.mag())
                continue;
            complex_t term = qn * Gk.ff(q, m_sym_Ci);
#ifdef ALGORITHM_DIAGNOSTIC //_LEVEL2
            polyhedralDiagnosis.msg += boost::str(boost::format("  + face_ff = %23.17e+i*%23.17e\n")
                                                  % term.real() % term.imag());
#endif
            sum += term;
        }
#ifdef ALGORITHM_DIAGNOSTIC //_LEVEL2
        polyhedralDiagnosis.msg +=
            boost::str(boost::format(" -> raw sum = %23.17e+i*%23.17e; divisor = %23.17e\n")
                       % sum.real() % sum.imag() % q.mag2());
#endif
        return sum / I / q.mag2();
    }
}

References I, m_faces, m_radius, m_sym_Ci, m_volume, BasicVector3D< T >::mag(), BasicVector3D< T >::mag2(), and mul_I().

Referenced by evaluate_for_q().

Here is the call graph for this function:

evaluate_for_q()

complex_t Polyhedron::evaluate_for_q

(

const cvector_t &

q

)

const

needed for topZ, bottomZ computation

Returns the form factor F(q) of this polyhedron, respecting the offset z_bottom.

Definition at line 124 of file Polyhedron.cpp.

{
    try {
        return exp_I(-m_z_bottom * q.z()) * evaluate_centered(q);
    } catch (std::logic_error& e) {
        throw std::logic_error(std::string("Bug in Polyhedron: ") + e.what()
                               + " [please report to the maintainers]");
    } catch (std::runtime_error& e) {
        throw std::runtime_error(std::string("Numeric computation failed in Polyhedron: ")
                                 + e.what() + " [please report to the maintainers]");
    } catch (std::exception& e) {
        throw std::runtime_error(std::string("Unexpected exception in Polyhedron: ") + e.what()
                                 + " [please report to the maintainers]");
    }
}

References evaluate_centered(), exp_I(), m_z_bottom, and BasicVector3D< T >::z().

Here is the call graph for this function:

radius()

double Polyhedron::radius

(

)

const

Definition at line 112 of file Polyhedron.cpp.

{
    return m_radius;
}

References m_radius.

vertices()

const std::vector< kvector_t > & Polyhedron::vertices

(

)

Definition at line 117 of file Polyhedron.cpp.

{
    return m_vertices;
}

References m_vertices.

Referenced by Polyhedron().

volume()

double Polyhedron::volume

(

)

const

Definition at line 108 of file Polyhedron.cpp.

{
    return m_volume;
}

References m_volume.

Member Data Documentation

m_faces

std::vector<PolyhedralFace> Polyhedron::m_faces

private

Definition at line 48 of file Polyhedron.h.

Referenced by Polyhedron(), assert_platonic(), and evaluate_centered().

m_radius

double Polyhedron::m_radius

private

Definition at line 49 of file Polyhedron.h.

Referenced by Polyhedron(), evaluate_centered(), and radius().

m_sym_Ci

bool Polyhedron::m_sym_Ci

private

if true, then faces obtainable by inversion are not provided

Definition at line 46 of file Polyhedron.h.

Referenced by Polyhedron(), and evaluate_centered().

m_vertices

std::vector<kvector_t> Polyhedron::m_vertices

private

Definition at line 51 of file Polyhedron.h.

Referenced by Polyhedron(), and vertices().

m_volume

double Polyhedron::m_volume

private

Definition at line 50 of file Polyhedron.h.

Referenced by Polyhedron(), evaluate_centered(), and volume().

m_z_bottom

double Polyhedron::m_z_bottom

private

Definition at line 45 of file Polyhedron.h.

Referenced by Polyhedron(), and evaluate_for_q().

---

The documentation for this class was generated from the following files:

• /home/www/ba/Sample/HardParticle/Polyhedron.h
• /home/www/ba/Sample/HardParticle/Polyhedron.cpp