Пример #1
0
 XC::Vector
XC::SecantRootFinding::findLimitStateSurface(int space, double g, Vector pDirection, Vector thePoint)
{
	// Set scale factor for 'g' for convergence check
	double scaleG;
	if (fabs(g)>1.0e-4) { scaleG = g;}
	else { 		scaleG = 1.0;}

	// Normalize the direction vector
	Vector Direction = pDirection/pDirection.Norm();

	// Scale 'maxStepLength' by standard deviation
	// (only if the user has specified to "walk" in original space)
	double perturbation;
	double realMaxStepLength = maxStepLength;
	if (space == 1) {

		// Go through direction vector and see which element is biggest
		// compared to its standard deviation
		int nrv = theReliabilityDomain->getNumberOfRandomVariables();
		RandomVariable *theRV;
		double stdv, theStdv= 0.0;
		int theBiggest;
		double maxRatio = 0.0;
		for(int i=0; i<nrv; i++)
                  {
		    theRV = theReliabilityDomain->getRandomVariablePtr(i+1);
		    stdv = theRV->getStdv();
			if (Direction(i)/stdv > maxRatio) {
				maxRatio = Direction(i)/stdv;
				theStdv = stdv;
				theBiggest = i+1;
			}
		}

		// Now scale so that 'maxStepSize' is related to the real stdv
		perturbation = maxStepLength * theStdv;
		realMaxStepLength = perturbation;
	}
	else {
		perturbation = maxStepLength;
	}

	Vector theTempPoint;
	double g_old= 0.0, g_new;
	bool didNotConverge=true;
	double result;
	double tangent;


	int i=0;
	while (i<=maxIter && didNotConverge) {


		// Increment counter right away...
		i++;

		if (i!=1) {

			// Transform the point into x-space if the user has given it in 2-space
			if (space==2) {
				result = theProbabilityTransformation->set_u(thePoint);
				if (result < 0) {
					std::cerr << "XC::GFunVisualizationAnalysis::analyze() - " << std::endl
						<< " could not set u in the xu-transformation." << std::endl;
					//return -1; Comentado LCPT.
				}

				result = theProbabilityTransformation->transform_u_to_x();
				if (result < 0) {
					std::cerr << "XC::GFunVisualizationAnalysis::analyze() - " << std::endl
						<< " could not transform from u to x and compute Jacobian." << std::endl;
					//return -1; Comentado LCPT.
				}
				theTempPoint = theProbabilityTransformation->get_x();
			}
			else {
				theTempPoint = thePoint;
			}


			// Evaluate limit-state function
			result = theGFunEvaluator->runGFunAnalysis(theTempPoint);
			if (result < 0) {
				std::cerr << "XC::GFunVisualizationAnalysis::analyze() - " << std::endl
					<< " could not run analysis to evaluate limit-state function. " << std::endl;
				//return -1; Comentado LCPT.
			}
			result = theGFunEvaluator->evaluateG(theTempPoint);
			if (result < 0) {
				std::cerr << "XC::GFunVisualizationAnalysis::analyze() - " << std::endl
					<< " could not tokenize limit-state function. " << std::endl;
				//return -1; Comentado LCPT.
			}
			g_new = theGFunEvaluator->getG();
		}
		else {
			g_new = g;
		}

		

		// Check convergence
		if (fabs(g_new/scaleG) < tol) {
			didNotConverge = false;
		}
		else {
			if (i==maxIter) {
				std::cerr << "WARNING: Projection scheme failed to find surface..." << std::endl;
			}
			else if (i==1) {
				thePoint = thePoint - perturbation * Direction;
				g_old = g_new;
			}
			else {

				// Take a step
				tangent = (g_new-g_old)/perturbation;
				perturbation = -g_new/tangent;
				if (fabs(perturbation) > realMaxStepLength) {
					perturbation = perturbation/fabs(perturbation)*realMaxStepLength;
				}
				thePoint = thePoint - perturbation * Direction;
				g_old = g_new;
			}
		}
	}

	return thePoint;
}
Пример #2
0
int 
MVFOSMAnalysis::analyze(void)
{

	// Alert the user that the FORM analysis has started
	opserr << "MVFOSM Analysis is running ... " << endln;


	// Initial declarations
	int i,j,k;


	// Open output file
	ofstream outputFile( fileName, ios::out );


	// Get number of random variables 
	int nrv = theReliabilityDomain->getNumberOfRandomVariables();

	
	// Get mean point
	RandomVariable *aRandomVariable;
	Vector meanVector(nrv);
	for (i=1; i<=nrv; i++)
	{
		aRandomVariable = theReliabilityDomain->getRandomVariablePtr(i);
		if (aRandomVariable == 0) {
			opserr << "MVFOSMAnalysis::analyze() -- Could not find" << endln
				<< " random variable with tag #" << i << "." << endln;
			return -1;
		}
		meanVector(i-1) = aRandomVariable->getMean();
	}


	// Establish vector of standard deviations
	Vector stdvVector(nrv);
	for (i=1; i<=nrv; i++)
	{
		aRandomVariable = theReliabilityDomain->getRandomVariablePtr(i);
		stdvVector(i-1) = aRandomVariable->getStdv();
	}


	// Evaluate limit-state function
	int result;
	result = theGFunEvaluator->runGFunAnalysis(meanVector);
	if (result < 0) {
		opserr << "SearchWithStepSizeAndStepDirection::doTheActualSearch() - " << endln
			<< " could not run analysis to evaluate limit-state function. " << endln;
		return -1;
	}


	// Establish covariance matrix
	Matrix covMatrix(nrv,nrv);
	for (i=1; i<=nrv; i++) {
		covMatrix(i-1,i-1) = stdvVector(i-1)*stdvVector(i-1);
	}
	int ncorr = theReliabilityDomain->getNumberOfCorrelationCoefficients();
	CorrelationCoefficient *theCorrelationCoefficient;
	double covariance, correlation;
	int rv1, rv2;
	for (i=1 ; i<=ncorr ; i++) {
		theCorrelationCoefficient = theReliabilityDomain->getCorrelationCoefficientPtr(i);
		correlation = theCorrelationCoefficient->getCorrelation();
		rv1 = theCorrelationCoefficient->getRv1();
		rv2 = theCorrelationCoefficient->getRv2();
		covariance = correlation*stdvVector(rv1-1)*stdvVector(rv2-1);
		covMatrix(rv1-1,rv2-1) = covariance;
		covMatrix(rv2-1,rv1-1) = covariance;
	}


	// 'Before loop' declarations
	int numLsf = theReliabilityDomain->getNumberOfLimitStateFunctions();
	Vector gradient(nrv);
	Matrix matrixOfGradientVectors(nrv,numLsf);
	Vector meanEstimates(numLsf);
	Vector responseStdv(numLsf);
	double responseVariance;
	

	// Loop over limit-state functions
	for (int lsf=1; lsf<=numLsf; lsf++ ) {

		// Inform the user which limit-state function is being evaluated
		opserr << "Limit-state function number: " << lsf << endln;


		// Set tag of active limit-state function
		theReliabilityDomain->setTagOfActiveLimitStateFunction(lsf);


		// Get limit-state function value (=estimation of the mean)
		result = theGFunEvaluator->evaluateG(meanVector);
		if (result < 0) {
			opserr << "SearchWithStepSizeAndStepDirection::doTheActualSearch() - " << endln
				<< " could not tokenize limit-state function. " << endln;
			return -1;
		}
		meanEstimates(lsf-1) = theGFunEvaluator->getG();


		// Evaluate (and store) gradient of limit-state function
		result = theGradGEvaluator->evaluateGradG(meanEstimates(lsf-1),meanVector);
		if (result < 0) {
			opserr << "MVFOSMAnalysis::analyze() -- could not" << endln
				<< " compute gradients of the limit-state function. " << endln;
			return -1;
		}
		gradient = theGradGEvaluator->getGradG();
		for (i=1 ; i<=nrv ; i++) {
			matrixOfGradientVectors(i-1,lsf-1) = gradient(i-1);
		}


		// Estimate of standard deviation
		responseVariance = (covMatrix^gradient)^gradient;
		if (responseVariance <= 0.0) {
			opserr << "ERROR: Response variance of limit-state function number "<< lsf << endln
				<< " is zero! " << endln;
		}
		else {
			responseStdv(lsf-1) = sqrt(responseVariance);
		}

	
		// Print MVFOSM results to the output file
		outputFile << "#######################################################################" << endln;
		outputFile << "#  MVFOSM ANALYSIS RESULTS, LIMIT-STATE FUNCTION NUMBER "
			<<setiosflags(ios::left)<<setprecision(1)<<setw(4)<<lsf <<"          #" << endln;
		outputFile << "#                                                                     #" << endln;
		
		outputFile << "#  Estimated mean: .................................... " 
			<<setiosflags(ios::left)<<setprecision(5)<<setw(12)<<meanEstimates(lsf-1) 
			<< "  #" << endln;
		outputFile << "#  Estimated standard deviation: ...................... " 
			<<setiosflags(ios::left)<<setprecision(5)<<setw(12)<<responseStdv(lsf-1) 
			<< "  #" << endln;
		outputFile << "#                                                                     #" << endln;
		outputFile << "#######################################################################" << endln << endln << endln;


		// Inform the user that we are done with this limit-state function
		opserr << "Done analyzing limit-state function " << lsf << endln;	
	}


	// Estimation of response covariance matrix
	Matrix responseCovMatrix(numLsf,numLsf);
	double responseCovariance;
	Vector gradientVector1(nrv), gradientVector2(nrv);
	for (i=1; i<=numLsf; i++) {
		for (k=0; k<nrv; k++) {
			gradientVector1(k) = matrixOfGradientVectors(k,i-1);
		}
		for (j=i+1; j<=numLsf; j++) {
			for (k=0; k<nrv; k++) {
				gradientVector2(k) = matrixOfGradientVectors(k,j-1);
			}
			responseCovariance = (covMatrix^gradientVector1)^gradientVector2;
			responseCovMatrix(i-1,j-1) = responseCovariance;
		}
	}
	for (i=1; i<=numLsf; i++) {
		for (j=1; j<i; j++) {
			responseCovMatrix(i-1,j-1) = responseCovMatrix(j-1,i-1);
		}
	}


	// Corresponding correlation matrix
	Matrix correlationMatrix(numLsf,numLsf);
	for (i=1; i<=numLsf; i++) {
		for (j=i+1; j<=numLsf; j++) {
			correlationMatrix(i-1,j-1) = responseCovMatrix(i-1,j-1)/(responseStdv(i-1)*responseStdv(j-1));
		}
	}
	for (i=1; i<=numLsf; i++) {
		for (j=1; j<i; j++) {
			correlationMatrix(i-1,j-1) = correlationMatrix(j-1,i-1);
		}
	}

	
	// Print correlation results
	outputFile << "#######################################################################" << endln;
	outputFile << "#  RESPONSE CORRELATION COEFFICIENTS                                  #" << endln;
	outputFile << "#                                                                     #" << endln;
	if (numLsf <=1) {
		outputFile << "#  Only one limit-state function!                                     #" << endln;
	}
	else {
		outputFile << "#   gFun   gFun     Correlation                                       #" << endln;
		outputFile.setf(ios::fixed, ios::floatfield);
		for (i=0; i<numLsf; i++) {
			for (j=i+1; j<numLsf; j++) {
//				outputFile.setf(ios::fixed, ios::floatfield);
				outputFile << "#    " <<setw(3)<<(i+1)<<"    "<<setw(3)<<(j+1)<<"     ";
				if (correlationMatrix(i,j)<0.0) { outputFile << "-"; }
				else { outputFile << " "; }
//				outputFile.setf(ios::scientific, ios::floatfield);
				outputFile <<setprecision(7)<<setw(11)<<fabs(correlationMatrix(i,j));
				outputFile << "                                      #" << endln;
			}
		}
	}
	outputFile << "#                                                                     #" << endln;
	outputFile << "#######################################################################" << endln << endln << endln;



	// Print summary of results to screen (more here!!!)
	opserr << "MVFOSMAnalysis completed." << endln;


	return 0;
}