extforce.cc File Reference

#include "mbconfig.h"
#include "dataman.h"
#include "extforce.h"
#include "extedge.h"
#include "except.h"
#include "solver.h"
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <cstdlib>
#include <unistd.h>
#include <cerrno>

Include dependency graph for extforce.cc:

Go to the source code of this file.

Functions
void	ReadExtFileParams (DataManager *pDM, MBDynParser &HP, unsigned int uLabel, mbsleep_t &SleepTime, std::streamsize &Precision)
static ExtFileHandlerBase *	ReadExtSocketHandler (DataManager *pDM, MBDynParser &HP, unsigned int uLabel)
static ExtFileHandlerBase *	ReadExtFileHandler (DataManager *pDM, MBDynParser &HP, unsigned int uLabel)
void	ReadExtForce (DataManager *pDM, MBDynParser &HP, unsigned int uLabel, ExtFileHandlerBase *&pEFH, bool &bSendAfterPredict, int &iCoupling)

Function Documentation

static ExtFileHandlerBase* ReadExtFileHandler ( DataManager *  pDM, MBDynParser &  HP, unsigned int  uLabel  )

static

Definition at line 1087 of file extforce.cc.

References IncludeParser::GetFileName(), IncludeParser::GetLineData(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, mbsleep_init(), ReadExtFileHandlerEDGE(), ReadExtFileParams(), ReadExtSocketHandler(), and SAFENEWWITHCONSTRUCTOR.

Referenced by ReadExtForce().

{
        if (HP.IsKeyWord("EDGE")) {
                return ReadExtFileHandlerEDGE(pDM, HP, uLabel);

        } else if (HP.IsKeyWord("socket")) {
                return ReadExtSocketHandler(pDM, HP, uLabel);
        }

        ExtFileHandlerBase *pEFH = 0;

        // default
        const char      *s = HP.GetFileName();
        if (s == 0) {
                silent_cerr("ExtForce(" << uLabel << "): "
                        "unable to get input file name "
                        "at line " << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
        std::string fin = s;

        bool bUnlinkIn = false;
        if (HP.IsKeyWord("unlink")) {
                bUnlinkIn = true;
        }

        s = HP.GetFileName();
        if (s == 0) {
                silent_cerr("ExtForce(" << uLabel << "): "
                        "unable to get output file name "
                        "at line " << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
        std::string fout = s;

        bool bNoClobberOut = false;
        if (HP.IsKeyWord("no" "clobber")) {
                bNoClobberOut = true;
        }

        mbsleep_t SleepTime = mbsleep_init(1);
        std::streamsize Precision = 0;
        ReadExtFileParams(pDM, HP, uLabel, SleepTime, Precision);

        SAFENEWWITHCONSTRUCTOR(pEFH, ExtFileHandler,
                ExtFileHandler(fin, bUnlinkIn, fout, bNoClobberOut,
                        SleepTime, Precision));

        return pEFH;
}

Here is the call graph for this function:

void ReadExtFileParams	(	DataManager *	pDM,
		MBDynParser &	HP,
		unsigned int	uLabel,
		mbsleep_t &	SleepTime,
		std::streamsize &	Precision
	)

Definition at line 845 of file extforce.cc.

References HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetTimeout(), HighParser::IsKeyWord(), and MBDYN_EXCEPT_ARGS.

Referenced by ReadExtFileHandler(), ReadExtFileHandlerEDGE(), and ReadExtSocketHandler().

{
        mbsleep_t MinSleepTime = SleepTime;
        if (HP.IsKeyWord("sleep" "time")) {
                SleepTime = HP.GetTimeout(SleepTime);
                if (SleepTime < MinSleepTime ) {
                        silent_cerr("ExtForce(" << uLabel << "): "
                                "invalid sleep time " << SleepTime
                                << " less than " << MinSleepTime
                                << " at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }

        Precision = 6;
        if (HP.IsKeyWord("precision")) {
                if (!HP.IsKeyWord("default")) {
                        Precision = HP.GetInt();
                        if (Precision < 0) {
                                silent_cerr("ExtForce(" << uLabel << "): "
                                        "invalid precision value "
                                        "\"" << Precision << "\""
                                        " at line " << HP.GetLineData()
                                        << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }
        }
}

Here is the call graph for this function:

void ReadExtForce	(	DataManager *	pDM,
		MBDynParser &	HP,
		unsigned int	uLabel,
		ExtFileHandlerBase *&	pEFH,
		bool &	bSendAfterPredict,
		int &	iCoupling
	)

Definition at line 1141 of file extforce.cc.

References ExtForce::COUPLING_LOOSE, ExtForce::COUPLING_NONE, ExtForce::COUPLING_STAGGERED, ExtForce::COUPLING_TIGHT, HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetYesNo(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, and ReadExtFileHandler().

Referenced by ReadModalExtForce(), ReadModalMappingExtForce(), ReadStructExtForce(), and ReadStructMappingExtForce().

{
        pEFH = ReadExtFileHandler(pDM, HP, uLabel);

        iCoupling = ExtForce::COUPLING_LOOSE;
        if (HP.IsKeyWord("coupling")) {
                if (HP.IsKeyWord("none")) {
                        iCoupling = ExtForce::COUPLING_NONE;

                } else if (HP.IsKeyWord("staggered")) {
                        iCoupling = ExtForce::COUPLING_STAGGERED;

                } else if (HP.IsKeyWord("loose")) {
                        iCoupling = ExtForce::COUPLING_LOOSE;

                } else if (HP.IsKeyWord("tight")) {
                        iCoupling = ExtForce::COUPLING_TIGHT;

                } else {
                        iCoupling = HP.GetInt();
                        if (iCoupling < -1) {
                                silent_cerr("ExtForce(" << uLabel << "): "
                                        "invalid coupling value "
                                        "\"" << iCoupling << "\""
                                        " at line " << HP.GetLineData()
                                        << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }
        }

        if (iCoupling >= ExtForce::COUPLING_LOOSE) {
                bSendAfterPredict = true;
                if (HP.IsKeyWord("send" "after" "predict")) {
                        if (!HP.GetYesNo(bSendAfterPredict)) {
                                silent_cerr("ExtForce(" << uLabel << "): "
                                        "invalud \"send after predict\" value "
                                        "at line " << HP.GetLineData()
                                        << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }

        } else {
                bSendAfterPredict = false;
        }
}

Here is the call graph for this function:

static ExtFileHandlerBase* ReadExtSocketHandler ( DataManager *  pDM, MBDynParser &  HP, unsigned int  uLabel  )

static

Definition at line 882 of file extforce.cc.

References IncludeParser::GetFileName(), HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetStringWithDelims(), HighParser::GetYesNo(), host, IPPORT_USERRESERVED, HighParser::IsArg(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, mbsleep_init(), MSG_NOSIGNAL, path, port, ReadExtFileParams(), and SAFENEWWITHCONSTRUCTOR.

Referenced by ReadExtFileHandler().

{
#ifdef USE_SOCKET
        ExtFileHandlerBase *pEFH = 0;

        bool bGotCreate(false);
        bool bCreate(false);
        unsigned short int port = (unsigned short int)-1; 
        std::string host;
        std::string path;

        if (HP.IsKeyWord("create")) {
                bGotCreate = true;
                if (!HP.GetYesNo(bCreate)) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "\"create\" must be either \"yes\" or \"no\" "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }
                
        if (HP.IsKeyWord("local") || HP.IsKeyWord("path")) {
                const char *m = HP.GetFileName();
                
                if (m == 0) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "unable to read local path "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                
                path = m;
        }
        
        if (HP.IsKeyWord("port")) {
                if (!path.empty()) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "cannot specify port "
                                "for a local socket "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);            
                }

                int p = HP.GetInt();
                /* Da sistemare da qui */
#ifdef IPPORT_USERRESERVED
                if (p <= IPPORT_USERRESERVED) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "cannot listen on reserved port "
                                << port << ": less than "
                                "IPPORT_USERRESERVED=" << IPPORT_USERRESERVED
                                << " at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                /* if #undef'd, don't bother checking;
                 * the OS will do it for us */
#endif /* IPPORT_USERRESERVED */

                port = p;
        }

        if (HP.IsKeyWord("host")) {
                if (!path.empty()) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "cannot specify host for a local socket "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);            
                }

                const char *h;
                
                h = HP.GetStringWithDelims();
                if (h == 0) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "unable to read host "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                host = h;

        } else if (path.empty() && !bCreate) {
                silent_cerr("ExtSocketHandler"
                        "(" << uLabel << "): "
                        "host undefined "
                        "at line " << HP.GetLineData()
                        << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        int socket_type = SOCK_STREAM;
        if (HP.IsKeyWord("socket" "type")) {
                if (HP.IsKeyWord("udp")) {
                        socket_type = SOCK_DGRAM;

                        if (!bGotCreate) {
                                bCreate = true;
                        }

                } else if (!HP.IsKeyWord("tcp")) {
                        silent_cerr("ExtSocketHandler(" << uLabel << "\"): "
                                "invalid socket type "
                                "at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }

        if ((socket_type == SOCK_DGRAM) && !bCreate) {
                silent_cerr("ExtSocketHandler(" << uLabel << "\"): "
                        "socket type=udp incompatible with create=no "
                        "at line " << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        // we want to block until the whole chunk is received
        int recv_flags = 0;
        int send_flags = 0;
#ifdef MSG_WAITALL
        recv_flags |= MSG_WAITALL;
#endif // MSG_WAITALL

        while (HP.IsArg()) {
                if (HP.IsKeyWord("signal")) {
#ifdef MSG_NOSIGNAL
                        recv_flags &= ~MSG_NOSIGNAL;
                        send_flags &= ~MSG_NOSIGNAL;
#else // ! MSG_NOSIGNAL
                        silent_cout("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "MSG_NOSIGNAL not defined (ignored) "
                                "at line " << HP.GetLineData()
                                << std::endl);
#endif // ! MSG_NOSIGNAL

                // not honored by recv(2)
                } else if (HP.IsKeyWord("no" "signal")) {
#ifdef MSG_NOSIGNAL
                        recv_flags |= MSG_NOSIGNAL;
                        send_flags |= MSG_NOSIGNAL;
#else // ! MSG_NOSIGNAL
                        silent_cout("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "MSG_NOSIGNAL not defined (ignored) "
                                "at line " << HP.GetLineData()
                                << std::endl);
#endif // ! MSG_NOSIGNAL

                } else {
                        break;
                }
        }

        UseSocket *pUS = 0;
        if (path.empty()) {
                if (port == (unsigned short int)(-1)) {
                        silent_cerr("ExtSocketHandler"
                                "(" << uLabel << "): "
                                "port missing"
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                SAFENEWWITHCONSTRUCTOR(pUS, UseInetSocket, UseInetSocket(host, port, socket_type, bCreate));

        } else {
                SAFENEWWITHCONSTRUCTOR(pUS, UseLocalSocket, UseLocalSocket(path, socket_type, bCreate));
        }

        if (bCreate) {
                pDM->RegisterSocketUser(pUS);

        } else {
                pUS->Connect();
        }

        mbsleep_t SleepTime = mbsleep_init(0);
        std::streamsize Precision = 0;
        ReadExtFileParams(pDM, HP, uLabel, SleepTime, Precision);
        // NOTE: so far, precision is ignored

        SAFENEWWITHCONSTRUCTOR(pEFH, ExtSocketHandler,
                ExtSocketHandler(pUS, SleepTime, recv_flags, send_flags));

        return pEFH;
#else // ! USE_SOCKET
        silent_cerr("ExtSocketHandler not supported" << std::endl);
        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif // ! USE_SOCKET
}

Here is the call graph for this function: