#include <sstream>
#include <iostream>
#include <iomanip>
#include <cmath>
#include "Mercury3D.h"
#include "Species/LinearViscoelasticFrictionSpecies.h"
#include "Walls/AxisymmetricIntersectionOfWalls.h"
#include "Walls/InfiniteWall.h"
#include "Boundaries/PeriodicBoundary.h"
#include <chrono>
Classes
class	RotatingDrum
Functions
int	main (int argc, char *argv[])
Function Documentation

◆ main()

int main	(	int argc	,
		char *	argv[]
	)
 {
  
     // Start measuring elapsed time
     std::chrono::time_point<std::chrono::system_clock> startClock, endClock;
     startClock = std::chrono::system_clock::now();
  
     RotatingDrum problem;
     
     //setting locally-available variables to define key
     //parameters such that they can be automatically included in
     //the name of the file
     //*******************Excitation Properties*****************************************
     //Drum rotation rate (rpm)
     double rotRateBasal = 15.0; 
     
     //vibration amplitude and frequency
     double fVib = 0.0;
     double aVib = 0.0;
     
     //*******************Frictional Properties*****************************************
     //sliding friction for species 1, 2 and wall
     double muSWall = 0.6;
     double muS1 = 0.1;
     double muS2 = 0.1;
     
     //rolling friction for species 1, 2 and wall
     double muRWall = 0.06;
     double muR1 = 0.01;
     double muR2 = 0.01;
     
     //torsion friction for species 1, 2 and wall
     double muTWall = 0.0;
     double muT1 = 0.000;
     double muT2 = 0.000;
     
     //the density ratio of particles
     double rhoRatio = 2500.0/2500.0;
     //the size ratio of particles
     double dRatio = 1.5;
     
     //the fraction of species 1 particles
     double specFrac = 0.5;
     
     double drumRad = 30*1.5*0.0015;
  
     double rotRate = 15.0;
         
     double froudeNumber = (rotRate * 2.0 * 3.1415926535 / 60.0) * (rotRate * 2.0 * 3.1415926535 / 60.0) * drumRad / 9.81;
  
     //the dimensionless drum length per core (L/(d_l*core))
     double dimDrumLengthPerCore = 10.0;
  
     unsigned nDoms = 8; // The number of domains into which the system is divided 
  
     double drumLength = dimDrumLengthPerCore*0.003*1.5*nDoms;
  
     //Set the number of domains for parallel decomposition
     problem.setNumberOfDomains({1,nDoms,1});
  
       
     //*******************Setting Up Filename******************************************
     //setting up a stringstream to use in order to create an instructive filename
     std::stringstream nameStream;
     //the generic 'root' of the name for the file that will be applied to all files
     //irrespective of parameters
     //std::string nameBase = "binary";
     std::string nameBase = "constLPerCore";
     
     //Name stream for tests looking at size segregation and concentration
     nameStream << nameBase << "-length" << dimDrumLengthPerCore << "-nDomains" << nDoms << "-rpm" << rotRate;
  
  
     //Name stream for tests looking at effect of vibration
     /*nameStream << nameBase << "-rotationRate" << rotRate 
                 << "-frequency" << fVib << "-amplitude" << aVib;
     */
  
     /*Name stream for tests looking for particle 'sinkage'
      * nameStream << nameBase << "-mu_s" << muS1 << "," << muS2 << "," << muSWall << ","
                             << "-mu_r" << muR1 << "," << muR2 << "," << muRWall << ","
                             << "-mu_t" << muT1 << "," << muT2 << "," << muTWall
                             << "-velocity" << rotRate << "-densityRatio" << rhoRatio;
     */
     std::string fullName = nameStream.str();
     problem.setName(fullName);
     //problem.autoNumber();
     problem.setDrumRadius(drumRad);// in meters
  
     problem.setXMin(0.0);
     problem.setYMin(0.0);
     problem.setZMin(0.0);
  
     problem.setXMax(2. * problem.getDrumRadius());
     problem.setZMax(2. * problem.getDrumRadius());
     problem.setYMax(drumLength);// in meters
     
     problem.setTimeMax(30.); //600s - equal to 150 rotations @ 15 rpm
     problem.setTimeStep(1.0/(800.0 * 50.0));
  
     problem.setGravity(Vec3D(0.,0.,-9.81));
     problem.setCOR(0.97,0.97,0.97);//drumWall, species1, species2
     problem.setSizeAndDensityRatio(dRatio,rhoRatio);//size ratio and density ratio
     problem.setFractionalPolydispersity(0.05);//10% dispersity
     problem.setDrumFillFraction(0.3);// At 0.5 the drum is 3/4 filled. 
     problem.setSpeciesVolumeFraction(specFrac);//Species1 volume fraction
     //redundant
     //problem.setFrictionCoeff(.6,.19);//(particle-wall-friction,part-part-friction)
     problem.setSlidingFriction(muSWall,muS1,muS2); //wall, species1, species2
     problem.setRollingFriction(muRWall,muR1,muR2); //wall, species1, species2
     problem.setTorsionFriction(muTWall,muT1,muT2); //wall, species1, species2
  
     problem.setRevolutionSpeed(rotRate);//rpm
     
     //setting vibration parameters
     problem.setVibrationAmplitude(aVib);
     problem.setVibrationFrequency(fVib);
  
     //problem.setSaveCount(1);
     problem.setSaveCount(20000);
     problem.setXBallsAdditionalArguments("-cmode 8 -solidf -v0");
     problem.readArguments(argc,argv);
  
     problem.speciesHandler.copyAndAddObject(LinearViscoelasticFrictionSpecies());
  
     problem.solve();
  
     // Measure elapsed time
     endClock = std::chrono::system_clock::now();
     std::chrono::duration<double> elapsed_seconds = endClock - startClock;
     logger(INFO, "Elapsed time for solving the PDE: % s", elapsed_seconds.count());
  
     return 0;
 }
Classes

Functions

Function Documentation

◆ main()
