moose Namespace Reference

Namespaces
	assertion
	detail
	details

Classes
class	AdExIF
class	AdThreshIF
class	Compartment
class	CompartmentBase
class	CompartmentDataHolder
class	ExIF
class	IntFireBase
class	IzhIF
class	LIF
class	normal_distribution
class	QIF
class	RNG
class	VClamp

Typedefs
template<typename T = double>
using	MOOSE_NORMAL_DISTRIBUTION = moose::normal_distribution< T >
typedef std::random_device	MOOSE_RANDOM_DEVICE
typedef std::mersenne_twister_engine < std::uint_fast32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 >	MOOSE_RNG_DEFAULT_ENGINE
template<typename T = double>
using	MOOSE_UNIFORM_DISTRIBUTION = std::uniform_real_distribution< T >

Enumerations
enum	serverity_level_ {   trace, debug, info, warning,   fixme, error, fatal, failed }
	Enumerate type for debug and log. More...

Functions
void	__dump__ (string msg, serverity_level_ type=debug, bool autoFormat=true)
string	basename (const string &path)
	Givem path of MOOSE element, return its name. It's behaviour is like basename of unix command e.g. /a/b/c –> c. More...
int	checkPath (const string &path)
	Checks if given path is correct. If not, return false and error-code as well. More...
string &	clean_type_name (string &arg)
string	colored (string msg)
string	colored (string msg, string colorName)
string	createMOOSEPath (const string &path)
	Create a POSIX compatible path from a given string. Remove/replace bad characters. More...
bool	createParentDirs (const string &path)
	Create directories recursively needed to open the given file p. More...
string	debugPrint (string msg, string prefix="DEBUG", string color=T_RESET, unsigned debugLevel=0)
bool	endswith (const string &full, const string &ending)
std::string	fix (const std::string userPath, const string &delimiters)
string	fixPath (string path)
	Fix a path. For testing purpose. More...
string	formattedMsg (string &msg)
const map< string, string > &	getArgMap ()
string	getExtension (const string &path, bool without_dot=true)
	Get the extension of a given filepath. More...
int	getGlobalSeed ()
char	innerType (char typecode)
bool	isBackTick (char a)
string	joinPath (string pathA, string pathB)
	Append pathB to pathA and return the result. More...
void	log (string msg, serverity_level_ type=debug, bool redirectToConsole=true, bool removeTicks=true)
	Log to console (and to a log-file) More...
template<typename A , typename B >
string	mapToString (const map< A, B > &m, bool value=true)
string	moosePathToUserPath (string path)
	When user gives a path /a/b/c, moose creates a path /a[0]/b[0]/c[0]. This is helpful in cases where one needs to create more than 1 element. More...
double	mtrand (void)
	Generate a random double between 0 and 1. More...
void	mtseed (unsigned int x)
	Set the global seed or all rngs. More...
string	pathToName (const string &path)
	Return the name when path is given. Its behaviour is exactly the same as of basename command on unix system. More...
string	random_string (const unsigned len)
void	setGlobalSeed (int seed)
char	shortFinfo (std::string ftype)
char	shortType (std::string type)
void	showDebug (const string msg)
void	showError (string msg)
void	showInfo (string msg)
void	showWarn (string msg)
int	strncasecmp (const std::string &a, const std::string &b, size_t n)
	Compares the two strings a and b for first n characters, ignoring the case of the characters. Return 0 in case both are same upto first n characters. Othere a non-zero value is returned. When n is smaller or equal to the size of both strings, positive is return if a is larger than b, or negative when a is smaller than b. More...
int	testTrim ()
string	toFilename (const string &path)
	Replace all directory sepearator with _. This creates a filepath which can be created in current directory without any need to create parent directory. More...
void	tokenize (const string &str, const string &delimiters, vector< string > &tokens)
string	toString (double x)
	Convert a given value to string. More...
std::string	trim (const std::string myString, const string &delimiters)

Variables
unsigned long	__rng_seed__ = 0
	A global seed for all RNGs in moose. When moose.seed( x ) is called, this variable is set. Other's RNGs (except muparser) uses this seed to initialize them. By default it is initialized by random_device (see global.cpp). More...
static const char *const	DELIMITERS =" \t\r\n"
static string	levels_ [9]
moose::RNG< double >	rng

Detailed Description

The Compartment class sets up an asymmetric compartment for branched nerve calculations. Handles electronic structure and also channels. This is not a particularly efficient way of doing this, so we should use a solver for any substantial calculations.

The CompartmentBase class sets up the interface for all the derived Compartment classes, used in branched nerve calculations. Handles electronic structure and also channels.

Typedef Documentation

template<typename T = double>

using moose::MOOSE_NORMAL_DISTRIBUTION = typedef moose::normal_distribution<T>

Definition at line 29 of file Distributions.h.

typedef std::random_device moose::MOOSE_RANDOM_DEVICE

MOOSE's random device. Use it from <random>

Definition at line 29 of file Definitions.h.

typedef std::mersenne_twister_engine< std::uint_fast32_t, 32, 624, 397, 31 , 0x9908b0df, 11 , 0xffffffff, 7 , 0x9d2c5680, 15 , 0xefc60000, 18, 1812433253 > moose::MOOSE_RNG_DEFAULT_ENGINE

Global random number generator engine. Everywhere we use this engine.

Definition at line 42 of file Definitions.h.

template<typename T = double>

using moose::MOOSE_UNIFORM_DISTRIBUTION = typedef std::uniform_real_distribution<T>

Definition at line 26 of file Distributions.h.

Enumeration Type Documentation

enum moose::serverity_level_

Enumerate type for debug and log.

Enumerator
trace
debug
info
warning
fixme
error
fatal
failed

Definition at line 76 of file print_function.hpp.

                          {
        trace, debug, info , warning, fixme , error, fatal, failed
    };

Function Documentation

void moose::__dump__ ( string  msg, serverity_level_  type = debug, bool  autoFormat = true  )

inline

Definition at line 170 of file print_function.hpp.

References debug, error, failed, fixme, info, levels_, T_CYAN, T_GREEN, T_MAGENTA, T_RED, T_RESET, T_YELLOW, and warning.

Referenced by log(), showDebug(), showError(), showInfo(), and showWarn().

    {
        stringstream ss;
        ss << "[" << levels_[type] << "] ";
        bool set = false;
        bool reset = true;
        string color = T_GREEN;
        if(type == warning || type == fixme )
            color = T_YELLOW;
        else if(type ==  debug )
            color = T_CYAN;
        else if(type == error || type == failed )
            color = T_RED;
        else if(type == info )
            color = T_MAGENTA;

        for(unsigned int i = 0; i < msg.size(); ++i)
        {
            if('`' == msg[i])
            {
                if(!set and reset)
                {
                    set = true;
                    reset = false;
                    ss << color;
                }
                else if(set && !reset)
                {
                    reset = true;
                    set = false;
                    ss << T_RESET;
                }
            }
            else if('\n' == msg[i])
                ss << "\n | ";
            else
                ss << msg[i];
        }

        /*  Be safe than sorry */
        if(!reset)
            ss << T_RESET;
        cout << ss.str() << endl;
        cout.flush( );
    }

Here is the caller graph for this function:

string moose::basename ( const string &  path )

inline

Givem path of MOOSE element, return its name. It's behaviour is like basename of unix command e.g. /a/b/c –> c.

Returns

Definition at line 31 of file utility.h.

    {
        return path.substr( path.find_last_of('/') + 1 );
    }

int moose::checkPath

(

const string &

path

)

Checks if given path is correct. If not, return false and error-code as well.

Parameters

path	Path name.

Returns

0 if path is all-right. Negative number if path is not OK.

Definition at line 50 of file global.cpp.

References BAD_CHARACTER_IN_PATH, EMPTY_PATH, and MISSING_BRACKET_AT_END.

Referenced by fixPath().

    {
        if( path.size() < 1)
            return EMPTY_PATH;

        if( path.find_first_of( " \\!") != std::string::npos )
            return BAD_CHARACTER_IN_PATH;

        if ( path[path.size() - 1 ] != ']')
        {
            return MISSING_BRACKET_AT_END;
        }
        return 0;
    }

Here is the caller graph for this function:

std::string & moose::clean_type_name

(

string &

arg

)

Definition at line 36 of file strutil.cpp.

{
    for (size_t pos = arg.find(' '); pos != string::npos; pos = arg.find(' '))
    {
        arg.replace(pos, 1, 1, '_');
    }
    for (size_t pos = arg.find('<'); pos != string::npos; pos = arg.find('<'))
    {
        arg.replace(pos, 1, 1, '_');
    }
    for (size_t pos = arg.find('>'); pos != string::npos; pos = arg.find('>'))
    {
        arg.replace(pos, 1, 1, '_');
    }
    return arg;
}

string moose::colored ( string  msg )

inline

Definition at line 137 of file print_function.hpp.

References T_RED, and T_RESET.

    {
        stringstream ss;
        ss << T_RED << msg << T_RESET;
        return ss.str();
    }

string moose::colored ( string  msg, string  colorName  )

inline

Definition at line 144 of file print_function.hpp.

References T_RESET.

    {
        stringstream ss;
        ss << colorName << msg << T_RESET;
        return ss.str();
    }

string moose::createMOOSEPath

(

const string &

path

)

Create a POSIX compatible path from a given string. Remove/replace bad characters.

Parameters

path	Reutrn path is given path if creation was successful, else directory is renamed to a filename.

Definition at line 105 of file global.cpp.

References path.

Referenced by moosePathToUserPath(), and Table::setOutfile().

    {
        string s = path;                        /* Local copy */
        // Remove [0] from paths. They will be annoying for normal users.
        std::string::size_type n = 0;
        string zeroIndex("[0]");
        while( (n = s.find( zeroIndex, n )) != std::string::npos )
            s.erase( n, zeroIndex.size() );
        return s;
    }

Here is the caller graph for this function:

bool moose::createParentDirs

(

const string &

path

)

Create directories recursively needed to open the given file p.

Create directory, recursively.

Parameters

path	When successfully created, returns created path, else convert path to a filename by replacing '/' by '_'.

Definition at line 122 of file global.cpp.

References failed, info, LOG, path, and warning.

Referenced by Table::setOutfile(), and Streamer::setOutFilepath().

    {
        // Remove the filename from the given path so we only have the
        // directory.
        string p = path;
        bool failed = false;
        size_t pos = p.find_last_of( '/' );
        if( pos != std::string::npos )
            p = p.substr( 0, pos );
        else                                    /* no parent directory to create */
            return true;

        if( p.size() == 0 )
            return true;

        string command( "mkdir -p ");
        command += p;
        int ret = system( command.c_str() );
        struct stat info;
        if( stat( p.c_str(), &info ) != 0 )
        {
            LOG( moose::warning, "cannot access " << p );
            return false;
        }
        else if( info.st_mode & S_IFDIR )
        {
            LOG( moose::info, "Created directory " <<  p );
            return true;
        }
        else
        {
            LOG( moose::warning, p << " is no directory" );
            return false;
        }
        return true;
    }

Here is the caller graph for this function:

string moose::debugPrint ( string  msg, string  prefix = "DEBUG", string  color = T_RESET, unsigned  debugLevel = 0  )

inline

Definition at line 152 of file print_function.hpp.

References DEBUG_LEVEL, and T_RESET.

    {
        stringstream ss; ss.str("");
        if(debugLevel <= DEBUG_LEVEL)
        {
            ss << setw(debugLevel/2) << "[" << prefix << "] "
                << color << msg << T_RESET;
        }
        return ss.str();
    }

bool moose::endswith	(	const string &	full,
		const string &	ending
	)

Definition at line 138 of file strutil.cpp.

Referenced by moose_Id_getPath().

{
    if (full.length() < ending.length())
    {
        return false;
    }
    return (0 == full.compare(full.length() - ending.length(), ending.length(), ending));
}

Here is the caller graph for this function:

std::string moose::fix	(	const std::string	myString,
		const std::string &	delimiters = " \t\r\n"
	)

Fix the user-given path whenever possible

Definition at line 71 of file strutil.cpp.

References trim().

Referenced by moose_ObjId_init_from_path().

{
    string trimmedPath = trim(userPath, delimiters);

    string fixedPath;
    char prev = 0;

    // In this loop, we check if there are more than one '/' together. If yes,
    // then accept only first one and reject other.
    for(unsigned int i = 0; i < trimmedPath.size(); ++i)
    {
        const char c = trimmedPath[i];
        if(c != '/' || c != prev)
            fixedPath.push_back(c);
    prev = c;
    }
    return fixedPath;
}

Here is the call graph for this function:

Here is the caller graph for this function:

string moose::fixPath

(

string

path

)

Fix a path. For testing purpose.

Parameters

path	Path as string.

Returns

A fixed path.

Definition at line 74 of file global.cpp.

References checkPath(), MISSING_BRACKET_AT_END, and path.

Referenced by HSolveUtils::gates(), and joinPath().

    {
        int pathOk = moose::checkPath( path );
        if( pathOk == 0)
            return path;
        else if( pathOk == MISSING_BRACKET_AT_END)
            return path + "[0]";
        return path;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

string moose::formattedMsg ( string &  msg )

inline

Definition at line 267 of file print_function.hpp.

References isBackTick().

Referenced by log().

    {
        remove_if(msg.begin(), msg.end(), isBackTick);
        return msg;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

const map< std::string, std::string > & moose::getArgMap

(

)

Definition at line 41 of file setupenv.cpp.

References doRegressionTests, doUnitTests, getNumCores(), isInfinite, numCores, numNodes, and verbosity.

Referenced by setup_runtime_env().

    {
        static map<string, string> argmap;
        if (argmap.empty()){
            char * verbosity = getenv("VERBOSITY");
            if (verbosity != NULL){
                argmap.insert(pair<string, string>("VERBOSITY", string(verbosity)));
            } else {
                argmap.insert(pair<string, string>("VERBOSITY", "0"));
            }
            char * isSingleThreaded = getenv("SINGLETHREADED");
            if (isSingleThreaded != NULL){
                argmap.insert(pair<string, string>("SINGLETHREADED", string(isSingleThreaded)));
            }
            else {
                argmap.insert(pair<string, string>("SINGLETHREADED", "0"));
            }
            char * isInfinite = getenv("INFINITE");
            if (isInfinite != NULL){
                argmap.insert(pair<string, string>("INFINITE", string(isInfinite)));
            }
            // else {
            //     argmap.insert(pair<string, string>("INFINITE", "0"));
            // }

            char * numCores = getenv("NUMCORES");
            if (numCores != NULL){
                argmap.insert(pair<string, string>("NUMCORES", string(numCores)));
            } else {
                unsigned int cores = getNumCores();
                stringstream s;
                s << cores;
                argmap.insert(pair<string, string>("NUMCORES", s.str()));
            }
            char * numNodes = getenv("NUMNODES");
            if (numNodes != NULL){
                argmap.insert(pair<string, string>("NUMNODES", string(numNodes)));
            } // else {
            //     argmap.insert(pair<string, string>("NUMNODES", "1"));
            // }
            char * numProcessThreads = getenv("NUMPTHREADS");
            if (numProcessThreads != NULL){
                argmap.insert(pair<string, string>("NUMPTHREADS", string(numProcessThreads)));
            }
            char * doQuit = getenv("QUIT");
            if (doQuit != NULL){
                argmap.insert(pair<string, string>("QUIT", string(doQuit)));
            } // else {
            //     argmap.insert(pair<string, string>("QUIT", "0"));
            // }
            char * doUnitTests = getenv("DOUNITTESTS");
            if (doUnitTests != NULL){
                argmap.insert(pair<string, string>("DOUNITTESTS", string(doUnitTests)));
            } // else {
            //     argmap.insert(pair<string, string>("DOUNITTESTS", "0"));
            // }
            char * doRegressionTests = getenv("DOREGRESSIONTESTS");
            if (doRegressionTests != NULL){
                argmap.insert(pair<string, string>("DOREGRESSIONTESTS", string(doRegressionTests)));
            } // else {
            //     argmap.insert(pair<string, string>("DOREGRESSIONTESTS", "0"));
            // }

        }
        return argmap;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

string moose::getExtension	(	const string &	path,
		bool	without_dot = true
	)

Get the extension of a given filepath.

Parameters

path	Given path.

Returns

Extension (with or without preceeding '.' )

Definition at line 170 of file global.cpp.

Referenced by Table::setOutfile(), and Streamer::setOutFilepath().

    {
        size_t dotPos = path.find_last_of( '.' );
        if( dotPos == std::string::npos )
            return "";

        if( without_dot )
            return path.substr( dotPos + 1 );

        return path.substr( dotPos );
    }

Here is the caller graph for this function:

int moose::getGlobalSeed

(

)

Get the global seed set by call of moose.seed( X )

seed (int).

Definition at line 206 of file global.cpp.

References __rng_seed__.

Referenced by GraupnerBrunel2012CaPlasticitySynHandler::reinitSeed().

    {
        return __rng_seed__;
    }

Here is the caller graph for this function:

char moose::innerType

(

char

typecode

)

Definition at line 104 of file types.cpp.

                             {
    static map<char, char> innerTypeMap;
    if (innerTypeMap.empty()){
        innerTypeMap.insert(pair<char, char>('D', 'd')); // vector<double>
        innerTypeMap.insert(pair<char, char>('v', 'i')); // vector<int>
        innerTypeMap.insert(pair<char, char>('M', 'l')); // vector<long>
        innerTypeMap.insert(pair<char, char>('X', 'x')); // vector<Id>
        innerTypeMap.insert(pair<char, char>('Y', 'y')); // vector<ObjId>
        innerTypeMap.insert(pair<char, char>('C', 'c')); // vector<char>
        innerTypeMap.insert(pair<char, char>('w', 'h')); // vector<short>
        innerTypeMap.insert(pair<char, char>('N', 'I')); // vector<unsigned int>
        innerTypeMap.insert(pair<char, char>('P', 'k')); // vector<unsigned long>
        innerTypeMap.insert(pair<char, char>('A', 'L')); // vector<long long>
        innerTypeMap.insert(pair<char, char>('B', 'K')); // vector<unsigned long long>
        innerTypeMap.insert(pair<char, char>('F', 'f')); // vector<float>
        innerTypeMap.insert(pair<char, char>('S', 's')); // vector<string>
        innerTypeMap.insert(pair<char, char>('T', 'N')); // vector<vector<unsigned>>
        innerTypeMap.insert(pair<char, char>('Q', 'v')); // vector<vector<int>>
        innerTypeMap.insert(pair<char, char>('R', 'D')); // vector<vector<double>>
    }
    map<char, char>::iterator iter = innerTypeMap.find(typecode);
    if (iter == innerTypeMap.end()){
        return 0;
    }
    return iter->second;
}

bool moose::isBackTick ( char  a )

inline

Definition at line 260 of file print_function.hpp.

Referenced by formattedMsg().

    {
        if('`' == a)
            return true;
        return false;
    }

Here is the caller graph for this function:

string moose::joinPath	(	string	pathA,
		string	pathB
	)

Append pathB to pathA and return the result.

If pathA does not have [indexs] at the end, append "[0]" to pathA and then add pathB to it. This version does not care if the result has '[0]' at its end.

Parameters

pathA	First path.
pathB	Second path.

Returns

A string representing moose-path.

Definition at line 66 of file global.cpp.

References fixPath().

    {
        pathA = moose::fixPath( pathA );
        string newPath = pathA + "/" + pathB;
        return moose::fixPath( newPath );
    }

Here is the call graph for this function:

void moose::log ( string  msg, serverity_level_  type = debug, bool  redirectToConsole = true, bool  removeTicks = true  )

inline

Log to console (and to a log-file)

Parameters

msg	String, message to be written.
type	Type of the message.
redirectToConsole
removeTicks

Definition at line 281 of file print_function.hpp.

References __dump__(), and formattedMsg().

Referenced by GssaVoxelPools::advance(), MarkovSolver::computeMatrixExponential(), estT(), SynChan::normalizeGbar(), moose::normal_distribution< double >::operator()(), ChannelStruct::powerN(), HHChannelBase::powerN(), HHChannel2D::powerN(), GssaVoxelPools::recalcTime(), RandSpike::reinit(), GraupnerBrunel2012CaPlasticitySynHandler::updateCaWeightFactors(), Nernst::updateE(), and NMDAChan::vProcess().

    {

        if(redirectToConsole)
            __dump__(msg, type, true);

        /* remove any backtick from the string. */
        formattedMsg( msg );

        fstream logF;
        logF.open( "__moose__.log", ios::app);
        time_t rawtime; time(&rawtime);
        struct tm* timeinfo;
        timeinfo = localtime(&rawtime);

        logF << asctime(timeinfo) << ": " << msg;

        logF.close();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename A , typename B >

string moose::mapToString	(	const map< A, B > &	m,
		bool	value = true
	)

Definition at line 95 of file print_function.hpp.

References value.

        {
            unsigned int width = 81;
            unsigned int mapSize = m.size();
            unsigned int size = 0;

            vector<string> row;

            /* Get the maximum size of any entry in map */
            stringstream ss;
            typename map<A, B>::const_iterator it;
            for(it = m.begin(); it != m.end(); it++)
            {
                ss.str("");
                ss << it->first;
                if(value)
                    ss << ": " << it->second;
                row.push_back(ss.str());
                if(ss.str().size() > size)
                    size = ss.str().size()+1;
            }

            unsigned int colums = width / size;
            ss.str("");

            size_t i = 0;
            for(unsigned int ii = 0; ii < row.size(); ii++)
            {
                if(i < colums)
                {
                    ss << setw(size+1) << row[ii];
                    i++;
                }
                else
                {
                    ss << endl;
                    i = 0;
                }
            }
            return ss.str();
        }

string moose::moosePathToUserPath

(

string

path

)

When user gives a path /a/b/c, moose creates a path /a[0]/b[0]/c[0]. This is helpful in cases where one needs to create more than 1 element.

Parameters

path	Removed '[0]' from path and return.

Returns

Definition at line 189 of file global.cpp.

References createMOOSEPath().

Referenced by Streamer::addTable(), Table::reinit(), and Streamer::reinit().

    {
        // Just write the moose path. Things becomes messy when indexing is
        // used.
        return createMOOSEPath( path );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

double moose::mtrand

(

void

)

Generate a random double between 0 and 1.

Returns

A random number between 0 and 1.

Definition at line 97 of file global.cpp.

References rng, and moose::RNG< T >::uniform().

Referenced by addPos(), SteadyState::fitConservationRules(), makeAngleDistrib(), makeSizeDistrib(), RandSpike::process(), Gsolve::process(), pymoose_mtrand_(), SeqSynHandler::refillSynapseOrder(), RandSpike::reinit(), testSparseMsg(), and moose::Compartment::vRandInject().

    {
        return moose::rng.uniform( );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void moose::mtseed

(

unsigned int

x

)

Set the global seed or all rngs.

Seed seed for RNG.

Parameters

x
seed

Definition at line 89 of file global.cpp.

References __rng_seed__, isRNGInitialized, rng, and moose::RNG< T >::setSeed().

Referenced by pymoose_mtseed_(), and SeqSynHandler::refillSynapseOrder().

    {
        moose::__rng_seed__ = x;
        moose::rng.setSeed( x );
        isRNGInitialized = true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

string moose::pathToName

(

const string &

path

)

Return the name when path is given. Its behaviour is exactly the same as of basename command on unix system.

Parameters

path

Returns

name.

Definition at line 183 of file global.cpp.

    {
        return path.substr( path.find_last_of( '/' ) );
    }

std::string moose::random_string

(

const unsigned

size

)

Generate random string of given length.

Definition at line 162 of file strutil.cpp.

{
    static const char alphanum[] =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";

    string s(len, '_' );
    for (unsigned i = 0; i < len; ++i)
    {
        s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
    }

    return s;
}

void moose::setGlobalSeed

(

int

seed

)

Set the seed for all random generator. When seed of a RNG is not set, this seed it used. It is set to -1 by default.

seed

Definition at line 211 of file global.cpp.

References __rng_seed__.

Referenced by testSparseMsg().

    {
        __rng_seed__ = seed;
    }

Here is the caller graph for this function:

char moose::shortFinfo

(

std::string

ftype

)

Definition at line 87 of file types.cpp.

{
    static map<string, char> finfomap;
    if (finfomap.empty()){
        finfomap.insert(pair<string, char>("srcFinfo", 's'));
        finfomap.insert(pair<string, char>("destFinfo", 'd'));
        finfomap.insert(pair<string, char>("sharedFinfo", 'x'));
        finfomap.insert(pair<string, char>("valueFinfo", 'v'));
        finfomap.insert(pair<string, char>("lookupFinfo", 'l'));
    }
    map <string, char>::iterator iter = finfomap.find(finfoType);
    if (iter == finfomap.end()){
        return 0;
    }
    return iter->second;
}

char moose::shortType

(

string

name

)

returns a single character code for a given string representation of data type. Mostly follows Python/C API's PyArg_ParseTuple convention.

Definition at line 41 of file types.cpp.

{
    static map<string, char> typemap;
    if (typemap.empty()){
        typemap.insert(pair<string, char>("bool", 'b'));
        typemap.insert(pair<string, char>("char", 'c'));
        typemap.insert(pair<string, char>("int", 'i')); // python
        typemap.insert(pair<string, char>("short", 'h')); // python
        typemap.insert(pair<string, char>("unsigned short", 'H')); // python
        typemap.insert(pair<string, char>("long", 'l')); // python
        typemap.insert(pair<string, char>("long long", 'L')); // python
        typemap.insert(pair<string, char>("unsigned int", 'I')); // python
        typemap.insert(pair<string, char>("unsigned long", 'k')); // python
        typemap.insert(pair<string, char>("unsigned long long", 'K')); // python
        typemap.insert(pair<string, char>("float", 'f')); // python
        typemap.insert(pair<string, char>("double", 'd')); // python
        typemap.insert(pair<string, char>("string", 's')); // python
        typemap.insert(pair<string, char>("Id", 'x')); // moose
        typemap.insert(pair<string, char>("ObjId", 'y')); // moose
        typemap.insert(pair<string, char>("DataId", 'z')); // moose
        typemap.insert(pair<string, char>("vector<char>", 'C')); // moose
        typemap.insert(pair<string, char>("vector<int>", 'v')); // moose
        typemap.insert(pair<string, char>("vector<short>", 'w')); // moose
        typemap.insert(pair<string, char>("vector<long>", 'M')); // moose
        typemap.insert(pair<string, char>("vector<long long>", 'A')); // moose
        typemap.insert(pair<string, char>("vector<unsigned long long>", 'B')); // moose
        typemap.insert(pair<string, char>("vector<unsigned int>", 'N')); // moose
        typemap.insert(pair<string, char>("vector<unsigned long>", 'P')); // moose
        typemap.insert(pair<string, char>("vector<float>", 'F')); // moose
        typemap.insert(pair<string, char>("vector<double>", 'D')); // moose
        typemap.insert(pair<string, char>("vector<string>", 'S')); // moose
        typemap.insert(pair<string, char>("vector<Id>", 'X')); // moose
        typemap.insert(pair<string, char>("vector<ObjId>", 'Y')); // moose
        typemap.insert(pair<string, char>("vector<DataId", 'Z')); //moose
        typemap.insert(pair<string, char>("void", '_')); // moose
        typemap.insert(pair<string, char>("vector< vector<unsigned int> >", 'T'));
        typemap.insert(pair<string, char>("vector< vector<int> >", 'Q'));
        typemap.insert(pair<string, char>("vector< vector<double> >", 'R'));
    }
    map<string, char>::iterator iter = typemap.find(name);
    if (iter == typemap.end()){
        return 0;
    }
    return iter->second;
}

void moose::showDebug ( const string  msg )

inline

Definition at line 229 of file print_function.hpp.

References __dump__(), and debug.

        {
#ifdef DISABLE_DEBUG

#else
                moose::__dump__(msg, moose::debug );
#endif
        }

Here is the call graph for this function:

void moose::showError ( string  msg )

inline

Definition at line 238 of file print_function.hpp.

References __dump__(), and error.

Referenced by cnpy2::save_numpy().

    {
        moose::__dump__( msg, moose::error );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void moose::showInfo ( string  msg )

inline

Definition at line 219 of file print_function.hpp.

References __dump__(), and info.

    {
        moose::__dump__( msg, moose::info );
    }

Here is the call graph for this function:

void moose::showWarn ( string  msg )

inline

Definition at line 224 of file print_function.hpp.

References __dump__(), and warning.

Referenced by cnpy2::change_shape_in_header(), Shell::doCreate(), Streamer::reinit(), cnpy2::save_numpy(), and Shell::warning().

    {
        moose::__dump__(msg, moose::warning );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

int moose::strncasecmp	(	const std::string &	a,
		const std::string &	b,
		size_t	n
	)

Compares the two strings a and b for first n characters, ignoring the case of the characters. Return 0 in case both are same upto first n characters. Othere a non-zero value is returned. When n is smaller or equal to the size of both strings, positive is return if a is larger than b, or negative when a is smaller than b.

When n is larger than size of a or b, non-zero values is returned when a and b are not equal upto min(n, min(a.size(), b.size())) characters.

Parameters

a	First string.
b	Second string.
n	Compare up n characters/bytes.

Definition at line 148 of file strutil.cpp.

Referenced by NeuroNode::findStartNode(), and NeuroMesh::putSomaAtStart().

{
    for( size_t i = 0; i < std::min(n, b.size()); ++i )
        if( tolower(a[i]) != tolower(b[i]) )
            return tolower(a[i]) - tolower(b[i]);

    if( b.size() < n )
        return a.size() - b.size();

    return 0;
}

Here is the caller graph for this function:

int moose::testTrim

(

)

Definition at line 90 of file strutil.cpp.

References trim().

{

    std::string testStrings [] =
    {
        " space at beginning",
        "space at end ",
        " space at both sides ",
        "\ttab at beginning",
        "tab at end\t",
        "\ttab at both sides\t",
        "\nnewline at beginning",
        "newline at end\n",
        "\nnewline at both sides\n",
        "\n\tnewline and tab at beginning",
        "space and tab at end \t",
        "   \rtab and return at both sides \r"
    };

    std::string results[] =
    {
        "space at beginning",
        "space at end",
        "space at both sides",
        "tab at beginning",
        "tab at end",
        "tab at both sides",
        "newline at beginning",
        "newline at end",
        "newline at both sides",
        "newline and tab at beginning",
        "space and tab at end",
        "tab and return at both sides"
    };

    bool success = true;

    for (unsigned int i = 0; i < sizeof(testStrings)/sizeof(*testStrings); ++i )
    {
        std::string trimmed = trim(testStrings[i]);
        success = (results[i].compare(trimmed)==0);

        cout << "'" << trimmed << "'" << (success ?" SUCCESS":"FAILED") << endl;
    }
    return success?1:0;
}

Here is the call graph for this function:

string moose::toFilename

(

const string &

path

)

Replace all directory sepearator with _. This creates a filepath which can be created in current directory without any need to create parent directory.

Parameters

path

string

Returns

filename without directory separator.

Definition at line 161 of file global.cpp.

References path.

Referenced by Table::setOutfile(), and Streamer::setOutFilepath().

    {
        string p = path;
        std::replace(p.begin(), p.end(), '/', '_' );
        std::replace(p.begin(), p.end(), '\\', '_' );
        return p;
    }

Here is the caller graph for this function:

void moose::tokenize	(	const std::string &	str,
		const std::string &	delimiters,
		std::vector< std::string > &	tokens
	)

Splits given string into tokens

Definition at line 19 of file strutil.cpp.

Referenced by ReadCell::addChannelMessage(), parseFinfoType(), ReadCell::readData(), and ReadCell::readScript().

{
    // Token boundaries
    string::size_type begin = str.find_first_not_of( delimiters, 0 );
    string::size_type end = str.find_first_of( delimiters, begin );

    while ( string::npos != begin || string::npos != end )
    {
        // Found a token, add it to the vector.
        tokens.push_back( str.substr( begin, end - begin ) );

        // Update boundaries
        begin = str.find_first_not_of( delimiters, end );
        end = str.find_first_of( delimiters, begin );
    }
}

Here is the caller graph for this function:

string moose::toString

(

double

x

)

Convert a given value to string.

Template Parameters

T

Parameters

x

Returns

String representation

Definition at line 199 of file global.cpp.

Referenced by cnpy2::change_shape_in_header(), cnpy2::write_header(), and StreamerBase::writeToCSVFile().

    {
        char buffer[50];
        sprintf(buffer, "%.17g", x );
        return string( buffer );
    }

Here is the caller graph for this function:

std::string moose::trim	(	const std::string	myString,
		const std::string &	delimiters = " \t\r\n"
	)

trims the leading and trailing white spaces

Definition at line 53 of file strutil.cpp.

Referenced by chopLine(), create_Id_from_path(), findModelType(), fix(), innerLoadXplot(), ReadCell::innerRead(), ReadKkit::innerRead(), Interpol2D::load(), moose_Id_init(), Func::reinit(), Function::reinit(), and testTrim().

{
    if (myString.length() == 0 )
    {
        return myString;
    }

    string::size_type  end = myString.find_last_not_of(delimiters);
    string::size_type begin = myString.find_first_not_of(delimiters);

    if(begin != string::npos)
    {
        return std::string(myString, begin, end-begin+1);
    }

    return "";
}

Here is the caller graph for this function:

Variable Documentation

unsigned long moose::__rng_seed__ = 0

A global seed for all RNGs in moose. When moose.seed( x ) is called, this variable is set. Other's RNGs (except muparser) uses this seed to initialize them. By default it is initialized by random_device (see global.cpp).

Definition at line 45 of file global.cpp.

Referenced by getGlobalSeed(), mtseed(), GssaVoxelPools::reinit(), setGlobalSeed(), and ZombieCompartment::vReinit().

const char* const moose::DELIMITERS =" \t\r\n"

static

List of characters considered to be whitespace

Definition at line 17 of file strutil.h.

string moose::levels_[9]

static

Initial value:

= {
        "TRACE", "DEBUG", "INFO", "WARNING", "FIXME" , "ERROR", "FATAL", "FAILED"
    }

Definition at line 80 of file print_function.hpp.

Referenced by __dump__().

moose::RNG< double > moose::rng

Definition at line 47 of file global.cpp.

Referenced by mtrand(), ZombieCompartment::mtrand(), mtseed(), and ZombieCompartment::vReinit().