a_block.cxx

Go to the documentation of this file.

/*
Copyright 2010-2018 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.h"
 
#include "config.h"
 
//---------------------------------------------------------------------------
a_block::a_block() 
{
        pos_ = new a_twist();
        material_ = new a_material;
        material_->density(1.);
        material_auto_ = true;
        exit_face_ = -1;
        g_ = new a_point(0.,0.,-9.81);
}
//---------------------------------------------------------------------------
a_block::~a_block() 
{
        this->clear();
        delete pos_;
}
//---------------------------------------------------------------------------
void a_block::clear()
{
  for(std::vector<a_point *>::iterator it = vertices_.begin(); it != vertices_.end(); ++it) (*it)->clear();
  for(std::vector<a_face *>::iterator it = faces_.begin(); it != faces_.end(); ++it) (*it)->clear();
  vertices_.clear();
  faces_.clear();
}
//: exit_face_(-1), a_wrench_()
//---------------------------------------------------------------------------
const std::string a_block::help()
{
        std::ostringstream o;
        o << "*********" << std::endl;
        o << "a_block:" << std::endl;
        o << "*********" << std::endl;
        o << "This class is used to model the blocks of a 'a_structure' (see a_structure_help for more information)" << std::endl;
        o << "This is a virtual class, it cannot be used directly, see a_block_... for usable classes" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "clear: clear the block object" << std::endl;
        o << "deepcopy 'b': make a completely independant copy of block 'b'" << std::endl;
        o << "g 'val': sets value of the acceleration of gravity to 'val'" << std::endl;
        o << "g: gets value of gravity" << std::endl;
        o << "c: gets centre of mass in world coordinates" << std::endl;
        o << "cl: get centre of mass in local coordinates" << std::endl;
        o << "name: gets class name" << std::endl;
        o << "m: gets mass" << std::endl;
        o << "Ws: gets scalar value of weight" << std::endl;
        o << "W: gets weight (returns a wrench, see a_wrench_help)" << std::endl;
        o << "fe: gets external force on block (returns a wrench)" << std::endl;
        o << "ft: gets total force on block (returns a wrench)" << std::endl;
        o << "potential: gets potential energy" << std::endl;
        o << "nextblock: block connected (return 0 if end or problem)" << std::endl;
        o << "clearinternal: clear all the internal face forces" << std::endl;
        o << "clearexternal: clear all the external face forces" << std::endl;
        o << "clearall: clear all the forces on faces" << std::endl;
        o << "material 'material': link a material" << std::endl;
        o << "material: gets material" << std::endl;
        o << "nv: gets number of vertices" << std::endl;
        o << "nvt: gets number of vertices (not only the reference vertices)" << std::endl;
        o << "ni: gets number of faces" << std::endl;
        o << "nit: gets number of faces (not only the reference faces)" << std::endl;
        o << "av 'a_point': add a vertex" << std::endl;
        o << "ai 'a_face': add a face" << std::endl;
        o << "v 'ref': gets vertex 'ref' (starts from 0)" << std::endl;
        o << "v3d 'ref': gets vertex 'ref' (world coordinate, 3D)" << std::endl;
        o << "i 'ref': gets face 'ref'" << std::endl;
        o << "pos: gets position handle (a a_twist, see a_twist_help)" << std::endl;
        o << "in: gets insides faces" << std::endl;
        o << "out: gets outside faces" << std::endl;
        o << "exit 'ref': set exit face" << std::endl;
        o << "exit: gets exit face" << std::endl;
        o << "entrance 'ref': set exit face specifying where the force enters" << std::endl;
        o << "criteria: set resistance criteria" << std::endl;
        o << "ok: check whether forces on face are acceptable" << std::endl;
        o << "penalty: gets penalty value used for optimization" << std::endl;
        o << "writeb 'file': write block in  blender format" << std::endl;
        o << "writeg 'file': write block in  brlcad format" << std::endl;
        o << "trianglecloud 'a_trianglecloud': write block in a 'a_trianglecloud' object (points&forces)" << std::endl;
        return o.str();
}
//---------------------------------------------------------------------------
void a_block::copy(const a_block& b)
{
        for (int i=0; i<b.nv(); i++)
                this->av(b.v(i));
        material_ = b.material();
        g_ = b.g();
        material_auto_ = false;
        pos_ = new a_twist();
        //no faces is copied
}
//---------------------------------------------------------------------------
void a_block::deepcopy(const a_block& b)
{
        for (int i=0; i<b.nv(); i++)
        {
                a_point * v = new a_point(*(b.v(i)));
                this->av(v);
        }
        g_ = b.g();
        material_ = new a_material(*(b.material()));
        material_auto_ = true;
        pos_ = new a_twist();
        //no faces is copied
}
//---------------------------------------------------------------------------
void a_block::material(a_material * material) 
{
        if (material_auto_)
        {
                delete material_;
                material_auto_ = false;
        }
        material_ = material;
}
//---------------------------------------------------------------------------
a_point * a_block::v(const int i)
{
        if ((i>=0)&&(i<vertices_.size()))
                return vertices_[i];
        return 0;
}     
//---------------------------------------------------------------------------
a_point * a_block::v(const int i) const 
{
        if ((i>=0)&&(i<vertices_.size()))
                return vertices_[i];
        return 0;
} 
//---------------------------------------------------------------------------
a_face * a_block::i(const int i) 
{
        if ((i>=0)&&(i<faces_.size()))
                return faces_[i];
        return 0;
} 
//---------------------------------------------------------------------------
a_face * a_block::i(const int i) const 
{
        if ((i>=0)&&(i<faces_.size()))
                return faces_[i];
        return 0;
} 
//---------------------------------------------------------------------------
a_point a_block::c() const
{
        return (*pos_)*this->cl();
}
//---------------------------------------------------------------------------
double a_block::m() const
{
        return this->V()*this->material()->density();
}
//---------------------------------------------------------------------------
double a_block::Ws() const
{
        double g = this->g()->norm();
        return g*this->m();
}
//---------------------------------------------------------------------------
a_wrench a_block::W() const 
{
        a_point c = this->c();
        a_point g = *this->g();
        double m = this->m();
        return a_wrench(c,g*m);
}
//---------------------------------------------------------------------------
a_wrench a_block::fe() const
{
        a_wrench w;
        for (int i=0; i<faces_.size(); i++)
        {
                a_face * f = faces_[i];
                if (f->out())
                {
                        w += f->f();    
                }
        }
        return w;
}
//---------------------------------------------------------------------------
a_wrench a_block::ft() const
{
        a_wrench w1 = this->W();
        a_wrench w2 = this->fe();
        return w1+w2;
}
//---------------------------------------------------------------------------
a_wrench a_block::W(const a_block& be) const
{
        if (this==&be)
                return this->W();
        a_block * nb = this->nextblock();
        if (nb==0)
                throw a_block::no_block_error();
        a_wrench w2 = nb->W(be);
        return w2+this->W();
}
//---------------------------------------------------------------------------
a_wrench a_block::ft(const a_block& be) const
{
        if (this==&be)
                return this->ft();
        a_block * nb = this->nextblock();
        if (nb==0)
                throw a_block::no_block_error();
        a_wrench w2 = nb->ft(be);
        return w2+this->ft();
}
//---------------------------------------------------------------------------
a_block * a_block::nextblock() const
{
        int ri = this->exit();
        if (ri==-1)
                return 0;
        a_face * f = this->i(ri);
        a_face * f2 = f->lface();
        if (f2==0)
                return 0;
        a_block * b2 = f2->block();
        //get reference of face
        int r2 = f2->rf();
        //set the exit face of the next block
        b2->entrance(r2);
        return b2;
}
//---------------------------------------------------------------------------
double a_block::potential() const
{
        a_point c = this->c();
        a_point n = -this->g()->normalise();
        return this->Ws()*(c*n);        
}
//---------------------------------------------------------------------------
void a_block::clearinternal()
{
        for (int i=0; i<faces_.size(); i++)
        {
                a_face * f = faces_[i];
                if (f->in())
                        f->clear();
        }
}
//---------------------------------------------------------------------------
void a_block::clearexternal()
{
        for (int i=0; i<faces_.size(); i++)
        {
                a_face * f = faces_[i];
                if (f->out())
                        f->clear();
        }
}
//---------------------------------------------------------------------------
void a_block::clearall()
{
        for (int i=0; i<faces_.size(); i++)
        {
                a_face * f = faces_[i];
                f->clear();
        }
}
//---------------------------------------------------------------------------
void a_block::criteria(a_fcriteria * criteria) 
{
        for (int i=0; i<faces_.size(); i++)
                faces_[i]->criteria(criteria);
}
//---------------------------------------------------------------------------
bool a_block::ok() const
{
        for (int i=0; i<faces_.size(); i++)
        {
                if (!faces_[i]->ok())
                        return false;
        }
        return true;
}
//---------------------------------------------------------------------------
double a_block::penalty() const
{
        double val = 0.;
        for (int i=0; i<faces_.size(); i++)
        {
                double v = faces_[i]->penalty();
                if (v>val)
                        val = v;
        }
        return val;
}
//---------------------------------------------------------------------------
a_block * a_block::compute()
{
        a_wrench * exit = new a_wrench;
        int ri = -1;
        //compute summ of forces from faces
        for (int i=0; i<ni(); i++)
        {
                a_face * f = this->i(i);
                if (f->exit())
                        ri = i;
                else 
                        *exit -= f->f();
        }
        //add weight
        *exit -= this->W();
        if (ri != -1)
        {
                //get exit face
                a_face * f = this->i(ri);
                //assign force to the exit face
                f->f(exit);
                //get connected face
                a_face * f2 = f->lface();
                //if there is a connect face
                if (f2 != 0)
                {
                        //prepare next block
                        //assign opposite of force to connected face
                        a_wrench * exit2 = new a_wrench;
                        *exit2 = *exit; 
                        *exit2 *= -1.;
                        f2->f(exit2);
                        //get connected block
                        a_block * b2 = f2->block();
                        //get reference of face
                        int r2 = f2->rf();
                        //set the exit face of the next block
                        b2->entrance(r2);
                        return b2;
                }
                return 0;
        }
        return 0;
}
//---------------------------------------------------------------------------
void a_block::place(const int fi, a_block * block, const int fe, double u, double v)
{
        a_face * fip = this->i(fi);
        a_point ci = fip->c();
        a_face * fep = block->i(fe);
        a_point nxi = fip->nx();
        a_point nxe = -fep->nx();
        a_point nyi = fip->ny();
        a_point nye = -fep->ny();
        double ax = angle(nxi,nxe);
        double ay = angle(nyi,nye);
        a_point pt = fep->c()+u*nxe+v*nye;
        a_point d = pt-ci;
        pos_->translate(d);
        pos_->rotate(pt,nye,ax);
//      pos_->rotate(pt,nxe,ay);
}
//---------------------------------------------------------------------------
std::vector<int> a_block::in() const
{
        std::vector<int> list;
        for (int i=0; i<ni(); i++)
        {
                a_face * f = this->i(i);
                if (f->in())
                        list.push_back(i);
        }
        return list;
}
//---------------------------------------------------------------------------
std::vector<int> a_block::out() const
{
        std::vector<int> list;
        for (int i=0; i<ni(); i++)
        {
                a_face * f = this->i(i);
                if (f->out())
                        list.push_back(i);
        }
        return list;
}
//---------------------------------------------------------------------------
void a_block::exit(int ref) 
{
        for (int i=0; i<this->ni(); i++)
        {
                if (i == ref)
                        faces_[i]->exit(true);
                else
                        faces_[i]->exit(false);
        }
        exit_face_ = ref; 
}
//---------------------------------------------------------------------------
int a_block::entrance(int val)
{
        a_face * in = this->i(val);
        in->exit(false);
        //number of inside faces
        int nc = 0;
        int ref;
        for (int i=0; i<this->ni(); i++)
        {
                //do not count entrance face
                if (i != val)
                {
                        a_face * f = this->i(i);
                        //if inside face, possible exit
                        if (f->in())
                        {
                                nc++;
                                ref = i;
                        }
                }
        }
        //if more than one possible exit, stop
        if (nc>1)
                return -2;
        //no candidate -> probably the last block
        else if (nc==0)
        {
                //check whether there is already an exit face specified
                //that should be the case
                if (exit_face_ != -1)
                       return 0;        
                //last block will not be computed
                return -1;
        }
        //if nc==1 set exit face
        exit_face_ = ref;
        faces_[ref]->exit(true);
        return 0;
}
//---------------------------------------------------------------------------
void a_block::read(std::istream &in)
{
        std::string name;
        in >> name;
        if (name != this->name())
                throw compatibility_error();
        int nv;
        in >> nv;
        for (int i=0; i<nv; i++)
        {
                a_point * vertex = new a_point;
                in >> *vertex;
                this->av(vertex);
        }
        in >> g_;
        //type of face will depend of type of block... this part will be read in children of a_block
        int ni;
        in >> ni;
        for (int i=0; i<ni; i++)
        {
        }
        in >> *pos_;
}
//---------------------------------------------------------------------------
void a_block::write(std::ostream &o) const
{
        o << this->name() << std::endl;
        int nv = this->nv();
        o << nv << std::endl;
        for (int i=0; i<nv; i++)
                o << this->v(i) << std::endl;
        o << this->g() << std::endl;
        int ni = this->ni();
        o << ni << std::endl;
        for (int i=0; i<ni; i++)
                this->i(i)->write(o);
        o << *(this->pos()) << std::endl;
}
//---------------------------------------------------------------------------
void a_block::writeverts(std::ostream &o) const
{
        int nv = this->nvt();
        for (int i=0; i<nv; i++)
                o << this->v3d(i) << std::endl;
}
//*****************************************************************************
//-operator>>----------------------------------------------------------------
std::istream& operator>> (std::istream& in, a_block& b)
{
        b.read(in);
        return in;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_block& b)
{
        b.write(o);
        return o;
}