a_block_2d4.cxx

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