containers.h

Go to the documentation of this file.

// Copyright 2015. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Author: ryan.latture@gmail.com (Ryan Latture)

#ifndef FEA_CONTAINERS_H
#define FEA_CONTAINERS_H

#include <vector>
#include <Eigen/Core>

namespace fea {

    typedef Eigen::Vector3d Node;

    struct BC {
        unsigned int node;
        unsigned int dof;

        double value;
        BC() : node(0), dof(0), value(0) { };

        BC(unsigned int _node, unsigned int _dof, double _value) : node(_node), dof(_dof), value(_value) { };
    };

    struct Force {
        unsigned int node;
        unsigned int dof;

        double value;
        Force() : node(0), dof(0), value(0) { };

        Force(unsigned int _node, unsigned int _dof, double _value) : node(_node), dof(_dof), value(_value) { };
    };

    struct Props {
        double EA;
        double EIz;
        double EIy;
        double GJ;
        Eigen::Vector3d normal_vec;
        Props() : EA(0), EIz(0), EIy(0), GJ(0) { };
        Props(double _EA, double _EIz, double _EIy, double _GJ, const std::vector<double> &_normal_vec)
                : EA(_EA), EIz(_EIz), EIy(_EIy), GJ(_GJ) {
            normal_vec << _normal_vec[0], _normal_vec[1], _normal_vec[2];
        };
    };

    struct Tie {
        unsigned int node_number_1;
        unsigned int node_number_2;
        double lmult;
        double rmult; 
        Tie() : node_number_1(0), node_number_2(0), lmult(0), rmult(0) { };

        Tie(unsigned int _node_number_1, unsigned int _node_number_2, double _lmult, double _rmult) :
                node_number_1(_node_number_1), node_number_2(_node_number_2), lmult(_lmult), rmult(_rmult) { };
    };

    struct Equation {

      struct Term {
        unsigned int node_number;
        unsigned int dof;
        double coefficient;
        Term() : node_number(0), dof(0), coefficient(0) {};

        Term(unsigned int _node_number, unsigned int _dof, double _coefficient) :
            node_number(_node_number), dof(_dof), coefficient(_coefficient) {};
      };

      std::vector<Term> terms;
      Equation() : terms(0) {};

      Equation(const std::vector<Term> &_terms) : terms(_terms) {};
    };

    struct Elem {
        Eigen::Vector2i node_numbers;
        Props props;
        Elem() { };

        Elem(unsigned int node1, unsigned int node2, const Props &_props) : props(_props) {
            node_numbers << node1, node2;
        }
    };

    struct Job {
        std::vector<Node> nodes;
        std::vector<Eigen::Vector2i> elems;
        std::vector<Props> props;
        Job() : nodes(0), elems(0), props(0) { };

        Job(const std::vector<Node> &_nodes, const std::vector<Elem> _elems) : nodes(_nodes) {
            unsigned int num_elems = _elems.size();
            elems.reserve(num_elems);
            props.reserve(num_elems);

            for (unsigned int i = 0; i < num_elems; i++) {
                elems.push_back(_elems[i].node_numbers);
                props.push_back(_elems[i].props);
            }
        };
    };

    enum DOF {
        DISPLACEMENT_X,

        DISPLACEMENT_Y,

        DISPLACEMENT_Z,

        ROTATION_X,

        ROTATION_Y,

        ROTATION_Z,
        NUM_DOFS
    };

} // namespace fea

#endif // FEA_CONTAINERS_H