#include <Streamer.h>

Inheritance diagram for Streamer:

Collaboration diagram for Streamer:

Public Member Functions
void	addTable (Id table)
	Add a table to streamer. More...

void	addTables (vector< Id > tables)
	Add multiple tables to Streamer. More...

void	cleanUp (void)
	This function is called from Shell when simulation is called to write the left-over data to streamer file. More...

string	getFormat (void) const

size_t	getNumTables (void) const
	Get the number of tables handled by Streamer. More...

string	getOutFilepath (void) const

Streamer &	operator= (const Streamer &st)

void	process (const Eref &e, ProcPtr p)
	This function is called at its clock tick. More...

void	reinit (const Eref &e, ProcPtr p)
	Reinit. More...

void	removeTable (Id table)
	Remove a table from Streamer. More...

void	removeTables (vector< Id > table)
	Remove multiple tables – if found – from Streamer. More...

void	setFormat (string format)

void	setOutFilepath (string path)

	Streamer ()

void	zipWithTime ()
	This function prepares data to be written to a file. More...

	~Streamer ()

Public Member Functions inherited from StreamerBase
string	getOutFilepath () const

StreamerBase &	operator= (const StreamerBase &st)

void	setOutFilepath (string stream)

	StreamerBase ()

	~StreamerBase ()

Public Member Functions inherited from TableBase
void	clearVec ()

void	compareVec (vector< double > other, string op)

void	compareXplot (string fname, string plotname, string op)

const vector< double > &	data ()

double	getOutputValue () const

string	getPlotDump () const

vector< double >	getVec () const

unsigned int	getVecSize () const

double	getY (unsigned int index) const

double	interpolate (double x, double xmin, double xmax) const

void	linearTransform (double scale, double offset)

void	loadCSV (string fname, int startLine, int colNum, char separator)

void	loadXplot (string fname, string plotname)

void	loadXplotRange (string fname, string plotname, unsigned int start, unsigned int end)

double *	lookupVec (unsigned int index)

void	plainPlot (string file)

void	setOutputValue (double val)

void	setPlotDump (string v)

void	setVec (vector< double > val)

void	setVecSize (unsigned int num)

	TableBase ()

void	xplot (string file, string plotname)

Static Public Member Functions
static const Cinfo *	initCinfo ()

Static Public Member Functions inherited from StreamerBase
static void	writeToCSVFile (const string &filepath, const string &openmode, const vector< double > &data, const vector< string > &columns)
	Write data to csv file. See the documentation of writeToOutfile for details. More...

static void	writeToNPYFile (const string &filepath, const string &openmode, const vector< double > &data, const vector< string > &columns)
	Write to NPY format. See the documentation of writeToOutfile for more details. More...

static void	writeToOutFile (const string &filepath, const string &format, const string &openmode, const vector< double > &data, const vector< string > &columns)
	Write to a output file in given format. More...

Static Public Member Functions inherited from TableBase
static const Cinfo *	initCinfo ()

Private Attributes
vector< string >	columns_

double	currTime_

vector< double >	data_

string	format_

bool	isOutfilePathSet_

string	outfilePath_

vector< double >	tableDt_

vector< Id >	tableIds_

vector< Table * >	tables_

vector< unsigned int >	tableTick_

Additional Inherited Members
Protected Member Functions inherited from TableBase
vector< double > &	vec ()

Detailed Description

Definition at line 33 of file Streamer.h.

Constructor & Destructor Documentation

Streamer::Streamer ( )

Definition at line 139 of file Streamer.cpp.

References columns_, data_, format_, tableDt_, tableIds_, tables_, and tableTick_.

 {
     // Not all compilers allow initialization during the declaration of class
     // methods.
     format_ = "npy";
     columns_.push_back( "time" );               /* First column is time. */
     tables_.resize(0);
     tableIds_.resize(0);
     tableTick_.resize(0);
     tableDt_.resize(0);
     data_.resize(0);
 }

Streamer::~Streamer ( )

Definition at line 158 of file Streamer.cpp.

159 {

160 }

Member Function Documentation

void Streamer::addTable ( Id table )

Add a table to streamer.

Parameters

table Id of table.

Definition at line 281 of file Streamer.cpp.

References columns_, Eref::data(), Id::element(), Id::eref(), Table::getColumnName(), Element::getTick(), moose::moosePathToUserPath(), Id::path(), tableIds_, tables_, and tableTick_.

Referenced by addTables(), and initCinfo().

 {
     // If this table is not already in the vector, add it.
     for( size_t i = 0; i < tableIds_.size(); i++)
         if( table.path() == tableIds_[i].path() )
             return;                             /* Already added. */
 
     Table* t = reinterpret_cast<Table*>(table.eref().data());
     tableIds_.push_back( table );
     tables_.push_back( t );
     tableTick_.push_back( table.element()->getTick() );
 
     // NOTE: If user can make sure that names are unique in table, using name is
     // better than using the full path.
     if( t->getColumnName().size() > 0 )
         columns_.push_back( t->getColumnName( ) );
     else
         columns_.push_back( moose::moosePathToUserPath( table.path() ) );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::addTables ( vector< Id > tables )

Add multiple tables to Streamer.

Parameters

tables

Definition at line 306 of file Streamer.cpp.

References addTable().

Referenced by initCinfo().

 {
     if( tables.size() == 0 )
         return;
     for( vector<Id>::const_iterator it = tables.begin(); it != tables.end(); it++)
         addTable( *it );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::cleanUp ( void )

This function is called from Shell when simulation is called to write the left-over data to streamer file.

Definition at line 249 of file Streamer.cpp.

References columns_, data_, format_, outfilePath_, StreamerBase::writeToOutFile(), and zipWithTime().

Referenced by Shell::doStart().

 {
     zipWithTime( );
     StreamerBase::writeToOutFile( outfilePath_, format_, "a", data_, columns_ );
     data_.clear( );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

string Streamer::getFormat ( void ) const

Definition at line 386 of file Streamer.cpp.

References format_.

Referenced by initCinfo().

 {
     return format_;
 }

Here is the caller graph for this function:

size_t Streamer::getNumTables ( void ) const

Get the number of tables handled by Streamer.

Returns: Number of tables.

Definition at line 354 of file Streamer.cpp.

References tables_.

Referenced by initCinfo().

 {
     return tables_.size();
 }

Here is the caller graph for this function:

string Streamer::getOutFilepath ( void ) const

Definition at line 360 of file Streamer.cpp.

References outfilePath_.

Referenced by initCinfo().

 {
     return outfilePath_;
 }

Here is the caller graph for this function:

const Cinfo * Streamer::initCinfo ( )

static

Definition at line 28 of file Streamer.cpp.

References addTable(), addTables(), getFormat(), getNumTables(), getOutFilepath(), TableBase::initCinfo(), process(), reinit(), removeTable(), removeTables(), setFormat(), setOutFilepath(), and tableStreamCinfo.

 {
     /*-----------------------------------------------------------------------------
      * Finfos
      *-----------------------------------------------------------------------------*/
     static ValueFinfo< Streamer, string > outfile(
         "outfile"
         , "File/stream to write table data to. Default is is __moose_tables__.dat.n"
         " By default, this object writes data every second \n"
         , &Streamer::setOutFilepath
         , &Streamer::getOutFilepath
     );
 
     static ValueFinfo< Streamer, string > format(
         "format"
         , "Format of output file, default is csv"
         , &Streamer::setFormat
         , &Streamer::getFormat
     );
 
     static ReadOnlyValueFinfo< Streamer, size_t > numTables (
         "numTables"
         , "Number of Tables handled by Streamer "
         , &Streamer::getNumTables
     );
 
     /*-----------------------------------------------------------------------------
      *
      *-----------------------------------------------------------------------------*/
     static DestFinfo process(
         "process"
         , "Handle process call"
         , new ProcOpFunc< Streamer >( &Streamer::process )
     );
 
     static DestFinfo reinit(
         "reinit"
         , "Handles reinit call"
         , new ProcOpFunc< Streamer > ( &Streamer::reinit )
     );
 
 
     static DestFinfo addTable(
         "addTable"
         , "Add a table to Streamer"
         , new OpFunc1<Streamer, Id>( &Streamer::addTable )
     );
 
     static DestFinfo addTables(
         "addTables"
         , "Add many tables to Streamer"
         , new OpFunc1<Streamer, vector<Id> >( &Streamer::addTables )
     );
 
     static DestFinfo removeTable(
         "removeTable"
         , "Remove a table from Streamer"
         , new OpFunc1<Streamer, Id>( &Streamer::removeTable )
     );
 
     static DestFinfo removeTables(
         "removeTables"
         , "Remove tables -- if found -- from Streamer"
         , new OpFunc1<Streamer, vector<Id> >( &Streamer::removeTables )
     );
 
     /*-----------------------------------------------------------------------------
      *  ShareMsg definitions.
      *-----------------------------------------------------------------------------*/
     static Finfo* procShared[] =
     {
         &process , &reinit , &addTable, &addTables, &removeTable, &removeTables
     };
 
     static SharedFinfo proc(
         "proc",
         "Shared message for process and reinit",
         procShared, sizeof( procShared ) / sizeof( const Finfo* )
     );
 
     static Finfo * tableStreamFinfos[] =
     {
         &outfile, &format, &proc, &numTables
     };
 
     static string doc[] =
     {
         "Name", "Streamer",
         "Author", "Dilawar Singh, 2016, NCBS, Bangalore.",
         "Description", "Streamer: Stream moose.Table data to out-streams\n"
     };
 
     static Dinfo< Streamer > dinfo;
 
     static Cinfo tableStreamCinfo(
         "Streamer",
         TableBase::initCinfo(),
         tableStreamFinfos,
         sizeof( tableStreamFinfos )/sizeof(Finfo *),
         &dinfo,
         doc,
         sizeof(doc) / sizeof(string)
     );
 
     return &tableStreamCinfo;
 }

Here is the call graph for this function:

Streamer & Streamer::operator= ( const Streamer & st )

Definition at line 152 of file Streamer.cpp.

 {
     return *this;
 }

void Streamer::process	(	const Eref &	e,
		ProcPtr	p
	)

This function is called at its clock tick.

Dest functions. The process function called by scheduler on every tick

Parameters

e
p

Definition at line 262 of file Streamer.cpp.

References columns_, data_, format_, TableBase::getVecSize(), outfilePath_, tables_, StreamerBase::writeToOutFile(), and zipWithTime().

Referenced by initCinfo().

 {
     //LOG( moose::debug, "Writing to table" );
     zipWithTime( );
 
     // Write only if there are more than 100 entry in first table.
     if( tables_[0]->getVecSize() > 100 )
     {
         StreamerBase::writeToOutFile( outfilePath_, format_, "a", data_, columns_ );
         data_.clear( );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::reinit	(	const Eref &	e,
		ProcPtr	p
	)

Reinit.

The reinit function called by scheduler for the reset

Parameters

e
p

Definition at line 168 of file Streamer.cpp.

References columns_, currTime_, Eref::data(), data_, Eref::element(), Id::element(), Id::eref(), format_, Element::getTick(), Clock::getTickDt(), Eref::id(), isOutfilePathSet_, LOG, moose::moosePathToUserPath(), outfilePath_, Id::path(), path, setOutFilepath(), Element::setTick(), moose::showWarn(), tableDt_, tableIds_, tables_, tableTick_, moose::warning, StreamerBase::writeToOutFile(), and zipWithTime().

Referenced by initCinfo().

 {
 
     if( tables_.size() == 0 )
     {
         moose::showWarn( "Zero tables in streamer. Disabling Streamer" );
         e.element()->setTick( -2 );             /* Disable process */
         return;
     }
 
     Clock* clk = reinterpret_cast<Clock*>( Id(1).eref().data() );
     for (size_t i = 0; i < tableIds_.size(); i++)
     {
         int tickNum = tableIds_[i].element()->getTick();
         double tick = clk->getTickDt( tickNum );
         tableDt_.push_back( tick );
         // Make sure that all tables have the same tick.
         if( i > 0 )
         {
             if( tick != tableDt_[0] )
             {
                 moose::showWarn( "Table " + tableIds_[i].path() + " has "
                         " different clock dt. "
                         " Make sure all tables added to Streamer have the same "
                         " dt value."
                         );
             }
         }
     }
 
 
     // Push each table dt_ into vector of dt
     for( size_t i = 0; i < tables_.size(); i++)
     {
         Id tId = tableIds_[i];
         int tickNum = tId.element()->getTick();
         tableDt_.push_back( clk->getTickDt( tickNum ) );
     }
 
     // Make sure all tables have same dt_ else disable the streamer.
     vector<unsigned int> invalidTables;
     for (size_t i = 1; i < tableTick_.size(); i++)
     {
         if( tableTick_[i] != tableTick_[0] )
         {
             LOG( moose::warning
                     , "Table " << tableIds_[i].path()
                     << " has tick (dt) which is different than the first table."
                     << endl
                     << " Got " << tableTick_[i] << " expected " << tableTick_[0]
                     << endl << " Disabling this table."
                     );
             invalidTables.push_back( i );
         }
     }
 
     for (size_t i = 0; i < invalidTables.size(); i++)
     {
         tables_.erase( tables_.begin() + i );
         tableDt_.erase( tableDt_.begin() + i );
         tableIds_.erase( tableIds_.begin() + i );
     }
 
     if( ! isOutfilePathSet_ )
     {
         string defaultPath = "_tables/" + moose::moosePathToUserPath( e.id().path() );
         setOutFilepath( defaultPath );
     }
 
     // Prepare data. Add columns names and write whatever values are available
     // write now.
     currTime_ = 0.0;
     zipWithTime( );
     StreamerBase::writeToOutFile( outfilePath_, format_, "w", data_, columns_);
     data_.clear( );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::removeTable ( Id table )

Remove a table from Streamer.

Parameters

table. Id of table.

Definition at line 320 of file Streamer.cpp.

References columns_, Id::path(), tableIds_, and tables_.

Referenced by initCinfo(), and removeTables().

 {
     int matchIndex = -1;
     for (size_t i = 0; i < tableIds_.size(); i++)
         if( table.path() == tableIds_[i].path() )
         {
             matchIndex = i;
             break;
         }
 
     if( matchIndex > -1 )
     {
         tableIds_.erase( tableIds_.begin() + matchIndex );
         tables_.erase( tables_.begin() + matchIndex );
         columns_.erase( columns_.begin() + matchIndex );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::removeTables ( vector< Id > tables )

Remove multiple tables – if found – from Streamer.

Parameters

tables

Definition at line 343 of file Streamer.cpp.

References removeTable().

Referenced by initCinfo().

 {
     for( vector<Id>::const_iterator it = tables.begin(); it != tables.end(); it++)
         removeTable( *it );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::setFormat ( string format )

Definition at line 380 of file Streamer.cpp.

References format_.

Referenced by initCinfo(), and setOutFilepath().

 {
     format_ = fmt;
 }

Here is the caller graph for this function:

void Streamer::setOutFilepath ( string path )

Definition at line 365 of file Streamer.cpp.

References moose::createParentDirs(), moose::getExtension(), isOutfilePathSet_, outfilePath_, setFormat(), and moose::toFilename().

Referenced by initCinfo(), and reinit().

 {
     outfilePath_ = filepath;
     isOutfilePathSet_ = true;
     if( ! moose::createParentDirs( filepath ) )
         outfilePath_ = moose::toFilename( outfilePath_ );
 
     string format = moose::getExtension( outfilePath_, true );
     if( format.size() > 0)
         setFormat( format );
     else
         setFormat( "csv" );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Streamer::zipWithTime ( )

This function prepares data to be written to a file.

Definition at line 394 of file Streamer.cpp.

References TableBase::clearVec(), currTime_, data_, moose::debug, TableBase::getVec(), LOG, tableDt_, and tables_.

Referenced by cleanUp(), process(), and reinit().

 {
     size_t numEntriesInEachTable = tables_[0]->getVecSize( );
 
     //LOG( moose::debug, "Entries in each table " << numEntriesInEachTable );
 
     // Collect data from all table. If some table does not have enough data,
     // fill it with nan
     vector< vector< double > > collectedData;
     for( size_t i = 0; i < tables_.size( ); i++ )
     {
         vector<double> tVec( tables_[i]->getVec( ) );
         if( tVec.size( ) <= numEntriesInEachTable )
         {
 #if 0
             LOG( moose::debug
                     , "Table " << tables_[i]->getName( ) << " is not functional. Filling with zero "
                     );
 #endif
             tVec.resize( numEntriesInEachTable, 0 );
         }
         collectedData.push_back( tVec );
     }
 
     // Turn it into a table format. Its like taking a transpose of vector<
     // vector >.
     double allTableDt = tableDt_[ 0 ];
     for( size_t i = 0; i < collectedData[0].size( ); i++ )
     {
         data_.push_back( currTime_ );
         currTime_ += allTableDt;
         for( size_t ii = 0; ii < collectedData.size(); ii++ )
             data_.push_back( collectedData[ ii ][ i ] );
     }
 
     // After collection data from table, clear tables.
     for(size_t i = 0; i < tables_.size(); i++ )
         tables_[i]->clearVec( );
 
     return;
 }