CoupledProblem Class Reference

Inheritance diagram for CoupledProblem:

Public Member Functions
	CoupledProblem ()
void	setupOomph ()
void	setupMercury ()
void	actionsAfterTimeStep () override
void	getSolidDeflection ()
Public Member Functions inherited from SCoupling< M, O >
	SCoupling ()=default
void	solveSurfaceCoupling (const unsigned max_adapt=0)
void	solveSurfaceCoupling (unsigned nStep, const unsigned max_adapt)
void	solveSurfaceCouplingForgiving (unsigned nStep, double timeMaxMin=-constants::inf, const unsigned max_adapt=0)
void	solveSurfaceCouplingFixedSolid ()
TriangleWall *	createTriangleWall (std::array< Vec3D, 3 > vertex)
void	updateTriangleWall (TriangleWall *&wall, std::array< Vec3D, 3 > vertex)
void	computeOneTimeStepForSCoupling (const unsigned &nStepsMercury, const unsigned max_adapt=0)
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 ()
void	setSolidFeelsParticles (bool val)
bool	getSolidFeelsParticles () const
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 (int max_adapt=0)
void	checkResidual ()
void	solveMercury (unsigned long nt)
void	setCGWidth (const double &width)
double	getCGWidth ()
bool	useCGMapping ()
CGFunctions::LucyXYZ	getCGFunction ()

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

Constructor & Destructor Documentation

CoupledProblem()

CoupledProblem::CoupledProblem ( )

inline

                      {
        //set name
        setName("SolidOnParticleBed");
        //remove existing output files
        removeOldFiles();
        
        // setup steps
        setupOomph();
        setupMercury();
        setOomphTimeStep(getTimeStep());
        setTimeMax(2000*getTimeStep());
        setSaveCount(10);
        logger(INFO,"Time step %", getTimeStep());
 
        // Solve the  problem
        writeToVTK();
        solveSurfaceCoupling();
        saveSolidMesh();
 
        helpers::writeToFile(getName()+".gnu","set key autotitle columnheader\n"
                                              "p '" + getName() + ".def' u 1:2");
    }

References BaseCoupling< M, O >::getName(), INFO, logger, BaseCoupling< M, O >::removeOldFiles(), BaseCoupling< M, O >::setName(), setupMercury(), setupOomph(), SCoupling< M, O >::solveSurfaceCoupling(), and helpers::writeToFile().

Member Function Documentation

actionsAfterTimeStep()

void CoupledProblem::actionsAfterTimeStep ( )

inlineoverride

                                          {
        getSolidDeflection();
    }

References getSolidDeflection().

getSolidDeflection()

void CoupledProblem::getSolidDeflection ( )

inline

                              {
        std::array<double,3> min;
        std::array<double,3> max;
        getDomainSize(min, max);
        
        Vector<double> xi(3);
        xi[0] = 0.5*(max[0]+min[0]);
        xi[1] = 0.5*(max[1]+min[1]);
        xi[2] = min[2];
        double deflection = getDeflection(xi,2);
 
        static std::ofstream file(getName()+".def");
        file << getTime() << " " << deflection << std::endl;
    }

References BaseCoupling< M, O >::getName(), max, and min.

Referenced by actionsAfterTimeStep().

setupMercury()

void CoupledProblem::setupMercury ( )

inline

                        {
        // set domain min, max. Used to getDomainSize
        std::array<double, 3> min;
        std::array<double, 3> max;
        getDomainSize(min, max);
        const double radius = 10e-3; //10mm radius
        min[2] = -2.5*radius;
        // Translating the array into a Vec3D. Mercury works with Vec3D to set the domain
        Vec3D minVec(min);
        Vec3D maxVec(max);
        // set domain in Mercury
        setDomain(minVec, maxVec);
        // add elastic species
        auto species = speciesHandler.copyAndAddObject(LinearViscoelasticSlidingFrictionSpecies());
        species->setDensity(1000);
        species->setStiffness(9.8*250.0); //should result in 1mm overlap
        const double mass = species->getMassFromRadius(radius);
        double tc = species->getCollisionTime(mass);
        species->setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(tc, 1, 1, mass);
        species->setSlidingFrictionCoefficient(0.2);
        // set time step
        setTimeStep(0.05*tc);
        // add particle
        SphericalParticle p(species);
        p.setRadius(radius);
        double x = 0.5*max[0], y = 0.8*max[1];
        p.setPosition({x, y, -radius});
        particleHandler.copyAndAddObject(p);
        p.setPosition({-x, y, -radius});
        particleHandler.copyAndAddObject(p);
        p.setPosition({x, -y, -radius});
        particleHandler.copyAndAddObject(p);
        p.setPosition({-x, -y, -radius});
        particleHandler.copyAndAddObject(p);
        // add bottom wall
        InfiniteWall w(species);
        w.set({0,0,-1},{0,0,-2.0*radius});
        wallHandler.copyAndAddObject(w);
        // set output file properties
        setParticlesWriteVTK(true);
        wallHandler.setWriteVTK(true);
        setFileType(FileType::NO_FILE);
        restartFile.setFileType(FileType::ONE_FILE);
        restartFile.writeFirstAndLastTimeStep();
        dataFile.setFileType(FileType::ONE_FILE);
        fStatFile.setFileType(FileType::ONE_FILE);
        // add gravity
        setGravity({0,0,-9.8});
    }

References calibrate::dataFile, e(), max, min, NO_FILE, ONE_FILE, p, UniformPSDSelfTest::radius, w, plotDoE::x, and y.

Referenced by CoupledProblem().

setupOomph()

void CoupledProblem::setupOomph ( )

inline

                      {
        // set stiffness
        setElasticModulus(1e6);
        // set density
        setDensity(1000);
        // set solid dimensions
        unsigned nx=2, ny=2, nz=2;
        double xMax=5e-2, xMin=-xMax; // one litre of material, density 1000 -> 1 kg
        double yMax=5e-2, yMin=-yMax;
        double zMax=10e-2, zMin=0;
        setSolidCubicMesh(nx, ny, nz, xMin, xMax, yMin, yMax, zMin, zMax);
        // no pinned boundaries
        setIsPinned([](SolidNode* n, unsigned d) {
            return false;
        });
        // set dissipation
        setDissipation(0.0);
        // set gravity
        setBodyForceAsGravity();
        // set solver properties
        setNewtonSolverTolerance(3e-8);
        disable_info_in_newton_solve();
        linear_solver_pt()->disable_doc_time();
        // assemble
        prepareForSolve();
        // couple all boundaries
        coupleBoundary(Boundary::Z_MIN);
 
        double mass, elasticEnergy, kineticEnergy;
        Vector<double> com(3), linearMomentum(3), angularMomentum(3);
        getMassMomentumEnergy(mass, com, linearMomentum, angularMomentum, elasticEnergy, kineticEnergy);
        logger(INFO, "mass %, linearMomentum %, angularMomentum %, elasticEnergy %, totalEnergy %",
               mass, linearMomentum, angularMomentum, elasticEnergy, elasticEnergy+kineticEnergy);
    }

References SCoupling< M, O >::coupleBoundary(), e(), INFO, logger, n, Mesh_Parameters::nx, Mesh_Parameters::ny, and Mesh_Parameters::nz.

Referenced by CoupledProblem().

---

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

• SolidOnParticleBed.cpp