module-octave.cc File Reference

#include <mbconfig.h>

Include dependency graph for module-octave.cc:

Go to the source code of this file.

Functions
bool	mbdyn_octave_set (void)
int	module_init (const char *module_name, void *pdm, void *php)
	This function registers our user defined element for the math parser. More...

Function Documentation

bool mbdyn_octave_set

(

void

)

Definition at line 5603 of file module-octave.cc.

References SetCL1D(), SetCL3D(), SetCL6D(), SetDC1D(), SetDC3D(), SetDC3x3D(), SetDC6D(), SetDC6x6D(), SetDriveCallerData(), SetSF(), and SetUDE().

Referenced by InitDriveCallerData(), and module_init().

{
#ifdef USE_OCTAVE
        using namespace oct;

        DriveCallerRead *rf = new OctaveDCR;
        if (!SetDriveCallerData("octave", rf)) {
                delete rf;
                return false;
        }

        OctaveTDCR<doublereal>* const rf1D = new OctaveTDCR<doublereal>;
        if (!SetDC1D("octave", rf1D)) {
                delete rf1D;
                return false;
        }

        OctaveTDCR<Vec3>* const rf3D = new OctaveTDCR<Vec3>;
        if (!SetDC3D("octave", rf3D)) {
                delete rf3D;
                return false;
        }

        OctaveTDCR<Vec6>* const rf6D = new OctaveTDCR<Vec6>;
        if (!SetDC6D("octave", rf6D)) {
                delete rf6D;
                return false;
        }

        OctaveTDCR<Mat3x3>* const rf3x3D = new OctaveTDCR<Mat3x3>;
        if (!SetDC3x3D("octave", rf3x3D)) {
                delete rf3x3D;
                return false;
        }

        OctaveTDCR<Mat6x6>* const rf6x6D = new OctaveTDCR<Mat6x6>;
        if (!SetDC6x6D("octave", rf6x6D)) {
                delete rf6x6D;
                return false;
        }

        rf = new DerivativeDCR;
        if (!SetDriveCallerData("derivative", rf)) {
                delete rf;
                return false;
        }

        ScalarFunctionRead* rsf = new OctaveSFR;
        if (!SetSF("octave", rsf)) {
                delete rsf;
                return false;
        }

        UserDefinedElemRead *urf = new UDERead<OctaveElement>;
        if (!SetUDE("octave", urf)) {
                delete urf;
                return false;
        }

        ConstitutiveLawRead<doublereal, doublereal> *rfcl1D = new OctaveCLR<doublereal, doublereal>;
        if (!SetCL1D("octave", rfcl1D)) {
                delete rfcl1D;
                return false;
        }

        ConstitutiveLawRead<Vec3, Mat3x3> *rfcl3D = new OctaveCLR<Vec3, Mat3x3>;
        if (!SetCL3D("octave", rfcl3D)) {
                delete rfcl3D;
                return false;
        }

        ConstitutiveLawRead<Vec6, Mat6x6> *rfcl6D = new OctaveCLR<Vec6, Mat6x6>;
        if (!SetCL6D("octave", rfcl6D)) {
                delete rfcl6D;
                return false;
        }
#else
        pedantic_cerr("warning: MBDyn has been configured without octave support\n"
                                  "warning: module-octave is not available in this version of MBDyn" << std::endl);
#endif

        // Return true also if USE_OCTAVE is not enabled
        // This prevents one assertion to fail in userelem.cc if built as a static module
        return true;
}

Here is the call graph for this function:

int module_init	(	const char *	module_name,
		void *	pdm,
		void *	php
	)

This function registers our user defined element for the math parser.

It is called when the "module load" statement appears in the input file.

Definition at line 5692 of file module-octave.cc.

References mbdyn_octave_set().

{
        if (!mbdyn_octave_set()) {
                silent_cerr("octave: "
                        "module_init(" << module_name << ") "
                        "failed" << std::endl);
                return -1;
        }

        return 0;
}

Here is the call graph for this function: