module-octave.h File Reference

Go to the source code of this file.

Functions
bool	mbdyn_octave_set (void)

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: