data2pvd.cpp File Reference

#include <iostream>
#include <fstream>
#include <Logger.h>
#include "MercuryData.h"
#include "VTKData.h"

Functions
template<std::size_t NDIMS>
int	transformMercuryToVTK (MercuryDataFile &infile, std::string prefix)
	Templated version to automatically generate VTK output files. More...
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

{
  //Check to see if we actually received two arguments
  if (argc != 3)
  {
    //We didn't. Print a usage and exit the program.
    logger(FATAL, "Usage: % [infile] [outfilePrefix]\n"
                 "  This program converts MercuryDPM .data files to ParaView .pvd data files.\n"
                 "  which can then be used directly into ParaView, to visualize your particles.\n"
                 "\n"
                 "   infile: MercuryDPM .data file\n"
                 "\n"
                 "   outfilePrefix: Prefix to prepend to the output files generated.\n"
                 "     The following files will be generated:\n"
                 "       - prefix.pvd\n"
                 "       - prefix_0.vtu\n"
                 "       - prefix_1.vtu\n"
                 "           ( ... )\n"
                 "       - prefix_987654321.vtu\n"
                 "     depending on the amount of time steps.", argv[0]);
  }
  
  // Open our Mercury 3D data file.
  MercuryDataFile infile(argv[1]);
  
  // Was it readable?
  if (!infile)
  {
    logger(FATAL, "Could not open ''%' for input.\n"
                 "Please make sure the file exists and you have the appropriate rights.", argv[1]);
  }
  //make sure we don't end in a slash, as this both breaks the creation of a relative path right now,
  //and it's really not what you want to end up with...
  if (std::string(argv[2]).back() == '/')
  {
    logger(ERROR, "The output prefix ends in a slash. This is not allowed.");
  }
 
  //And were we using a 3D file format?
  if (infile.isMercuryDataFile<3>())
  {
    logger(VERBOSE, "Assuming 3D data format.");
    return transformMercuryToVTK<3>(infile, argv[2]);
  }//Or a 2d format?
  else if (infile.isMercuryDataFile<2>())
  {
    logger(VERBOSE, "Assuming 2D data format.");
    return transformMercuryToVTK<2>(infile, argv[2]);
  }//help...
  else
  {
    logger(ERROR, "The file '%' does not seem to be a Mercury .data file.\n"
                  "Please make sure you are reading the correct file.", argv[1]);
    return 4;
  }
}

References ERROR, FATAL, MercuryDataFile::isMercuryDataFile(), logger, and VERBOSE.

transformMercuryToVTK()

template<std::size_t NDIMS>

int transformMercuryToVTK	(	MercuryDataFile &	infile,
		std::string	prefix
	)

Templated version to automatically generate VTK output files.

this function reads the NDIMS-dimensional Mercury .data file, and writes all the corresponding VTK output files.

{
  //We really want to describe our exit code.
  int exitCode = 0;
  
  //We'll set up a descriptor.
  //Let the compiler figure out what the types / dimensions are, that's too
  //much work anyway. Oh and make sure position is used as both a datafield
  //and the actual position of the object.
  VTKPointDescriptor< MercuryParticle<NDIMS> > descriptor;
  descriptor
    .addProperty( "Position",    & MercuryParticle< NDIMS >::position , true)
    .addProperty( "Velocity",    & MercuryParticle< NDIMS >::velocity  )
    .addProperty( "Rotation",    & MercuryParticle< NDIMS >::rotation  )
    .addProperty( "AngVelocity", & MercuryParticle< NDIMS >::angularV  )
    .addProperty( "Radius",      & MercuryParticle< NDIMS >::radius    )
    .addProperty( "Species",     & MercuryParticle< NDIMS >::speciesID );
    
  // We want a Collection file which lists all individual files
  VTKCollection collection( prefix + ".pvd" );
  // First, make sure it is sane.
  if (!collection)
    logger( FATAL, "Could not open '%.pvd' for output.\n"
                   "Please make sure you have the appropriate permissions and try again.", prefix);
  
  std::size_t timeStepCount = 0;
  
  //Now, read all the time steps as if they were NDIMS long.
  for (const MercuryTimeStep<NDIMS> & ts : infile.as<NDIMS>())
  {
    //Generate the filename for the individual data files.
    std::ostringstream filename;
    filename << prefix << '_' << ts.getTimeStepID() << ".vtu";
    
    //We'll set up a datafile containing the individual time step.
    VTKUnstructuredGrid< MercuryParticle<NDIMS> > timeStepFile(filename.str(), &descriptor);
    if (!timeStepFile) //but not after we've done some sanity checking!
    {
      logger(WARN, "Could not open '%' for output.\n"
                   "Please make sure you have the appropriate permissions and try again.", filename.str());
      exitCode = 6;
      break;
    }
    
    if (!infile) //Some sanity checking? More sanity checking! ALL the sanity checking!!!
    {
      logger(WARN, "An IOError occurred during the reading of the input file.\n"
                   "Please make sure you are feeding this tool mercury data files.");
      exitCode = 5; 
      break;
    }
    //Okay. we done.
    //Let's write.
    timeStepFile.write(ts);
    
    //So, a user may give an output path which is in a different directory. 
    // However, since the index files resides in the same output directory
    // as the time step files, we need to specify relative paths.
    std::string strippedPath = filename.str();
    //so, we try to find the last / - because to hell with everybody with other
    //path separators...
    std::string::size_type slashPosition = strippedPath.rfind('/');
    //and take only the last part. It's not the last character, trust me.
    //we checked for that in main().
    if (slashPosition != std::string::npos)
      strippedPath = strippedPath.substr(slashPosition + 1);
    //And now put the relative path in the listing file
    collection.append(strippedPath);
    
    timeStepCount++;
    logger(INFO, "Written %", filename.str());
  }
  
  logger(INFO, "Written % time steps in a %D system.", timeStepCount, NDIMS);
  
  return exitCode;
}

References VTKPointDescriptor< T >::addProperty(), VTKCollection::append(), MercuryDataFile::as(), FATAL, INFO, logger, WARN, and VTKUnstructuredGrid< T >::write().