FileReader Class Reference

This gives functionality to read information from binary formats like STL etc. This class is complete stand-alone and is tested with one any reference to other MecuryDPM code except Vections and Logger. More...

Public Member Functions
	FileReader (std::string name)
	Default constuction, requires to users to prove the name of the file that will be opened. More...
bool	read ()
	~FileReader ()
	Destructor, simple closes the file. More...

Private Types
enum class	Version { P3 , P4 }
	The version number of the particle analytics files. More...

Private Attributes
std::ifstream	pFile_
	Pointers for the input files. More...
std::ifstream	cFile_
std::ifstream	wFile_
enum FileReader::Version	version_
Mercury3D	dpm

Detailed Description

This gives functionality to read information from binary formats like STL etc. This class is complete stand-alone and is tested with one any reference to other MecuryDPM code except Vections and Logger.

Member Enumeration Documentation

Version

enum FileReader::Version

strongprivate

The version number of the particle analytics files.

Enumerator
P3
P4

{P3, P4} version_;

Constructor & Destructor Documentation

FileReader()

FileReader::FileReader ( std::string  name )

inlineexplicit

Default constuction, requires to users to prove the name of the file that will be opened.

                                        {
        pFile_.open(name+".p3p");
        if (pFile_) {
            version_ = Version::P3;
            wFile_.open(name+".p3w");
            cFile_.open(name+".p3c");
            if (!wFile_) logger(ERROR, "Could not open %", name + ".p3w");
            if (!cFile_) logger(ERROR, "Could not open %", name + ".p3c");
        } else {
            version_ = Version::P4;
            pFile_.open(name+".p4p");
            wFile_.open(name+".p4w");
            cFile_.open(name+".p4c");
            if (!pFile_) logger(ERROR, "Could not open % or %", name + ".p3p",name + ".p4p");
            if (!wFile_) logger(ERROR, "Could not open %", name + ".p4w");
            if (!cFile_) logger(ERROR, "Could not open %", name + ".p4c");
        }
        logger(INFO,"Input files opened");
 
        dpm.setName(name);
    }

References cFile_, dpm, ERROR, INFO, logger, units::name, P3, P4, pFile_, DPMBase::setName(), version_, and wFile_.

~FileReader()

FileReader::~FileReader ( )

inline

Destructor, simple closes the file.

                  {
        pFile_.close();
        wFile_.close();
        cFile_.close();
        logger(INFO,"Input files closed");
    }

References cFile_, INFO, logger, pFile_, and wFile_.

Member Function Documentation

read()

bool FileReader::read ( )

inline

Todo:

taking this line of of the for loop gives a huge speed improvement; why?

                {
        dpm.interactionHandler.clear();
        dpm.particleHandler.clear();
        dpm.wallHandler.clear();
 
        std::string line;
 
        //read first line p3p
        std::getline(pFile_, line);
        if (!line.compare(""))
            return false;
 
        //read second line p3p
        Mdouble time;
        unsigned N;
        pFile_ >> time >> N;
        dpm.setTime(time);
        dpm.particleHandler.setStorageCapacity(N);
        std::getline(pFile_, line);
 
        //read third line p3p
        std::getline(pFile_, line);
 
        //read next lines p3p
        logger(INFO,"Reading % particles at time %",N,time);
        {
            SphericalParticle p; 
            for (unsigned i = 0; i < N; ++i) {
                unsigned id, species;
                Mdouble volume, mass;
                Vec3D position, velocity;
                pFile_ >> id >> species >> volume >> mass >> position >> velocity;
                std::getline(pFile_, line);
                if (version_==Version::P3) species--;
                //logger(INFO,"% % % % % %",id, species, volume, mass, position, velocity);
                // add new species as necessary
                while (dpm.speciesHandler.getNumberOfObjects() <= species) {
                    LinearViscoelasticReversibleAdhesiveSpecies species;
                    species.setDensity(mass / volume);
                    //use an infinite interaction radius
                    species.setAdhesionForceMax(1e20);
                    species.setAdhesionStiffness(1);
                    logger(INFO, "Adding species of density %", species.getDensity());
                    dpm.speciesHandler.copyAndAddObject(species);
                }
                p.setSpecies(dpm.speciesHandler.getObject(species));
                p.setRadius(cbrt(0.75 / pi * volume));
                p.setPosition(position);
                p.setVelocity(velocity);
                dpm.particleHandler.copyAndAddObject(p)->setId(id);
            }
        }
        //logger(INFO,"Read % particles",dpm.particleHandler.getNumberOfObjects());
 
        //read first line p3c
        std::getline(cFile_, line);
        if (!line.compare(""))
            return false;
 
        //read second line p3c
        cFile_ >> time >> N;
        if (fabs(dpm.getTime()/time-1)>0.01)
            logger(ERROR,"Timesteps in p3c and p3p do not agree: % %",dpm.getTime(),time);
        dpm.interactionHandler.setStorageCapacity(N);
        std::getline(cFile_, line);
 
        //read third line p3c
        std::getline(cFile_, line);
 
        //read next lines p3c
        logger(INFO,"Reading % contacts",N,time);
        for (unsigned i=0; i<N; ++i) {
            unsigned id1, id2;
            Vec3D force, contact;
            cFile_ >> id1 >> id2;
            BaseParticle* p1 = dpm.particleHandler.getObjectById(id1);
            BaseParticle* p2 = dpm.particleHandler.getObjectById(id2);
            logger.assert_debug(p1 != nullptr, "Particle % does not exist", id1);
            logger.assert_debug(p2 != nullptr, "Particle % does not exist", id1);
            Vec3D P1ToP2 = p2->getPosition() - p1->getPosition();
            BaseInteraction* c = p1->getInteractionWith(p2, time, &dpm.interactionHandler);
            logger.assert_debug(c != nullptr, "Particle-particle interaction % % does not exist", p1, p2);
            c->setDistance(P1ToP2.getLength());
            c->setNormal(P1ToP2 / c->getDistance());
            c->setOverlap(c->getDistance() - p1->getRadius() - p2->getRadius());
            if (version_ == Version::P3)
            {
                cFile_ >> force;
                contact = p1->getPosition() - P1ToP2 * ((p1->getRadius() - 0.5 * c->getOverlap()) / c->getDistance());
            }
            else
            {
                cFile_ >> contact >> force;
            }
            std::getline(cFile_, line);
            c->setContactPoint(contact);
            c->setForce(force);
            if (i % (N / 10) == 0)
            {
                logger(INFO, "\r %", std::round((double) i / N * 100));
            }
        }
        logger(INFO, "");
    
        //read first line p3w
        std::getline(wFile_, line);
        if (!line.compare(""))
            return false;
    
        //read second line p3w
        wFile_ >> time >> N;
        if (fabs(dpm.getTime() / time - 1) > 0.01)
            logger(ERROR, "Timesteps in p3w and p3p do not agree");
        dpm.interactionHandler.setStorageCapacity(N);
        std::getline(wFile_, line);
    
        //read third line p3w
        std::getline(wFile_, line);
    
        //create wall
        InfiniteWall wall;
        wall.setSpecies(dpm.speciesHandler.getObject(0));
        auto w = dpm.wallHandler.copyAndAddObject(wall);
 
        //read next lines p3w
        logger(INFO,"Reading % wall contacts",N,time);
        for (unsigned i=0; i<N; ++i) {
            unsigned id;
            Vec3D force, contact, particleToContact;
            wFile_ >> id;
            BaseParticle* p = dpm.particleHandler.getObjectById(id);
            logger.assert_debug(p!=nullptr,"Particle % does not exist",id);
            BaseInteraction* c = w->getInteractionWith(p,time,&dpm.interactionHandler);
            logger.assert_debug(c!= nullptr,"Particle-wall interaction % % does not exist",p,w);
            if (version_==Version::P3) {
                wFile_ >> force >> particleToContact;
                contact = p->getPosition()-particleToContact;
            } else {
                wFile_ >> contact >> force;
                particleToContact = p->getPosition()-contact;
            }
            std::getline(wFile_, line);
            c->setContactPoint(contact);
            c->setDistance(particleToContact.getLength());
            c->setNormal(particleToContact/c->getDistance());
            c->setOverlap(c->getDistance()-p->getRadius());
            c->setForce(force);
        }
 
        logger(INFO,"Writing output files");
        for (const auto p : dpm.particleHandler) {
            dpm.setMin(Vec3D::min(dpm.getMin(),p->getPosition()));
            dpm.setMax(Vec3D::max(dpm.getMax(),p->getPosition()));
        }
        for (const auto c : dpm.interactionHandler) {
            dpm.setMin(Vec3D::min(dpm.getMin(),c->getContactPoint()));
            dpm.setMax(Vec3D::max(dpm.getMax(),c->getContactPoint()));
        }
        dpm.forceWriteOutputFiles();
        return true;
    }

References cFile_, BaseHandler< T >::clear(), ParticleHandler::clear(), BaseHandler< T >::copyAndAddObject(), dpm, ERROR, DPMBase::forceWriteOutputFiles(), ParticleSpecies::getDensity(), BaseInteraction::getDistance(), BaseParticle::getInteractionWith(), Vec3D::getLength(), DPMBase::getMax(), DPMBase::getMin(), BaseHandler< T >::getNumberOfObjects(), BaseHandler< T >::getObject(), BaseHandler< T >::getObjectById(), BaseInteraction::getOverlap(), BaseInteractable::getPosition(), BaseParticle::getRadius(), DPMBase::getTime(), constants::i, INFO, DPMBase::interactionHandler, logger, Vec3D::max(), Vec3D::min(), P3, DPMBase::particleHandler, pFile_, constants::pi, helpers::round(), BaseInteraction::setContactPoint(), ParticleSpecies::setDensity(), BaseInteraction::setDistance(), BaseInteraction::setForce(), DPMBase::setMax(), DPMBase::setMin(), BaseInteraction::setNormal(), BaseInteraction::setOverlap(), BaseInteractable::setPosition(), BaseParticle::setRadius(), BaseParticle::setSpecies(), BaseWall::setSpecies(), BaseHandler< T >::setStorageCapacity(), DPMBase::setTime(), BaseInteractable::setVelocity(), DPMBase::speciesHandler, version_, DPMBase::wallHandler, and wFile_.

Referenced by main().

Member Data Documentation

cFile_

std::ifstream FileReader::cFile_

private

Referenced by FileReader(), read(), and ~FileReader().

dpm

Mercury3D FileReader::dpm

private

Referenced by FileReader(), and read().

pFile_

std::ifstream FileReader::pFile_

private

Pointers for the input files.

Referenced by FileReader(), read(), and ~FileReader().

version_

enum FileReader::Version FileReader::version_

private

Referenced by FileReader(), and read().

wFile_

std::ifstream FileReader::wFile_

private

Referenced by FileReader(), read(), and ~FileReader().

---

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

• ParticleAnalytics2Mercury.cpp