void compute(const QUESO::FullEnvironment& env) { // Step 1 of 5: Instantiate the parameter space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env, "param_", 2, NULL); // Step 2 of 5: Instantiate the parameter domain QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(-INFINITY); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet( INFINITY); QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("param_",paramSpace,paramMins,paramMaxs); // Step 3 of 5: Instantiate the likelihood function object QUESO::GslVector meanVector(paramSpace.zeroVector()); meanVector[0] = -1; meanVector[1] = 2; QUESO::GslMatrix covMatrix(paramSpace.zeroVector()); covMatrix(0,0) = 4.; covMatrix(0,1) = 0.; covMatrix(1,0) = 0.; covMatrix(1,1) = 1.; likelihoodRoutine_DataType likelihoodRoutine_Data; likelihoodRoutine_Data.meanVector = &meanVector; likelihoodRoutine_Data.covMatrix = &covMatrix; QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix> likelihoodFunctionObj("like_", paramDomain, likelihoodRoutine, (void *) &likelihoodRoutine_Data, true); // routine computes [ln(function)] // Step 4 of 5: Instantiate the inverse problem QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_", paramDomain); QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix> ip("", NULL, priorRv, likelihoodFunctionObj, postRv); // Step 5 of 5: Solve the inverse problem QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.1; paramInitials[1] = -1.4; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0,0) = 8.; proposalCovMatrix(0,1) = 4.; proposalCovMatrix(1,0) = 4.; proposalCovMatrix(1,1) = 16.; ip.solveWithBayesMetropolisHastings(NULL,paramInitials, &proposalCovMatrix); return; }
void computeGravityAndTraveledDistance(const QUESO::FullEnvironment& env) { struct timeval timevalNow; gettimeofday(&timevalNow, NULL); if (env.fullRank() == 0) { std::cout << "\nBeginning run of 'Gravity + Projectile motion' example at " << ctime(&timevalNow.tv_sec) << "\n my fullRank = " << env.fullRank() << "\n my subEnvironmentId = " << env.subId() << "\n my subRank = " << env.subRank() << "\n my interRank = " << env.inter0Rank() << std::endl << std::endl; } // Just examples of possible calls if ((env.subDisplayFile() ) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Beginning run of 'Gravity + Projectile motion' example at " << ctime(&timevalNow.tv_sec) << std::endl; } env.fullComm().Barrier(); env.subComm().Barrier(); // Just an example of a possible call //================================================================ // Statistical inverse problem (SIP): find posterior PDF for 'g' //================================================================ gettimeofday(&timevalNow, NULL); if (env.fullRank() == 0) { std::cout << "Beginning 'SIP -> Gravity estimation' at " << ctime(&timevalNow.tv_sec) << std::endl; } //------------------------------------------------------ // SIP Step 1 of 6: Instantiate the parameter space //------------------------------------------------------ QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); //------------------------------------------------------ // SIP Step 2 of 6: Instantiate the parameter domain //------------------------------------------------------ QUESO::GslVector paramMinValues(paramSpace.zeroVector()); QUESO::GslVector paramMaxValues(paramSpace.zeroVector()); paramMinValues[0] = 8.; paramMaxValues[0] = 11.; QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues); //------------------------------------------------------ // SIP Step 3 of 6: Instantiate the likelihood function // object to be used by QUESO. //------------------------------------------------------ likelihoodRoutine_Data likelihoodRoutine_Data(env); QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix> likelihoodFunctionObj("like_", paramDomain, likelihoodRoutine, (void *) &likelihoodRoutine_Data, true); // the routine computes [ln(function)] //------------------------------------------------------ // SIP Step 4 of 6: Define the prior RV //------------------------------------------------------ #ifdef PRIOR_IS_GAUSSIAN QUESO::GslVector meanVector( paramSpace.zeroVector() ); meanVector[0] = 9; QUESO::GslMatrix covMatrix = QUESO::GslMatrix(paramSpace.zeroVector()); covMatrix(0,0) = 1.; // Create a Gaussian prior RV QUESO::GaussianVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_",paramDomain,meanVector,covMatrix); #else // Create an uniform prior RV QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_",paramDomain); #endif //------------------------------------------------------ // SIP Step 5 of 6: Instantiate the inverse problem //------------------------------------------------------ QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> postRv("post_", // Extra prefix before the default "rv_" prefix paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix> ip("", // No extra prefix before the default "ip_" prefix NULL, priorRv, likelihoodFunctionObj, postRv); //------------------------------------------------------ // SIP Step 6 of 6: Solve the inverse problem, that is, // set the 'pdf' and the 'realizer' of the posterior RV //------------------------------------------------------ std::cout << "Solving the SIP with Metropolis Hastings" << std::endl << std::endl; QUESO::GslVector paramInitials(paramSpace.zeroVector()); priorRv.realizer().realization(paramInitials); QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0,0) = std::pow( fabs(paramInitials[0])/20. , 2. ); ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); //================================================================ // Statistical forward problem (SFP): find the max distance // traveled by an object in projectile motion; input pdf for 'g' // is the solution of the SIP above. //================================================================ gettimeofday(&timevalNow, NULL); std::cout << "Beginning 'SFP -> Projectile motion' at " << ctime(&timevalNow.tv_sec) << std::endl; //------------------------------------------------------ // SFP Step 1 of 6: Instantiate the parameter *and* qoi spaces. // SFP input RV = FIP posterior RV, so SFP parameter space // has been already defined. //------------------------------------------------------ QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> qoiSpace(env, "qoi_", 1, NULL); //------------------------------------------------------ // SFP Step 2 of 6: Instantiate the parameter domain //------------------------------------------------------ // Not necessary because input RV of the SFP = output RV of SIP. // Thus, the parameter domain has been already defined. //------------------------------------------------------ // SFP Step 3 of 6: Instantiate the qoi function object // to be used by QUESO. //------------------------------------------------------ qoiRoutine_Data qoiRoutine_Data; qoiRoutine_Data.m_angle = M_PI/4.0; //45 degrees (radians) qoiRoutine_Data.m_initialVelocity= 5.; //initial speed (m/s) qoiRoutine_Data.m_initialHeight = 0.; //initial height (m) QUESO::GenericVectorFunction<QUESO::GslVector,QUESO::GslMatrix,QUESO::GslVector,QUESO::GslMatrix> qoiFunctionObj("qoi_", paramDomain, qoiSpace, qoiRoutine, (void *) &qoiRoutine_Data); //------------------------------------------------------ // SFP Step 4 of 6: Define the input RV //------------------------------------------------------ // Not necessary because input RV of SFP = output RV of SIP // (postRv). //------------------------------------------------------ // SFP Step 5 of 6: Instantiate the forward problem //------------------------------------------------------ QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> qoiRv("qoi_", qoiSpace); QUESO::StatisticalForwardProblem<QUESO::GslVector,QUESO::GslMatrix,QUESO::GslVector,QUESO::GslMatrix> fp("", NULL, postRv, qoiFunctionObj, qoiRv); //------------------------------------------------------ // SFP Step 6 of 6: Solve the forward problem //------------------------------------------------------ std::cout << "Solving the SFP with Monte Carlo" << std::endl << std::endl; fp.solveWithMonteCarlo(NULL); //------------------------------------------------------ gettimeofday(&timevalNow, NULL); if ((env.subDisplayFile() ) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Ending run of 'Gravity + Projectile motion' example at " << ctime(&timevalNow.tv_sec) << std::endl; } if (env.fullRank() == 0) { std::cout << "Ending run of 'Gravity + Projectile motion' example at " << ctime(&timevalNow.tv_sec) << std::endl; } return; }
void solveSip(const uqFullEnvironmentClass& env) { if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Entering solveSip()..." << std::endl; } //////////////////////////////////////////////////////// // Step 1 of 5: Instantiate the parameter space //////////////////////////////////////////////////////// unsigned int p = 2; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL); uqGslVectorClass aVec(paramSpace.zeroVector()); aVec[0] = 2.; aVec[1] = 5.; uqGslVectorClass xGiven(paramSpace.zeroVector()); xGiven[0] = -1.; xGiven[1] = 7.; //////////////////////////////////////////////////////// // 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 = 5; uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", n, NULL); uqGslVectorClass yMeanVec(dataSpace.zeroVector()); double tmp = scalarProduct(aVec,xGiven); for (unsigned int i = 0; i < n; ++i) { yMeanVec[i] = tmp; } double sigmaEps = 2.1; uqGslMatrixClass yCovMat(dataSpace.zeroVector()); tmp = sigmaEps*sigmaEps; for (unsigned int i = 0; i < n; ++i) { yCovMat(i,i) = tmp; } uqGslVectorClass ySamples(dataSpace.zeroVector()); uqGaussianVectorRVClass<uqGslVectorClass,uqGslMatrixClass> yRv("y_", dataSpace, yMeanVec, yCovMat); yRv.realizer().realization(ySamples); double ySampleMean = 0.; for (unsigned int i = 0; i < n; ++i) { ySampleMean += ySamples[i]; } ySampleMean /= ((double) n); struct likelihoodDataStruct likelihoodData; likelihoodData.aVec = &aVec; likelihoodData.sigmaEps = sigmaEps; 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 //////////////////////////////////////////////////////// uqGslVectorClass xPriorMeanVec(paramSpace.zeroVector()); xPriorMeanVec[0] = 0.; xPriorMeanVec[1] = 0.; uqGslMatrixClass sigma0Mat(paramSpace.zeroVector()); sigma0Mat(0,0) = 1.e-3; sigma0Mat(0,1) = 0.; sigma0Mat(1,0) = 0.; sigma0Mat(1,1) = 1.e-3; uqGslMatrixClass sigma0MatInverse(paramSpace.zeroVector()); sigma0MatInverse = sigma0Mat.inverse(); uqGaussianVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain, xPriorMeanVec, sigma0MatInverse); 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 xGiven = " << xGiven << "\n sigma0Mat = " << sigma0Mat << "\n sigma0MatInverse = " << sigma0MatInverse << "\n aVec = " << aVec << "\n n = " << n << "\n sigmaEps = " << sigmaEps << "\n yMeanVec = " << yMeanVec << "\n yCovMat = " << yCovMat << "\n ySamples = " << ySamples << "\n ySampleMean = " << ySampleMean << std::endl; } uqGslMatrixClass sigmaMatInverse(paramSpace.zeroVector()); sigmaMatInverse = matrixProduct(aVec,aVec); sigmaMatInverse *= (((double) n)/sigmaEps/sigmaEps); sigmaMatInverse += sigma0Mat; uqGslMatrixClass sigmaMat(paramSpace.zeroVector()); sigmaMat = sigmaMatInverse.inverse(); uqGslVectorClass muVec(paramSpace.zeroVector()); muVec = sigmaMat * aVec; muVec *= (((double) n) * ySampleMean)/sigmaEps/sigmaEps; if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "In solveSip():" << "\n muVec = " << muVec << "\n sigmaMat = " << sigmaMat << "\n sigmaMatInverse = " << sigmaMatInverse << std::endl; } //////////////////////////////////////////////////////// // Step 5 of 5: Solve the inverse problem //////////////////////////////////////////////////////// uqGslVectorClass initialValues(paramSpace.zeroVector()); initialValues[0] = 25.; initialValues[1] = 25.; uqGslMatrixClass proposalCovMat(paramSpace.zeroVector()); proposalCovMat(0,0) = 10.; proposalCovMat(0,1) = 0.; proposalCovMat(1,0) = 0.; proposalCovMat(1,1) = 10.; sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat); if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) { *env.subDisplayFile() << "Leaving solveSip()" << std::endl; } return; }
void GaussianMean1DRegressionCompute(const QUESO::BaseEnvironment& env, double priorMean, double priorVar, const likelihoodData& dat) { // parameter space: 1-D on (-infinity, infinity) QUESO::VectorSpace<P_V, P_M> paramSpace( env, // queso environment "param_", // name prefix 1, // dimensions NULL); // names P_V paramMin(paramSpace.zeroVector()); P_V paramMax(paramSpace.zeroVector()); paramMin[0] = -INFINITY; paramMax[0] = INFINITY; QUESO::BoxSubset<P_V, P_M> paramDomain( "paramBox_", // name prefix paramSpace, // vector space paramMin, // min values paramMax); // max values // gaussian prior with user supplied mean and variance P_V priorMeanVec(paramSpace.zeroVector()); P_V priorVarVec(paramSpace.zeroVector()); priorMeanVec[0] = priorMean; priorVarVec[0] = priorVar; QUESO::GaussianVectorRV<P_V, P_M> priorRv("prior_", paramDomain, priorMeanVec, priorVarVec); // likelihood is important QUESO::GenericScalarFunction<P_V, P_M> likelihoodFunctionObj( "like_", // name prefix paramDomain, // image set LikelihoodFunc<P_V, P_M>, // routine (void *) &dat, // routine data ptr true); // routineIsForLn QUESO::GenericVectorRV<P_V, P_M> postRv( "post_", // name prefix paramSpace); // image set // Initialize and solve the Inverse Problem with Bayes multi-level sampling QUESO::StatisticalInverseProblem<P_V, P_M> invProb( "", // name prefix NULL, // alt options priorRv, // prior RV likelihoodFunctionObj, // likelihood fcn postRv); // posterior RV invProb.solveWithBayesMLSampling(); // compute mean and second moment of samples on each proc via Knuth online mean/variance algorithm int N = invProb.postRv().realizer().subPeriod(); double subMean = 0.0; double subM2 = 0.0; double delta; P_V sample(paramSpace.zeroVector()); for (int n = 1; n <= N; n++) { invProb.postRv().realizer().realization(sample); delta = sample[0] - subMean; subMean += delta / n; subM2 += delta * (sample[0] - subMean); } // gather all Ns, means, and M2s to proc 0 std::vector<int> unifiedNs(env.inter0Comm().NumProc()); std::vector<double> unifiedMeans(env.inter0Comm().NumProc()); std::vector<double> unifiedM2s(env.inter0Comm().NumProc()); MPI_Gather(&N, 1, MPI_INT, &(unifiedNs[0]), 1, MPI_INT, 0, env.inter0Comm().Comm()); MPI_Gather(&subMean, 1, MPI_DOUBLE, &(unifiedMeans[0]), 1, MPI_DOUBLE, 0, env.inter0Comm().Comm()); MPI_Gather(&subM2, 1, MPI_DOUBLE, &(unifiedM2s[0]), 1, MPI_DOUBLE, 0, env.inter0Comm().Comm()); // get the total number of likelihood calls at proc 0 unsigned long totalLikelihoodCalls = 0; MPI_Reduce(&likelihoodCalls, &totalLikelihoodCalls, 1, MPI_UNSIGNED_LONG, MPI_SUM, 0, env.inter0Comm().Comm()); // compute global posterior mean and std via Chan algorithm, output results on proc 0 if (env.inter0Rank() == 0) { int postN = unifiedNs[0]; double postMean = unifiedMeans[0]; double postVar = unifiedM2s[0]; for (unsigned int i = 1; i < unifiedNs.size(); i++) { delta = unifiedMeans[i] - postMean; postMean = (postN * postMean + unifiedNs[i] * unifiedMeans[i]) / (postN + unifiedNs[i]); postVar += unifiedM2s[i] + delta * delta * (((double)postN * unifiedNs[i]) / (postN + unifiedNs[i])); postN += unifiedNs[i]; } postVar /= postN; //compute exact answer - available in this case since the exact posterior is a gaussian N = dat.dataSet.size(); double dataSum = 0.0; for (int i = 0; i < N; i++) dataSum += dat.dataSet[i]; double datMean = dataSum / N; double postMeanExact = (N * priorVar / (N * priorVar + dat.samplingVar)) * datMean + (dat.samplingVar / (N * priorVar + dat.samplingVar)) * priorMean; double postVarExact = 1.0 / (N / dat.samplingVar + 1.0 / priorVar); std::cout << "Number of posterior samples: " << postN << std::endl; std::cout << "Estimated posterior mean: " << postMean << " +/- " << std::sqrt(postVar) << std::endl; std::cout << "Likelihood function calls: " << totalLikelihoodCalls << std::endl; std::cout << "\nExact posterior: Gaussian with mean " << postMeanExact << ", standard deviation " << std::sqrt(postVarExact) << std::endl; } }
void compute(const QUESO::FullEnvironment& env, unsigned int numModes) { //////////////////////////////////////////////////////// // Step 1 of 5: Instantiate the parameter space //////////////////////////////////////////////////////// #ifdef APPLS_MODAL_USES_CONCATENATION QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpaceA(env, "paramA_", 2, NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpaceB(env, "paramB_", 1, NULL); #endif QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 3, NULL); //////////////////////////////////////////////////////// // Step 2 of 5: Instantiate the parameter domain //////////////////////////////////////////////////////// #ifdef APPLS_MODAL_USES_CONCATENATION QUESO::GslVector paramMinsA(paramSpaceA.zeroVector()); paramMinsA[0] = 0.; paramMinsA[1] = 0.; QUESO::GslVector paramMaxsA(paramSpaceA.zeroVector()); paramMaxsA[0] = 3.; paramMaxsA[1] = 3.; QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomainA("paramA_",paramSpaceA,paramMinsA,paramMaxsA); QUESO::GslVector paramMinsB(paramSpaceB.zeroVector()); paramMinsB[0] = 0.; QUESO::GslVector paramMaxsB(paramSpaceB.zeroVector()); paramMaxsB[0] = INFINITY; QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomainB("paramB_",paramSpaceB,paramMinsB,paramMaxsB); QUESO::ConcatenationSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("",paramSpace,paramDomainA,paramDomainB); #else QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins[0] = 0.; paramMins[1] = 0.; paramMins[2] = 0.; QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs[0] = 3.; paramMaxs[1] = 3.; paramMaxs[2] = .3; QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("param_",paramSpace,paramMins,paramMaxs); #endif //////////////////////////////////////////////////////// // Step 3 of 5: Instantiate the likelihood function object //////////////////////////////////////////////////////// likelihoodRoutine_DataType likelihoodRoutine_Data; likelihoodRoutine_Data.numModes = numModes; QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix> likelihoodFunctionObj("like_", paramDomain, likelihoodRoutine, (void *) &likelihoodRoutine_Data, true); // routine computes [-2.*ln(function)] //////////////////////////////////////////////////////// // Step 4 of 5: Instantiate the inverse problem //////////////////////////////////////////////////////// #ifdef APPLS_MODAL_USES_CONCATENATION QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRvA("priorA_", paramDomainA); QUESO::GslVector alpha(paramSpaceB.zeroVector()); alpha[0] = 3.; QUESO::GslVector beta(paramSpaceB.zeroVector()); if (numModes == 1) { beta[0] = 0.09709133373799; } else { beta[0] = 0.08335837191688; } QUESO::InverseGammaVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRvB("priorB_", paramDomainB,alpha,beta); QUESO::ConcatenatedVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_", priorRvA, priorRvB, paramDomain); #else QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_", paramDomain); #endif QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix> ip("", NULL, priorRv, likelihoodFunctionObj, postRv); //////////////////////////////////////////////////////// // Step 5 of 5: Solve the inverse problem //////////////////////////////////////////////////////// ip.solveWithBayesMLSampling(); //////////////////////////////////////////////////////// // Print some statistics //////////////////////////////////////////////////////// unsigned int numPosTotal = postRv.realizer().subPeriod(); if (env.subDisplayFile()) { *env.subDisplayFile() << "numPosTotal = " << numPosTotal << std::endl; } QUESO::GslVector auxVec(paramSpace.zeroVector()); unsigned int numPosTheta1SmallerThan1dot5 = 0; for (unsigned int i = 0; i < numPosTotal; ++i) { postRv.realizer().realization(auxVec); if (auxVec[0] < 1.5) numPosTheta1SmallerThan1dot5++; } if (env.subDisplayFile()) { *env.subDisplayFile() << "numPosTheta1SmallerThan1dot5 = " << numPosTheta1SmallerThan1dot5 << ", ratio = " << ((double) numPosTheta1SmallerThan1dot5)/((double) numPosTotal) << std::endl; } return; }
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; }
void compute(const QUESO::FullEnvironment& env) { struct timeval timevalNow; gettimeofday(&timevalNow, NULL); std::cout << std::endl << "Beginning run of 'Hysteretic' example at " << ctime(&timevalNow.tv_sec); //------------------------------------------------------ // Step 1 of 5: Instantiate the parameter space //------------------------------------------------------ QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpaceA(env, "paramA_", 1, NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpaceB(env, "paramB_", 14, NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace (env, "param_", 15, NULL); //------------------------------------------------------ // Step 2 of 5: Instantiate the parameter domain //------------------------------------------------------ QUESO::GslVector paramMinsA(paramSpaceA.zeroVector()); paramMinsA.cwSet(0); QUESO::GslVector paramMaxsA(paramSpaceA.zeroVector()); paramMaxsA.cwSet(5); QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomainA("paramA_",paramSpaceA,paramMinsA,paramMaxsA); QUESO::GslVector paramMinsB(paramSpaceB.zeroVector()); paramMinsB.cwSet(-INFINITY); QUESO::GslVector paramMaxsB(paramSpaceB.zeroVector()); paramMaxsB.cwSet( INFINITY); QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomainB("paramB_",paramSpaceB,paramMinsB,paramMaxsB); QUESO::ConcatenationSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("",paramSpace,paramDomainA,paramDomainB); //------------------------------------------------------ // Step 3 of 5: Instantiate the likelihood function object //------------------------------------------------------ std::cout << "\tInstantiating the Likelihood; calling internally the hysteretic model" << std::endl; likelihoodRoutine_DataType likelihoodRoutine_Data; likelihoodRoutine_Data.floor.resize(4,NULL); unsigned int numTimeSteps = 401; for (unsigned int i = 0; i < 4; ++i) { likelihoodRoutine_Data.floor[i] = new std::vector<double>(numTimeSteps,0.); } likelihoodRoutine_Data.accel.resize(numTimeSteps,0.); FILE *inp; inp = fopen("an.txt","r"); unsigned int numObservations = 0; double tmpA; while (fscanf(inp,"%lf",&tmpA) != EOF) { likelihoodRoutine_Data.accel[numObservations] = tmpA; numObservations++; } numObservations=0; FILE *inp1_1; inp1_1=fopen("measured_data1_1.txt","r"); while (fscanf(inp1_1,"%lf",&tmpA) != EOF) { (*likelihoodRoutine_Data.floor[0])[numObservations]=tmpA; numObservations++; } numObservations=0; FILE *inp1_2; inp1_2=fopen("measured_data1_2.txt","r"); while (fscanf(inp1_2,"%lf",&tmpA) != EOF) { (*likelihoodRoutine_Data.floor[1])[numObservations]=tmpA; numObservations++; } numObservations=0; FILE *inp1_3; inp1_3=fopen("measured_data1_3.txt","r"); while (fscanf(inp1_3,"%lf",&tmpA) != EOF) { (*likelihoodRoutine_Data.floor[2])[numObservations]=tmpA; numObservations++; } numObservations=0; FILE *inp1_4; inp1_4=fopen("measured_data1_4.txt","r"); while (fscanf(inp1_4,"%lf",&tmpA) != EOF) { (*likelihoodRoutine_Data.floor[3])[numObservations]=tmpA; numObservations++; } QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix> likelihoodFunctionObj("like_", paramDomain, likelihoodRoutine, (void *) &likelihoodRoutine_Data, true); // routine computes [ln(function)] //------------------------------------------------------ // Step 4 of 5: Instantiate the inverse problem //------------------------------------------------------ std::cout << "\tInstantiating the SIP" << std::endl; QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRvA("priorA_", paramDomainA); QUESO::GslVector meanVec(paramSpaceB.zeroVector()); QUESO::GslVector diagVec(paramSpaceB.zeroVector()); diagVec.cwSet(0.6*0.6); QUESO::GslMatrix covMatrix(diagVec); QUESO::GaussianVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRvB("priorB_", paramDomainB,meanVec,covMatrix); QUESO::ConcatenatedVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_", priorRvA, priorRvB, paramDomain); QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix> ip("", NULL, priorRv, likelihoodFunctionObj, postRv); //------------------------------------------------------ // Step 5 of 5: Solve the inverse problem //------------------------------------------------------ std::cout << "\tSolving the SIP with Multilevel method" << std::endl; ip.solveWithBayesMLSampling(); gettimeofday(&timevalNow, NULL); std::cout << "Ending run of 'Hysteretic' example at " << ctime(&timevalNow.tv_sec) << std::endl; return; }
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; }