Cosmos::Physics::Structure Class Reference

#include <physicsclass.h>

Collaboration diagram for Cosmos::Physics::Structure:

Public Types
enum	Type {   U1, U1X, U1Y, U1XY,   U1_5, U1_5X, U1_5Y, U1_5XY,   U2, U2X, U2Y, U2XY,   U3, U3X, U3Y, U3XY,   U6, U6X, U6Y, U6XY,   U12, U12X, U12Y, U12XY }
enum	ExternalPanelType { None = 0, X, Y, XY }

Public Member Functions
	Structure (physicsstruc *physp)
int32_t	Setup (Type type)
int32_t	add_u (double x, double y, double z, ExternalPanelType type)
int32_t	add_cuboid (string name, Vector size, double depth, Quaternion orientation, Vector offset)
int32_t	add_face (string name, Vector point0, Vector point1, Vector point2, Vector point3, double depth, uint8_t external=1, float pcell=.85, Quaternion orientation=Math::Quaternions::eye(), Vector offset=Vector())
int32_t	add_face (string name, Vector size, Quaternion orientation, Vector offset)
int32_t	add_triangle (Vector pointa, Vector pointb, Vector pointc, double depth, bool external=true, float pcell=.85)
int32_t	add_vertex (Vector point)

Public Attributes
physicsstruc *	newphys

Private Attributes
Type	type

Member Enumeration Documentation

enum Cosmos::Physics::Structure::Type

Enumerator
U1
U1X
U1Y
U1XY
U1_5
U1_5X
U1_5Y
U1_5XY
U2
U2X
U2Y
U2XY
U3
U3X
U3Y
U3XY
U6
U6X
U6Y
U6XY
U12
U12X
U12Y
U12XY

                {
                U1,
                U1X,
                U1Y,
                U1XY,
                U1_5,
                U1_5X,
                U1_5Y,
                U1_5XY,
                U2,
                U2X,
                U2Y,
                U2XY,
                U3,
                U3X,
                U3Y,
                U3XY,
                U6,
                U6X,
                U6Y,
                U6XY,
                U12,
                U12X,
                U12Y,
                U12XY
                };

enum Cosmos::Physics::Structure::ExternalPanelType

Enumerator
None
X
Y
XY

                {
                None = 0,
                X,
                Y,
                XY
                };

Constructor & Destructor Documentation

Cosmos::Physics::Structure::Structure ( physicsstruc *  physp )

inline

                                           : newphys{physp}
            {

            }

Member Function Documentation

int32_t Cosmos::Physics::Structure::Setup

(

Type

type

)

        {
            int32_t iretn;

            switch (type)
            {
            case U1:
                iretn = add_u(1, 1, 1, None);
                break;
            case U1X:
                iretn = add_u(1, 1, 1, X);
                break;
            case U1Y:
                iretn = add_u(1, 1, 1, Y);
                break;
            case U1XY:
                iretn = add_u(1, 1, 1, XY);
                break;
            case U1_5:
                iretn = add_u(1, 1, 1.5, None);
                break;
            case U1_5X:
                iretn = add_u(1, 1, 1.5, X);
                break;
            case U1_5Y:
                iretn = add_u(1, 1, 1.5, Y);
                break;
            case U1_5XY:
                iretn = add_u(1, 1, 1.5, XY);
                break;
            case U3:
                iretn = add_u(1, 1, 3, None);
                break;
            case U3X:
                iretn = add_u(1, 1, 3, X);
                break;
            case U3Y:
                iretn = add_u(1, 1, 3, Y);
                break;
            case U3XY:
                iretn = add_u(1, 1, 3, XY);
                break;
            case U6:
                iretn = add_u(1, 2, 3, None);
                break;
            case U6X:
                iretn = add_u(1, 2, 3, X);
                break;
            case U6Y:
                iretn = add_u(1, 2, 3, Y);
                break;
            case U6XY:
                iretn = add_u(1, 2, 3, XY);
                break;
            case U12:
                iretn = add_u(2, 2, 3, None);
                break;
            case U12X:
                iretn = add_u(2, 2, 3, X);
                break;
            case U12Y:
                iretn = add_u(2, 2, 3, Y);
                break;
            case U12XY:
                iretn = add_u(2, 2, 3, XY);
                break;
            default:
                iretn =  GENERAL_ERROR_OUTOFRANGE;
            }

            if (iretn < 0)
            {
                return iretn;
            }

            // Calculate physical quantities
            iretn = PhysSetup(newphys);
            if (iretn < 0)
            {
                return iretn;
            }

            return 0;
        }

