ElementAnalysis Class Reference

Inheritance diagram for ElementAnalysis:

Public Member Functions
	ElementAnalysis ()
Public Member Functions inherited from SCoupling< M, O >
	SCoupling ()=default
void	solveSurfaceCoupling ()
void	solveSurfaceCoupling (unsigned nStep)
void	solveSurfaceCouplingFixedSolid ()
TriangleWall *	createTriangleWall (std::array< Vec3D, 3 > vertex)
void	updateTriangleWall (TriangleWall *&wall, std::array< Vec3D, 3 > vertex)
void	computeOneTimeStepForSCoupling (const unsigned &nStepsMercury)
void	createDPMWallsFromFiniteElems ()
void	updateDPMWallsFromFiniteElems ()
void	updateTractionOnFiniteElems ()
bool	computeSCouplingForcesFromTriangles (ELEMENT *const elem_pt, const unsigned &nTriangles, unsigned &wallID, Vector< Vector< double > > &nodalCouplingForces)
void	getElementBoundingBox (ELEMENT *&elem_pt, Vec3D &min, Vec3D &max)
void	getSCoupledElements ()
void	coupleBoundary (unsigned b)
void	coupleBoundaries (std::vector< unsigned > b)
void	disableLogSurfaceCoupling ()
Public Member Functions inherited from BaseCoupling< M, O >
	BaseCoupling ()=default
void	setName (std::string name)
std::string	getName () const
void	removeOldFiles () const
void	writeEneTimeStep (std::ostream &os) const override
void	writeEneHeader (std::ostream &os) const override
void	solveOomph ()
void	solveMercury (unsigned long nt)
void	setCGWidth (const double &width)
double	getCGWidth ()
bool	useCGMapping ()
CGFunctions::LucyXYZ	getCGFunction ()

Static Public Member Functions
static Vector< double >	getXiCenter (ELEMENT *e_pt)

Additional Inherited Members
Public Types inherited from SCoupling< M, O >
typedef O::ELEMENT	ELEMENT

Detailed Description

Define a coupled problem

Constructor & Destructor Documentation

ElementAnalysis()

ElementAnalysis::ElementAnalysis ( )

inline

                       {
        //set name
        setName("ElementAnalysis");
        #ifdef OOMPH_HAS_MUMPS
        linear_solver_pt()=new MumpsSolver;
        #endif
        //remove existing output files
        removeOldFiles();
 
        // setup oomph
        setElasticModulus(1e6);
        setDensity(2500);
        setSolidCubicMesh(3, 3, 3, -1, 1, -1, 1, -1, 1);
        pinBoundaries({Boundary::X_MIN, Boundary::X_MAX});
        prepareForSolve();
        coupleBoundary(Boundary::Z_MAX);
 
        // number of elements
        logger(INFO, "\nElements: %", solid_mesh_pt()->nelement());
        std::cout << "Center Positions:\n";
        for (int e = 0; e < solid_mesh_pt()->nelement(); ++e) {
            ELEMENT* e_pt = dynamic_cast<ELEMENT*>(solid_mesh_pt()->element_pt(e));
            std::cout << " " << e << ": " << getXiCenter(e_pt) << std::endl;
        }
 
        ELEMENT* e_pt = dynamic_cast<ELEMENT*>(solid_mesh_pt()->element_pt(22));
//        // Set up memory for the shape/test functions
//        Shape psi(e_pt->nnode());
//        Vector<double> s(3, 0.0);
//        // Get shape/test fcts
//        e_pt->shape(s, psi);
//        GeomObject* geom_obj_pt = 0;
//        e_pt->locate_zeta(x, geom_obj_pt, s);
 
        logger(INFO, "Nodes per element: %", e_pt->nnode());
        std::cout << "Nodal positions element 22:\n";
        for (int n = 0; n < e_pt->nnode(); ++n) {
            SolidNode* n_pt = dynamic_cast<SolidNode*>(e_pt->node_pt(n));
            std::cout << " " << n << ": " << n_pt->x(0) << ' ' << n_pt->x(1) << ' ' << n_pt->x(2) << std::endl;
        }
 
        // Loop over the integration points
        logger(INFO, "Integration points per element: %", e_pt->integral_pt()->nweight());
        std::cout << "Local and global coordinates, weight, Jacobian and shape functions at integration points:\n";
        unsigned dim = e_pt->nodal_dimension();
        for (unsigned ipt = 0; ipt < e_pt->integral_pt()->nweight(); ipt++) {
            Vector<double> s(dim);
            // Assign the values of s
            for (unsigned i = 0; i < dim; ++i) {
                s[i] = e_pt->integral_pt()->knot(ipt, i);
            }
            //set shape and its derivatives
            Shape psi(e_pt->nnode(), e_pt->nnodal_position_type());
            DShape dpsidxi(e_pt->nnode(), e_pt->nnodal_position_type(), dim);
            double J = e_pt->dshape_lagrangian_at_knot(ipt, psi, dpsidxi);
            // weight
            double w = e_pt->integral_pt()->weight(ipt);
            //interpolate
            Vector<double> interpolated_x(dim, 0.0);
            Vector<double> interpolated_xi(dim, 0.0);
            std::stringstream psi_ss;
            for (int l = 0; l < e_pt->nnode(); ++l) { // test functions
                for (int k = 0; k < e_pt->nnodal_position_type(); ++k) { // eqn_number
                    for (int i = 0; i < dim; ++i) {
                        //local_eqn = position_local_eqn_at_node(k, i);
                        interpolated_xi[i] += e_pt->lagrangian_position_gen(l, k, i) * psi(l,k);
                        interpolated_x[i] += e_pt->nodal_position_gen(l, k, i) * psi(l, k);
                    }
                    psi_ss << psi(l, k) << ' ';
                }
            }
            std::cout << "ipt " << ipt << " w " << w << " J " << J << " s " << s << " xi " << interpolated_xi << " psi " << psi_ss.str() << std::endl;
        }
    }

References SCoupling< M, O >::coupleBoundary(), getXiCenter(), constants::i, INFO, logger, n, BaseCoupling< M, O >::removeOldFiles(), and BaseCoupling< M, O >::setName().

Member Function Documentation

getXiCenter()

static Vector<double> ElementAnalysis::getXiCenter ( ELEMENT *  e_pt )

inlinestatic

                                                     {
        Vector<double> center(3);
        for (int n = 0; n < e_pt->nnode(); ++n) {
            SolidNode* n_pt = dynamic_cast<SolidNode*>(e_pt->node_pt(n));
            for (unsigned d = 0; d < n_pt->ndim(); ++d) {
                center[d] += n_pt->xi(d) / e_pt->nnode();
            }
        }
        return center;
    }

References n.

Referenced by ElementAnalysis().

---

The documentation for this class was generated from the following file:

• ElementAnalysis.cpp