DLLEXPORT void vclAbs(const int n, const ScalarType a[], const int aOffset, ScalarType b[], const int bOffset) { auto aPtr = &(a[0]) + aOffset; auto bPtr = &(b[0]) + bOffset; viennacl::vector<ScalarType> aVec((ScalarType*)aPtr, viennacl::MAIN_MEMORY, n); viennacl::vector<ScalarType> bVec(bPtr, viennacl::MAIN_MEMORY, n); bVec = viennacl::linalg::element_abs(aVec); };
DLLEXPORT void vclSubstract(const int n, const ScalarType a[], const int aOffset, ScalarType b[], const int bOffset) { auto aPtr = &(a[0]) + aOffset; auto bPtr = &(b[0]) + bOffset; viennacl::vector<ScalarType> aVec((ScalarType*)aPtr, viennacl::MAIN_MEMORY, n); viennacl::vector<ScalarType> bVec(bPtr, viennacl::MAIN_MEMORY, n); bVec = aVec - bVec; };
void Ground::makeHole(b2Vec2 epicenter, float radius) { std::list<b2Vec2>::iterator first,second, firstToDel, lastToDel, circleStart, circleEnd, itr, leftCircleBorder, rightCircleBorder; b2Vec2 leftBorder, rightBorder; bool leftFound(false), rightFound(false); //find left border first = this->edges.begin(); for (second=++(this->edges.begin()); second!=this->edges.end(); first++,second++) { if (distance(*second, epicenter) <= radius) { leftBorder = (*first); circleStart = first; leftFound = true; firstToDel = second; break; } } //find right border first = --(this->edges.end()); for (second= --(--this->edges.end()); second!=this->edges.begin(); first--,second--) { if (distance(*second, epicenter) <= radius) { rightBorder = (*first); circleEnd = first; rightFound = true; lastToDel = second; break; } } if ( !(leftFound && rightFound) ) return; leftBorder = getBorder(*circleStart, *firstToDel, epicenter, radius); leftCircleBorder = circleStart; leftCircleBorder++; this->edges.insert(leftCircleBorder,leftBorder); leftCircleBorder--; rightBorder = getBorder(*circleEnd, *lastToDel, epicenter, radius); rightCircleBorder = circleEnd; this->edges.insert(rightCircleBorder,rightBorder); rightCircleBorder--; this->edges.erase(firstToDel, ++lastToDel); b2Vec2 aVec(leftBorder.x-epicenter.x, leftBorder.y-epicenter.y), bVec(rightBorder.x-epicenter.x, rightBorder.y-epicenter.y); positiveAngle ab = getPositiveAngle(aVec,bVec); positiveAngle step = 1/57.296; b2Vec2 toInsert = rotateVec(aVec, step); positiveAngle rotated(step); for (itr = ++leftCircleBorder; rotated < ab; rotated+=step) { this->edges.insert(itr,epicenter + toInsert); toInsert = rotateVec(toInsert,step); } }
void solveSip(const uqFullEnvironmentClass& env, bool useML) { if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Entering solveSip()..." << std::endl; } //////////////////////////////////////////////////////// // Step 1 of 5: Instantiate the parameter space //////////////////////////////////////////////////////// unsigned int p = 1; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL); uqGslVectorClass bVec(paramSpace.zeroVector()); bVec[0] = 0.045213; //////////////////////////////////////////////////////// // Step 2 of 5: Instantiate the parameter domain //////////////////////////////////////////////////////// //uqGslVectorClass paramMins (paramSpace.zeroVector()); //uqGslVectorClass paramMaxs (paramSpace.zeroVector()); //paramMins [0] = -1.e+16; //paramMaxs [0] = 1.e+16; //paramMins [1] = -1.e+16; //paramMaxs [1] = 1.e+16; //uqBoxSubsetClass<uqGslVectorClass,uqGslMatrixClass> paramDomain("param_",paramSpace,paramMins,paramMaxs); uqVectorSetClass<uqGslVectorClass,uqGslMatrixClass>* paramDomain = ¶mSpace; //////////////////////////////////////////////////////// // Step 3 of 5: Instantiate the likelihood function object //////////////////////////////////////////////////////// unsigned int nAll = 100000; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpaceAll(env, "data_", nAll, NULL); double sigmaTotal = bVec[0]/2.; std::set<unsigned int> tmpSet; tmpSet.insert(env.subId()); uqGslVectorClass ySamplesAll(dataSpaceAll.zeroVector()); ySamplesAll.subReadContents("input/dataPoints", "m", tmpSet); unsigned int numCases = 5; std::vector<unsigned int> ns(numCases,0); ns[0] = 1; ns[1] = 10; ns[2] = 100; ns[3] = 500; ns[4] = 1000; for (unsigned int caseId = 0; caseId < numCases; ++caseId) { uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", ns[caseId], NULL); uqGslVectorClass ySamples(dataSpace.zeroVector()); for (unsigned int i = 0; i < ns[caseId]; ++i) { ySamples[i] = ySamplesAll[i]; } struct likelihoodDataStruct likelihoodData; likelihoodData.bVec = &bVec; likelihoodData.sigmaTotal = sigmaTotal; likelihoodData.ySamples = &ySamples; uqGenericScalarFunctionClass<uqGslVectorClass,uqGslMatrixClass> likelihoodFunctionObj("like_", *paramDomain, likelihoodRoutine, (void *) &likelihoodData, true); // routine computes [ln(function)] //////////////////////////////////////////////////////// // Step 4 of 5: Instantiate the inverse problem //////////////////////////////////////////////////////// uqUniformVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain); uqGenericVectorRVClass<uqGslVectorClass,uqGslMatrixClass> postRv ("post_", paramSpace); char prefixStr[16+1]; sprintf(prefixStr,"sip%d_",caseId+1); uqStatisticalInverseProblemClass<uqGslVectorClass,uqGslMatrixClass> sip(prefixStr, NULL, priorRv, likelihoodFunctionObj, postRv); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "In solveSip():" << "\n caseId = " << caseId << "\n prefixStr = " << prefixStr << "\n p = " << p << "\n bVec = " << bVec << "\n ns[caseId] = " << ns[caseId] << "\n sigmaTotal = " << sigmaTotal << "\n ySamples = " << ySamples << "\n useML = " << useML << std::endl; } //////////////////////////////////////////////////////// // Step 5 of 5: Solve the inverse problem //////////////////////////////////////////////////////// uqGslVectorClass initialValues(paramSpace.zeroVector()); initialValues[0] = 0.; uqGslMatrixClass proposalCovMat(paramSpace.zeroVector()); proposalCovMat(0,0) = 1.; if (useML) { sip.solveWithBayesMLSampling(); } else { sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat); } } // for caseId if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Leaving solveSip()" << std::endl; } return; }
double likelihoodRoutine( const uqGslVectorClass& paramValues, const uqGslVectorClass* paramDirection, const void* functionDataPtr, uqGslVectorClass* gradVector, uqGslMatrixClass* hessianMatrix, uqGslVectorClass* hessianEffect) { struct timeval timevalBegin; gettimeofday(&timevalBegin, NULL); likelihoodCounter++; const uqBaseEnvironmentClass& env = paramValues.env(); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 3)) { *env.subDisplayFile() << "Entering likelihoodRoutine()..." << ": likelihoodCounter = " << likelihoodCounter << ", params = " << paramValues << ", env.subComm().NumProc() = " << env.subComm().NumProc() << ", my subRank = " << env.subRank() << std::endl; } if (env.subRank() == 0) { #if 0 std::cout << "Entering likelihoodRoutine()" << ", likelihoodCounter = " << likelihoodCounter << std::endl; #endif } ////////////////////////////////////////////////// // Begin actual likelihood routine ////////////////////////////////////////////////// double totalLnLikelihood = 0.; if (paramDirection && functionDataPtr && gradVector && hessianMatrix && hessianEffect) { // Just to eliminate INTEL compiler warnings } struct likelihoodDataStruct* likelihoodData = (likelihoodDataStruct *) functionDataPtr; uqGslVectorClass bVec(*(likelihoodData->bVec)); unsigned int p = bVec.sizeLocal(); double sigmaTotal = likelihoodData->sigmaTotal; uqGslVectorClass ySamples(*(likelihoodData->ySamples)); unsigned int n = ySamples.sizeLocal(); UQ_FATAL_TEST_MACRO(paramValues.sizeLocal() != p, env.fullRank(), "likelihoodRoutine()", "invalid parameter vector size"); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 4)) { *env.subDisplayFile() << "In likelihoodRoutine()" << ": likelihoodCounter = " << likelihoodCounter << ", params = " << paramValues << ", p = " << p << ", bVec = " << bVec << ", sigmaTotal = " << sigmaTotal << ", n = " << n << ", ySamples = " << ySamples << std::endl; } //****************************************************************************** // Compute likelihood //****************************************************************************** for (unsigned int i = 0; i < n; ++i) { double diff = (ySamples[i] - (bVec[0]*paramValues[0]))/sigmaTotal; totalLnLikelihood -= 0.5 * diff * diff; if ((env.subDisplayFile()) && (env.displayVerbosity() >= 4)) { *env.subDisplayFile() << "In likelihoodRoutine()" << ": likelihoodCounter = " << likelihoodCounter << ", params = " << paramValues << ", diff = " << diff << std::endl; } } //****************************************************************************** // Prepare to return //****************************************************************************** double totalTime = uqMiscGetEllapsedSeconds(&timevalBegin); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 3)) { *env.subDisplayFile() << "Leaving likelihoodRoutine()" << ": likelihoodCounter = " << likelihoodCounter << ", params = " << paramValues << ", totalLnLikelihood = " << totalLnLikelihood << " after " << totalTime << " seconds" << std::endl; } if (env.subRank() == 0) { #if 0 std::cout << "Leaving likelihoodRoutine()" << ": likelihoodCounter = " << likelihoodCounter << ", params = " << paramValues << ", totalLnLikelihood = " << totalLnLikelihood << " after " << totalTime << " seconds" << std::endl; #endif } env.subComm().Barrier(); //exit(1); return totalLnLikelihood; }
/** * @param A coefficient matrix * @param b right-hand side * @param[out] x solution of the linear system * @return whether all went well (false if errors occurred) */ bool solveInternal(const gmm::csr_matrix<float_t>& A, base::DataVector& b, base::DataVector& x) { // allow warnings gmm::warning_level::level(1); const size_t n = b.getSize(); std::vector<float_t> bVec(b.getPointer(), b.getPointer() + n); std::vector<float_t> xVec(n, 0.0); // ILU preconditioning Printer::getInstance().printStatusUpdate("constructing preconditioner"); gmm::ilu_precond<gmm::csr_matrix<float_t>> P(A); Printer::getInstance().printStatusNewLine(); Printer::getInstance().printStatusUpdate("solving with Gmm++"); gmm::iteration iter(1e-6, 0, 10000); iter.set_callback(&callback); try { // call GMRES gmm::gmres(A, xVec, bVec, P, 50, iter); float_t res = iter.get_res(); if (iter.converged() && (res < 1e3)) { // GMRES converged x = base::DataVector(xVec); Printer::getInstance().printStatusUpdate("solving with Gmm++ (k = " + std::to_string(iter.get_iteration()) + ", residual norm = " + std::to_string(res) + ")"); Printer::getInstance().printStatusEnd(); return true; } else { // GMRES didn't converge ==> try again without preconditioner gmm::identity_matrix P; Printer::getInstance().printStatusNewLine(); Printer::getInstance().printStatusUpdate( "solving with preconditioner failed, trying again without one"); Printer::getInstance().printStatusNewLine(); // call GMRES again gmm::gmres(A, xVec, bVec, P, 50, iter); res = iter.get_res(); if (iter.converged() && (res < 1e3)) { x = base::DataVector(xVec); Printer::getInstance().printStatusUpdate("solving with Gmm++ (k = " + std::to_string(iter.get_iteration()) + ", residual norm = " + std::to_string(res) + ")"); Printer::getInstance().printStatusEnd(); return true; } else { Printer::getInstance().printStatusEnd( "error: Could not solve linear system, " "method didn't converge"); return false; } } } catch (std::exception& e) { Printer::getInstance().printStatusEnd("error: Could not solve linear system, what(): " + std::string(e.what())); return false; } }
void solveSip(const uqFullEnvironmentClass& env, bool useML) { if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Entering solveSip()..." << std::endl; } //////////////////////////////////////////////////////// // Step 1 of 5: Instantiate the parameter space //////////////////////////////////////////////////////// unsigned int p = 1; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL); uqGslVectorClass aVec(paramSpace.zeroVector()); aVec[0] = 126831.7; uqGslVectorClass bVec(paramSpace.zeroVector()); bVec[0] = 112136.1; //////////////////////////////////////////////////////// // Step 2 of 5: Instantiate the parameter domain //////////////////////////////////////////////////////// //uqGslVectorClass paramMins (paramSpace.zeroVector()); //uqGslVectorClass paramMaxs (paramSpace.zeroVector()); //paramMins [0] = -1.e+16; //paramMaxs [0] = 1.e+16; //paramMins [1] = -1.e+16; //paramMaxs [1] = 1.e+16; //uqBoxSubsetClass<uqGslVectorClass,uqGslMatrixClass> paramDomain("param_",paramSpace,paramMins,paramMaxs); uqVectorSetClass<uqGslVectorClass,uqGslMatrixClass>* paramDomain = ¶mSpace; //////////////////////////////////////////////////////// // Step 3 of 5: Instantiate the likelihood function object //////////////////////////////////////////////////////// unsigned int n = 400; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", n, NULL); double sigmaTotal = 4229.55; std::set<unsigned int> tmpSet; tmpSet.insert(env.subId()); uqGslVectorClass ySamples(dataSpace.zeroVector()); ySamples.subReadContents("input/dataPoints", "m", tmpSet); struct likelihoodDataStruct likelihoodData; likelihoodData.aVec = &aVec; likelihoodData.bVec = &bVec; likelihoodData.sigmaTotal = sigmaTotal; likelihoodData.ySamples = &ySamples; uqGenericScalarFunctionClass<uqGslVectorClass,uqGslMatrixClass> likelihoodFunctionObj("like_", *paramDomain, likelihoodRoutine, (void *) &likelihoodData, true); // routine computes [ln(function)] //////////////////////////////////////////////////////// // Step 4 of 5: Instantiate the inverse problem //////////////////////////////////////////////////////// uqUniformVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain); uqGenericVectorRVClass<uqGslVectorClass,uqGslMatrixClass> postRv ("post_", paramSpace); uqStatisticalInverseProblemClass<uqGslVectorClass,uqGslMatrixClass> sip("sip_", NULL, priorRv, likelihoodFunctionObj, postRv); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "In solveSip():" << "\n p = " << p << "\n aVec = " << aVec << "\n bVec = " << bVec << "\n n = " << n << "\n sigmaTotal = " << sigmaTotal << "\n ySamples = " << ySamples << "\n useML = " << useML << std::endl; } //////////////////////////////////////////////////////// // Step 5 of 5: Solve the inverse problem //////////////////////////////////////////////////////// uqGslVectorClass initialValues(paramSpace.zeroVector()); initialValues[0] = 0.; uqGslMatrixClass proposalCovMat(paramSpace.zeroVector()); proposalCovMat(0,0) = 1.; if (useML) { sip.solveWithBayesMLSampling(); } else { sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat); } if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Leaving solveSip()" << std::endl; } return; }