int32_t Cosmos::Physics::Structure::add_u	(	double	x,
		double	y,
		double	z,
		ExternalPanelType	type
	)

        {
            switch (type)
            {
            case None:
                add_face("external+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(x/2., -y/2., z/2.), .004);
                add_face("external-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., y/2., z/2.), .004);
                add_face("external-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external+z", Vector(-x/2., -y/2., z/2.), Vector(x/2., -y/2., z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external-z", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(-x/2., -y/2., -z/2.), .004);
                break;
            case X:
                add_face("external+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("external-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("panel+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(z + x/2., y/2., -z/2.), Vector(z + x/2., -y/2., -z/2.), .004, false);
                add_face("panel-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-z - x/2., y/2., -z/2.), Vector(-z - x/2., -y/2., -z/2.), .004, false);

                add_face("external+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., y/2., z/2.), .004);
                add_face("external-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);

                add_face("external+z", Vector(-x/2., -y/2., z/2.), Vector(x/2., -y/2., z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external-z", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(-x/2., -y/2., -z/2.), .004);
                break;
            case Y:
                add_face("external+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(x/2., -y/2., z/2.), .004);
                add_face("external-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);

                add_face("external+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., y/2., z/2.), .004, 2, 0.);
                add_face("external-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("panel+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., z + y/2., -z/2.), Vector(-x/2., z + y/2., -z/2.), .004, false);
                add_face("panel-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., -z - y/2., -z/2.), Vector(-x/2., -z - y/2., -z/2.), .004, false);

                add_face("external+z", Vector(-x/2., -y/2., z/2.), Vector(x/2., -y/2., z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external-z", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(-x/2., -y/2., -z/2.), .004);
                break;
            case XY:
                add_face("external+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("external-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("panel+x", Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(z + x/2., y/2., -z/2.), Vector(z + x/2., -y/2., -z/2.), .004, false);
                add_face("panel-x", Vector(-x/2., -y/2., -z/2.), Vector(-x/2., y/2., -z/2.), Vector(-z - x/2., y/2., -z/2.), Vector(-z - x/2., -y/2., -z/2.), .004, false);

                add_face("external+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., y/2., z/2.), .004, 2, 0.);
                add_face("external-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004, 2, 0.);
                add_face("panel+y", Vector(-x/2., y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(x/2., z + y/2., -z/2.), Vector(-x/2., z + y/2., -z/2.), .004, false);
                add_face("panel-y", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., -z - y/2., -z/2.), Vector(-x/2., -z - y/2., -z/2.), .004, false);

                add_face("external+z", Vector(-x/2., -y/2., z/2.), Vector(x/2., -y/2., z/2.), Vector(x/2., y/2., z/2.), Vector(-x/2., -y/2., z/2.), .004);
                add_face("external-z", Vector(-x/2., -y/2., -z/2.), Vector(x/2., -y/2., -z/2.), Vector(x/2., y/2., -z/2.), Vector(-x/2., -y/2., -z/2.), .004);
                break;
            }

            return 0;
        }

int32_t Cosmos::Physics::Structure::add_cuboid	(	string	name,
		Vector	size,
		double	depth,
		Quaternion	orientation,
		Vector	offset
	)

        {
            add_face(name+"+x", Vector(size.x/2., -size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., size.z/2.), Vector(size.x/2., -size.y/2., size.z/2.), depth, 1, 0., orientation, offset);
            add_face(name+"-x", Vector(-size.x/2., -size.y/2., -size.z/2.), Vector(-size.x/2., size.y/2., -size.z/2.), Vector(-size.x/2., size.y/2., size.z/2.), Vector(-size.x/2., -size.y/2., size.z/2.), depth, 1, 0., orientation, offset);
            add_face(name+"+y", Vector(-size.x/2., size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., size.z/2.), Vector(-size.x/2., size.y/2., size.z/2.), depth, 1, 0., orientation, offset);
            add_face(name+"-y", Vector(-size.x/2., -size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., size.z/2.), Vector(-size.x/2., -size.y/2., size.z/2.), depth, 1, 0., orientation, offset);
            add_face(name+"+z", Vector(-size.x/2., -size.y/2., size.z/2.), Vector(size.x/2., -size.y/2., size.z/2.), Vector(size.x/2., size.y/2., size.z/2.), Vector(-size.x/2., -size.y/2., size.z/2.), depth, 1, 0., orientation, offset);
            add_face(name+"-z", Vector(-size.x/2., -size.y/2., -size.z/2.), Vector(size.x/2., -size.y/2., -size.z/2.), Vector(size.x/2., size.y/2., -size.z/2.), Vector(-size.x/2., -size.y/2., -size.z/2.), depth, 1, 0., orientation, offset);

            return 0;
        }

int32_t Cosmos::Physics::Structure::add_face	(	string	name,
		Vector	point0,
		Vector	point1,
		Vector	point2,
		Vector	point3,
		double	depth,
		uint8_t	external = 1,
		float	pcell = .85,
		Quaternion	orientation = Math::Quaternions::eye(),
		Vector	offset = Vector()
	)

        {
            point0 = orientation.irotate(point0);
            point0 += offset;
            point1 = orientation.irotate(point1);
            point1 += offset;
            point2 = orientation.irotate(point2);
            point2 += offset;
            point3 = orientation.irotate(point3);
            point3 += offset;
            Vector point4 = (point0 + point1 + point2 + point3) / 4.;

            add_triangle(point0, point1, point4, depth, external, pcell);
            add_triangle(point1, point2, point4, depth, external, pcell);
            add_triangle(point2, point3, point4, depth, external, pcell);
            add_triangle(point3, point0, point4, depth, external, pcell);

            return 0;
        }

int32_t Cosmos::Physics::Structure::add_face	(	string	name,
		Vector	size,
		Quaternion	orientation,
		Vector	offset
	)

        {
            Vector points[5];

            points[0].x = -size.x / 2.;
            points[2].x = -size.x / 2.;
            points[1].x = size.x / 2.;
            points[3].x = size.x / 2.;

            points[0].y = -size.y / 2.;
            points[1].y = -size.y / 2.;
            points[2].y = size.y / 2.;
            points[3].y = size.y / 2.;

            for (uint16_t i=0; i<5; ++i)
            {
                points[i] = orientation.irotate(points[i]);
                points[i] += offset;
            }

            add_triangle(points[0], points[1], points[4], size.z);
            add_triangle(points[1], points[1], points[4], size.z);
            add_triangle(points[2], points[3], points[4], size.z);
            add_triangle(points[3], points[0], points[4], size.z);

            return 4;
        }

int32_t Cosmos::Physics::Structure::add_triangle	(	Vector	pointa,
		Vector	pointb,
		Vector	pointc,
		double	depth,
		bool	external = true,
		float	pcell = .85
	)

        {
            trianglestruc triangle;

            triangle.tidx[0] = add_vertex(pointa);
            triangle.tidx[1] = add_vertex(pointb);
            triangle.tidx[2] = add_vertex(pointc);

            triangle.external = external;
            triangle.depth = depth;
            triangle.pcell = pcell;
            triangle.normal = (newphys->vertices[triangle.tidx[1]] - newphys->vertices[triangle.tidx[0]]).cross(newphys->vertices[triangle.tidx[2]] - newphys->vertices[triangle.tidx[0]]);
            triangle.com = (newphys->vertices[triangle.tidx[0]] + newphys->vertices[triangle.tidx[1]] + newphys->vertices[triangle.tidx[2]]) / 3.;
            triangle.area = (newphys->vertices[triangle.tidx[1]] - newphys->vertices[triangle.tidx[0]]).area(newphys->vertices[triangle.tidx[2]] - newphys->vertices[triangle.tidx[0]]);
            triangle.perimeter = (newphys->vertices[triangle.tidx[1]] - newphys->vertices[triangle.tidx[0]]).norm() + (newphys->vertices[triangle.tidx[2]] - newphys->vertices[triangle.tidx[1]]).norm() + (newphys->vertices[triangle.tidx[0]] - newphys->vertices[triangle.tidx[2]]).norm();
            newphys->triangles.push_back(triangle);

            return 1;
        }

int32_t Cosmos::Physics::Structure::add_vertex

(

Vector

point

)

        {
            bool found = false;

            int32_t index = -1;
            for (uint16_t i=0; i<newphys->vertices.size(); ++ i)
            {
                if ((point - newphys->vertices[i]).norm() < .001)
                {
                    found = true;
                    index = i;
                    break;
                }
            }

            if (found)
            {
                return index;
            }
            else {
                newphys->vertices.push_back(point);
                return newphys->vertices.size() - 1;
            }
        }

Member Data Documentation

physicsstruc* Cosmos::Physics::Structure::newphys

Type Cosmos::Physics::Structure::type

private

---

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

• physicsclass.h
• physicsclass.cpp