Dear Yade Developers, I am trying to create an element interface for yade(finite element). In this interface, The nodes and the triangles are held within the structure. The structures that I created as follows,
DeformableElement-> derived from Shape Gl1_DeformableElement->derived from GlShapeFunctor Every time in a step drawing of the element is not realized after NewtonIntegrator step. Initially all faces of the element is drawn in ::go function of the Gl1_DeformableElement but after one step it is not drawn. What is the reason for this behaviour? Here is the screenshots, before integration <a href="http://tinypic.com?ref=2eauds1"; target="_blank"><img src="http://i42.tinypic.com/2eauds1.png"; border="0" alt="Image and video hosting by TinyPic"></a> after integration <a href="http://tinypic.com?ref=280qckp"; target="_blank"><img src="http://i44.tinypic.com/280qckp.png"; border="0" alt="Image and video hosting by TinyPic"></a> The classes are as follows ******************************Gl1_DeformableElement.hpp**************************************** #pragma once #include<yade/pkg/common/GLDrawFunctors.hpp> #include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> class Gl1_DeformableElement : public GlShapeFunctor { public: virtual void go(const shared_ptr<Shape>&, const shared_ptr<State>&,bool,const GLViewInfo&); YADE_CLASS_BASE_DOC(Gl1_DeformableElement,GlShapeFunctor,"Renders :yref:`Node` object" ); RENDERS(DeformableElement); }; REGISTER_SERIALIZABLE(Gl1_DeformableElement); ***********************************************Gl1_DeformableElement.cpp**************************************** /************************************************************************* * Copyright (C) 2008 by Sergei Dorofeenko * * [email protected] * * * * This program is free software; it is licensed under the terms of the * * GNU General Public License v2 or later. See file LICENSE for details. * *************************************************************************/ #ifdef YADE_OPENGL #include<yade/pkg/dem/deformablecohesive/Gl1_DeformableElement.hpp> #include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> #include<yade/lib/opengl/OpenGLWrapper.hpp> typedef DeformableElement::NodeMap NodeMap; void Gl1_DeformableElement::go(const shared_ptr<Shape>& cm, const shared_ptr<State>& ,bool wire,const GLViewInfo&) { DeformableElement* element = static_cast<DeformableElement*>(cm.get()); std::vector<Vector3r> triangles = element->faces; Vector3r elempos=element->frame_get().position; Scene* scene(Omega::instance().getScene().get()); // get scene // if(!normals) return; // // DeformableElement's normal // glBegin(GL_LINES); // glColor3(0.0,0.0,1.0); // glVertex3(0.0,0.0,0.0); // glVertex3v(DeformableElement->normal); // glEnd(); // // normal of edges // glColor3(0.0,0.0,1.0); // glBegin(GL_LINES); // glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[0])); // glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[1])); // glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[2])); // glEnd(); if(!(cm->wire || wire)){ glDisable(GL_CULL_FACE); //Vector3r normal=(facet->vertices[1]-facet->vertices[0]).cross(facet->vertices[2]-facet->vertices[1]); normal.normalize(); glColor3v(cm->color); glBegin(GL_TRIANGLES); FOREACH(Vector3r vertices,triangles){ NodeMap::iterator i1(element->localmap.begin()); NodeMap::iterator i2(i1); NodeMap::iterator i3(i1); std::advance(i1,vertices[0]); std::advance(i2,vertices[1]); std::advance(i3,vertices[2]); const shared_ptr<Body>& member1=Body::byId(i1->first,scene); const shared_ptr<Body>& member2=Body::byId(i2->first,scene); const shared_ptr<Body>& member3=Body::byId(i3->first,scene); Vector3r pos1=member1->state->pos; Vector3r pos2=member2->state->pos; Vector3r pos3=member3->state->pos; cout<<"Pos1"<<pos1<<"\n"; cout<<"Pos2"<<pos2<<"\n"; cout<<"Pos3"<<pos3<<"\n"; glVertex3v(pos1); glVertex3v(pos2); glVertex3v(pos3); } } glEnd(); glBegin(GL_LINE_LOOP); glColor3v(Vector3r(0,0,0)); FOREACH(Vector3r vertices,triangles){ NodeMap::iterator i1(element->localmap.begin()); NodeMap::iterator i2(i1); NodeMap::iterator i3(i1); std::advance(i1,vertices[0]); std::advance(i2,vertices[1]); std::advance(i3,vertices[2]); const shared_ptr<Body>& member1=Body::byId(i1->first,scene); const shared_ptr<Body>& member2=Body::byId(i2->first,scene); const shared_ptr<Body>& member3=Body::byId(i3->first,scene); Vector3r pos1=member1->state->pos; Vector3r pos2=member2->state->pos; Vector3r pos3=member3->state->pos; glVertex3v(pos1); glVertex3v(pos2); glVertex3v(pos3); } glEnd(); } YADE_PLUGIN((Gl1_DeformableElement)); #endif /* YADE_OPENGL */ AND *****************************************************DeformableElement.hpp*************************************** /************************************************************************* * Copyright (C) 2013 by Burak ER * * * * * * This program is free software; it is licensed under the terms of the * * GNU General Public License v2 or later. See file LICENSE for details. * *************************************************************************/ #pragma once #include<vector> #include<map> #include<stdexcept> #include<yade/core/Body.hpp> #include<yade/lib/base/Logging.hpp> #include<yade/lib/base/Math.hpp> #include<yade/core/PartialEngine.hpp> //#include<yade/trunk/pkg/dem/deformablecohesive/Node.hpp> //Node shape /* Before starting the implementation of the deformable element, I am really dissappointed that deformableelement's algorithm relies on its shape. Shape means "shape" and I think it should not contain any other physical meaning or anything else. Therefore, DeformableElement like deformable element structure is not used. With respect to this view; The deformable element class is derived from the body and knows the information of its members that are node shaped bodies. */ class NewtonIntegrator; namespace yade{ class DeformableElement: public Shape { public: typedef std::map<Body::id_t,Se3r> NodeMap; typedef std::vector<Vector3r> Triangles; // Used for drawing the element virtual ~DeformableElement (); void addNode(const shared_ptr<Body>& subBody); void delNode(const shared_ptr<Body>& subBody); void addFace(Vector3r&); void removeLastFace(void); //! Recalculate physical properties of DeformableElement. Se3r frame_get(); void frame_set(Se3r); //! update member positions after deformableelement being moved by mouse (in case simulation is paused and engines will not do that). //void userForcedDisplacementRedrawHook(){ throw runtime_error("DeformableElement::userForcedDisplacementRedrawHook not yet implemented (with DeformableElement as subclass of Shape).");} python::dict localmap_get(); YADE_CLASS_BASE_DOC_ATTRS_INIT_CTOR_PY(DeformableElement,Shape,"Deformable aggregate of nodes", ((NodeMap,localmap,,,"Ids and relative positions+orientations of members of the deformable element (should not be accessed directly)")) ((Se3r,elementframe,,,"Position and orientation of the element frame")) ((Triangles,faces,,,"Faces of the element for drawing")), , createIndex(); /*ctor*/ , /*py*/ YADE_PY_TOPINDEXABLE(DeformableElement) .add_property("elementframe",&DeformableElement::frame_get) .def("addNode",&DeformableElement::addNode,"Add a node shared_pt<:yref:'Body'>& as into the element") .def("delNode",&DeformableElement::delNode,"Remove a node shared_pt<:yref:'Body'>& from the element") .def("addFace",&DeformableElement::addFace,"Add a face into the element") .def("removeLastFace",&DeformableElement::removeLastFace,"Remove a face from the element") ); DECLARE_LOGGER; REGISTER_CLASS_INDEX(DeformableElement,Shape); }; } // necessary using namespace yade; REGISTER_SERIALIZABLE(DeformableElement); *****************************************************DeformableElement.cpp*************************************** // (c) 2007-2010 Vaclav Smilauer <[email protected]> #include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> #include<algorithm> #include<yade/core/Scene.hpp> #include<yade/core/BodyContainer.hpp> #include<yade/core/State.hpp> #include<yade/pkg/common/Sphere.hpp> #include<yade/pkg/dem/deformablecohesive/Node.hpp> YADE_PLUGIN((DeformableElement)); CREATE_LOGGER(DeformableElement); python::dict DeformableElement::localmap_get(){ python::dict ret; FOREACH(NodeMap::value_type& b, localmap){ ret[b.first]=python::make_tuple(b.second.position,b.second.orientation); } return ret; } void DeformableElement::addFace(Vector3r& indexes){ faces.push_back(indexes); } DeformableElement::~DeformableElement(){ } void DeformableElement::removeLastFace(void){ faces.pop_back(); } void DeformableElement::addNode(const shared_ptr<Body>& nodeBody){ const shared_ptr<Node> node=YADE_PTR_CAST<Node>(nodeBody->shape);//Should be checked dynamically otherwise it will always cast: every shape is castable to Node shape Body::id_t subId=nodeBody->getId(); if(node){} else{ throw std::invalid_argument(("The body that is given #"+lexical_cast<string>(subId)+" is not a Node therefore cannot be added to the deformable element "));} if(subId<0){throw std::invalid_argument(("The Node that is given is not a member of the scene therefore it has no state, not adding exiting"));} if(this->localmap.count(subId)!=0) throw std::invalid_argument(("Node that has Body id #"+lexical_cast<string>(subId)+" is already part of this deformable element")); // Add body to localmap this->localmap[subId]=Se3r();// meaningful values will be put in by DeformableElement::updateProperties // Get first node Scene* scene(Omega::instance().getScene().get()); // get scene const shared_ptr<Body>& member=Body::byId(localmap.begin()->first,scene); //Substract from the current node, therefore find the local value, localmap[subId].position=nodeBody->state->pos-member->state->pos; //localmap[subId].orientation=nodeBody->state->ori; //this->setBounded(false); // disallow collisions with the element itself //If we have more than three nodes define a local triad that is clumped on the first node and initially parallel to the global frame if(this->localmap.size()>=3) { //define a local triad if needed } return; } void DeformableElement::delNode(const shared_ptr<Body>& subBody){ // erase the subBody; removing body that is not part of the element throws if(this->localmap.erase(subBody->id)!=1) throw std::invalid_argument(("Node #"+lexical_cast<string>(subBody->id)+" not a part of the deformable element, not removing...").c_str()); LOG_DEBUG("Removed node #"<<subBody->id); } Se3r DeformableElement::frame_get() const { Scene* scene(Omega::instance().getScene().get()); // get scene const shared_ptr<Body>& member=Body::byId(localmap.begin()->first,scene); return member->state->se3; } void DeformableElement::frame_set(Se3r) const { // Scene* scene(Omega::instance().getScene().get()); // get scene // NodeMap::iterator i=localmap.begin(); // const shared_ptr<Body>& member=Body::byId(i->first,scene); return; } _______________________________________________ Mailing list: https://launchpad.net/~yade-dev Post to : [email protected] Unsubscribe : https://launchpad.net/~yade-dev More help : https://help.launchpad.net/ListHelp
![http://i42.tinypic.com/2eauds1.png"](http://i42.tinypic.com/2eauds1.png"){kind=link}
![http://i44.tinypic.com/280qckp.png"](http://i44.tinypic.com/280qckp.png"){kind=link}