testDrum.cpp File Reference

#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;
}

References INFO, logger, problem, and oomph::Global_string_for_annotation::string().