a_block_2d5.cxx

Go to the documentation of this file.

/*
Copyright 2016 Pierre SMARS (smars@yuntech.edu.tw)
This program is free software: you can redistribute it and/or modify
it under the 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/>.
*/
#include "a_block_2d5.h"
#include "a_face_2d4.h"
#include "a_triangle.h"
#define DE(x) std::cerr << #x << ": " << x << std::endl; 
//---------------------------------------------------------------------------
a_block_2d5 * cb_2d5(a_block * b) {return dynamic_cast<a_block_2d5*>(b); }
 
//---------------------------------------------------------------------------
void a_block_2d5::create_faces()
{
        //create the 5 faces
        int r0 = 0;
        for (int i=0; i<5; i++)
        {
                a_face_2d4 * f = new a_face_2d4(this,i);
                this->ai(f);
                f->av(r0++);
                f->av(r0%5);
        }
}
//---------------------------------------------------------------------------
a_block_2d5::a_block_2d5() : a_block()
{
        thickness_ = new double;
        *thickness_ = 1.;
        this->create_faces();
}
//---------------------------------------------------------------------------
a_block_2d5::~a_block_2d5()
{
        //faces and vertices are erased in parent
        delete thickness_;
}
//---------------------------------------------------------------------------
a_block_2d5::a_block_2d5(a_point* p1, a_point* p2, a_point* p3, a_point* p4, a_point* p5, double thickness) : a_block()
{
        thickness_ = new double;
        *thickness_ = thickness;
        //assign the vertices
        this->av(p1);
        this->av(p2);
        this->av(p3);
        this->av(p4);
        this->av(p5);
        this->create_faces();
}
//---------------------------------------------------------------------------
const std::string a_block_2d5::help()
{
        std::ostringstream o;
        o << "*************" << std::endl;
        o << "a_block_2d5:" << std::endl;
        o << "*************" << std::endl;
        o << "a_block_2d5 is a special type of a_block, a class used to model the blocks of a 'a_structure' (see a_structure_help for more information)" << std::endl;
        o << "It is a pentagonal prism (a polyhedron with 7 faces: 2 parallel pentagonal faces and 5 rectangular faces joining them)." << std::endl;
        o << "The geometry of a block is defined by the 5 points defining the pentagonal middle surface and the thickness of the block." << std::endl;
        o << "The points used to define the geometry of the block could be directly the coordinates of the corners of the block in a world (or global) coordinate system." << std::endl; 
        o << "In practice, it is more convenient to define the geometry of the block in a local coordinate system, possibly rotate it, and then to move it in its final position." << std::endl;        
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "a_block_2d5 B 'p1' 'p2' 'p3' 'p4' 'p5' 't': create a block named B" << std::endl;
        o << "   'pi' are points (a_point) defining the shape of the block" << std::endl;
        o << "   't' is the thickness of the block (default: 1.0)" << std::endl;
        o << "thickness 'val': set the constant thickness of the block" << std::endl;
        o << "thickness: gets the thickness of the block" << std::endl;
        o << "normal: normal to the definition plan of the block (world coordinates)" << std::endl;
        o << "normall: gets normal to the definition plan of the block (local coordinates)" << std::endl;
        o << a_block::help();
        return o.str();
}
//---------------------------------------------------------------------------
void a_block_2d5::copy(const a_block_2d5& b)
{
        a_block::copy(b);
        //in a copy, the thickness pointers should be different
        //but their values should be the same
        *thickness_ = b.thickness();
}
//---------------------------------------------------------------------------
void a_block_2d5::deepcopy(const a_block_2d5& b)
{
        a_block::deepcopy(b);
        //in a deep copy, the thickness pointers should be the same 
        //and consquently, their values will be the same
        //as the block has already a pointer
        //this original pointer should first be deallocated
        delete thickness_;
        thickness_ = b.thickness_p();
}
//---------------------------------------------------------------------------
a_point a_block_2d5::v3d(const int i) const
{
        a_point n = this->normal();
        n *= this->thickness()/2.;
        int r = i%10;
        if (r<5)
                return *pos_*(*v(r))-n;
        return *pos_*(*v(r-5))+n;
}
//---------------------------------------------------------------------------
a_point a_block_2d5::cl() const
{
        a_triangle t1(*v(0),*v(1),*v(2));
        a_triangle t2(*v(0),*v(2),*v(3));
        a_triangle t3(*v(0),*v(3),*v(4));
        double s1 = t1.S();
        double s2 = t2.S();
        double s3 = t3.S();
        a_point c1 = t1.c();
        a_point c2 = t2.c();
        a_point c3 = t3.c();
        return (c1*s1+c2*s2+c3*s3)/(s1+s2+s3);
}
//---------------------------------------------------------------------------
double a_block_2d5::V() const
{
        a_triangle t1(*v(0),*v(1),*v(2));
        a_triangle t2(*v(0),*v(2),*v(3));
        a_triangle t3(*v(0),*v(3),*v(4));
        double s1 = t1.S();
        double s2 = t2.S();
        double s3 = t3.S();
        return (s1+s2+s3)*this->thickness();
}
//---------------------------------------------------------------------------
a_point a_block_2d5::normall() const
{
        a_point d1 = *v(1)-*v(0);
        a_point d2 = *v(4)-*v(0);
        return cross(d1,d2).normalise();
}
//---------------------------------------------------------------------------
a_point a_block_2d5::normal() const
{
        //attention passage to world coordinate also translate...
        return (*pos_)*(this->normall())-pos_->p2();
}
/*
//---------------------------------------------------------------------------
void a_block_2d5::compute()
{}
*/
//---------------------------------------------------------------------------
void a_block_2d5::read(std::istream &in)
{
        a_block::read(in);
        double thickness;
        in >> thickness;
        this->thickness(thickness);
}
//---------------------------------------------------------------------------
void a_block_2d5::write(std::ostream &o) const
{
        a_block::write(o);
        o << this->thickness() << std::endl;
}
//---------------------------------------------------------------------------
void a_block_2d5::writetri(std::ostream &o) const
{
        a_trianglecloud tri;
        this->trianglecloud(tri);
        tri.write(o);
        tri.clear();
}
//---------------------------------------------------------------------------
void a_block_2d5::writeb(std::ostream &o) const
{
        a_point n = this->normal()*(this->thickness()/2.);
        o << "a_block_2d5(";
        for (int i=0; i<this->nv(); i++)
        {
                a_point p0 = (*pos_)*(*this->v(i));
                for (int j=0; j<4; j++)
                        o << (p0+n)[j] << ",";
        }
        for (int i=0; i<this->nv(); i++)
        {
                a_point p0 = (*pos_)*(*this->v(i));
                if (i!=this->nv()-1)
                {
                        for (int j=0; j<4; j++)
                                o << (p0-n)[j] << ",";
                }
                else
                        o << (p0-n)[0] << "," << (p0-n)[1] << "," << (p0-n)[2] << ")";
        }
}
//---------------------------------------------------------------------------
void a_block_2d5::writeg(std::ostream &o) const
{
        a_point n = this->normal()*(this->thickness()/2.);
        o << "arb8 ";
        for (int i=0; i<this->nv(); i++)
        {
                a_point p0 = (*pos_)*(*this->v(i));
                o << p0+n << " ";
        }
        for (int i=0; i<this->nv(); i++)
        {
                a_point p0 = (*pos_)*(*this->v(i));
                o << p0-n << " ";
        }
}
//---------------------------------------------------------------------------
void a_block_2d5::writefaces(std::ostream &o, const int base = 0) const
{
        o << base+0 << " " << base+2 << " " << base+1 << std::endl;
        o << base+0 << " " << base+3 << " " << base+2 << std::endl;
        o << base+0 << " " << base+4 << " " << base+3 << std::endl;
        o << base+0 << " " << base+1 << " " << base+5 << std::endl;
        o << base+1 << " " << base+6 << " " << base+5 << std::endl;
        o << base+1 << " " << base+2 << " " << base+6 << std::endl;
        o << base+2 << " " << base+7 << " " << base+6 << std::endl;
        o << base+2 << " " << base+3 << " " << base+7 << std::endl;
        o << base+3 << " " << base+8 << " " << base+7 << std::endl;
        o << base+3 << " " << base+4 << " " << base+8 << std::endl;
        o << base+4 << " " << base+9 << " " << base+8 << std::endl;
        o << base+4 << " " << base+0 << " " << base+9 << std::endl;
        o << base+0 << " " << base+5 << " " << base+9 << std::endl;
        o << base+5 << " " << base+6 << " " << base+7 << std::endl;
        o << base+5 << " " << base+7 << " " << base+8 << std::endl;
        o << base+5 << " " << base+8 << " " << base+9 << std::endl;
}
//---------------------------------------------------------------------------
void a_block_2d5::trianglecloud(a_trianglecloud& tri) const
{
        tri.addtriangle(this->v3d(0),this->v3d(2),this->v3d(1));
        tri.addtriangle(this->v3d(0),this->v3d(3),this->v3d(2));
        tri.addtriangle(this->v3d(0),this->v3d(4),this->v3d(3));
        tri.addtriangle(this->v3d(0),this->v3d(1),this->v3d(5));
        tri.addtriangle(this->v3d(1),this->v3d(6),this->v3d(5));
        tri.addtriangle(this->v3d(1),this->v3d(2),this->v3d(6));
        tri.addtriangle(this->v3d(2),this->v3d(7),this->v3d(6));
        tri.addtriangle(this->v3d(2),this->v3d(3),this->v3d(7));
        tri.addtriangle(this->v3d(3),this->v3d(8),this->v3d(7));
        tri.addtriangle(this->v3d(3),this->v3d(4),this->v3d(8));
        tri.addtriangle(this->v3d(4),this->v3d(9),this->v3d(8));
        tri.addtriangle(this->v3d(4),this->v3d(0),this->v3d(9));
        tri.addtriangle(this->v3d(0),this->v3d(5),this->v3d(9));
        tri.addtriangle(this->v3d(5),this->v3d(6),this->v3d(7));
        tri.addtriangle(this->v3d(5),this->v3d(7),this->v3d(8));
        tri.addtriangle(this->v3d(5),this->v3d(8),this->v3d(9));
}