Method computeGradient

SRC/reliability/analysis/gradient/ImplicitGradient.cpp:67–128

const Vector &ImplicitGradient::getGradient() { return *grad_g; }

int ImplicitGradient::computeGradient(double g) {
    // Initialize gradient vector
    grad_g->Zero();

    // get limit-state function from reliability domain
    int lsf = theReliabilityDomain->getTagOfActiveLimitStateFunction();
    LimitStateFunction *theLimitStateFunction =
        theReliabilityDomain->getLimitStateFunctionPtr(lsf);
    const char *lsfExpression = theLimitStateFunction->getExpression();

    // get RVs created in the reliability domain
    int nrv = this->theReliabilityDomain->getNumberOfRandomVariables();

    // first check for dg/dimplicit partials
    for (int i = 0; i < nrv; i++) {
        // get RV
        auto *theRV =
            this->theReliabilityDomain->getRandomVariablePtrFromIndex(i);
        if (theRV == 0) {
            opserr << "ERROR: can't get RV " << i
                   << " -- ImplictGradient::computeGradient\n";
            return -1;
        }

        // get RV tag
        int rvTag = theRV->getTag();

        // get grad expression
        const char *gradExpression =
            theLimitStateFunction->getGradientExpression(rvTag);

        // not provided means zero
        if (gradExpression == 0) {
            opserr
                << "WARNING: lsf " << lsf
                << ": gradient expression for "
                   "random variable "
                << rvTag
                << " is not defined -- ImplicitGradient::computeGradient";
            return -1;
        }

        // set expression
        theFunctionEvaluator->setExpression(gradExpression);

        // update variables
        if (theFunctionEvaluator->setVariables() < 0) {
            opserr << "ERROR ImplicitGradient -- error setting "
                      "variables in namespace"
                   << endln;
            return -1;
        }

        // evaluate grad expression
        (*grad_g)(i) = theFunctionEvaluator->evaluateExpression();

        // Reset limit state function in evaluator
        theFunctionEvaluator->setExpression(lsfExpression);