DataFiles Class Reference

Public Member Functions
	DataFiles (int argc, char *argv[])
	~DataFiles ()
void	write ()

Private Member Functions
bool	writeTimeStep ()

Private Attributes
std::vector< IFile >	iFiles
std::ofstream	oFile
unsigned	oCount = 0
std::string	ending = ""

Constructor & Destructor Documentation

DataFiles()

DataFiles::DataFiles ( int  argc, char *  argv[]  )

inline

opens the input and output data files

    {
        std::string name = getName(argc, argv);
 
        //check if there is an ending (the user might just specify the file root)
        size_t dot = name.find_last_of('.');
        // if no ending is found, assume .data0
        if (dot==std::string::npos) {
            name += ".data0";
        }
 
        //take off ending .0000 if necessary
        dot = name.find_last_of('.');
        char afterDot = name[dot + 1];
        //if last ending is a number
        if (afterDot >= '0' && afterDot <= '9') {
            ending = name.substr(dot);
            name.resize(dot);
        }
 
        // take off ending .data0
        {
            size_t dot = name.find_last_of('.');
            name.resize(dot);
        }
 
        // opens the input data files, if they exist
        for(unsigned processorID = 0; true; ++processorID) {
            //get input file name
            std::string fileName = name + ".data" + std::to_string(processorID) + ending;
            auto* file = new std::ifstream(fileName.c_str());
            if (file->fail()) {
                break;
            } else {
                iFiles.emplace_back(file,0);
                logger(INFO,"Opened % for input",fileName);
            }
        }
        logger.assert_always(!iFiles.empty(),"No input file found with name % ",name + ".data0" + ending);
 
        // opens output data file
        std::string oFileName = name + ".data" + ending;
        oFile.open(oFileName);
        if (oFile.fail()) {
            logger(ERROR,"% could not be opened",oFileName);
        } else {
            logger(INFO, "Opened % for output", oFileName);
        }
 
        write();
    }

References ending, ERROR, getName(), iFiles, INFO, logger, units::name, oFile, and write().

~DataFiles()

DataFiles::~DataFiles ( )

inline

closes the input/output data files

                 {
        for (auto iFile : iFiles) {
            delete iFile.file;
        }
    }

References iFiles.

Member Function Documentation

write()

void DataFiles::write ( )

inline

write all time steps

                 {
        while (writeTimeStep()) {};
        if (oCount!=1) logger(INFO,"Written % time steps",oCount);
    }

References INFO, logger, oCount, and writeTimeStep().

Referenced by DataFiles().

writeTimeStep()

bool DataFiles::writeTimeStep ( )

inlineprivate

writes single timestep

                         {
        // read header line
        static Mdouble time = 0;
        unsigned n = 0;
        std::string line;
        for(auto& iFile : iFiles) {
            // read number of particles
            *iFile.file >> iFile.n;
            n += iFile.n;
            // read time stamp
            *iFile.file >> iFile.time;
            //stop if this was last time step
            if (iFile.file->fail()) return false;
            //read rest of line
            std::getline(*iFile.file, line);
            //check this is indeed a header line
            static std::string headerLine = line;
            // this is the error-catching routine:
            // if this is not a true header line, or the timestamp is in the past, keep reading
            if (line != headerLine || iFile.time < time) {
                do {
                    *iFile.file >> iFile.n;
                    n += iFile.n;
                    *iFile.file >> iFile.time;
                    if (iFile.file->fail()) return false;
                    std::getline(*iFile.file, line);
                } while (line != headerLine || iFile.time < time);
                logger(WARN,"Mistake detected; moving forward to time %",iFile.time);
                oCount--; //remove last-written timestep (if MULTIPLE_FILES)
            }
            time = iFile.time;
        }
        time *= 1.000000001; //so the next time step is surely bigger than the last
 
        //write header
        oFile << n << ' ' << time << line << '\n';
        logger(INFO,"Writing % %%",n,time,line);
        // write content
        for(auto& iFile : iFiles) {
            for (unsigned i=0; i<iFile.n; ++i) {
                std::getline(*iFile.file, line);
                oFile << line << '\n';
            }
        }
        ++oCount;
        return true;
    }

References constants::i, iFiles, INFO, logger, n, oCount, oFile, and WARN.

Referenced by write().

Member Data Documentation

ending

std::string DataFiles::ending = ""

private

Referenced by DataFiles().

iFiles

std::vector<IFile> DataFiles::iFiles

private

Referenced by DataFiles(), writeTimeStep(), and ~DataFiles().

oCount

unsigned DataFiles::oCount = 0

private

Referenced by write(), and writeTimeStep().

oFile

std::ofstream DataFiles::oFile

private

Referenced by DataFiles(), and writeTimeStep().

---

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

• CombineParallelDataFiles.cpp