a_block.h

Go to the documentation of this file.

/*
Copyright 2010-2016 Pierre SMARS (smars@yuntech.edu.tw)
This program is free software: you can redistribute it and/or modify
it under he terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _A_BLOCK_H_
#define _A_BLOCK_H_
 
#include <iostream> 
#include <vector> 
#include "a_wrench.h"
#include "a_twist.h"
#include "a_face.h"
#include "a_material.h"
#include "a_trianglecloud.h"
 
class a_block
{
public:
        a_block();
        virtual ~a_block();
        void clear();
        static const std::string help();
        virtual void copy(const a_block&);
        virtual void deepcopy(const a_block&);
        void g(a_point* g) {g_ = g;}
        a_point * g() const {return g_;}
        virtual double V() const = 0;
        a_point c() const; 
        virtual a_point cl() const = 0; 
        virtual std::string name() const {return "a_block";}
        double m() const;
        double Ws() const; 
        a_wrench W() const; 
        a_wrench fe() const; 
        a_wrench ft() const; 
        a_wrench W(const a_block& be) const;
        a_wrench ft(const a_block& be) const;
        a_block * nextblock() const;
        double potential() const;
        void clearinternal();
        void clearexternal();
        void clearall();
        a_block * compute();
        void material(a_material * material);
        a_material * material() const {return material_;}
        inline int nv() const {return vertices_.size();}
        virtual int nvt() const = 0;
        inline int ni() const {return faces_.size();}
        virtual int nit() const = 0;
        void av(a_point * vertex) {vertices_.push_back(vertex);}
        void ai(a_face * face) {faces_.push_back(face);}
        a_point * v(const int i);
        a_point * v(const int i) const;
        virtual a_point v3d(const int i) const = 0;
        a_face * i(const int i);
        a_face * i(const int i) const;
        a_twist * pos() const {return pos_;}
        void place(const int fi, a_block * block, const int fe, double u, double v);
        std::vector<int> in() const;
        std::vector<int> out() const;
        void exit(int ref);
        int exit() const {return exit_face_;}
        int entrance(int ref);
        void criteria(a_fcriteria * criteria);
        bool ok() const;
        double penalty() const;
        virtual void read(std::istream &i);
        virtual void write(std::ostream &o) const;
        virtual void writetri(std::ostream &o) const = 0;
        virtual void writeb(std::ostream &o) const = 0;
        virtual void writeg(std::ostream &o) const = 0;
        void writeverts(std::ostream &o) const;
        virtual void writefaces(std::ostream &o, const int base = 0) const = 0;
        virtual void trianglecloud(a_trianglecloud&) const = 0;
        friend std::istream&  operator>> (std::istream& i, a_block& b);
        friend std::ostream&  operator<< (std::ostream& o, const a_block& b);
 
        class compatibility_error {};
        class no_block_error {};
 
protected:
        std::vector<a_point *> vertices_;
        std::vector<a_face *> faces_;
        a_material * material_;
        bool material_auto_;
        int exit_face_;
        a_twist * pos_;
        a_point * g_;
};
 
#endif