a_block_2d3.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_2d3.h"
#include "a_face_2d4.h"
#include "a_triangle.h"
#define DE(x) std::cerr << #x << ": " << x << std::endl; 
//---------------------------------------------------------------------------
a_block_2d3 * cb_2d3(a_block * b) {return dynamic_cast<a_block_2d3*>(b); }
 
//---------------------------------------------------------------------------
void a_block_2d3::create_faces()
{
        //create the 3 faces
        int r0 = 0;
        for (int i=0; i<3; i++)
        {
                a_face_2d4 * f = new a_face_2d4(this,i);
                this->ai(f);
                f->av(r0++);
                f->av(r0%3);
        }
}
//---------------------------------------------------------------------------
a_block_2d3::a_block_2d3() : a_block()
{
        thickness_ = new double;
        *thickness_ = 1.;
        this->create_faces();
}
//---------------------------------------------------------------------------
a_block_2d3::~a_block_2d3()
{
        //faces and vertices are erased in parent
        delete thickness_;
}
//---------------------------------------------------------------------------
a_block_2d3::a_block_2d3(a_point* p1, a_point* p2, a_point* p3, double thickness) : a_block()
{
        thickness_ = new double;
        *thickness_ = thickness;
        //assign the vertices
        this->av(p1);
        this->av(p2);
        this->av(p3);
        this->create_faces();
}
//---------------------------------------------------------------------------
const std::string a_block_2d3::help()
{
        std::ostringstream o;
        o << "*************" << std::endl;
        o << "a_block_2d3:" << std::endl;
        o << "*************" << std::endl;
        o << "a_block_2d3 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 an trilateral prism (a polyhedron with 5 faces: 2 parallel trilateral faces and 3 rectangular faces joining them)." << std::endl;
        o << "The geometry of a block is defined by the 3 points defining the triangular 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_2d3 B 'p1' 'p2' 'p3' '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_2d3::copy(const a_block_2d3& 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_2d3::deepcopy(const a_block_2d3& 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_2d3::v3d(const int i) const
{
        a_point n = this->normal();
        n *= this->thickness()/2.;
        int r = i;
        if (r<0) r = 0;
        if (r>5) r = 5;
        if (r<3)
                return *pos_*(*v(r))-n;
        return *pos_*(*v(r-3))+n;
}
//---------------------------------------------------------------------------
a_point a_block_2d3::cl() const
{
        a_triangle t(*v(0),*v(1),*v(2));
        return t.c();
}
//---------------------------------------------------------------------------
double a_block_2d3::V() const
{
        a_triangle t(*v(0),*v(1),*v(2));
        return t.S()*this->thickness();
}
//---------------------------------------------------------------------------
a_point a_block_2d3::normall() const
{
        a_point d1 = *v(1)-*v(0);
        a_point d2 = *v(2)-*v(0);
        return cross(d1,d2).normalise();
}
//---------------------------------------------------------------------------
a_point a_block_2d3::normal() const
{
        //attention passage to world coordinate also translate...
        return (*pos_)*(this->normall())-pos_->p2();
}
/*
//---------------------------------------------------------------------------
void a_block_2d3::compute()
{}
*/
//---------------------------------------------------------------------------
void a_block_2d3::read(std::istream &in)
{
        a_block::read(in);
        double thickness;
        in >> thickness;
        this->thickness(thickness);
}
//---------------------------------------------------------------------------
void a_block_2d3::write(std::ostream &o) const
{
        a_block::write(o);
        o << this->thickness() << std::endl;
}
//---------------------------------------------------------------------------
void a_block_2d3::writetri(std::ostream &o) const
{
        a_trianglecloud tri;
        this->trianglecloud(tri);
        tri.write(o);
        tri.clear();
}
//---------------------------------------------------------------------------
void a_block_2d3::writeb(std::ostream &o) const
{
        a_point n = this->normal()*(this->thickness()/2.);
        o << "a_block_2d3(";
        for (int i=0; i<this->nv(); i++)
        {
                a_point p0 = (*pos_)*(*this->v(i));
                for (int j=0; j<3; 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<3; j++)
                                o << (p0-n)[j] << ",";
                }
                else
                        o << (p0-n)[0] << "," << (p0-n)[1] << "," << (p0-n)[2] << ")";
        }
}
//---------------------------------------------------------------------------
void a_block_2d3::writeg(std::ostream &o) const
{
        a_point n = this->normal()*(this->thickness()/2.);
        const unsigned short order[] = {3,4,1,0,5,2};
        o << "arb6 ";
        for (int i=0; i<6; i++)
        {
                if (order[i]<3)
                {
                        a_point p0 = (*pos_)*(*this->v(order[i]));
                        o << p0-n << " ";
                }
                else
                {
                        a_point p0 = (*pos_)*(*this->v(order[i]-3));
                        o << p0+n << " ";
                }
        }
}
//---------------------------------------------------------------------------
void a_block_2d3::writefaces(std::ostream &o, const int base = 0) const
{
        o << base+0 << " " << base+2 << " " << base+1 << std::endl;
        o << base+3 << " " << base+4 << " " << base+5 << std::endl;
        o << base+0 << " " << base+1 << " " << base+3 << std::endl;
        o << base+1 << " " << base+4 << " " << base+3 << std::endl;
        o << base+1 << " " << base+2 << " " << base+4 << std::endl;
        o << base+2 << " " << base+5 << " " << base+4 << std::endl;
        o << base+0 << " " << base+5 << " " << base+2 << std::endl;
        o << base+0 << " " << base+3 << " " << base+5 << std::endl;
}
//---------------------------------------------------------------------------
void a_block_2d3::trianglecloud(a_trianglecloud& tri) const
{
        tri.addtriangle(this->v3d(0),this->v3d(2),this->v3d(1));
        tri.addtriangle(this->v3d(3),this->v3d(4),this->v3d(5));
        tri.addtriangle(this->v3d(0),this->v3d(1),this->v3d(3));
        tri.addtriangle(this->v3d(1),this->v3d(4),this->v3d(3));
        tri.addtriangle(this->v3d(1),this->v3d(2),this->v3d(4));
        tri.addtriangle(this->v3d(2),this->v3d(5),this->v3d(4));
        tri.addtriangle(this->v3d(0),this->v3d(5),this->v3d(2));
        tri.addtriangle(this->v3d(0),this->v3d(3),this->v3d(5));
}