int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "space_", 3, NULL); QUESO::GslVector minBound(paramSpace.zeroVector()); minBound[0] = -10.0; minBound[1] = -10.0; minBound[2] = -10.0; QUESO::GslVector maxBound(paramSpace.zeroVector()); maxBound[0] = 10.0; maxBound[1] = 10.0; maxBound[2] = 10.0; QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> domain("", paramSpace, minBound, maxBound); ObjectiveFunction<QUESO::GslVector, QUESO::GslMatrix> objectiveFunction( "", domain); QUESO::GslVector initialPoint(paramSpace.zeroVector()); initialPoint[0] = 9.0; initialPoint[1] = -9.0; initialPoint[1] = -1.0; QUESO::GslOptimizer optimizer(objectiveFunction); double tol = 1.0e-10; optimizer.setTolerance(tol); optimizer.set_solver_type(QUESO::GslOptimizer::STEEPEST_DESCENT); QUESO::OptimizerMonitor monitor(env); monitor.set_display_output(true,true); std::cout << "Solving with Steepest Decent" << std::endl; optimizer.minimize(&monitor); if (std::abs( optimizer.minimizer()[0] - 1.0) > tol) { std::cerr << "GslOptimize failed. Found minimizer at: " << optimizer.minimizer()[0] << std::endl; std::cerr << "Actual minimizer is 1.0" << std::endl; queso_error(); } std::string nm = "nelder_mead2"; optimizer.set_solver_type(nm); monitor.reset(); monitor.set_display_output(true,true); std::cout << std::endl << "Solving with Nelder Mead" << std::endl; optimizer.minimize(&monitor); monitor.print(std::cout,false); return 0; }
/* Separated this out into a function because we want the destructor for paramSpace to be called before we delete env in main. */ int actualChecking(const uqFullEnvironmentClass* env) { int return_flag = 0; const double fp_tol = 1.0e-14; // Instantiate the parameter space uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace( (*env), "param_", 2, NULL); // Populate Matrix. uqGslMatrixClass* Matrix = paramSpace.newMatrix(); (*Matrix)(0,0) = 4.; (*Matrix)(0,1) = 3.; (*Matrix)(1,0) = 5.; (*Matrix)(1,1) = 7.; // Conduct test. uqGslMatrixClass Result( (*Matrix) ); Matrix->invertMultiply( (*Matrix), Result ); if( fabs(Result(0,0) - 1.0) > fp_tol || fabs(Result(1,1) - 1.0) > fp_tol || fabs(Result(1,0)) > fp_tol || fabs(Result(0,1)) > fp_tol ) { return_flag = 1; } // Deallocate pointers we created. delete Matrix; return return_flag; }
/* Separated this out into a function because we want the destructor for paramSpace to be called before we delete env in main. */ int actualChecking(const QUESO::FullEnvironment* env) { int return_flag = 0; // Instantiate the parameter space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace( (*env), "param_", 2, NULL); // Instantiate the parameter domain QUESO::GslVector Vector( paramSpace.zeroVector() ); Vector[0] = -4.; Vector[1] = 3.; // Conduct tests. double value; int index; Vector.getMinValueAndIndex( value, index ); if( index != 0 || value != Vector[0] ) { return_flag = 1; } Vector.getMaxValueAndIndex( value, index ); if( index != 1 || value != Vector[1] ) { return_flag = 1; } return return_flag; }
/* Separated this out into a function because we want the destructor for paramSpace to be called before we delete env in main. */ int actualChecking(const uqFullEnvironmentClass* env) { int return_flag = 0; // Instantiate the parameter space uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace( (*env), "param_", 2, NULL); // Instantiate the parameter domain uqGslVectorClass Vector( paramSpace.zeroVector() ); Vector[0] = -4.; Vector[1] = 3.; // Conduct tests. double value; int index; Vector.getMinValueAndIndex( value, index ); if( index != 0 || value != Vector[0] ) { return_flag = 1; } Vector.getMaxValueAndIndex( value, index ); if( index != 1 || value != Vector[1] ) { return_flag = 1; } return return_flag; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); #else QUESO::FullEnvironment env("", "", NULL); #endif QUESO::VectorSpace<> paramSpace1(env, "param1_", 4, NULL); QUESO::VectorSpace<> paramSpace2(env, "param2_", 2, NULL); QUESO::GslVector paramMins1(paramSpace1.zeroVector()); paramMins1[0] = 1e2; paramMins1[1] = -1e5; paramMins1[2] = 4e-3; paramMins1[3] = 1; QUESO::GslVector paramMaxs1(paramSpace1.zeroVector()); paramMaxs1[0] = 2e2; paramMaxs1[1] = 1e5; paramMaxs1[2] = 6e-3; paramMaxs1[3] = 11; QUESO::BoxSubset<> paramDomain1("", paramSpace1, paramMins1, paramMaxs1); QUESO::GslVector paramMins2(paramSpace2.zeroVector()); paramMins2[0] = -1e5; paramMins2[1] = 2e-3; QUESO::GslVector paramMaxs2(paramSpace2.zeroVector()); paramMaxs2[0] = 1e5; paramMaxs2[1] = 4e-3; QUESO::BoxSubset<> paramDomain2("", paramSpace2, paramMins2, paramMaxs2); QUESO::VectorSpace<> paramSpace(env, "param_", 6, NULL); QUESO::ConcatenationSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("",paramSpace,paramDomain1,paramDomain2); QUESO::GslVector centroid(paramSpace.zeroVector()); paramDomain.centroid(centroid); const char *msg = "ConcatenationSubset centroid is incorrect"; queso_require_less_equal_msg(std::abs(centroid[0]-1.5e2), TOL, msg); queso_require_less_equal_msg(std::abs(centroid[1]), TOL, msg); queso_require_less_equal_msg(std::abs(centroid[2]-5e-3), TOL, msg); queso_require_less_equal_msg(std::abs(centroid[3]-6), TOL, msg); queso_require_less_equal_msg(std::abs(centroid[4]), TOL, msg); queso_require_less_equal_msg(std::abs(centroid[5]-3e-3), TOL, msg); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char **argv) { MPI_Init(&argc, &argv); QUESO::EnvOptionsValues options; options.m_numSubEnvironments = 1; QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", &options); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 3, NULL); // Example RHS QUESO::GslVector b(paramSpace.zeroVector()); b[0] = 1.0; b[1] = 2.0; b[2] = 3.0; // Set up block sizes for observation covariance matrix std::vector<unsigned int> blockSizes(2); blockSizes[0] = 1; // First block is 1x1 (scalar) blockSizes[1] = 2; // Second block is 2x2 // Set up block (identity) matrix with specified block sizes QUESO::GslBlockMatrix covariance(blockSizes, b, 1.0); // The matrix [[1, 0, 0], [0, 1, 2], [0, 2, 8]] // has inverse 0.25 * [[1, 0, 0], [0, 2, -0.5], [0, -0.5, 0.25]] covariance.getBlock(0)(0, 0) = 1.0; covariance.getBlock(1)(0, 0) = 1.0; covariance.getBlock(1)(0, 1) = 2.0; covariance.getBlock(1)(1, 0) = 2.0; covariance.getBlock(1)(1, 1) = 8.0; // Compute solution QUESO::GslVector x(paramSpace.zeroVector()); covariance.invertMultiply(b, x); // This is the analytical solution QUESO::GslVector sol(paramSpace.zeroVector()); sol[0] = 1.0; sol[1] = 2.5; sol[2] = -0.25; // So if the solve worked, this sucker should be the zero vector sol -= x; // So its norm should be zero if (sol.norm2() > TOL) { std::cerr << "Computed solution:" << std::endl; std::cerr << b << std::endl; std::cerr << "Actual solution:" << std::endl; std::cerr << sol << std::endl; queso_error_msg("TEST: GslBlockMatrix::invertMultiply failed."); } MPI_Finalize(); return 0; }
void compute(const QUESO::FullEnvironment& env) { // Step 1 of 6: Instantiate the parameter space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env, "param_", 2, NULL); // Step 2 of 6: 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 6: Instantiate the qoi space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> qoiSpace(env, "qoi_", 1, NULL); // Step 4 of 6: Instantiate the qoi function object qoiRoutine_DataType qoiRoutine_Data; qoiRoutine_Data.coef1 = 1.; qoiRoutine_Data.coef2 = 1.; QUESO::GenericVectorFunction<QUESO::GslVector,QUESO::GslMatrix, QUESO::GslVector,QUESO::GslMatrix> qoiFunctionObj("qoi_", paramDomain, qoiSpace, qoiRoutine, (void *) &qoiRoutine_Data); // Step 5 of 6: Instantiate the forward problem // Parameters are Gaussian RV QUESO::GslVector meanVector( paramSpace.zeroVector() ); meanVector[0] = -1; meanVector[1] = 2; QUESO::GslMatrix covMatrix = QUESO::GslMatrix(paramSpace.zeroVector()); covMatrix(0,0) = 4.; covMatrix(0,1) = 0.; covMatrix(1,0) = 0.; covMatrix(1,1) = 1.; QUESO::GaussianVectorRV<QUESO::GslVector,QUESO::GslMatrix> paramRv("param_",paramDomain,meanVector,covMatrix); QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> qoiRv("qoi_", qoiSpace); QUESO::StatisticalForwardProblem<QUESO::GslVector,QUESO::GslMatrix, QUESO::GslVector,QUESO::GslMatrix> fp("", NULL, paramRv, qoiFunctionObj, qoiRv); // Step 6 of 6: Solve the forward problem fp.solveWithMonteCarlo(NULL); return; }
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; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); // Step 0 of 5: Set up environment QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); // Step 1 of 5: Instantiate the parameter space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); // Step 2 of 5: Set up the prior QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Uniform prior here. Could be a different prior. QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Step 3 of 5: Set up the likelihood using the class above Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain); // Step 4 of 5: Instantiate the inverse problem QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); // Step 5 of 5: Solve the inverse problem QUESO::GslVector paramInitials(paramSpace.zeroVector()); // Initial condition of the chain paramInitials[0] = 0.0; paramInitials[1] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 2; i++) { // Might need to tweak this proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "space_", 1, NULL); QUESO::GslVector minBound(paramSpace.zeroVector()); minBound[0] = -10.0; QUESO::GslVector maxBound(paramSpace.zeroVector()); maxBound[0] = 10.0; QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> domain("", paramSpace, minBound, maxBound); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> prior("", domain); Likelihood<QUESO::GslVector, QUESO::GslMatrix> likelihood("", domain); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> posterior("", domain); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, prior, likelihood, posterior); QUESO::GslVector initialValues(paramSpace.zeroVector()); initialValues[0] = 9.0; QUESO::GslMatrix proposalCovarianceMatrix(paramSpace.zeroVector()); proposalCovarianceMatrix(0, 0) = 1.0; ip.seedWithMAPEstimator(); ip.solveWithBayesMetropolisHastings(NULL, initialValues, &proposalCovarianceMatrix); // The first sample should be the seed QUESO::GslVector first_sample(paramSpace.zeroVector()); posterior.realizer().realization(first_sample); // Looser tolerance for the derivative calculated by using a finite // difference if (std::abs(first_sample[0]) > 1e-5) { std::cerr << "seedWithMAPEstimator failed. Seed was: " << first_sample[0] << std::endl; std::cerr << "Actual seed should be 0.0" << std::endl; queso_error(); } return 0; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); #else QUESO::FullEnvironment env("", "", NULL); #endif QUESO::VectorSpace<> paramSpace(env, "param_", 1, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(0.0); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(1.0); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); // We should test the other cases of alpha and beta QUESO::GslVector alpha(paramSpace.zeroVector()); alpha[0] = 2.0; QUESO::GslVector beta(paramSpace.zeroVector()); beta[0] = 3.0; QUESO::BetaJointPdf<> pdf("", paramDomain, alpha, beta); QUESO::GslVector mean(paramSpace.zeroVector()); pdf.distributionMean(mean); const char *msg = "BetaJointPdf mean is incorrect"; double real_mean = alpha[0] / (alpha[0] + beta[0]); queso_require_less_equal_msg(std::abs(mean[0]-real_mean), TOL, msg); QUESO::GslMatrix var(paramSpace.zeroVector()); pdf.distributionVariance(var); const char *msgv = "BetaJointPdf variance is incorrect"; double real_var = alpha[0] * beta[0] / (alpha[0] + beta[0]) / (alpha[0] + beta[0]) / (alpha[0] + beta[0] + 1); queso_require_less_equal_msg(std::abs(var(0,0)-real_var), TOL, msgv); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); #else QUESO::FullEnvironment env("", "", NULL); #endif QUESO::VectorSpace<> paramSpace(env, "param_", 2, NULL); QUESO::GslVector lawexp(paramSpace.zeroVector()); lawexp[0] = 2.4; lawexp[1] = 0.4; QUESO::GslVector lawvar(paramSpace.zeroVector()); lawvar[0] = 1.2; lawvar[1] = 0.9; QUESO::LogNormalJointPdf<> pdf("", paramSpace, lawexp, lawvar); QUESO::GslVector mean(paramSpace.zeroVector()); pdf.distributionMean(mean); double realmean0 = std::exp(lawexp[0] + lawvar[0]/2); double realmean1 = std::exp(lawexp[1] + lawvar[1]/2); const char *msg = "LogNormalJointPdf mean is incorrect"; queso_require_less_equal_msg(std::abs(mean[0]-realmean0), TOL, msg); queso_require_less_equal_msg(std::abs(mean[1]-realmean1), TOL, msg); QUESO::GslMatrix var(paramSpace.zeroVector()); pdf.distributionVariance(var); double realvar0 = (std::exp(lawvar[0])-1) * std::exp(2*lawexp[0] + lawvar[0]); double realvar1 = (std::exp(lawvar[1])-1) * std::exp(2*lawexp[1] + lawvar[1]); const char *msgv = "LogNormalJointPdf variance is incorrect"; queso_require_less_equal_msg(std::abs(var(0,0)-realvar0), TOL, msgv); queso_require_less_equal_msg(std::abs(var(0,1)), TOL, msgv); queso_require_less_equal_msg(std::abs(var(1,0)), TOL, msgv); queso_require_less_equal_msg(std::abs(var(1,1)-realvar1), TOL, msgv); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
void compute(const QUESO::FullEnvironment& env) { //step 1: instatiate parameter space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); //step 2: instantiate the parameter domain QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(0.001); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(100.); //TODO: this is not working with gsl sampling right now in FP QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); //step 3: instantiate the qoi space QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> qoiSpace(env, "qoi_", 1, NULL); //step 4: instantiate the qoi function object qoiRoutine_DataType qoiRoutine_Data; qoiRoutine_Data.coef1 = 1.; QUESO::GenericVectorFunction<QUESO::GslVector,QUESO::GslMatrix, QUESO::GslVector,QUESO::GslMatrix> qoiFunctionObj("qoi_", paramDomain, qoiSpace, qoiRoutine, (void *) &qoiRoutine_Data); //step 5: instantiate the forward problem //parameter is Jeffreys RV QUESO::JeffreysVectorRV<QUESO::GslVector,QUESO::GslMatrix> paramRv("param_", paramDomain); QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> qoiRv("qoi_",qoiSpace); QUESO::StatisticalForwardProblem<QUESO::GslVector,QUESO::GslMatrix, QUESO::GslVector,QUESO::GslMatrix> fp("", NULL, paramRv, qoiFunctionObj, qoiRv); //step 6: solve the forward problem fp.solveWithMonteCarlo(NULL); }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); QUESO::VectorSpace<> paramSpace(env, "param_", 1, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); double min_val = 0.0; double max_val = 1.0; paramMins.cwSet(min_val); paramMaxs.cwSet(max_val); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); Likelihood<> lhood("llhd_", paramDomain); QUESO::GenericVectorRV<> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0, 0) = 0.1; ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
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; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL); #else QUESO::FullEnvironment env("", "", NULL); #endif unsigned int dim = 3; QUESO::VectorSpace<> paramSpace(env, "param_", dim, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(-INFINITY); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(INFINITY); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::GslVector mean(paramSpace.zeroVector()); QUESO::GslMatrix var(paramSpace.zeroVector()); mean[0] = 2.0; mean[1] = 3.0; mean[2] = 4.0; var(0,0) = 5.0; var(1,1) = 6.0; var(2,2) = 7.0; // Construct a Gaussian PDF QUESO::GaussianJointPdf<> pdf("", paramDomain, mean, var); // Vectors to store gradient calculations QUESO::GslVector lnGradVector(paramSpace.zeroVector()); QUESO::GslVector gradVector(paramSpace.zeroVector()); // Where to evaluate the gradient. Evaluating at the mean (the mode for a // Gaussian) should give a gradient consisting of a vector of zeros. QUESO::GslVector point(mean); // We are testing that the gradient of log of the pdf is all zeros pdf.lnValue(point, NULL, &lnGradVector, NULL, NULL); queso_require_less_equal_msg(std::abs(lnGradVector[0]), TOL, "grad log gaussian pdf values are incorrect"); queso_require_less_equal_msg(std::abs(lnGradVector[1]), TOL, "grad log gaussian pdf values are incorrect"); queso_require_less_equal_msg(std::abs(lnGradVector[2]), TOL, "grad log gaussian pdf values are incorrect"); // We are testing that the of the pdf is all zeros pdf.actualValue(point, NULL, &gradVector, NULL, NULL); queso_require_less_equal_msg(std::abs(gradVector[0]), TOL, "grad guassian pdf values are incorrect"); queso_require_less_equal_msg(std::abs(gradVector[1]), TOL, "grad guassian pdf values are incorrect"); queso_require_less_equal_msg(std::abs(gradVector[2]), TOL, "grad guassian pdf values are incorrect"); // Now construct another Gaussian. This time we're constructing a Gaussian // that we know will have a gradient consisting entirely of ones (in log // space). mean[0] = 0.0; mean[1] = 0.0; mean[2] = 0.0; var(0,0) = 1.0; var(0,1) = 0.8; var(0,2) = 0.7; var(1,0) = 0.8; var(1,1) = 2.0; var(1,2) = 0.6; var(2,0) = 0.7; var(2,1) = 0.6; var(2,2) = 3.0; point[0] = -2.5; point[1] = -3.4; point[2] = -4.3; QUESO::GaussianJointPdf<> pdf2("", paramDomain, mean, var); pdf2.lnValue(point, NULL, &lnGradVector, NULL, NULL); queso_require_less_equal_msg(std::abs(lnGradVector[0] - 1.0), TOL, "grad log gaussian pdf2 values are incorrect"); queso_require_less_equal_msg(std::abs(lnGradVector[1] - 1.0), TOL, "grad log gaussian pdf2 values are incorrect"); queso_require_less_equal_msg(std::abs(lnGradVector[2] - 1.0), TOL, "grad log gaussian pdf2 values are incorrect"); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "test_gaussian_likelihoods/queso_input.txt", "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = -INFINITY; double max_val = INFINITY; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Fill up covariance 'matrix' QUESO::GslVector covariance(obsSpace.zeroVector()); covariance[0] = 1.0; covariance[1] = 2.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, covariance); double lhood_value; double truth_value; QUESO::GslVector point(paramSpace.zeroVector()); point[0] = 0.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = std::exp(-3.0); if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } point[0] = -2.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = 1.0; if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } MPI_Finalize(); return 0; }
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; } }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); #endif QUESO::EnvOptionsValues envOptions; envOptions.m_numSubEnvironments = 1; envOptions.m_subDisplayFileName = "test_outputNoInputFile/display"; envOptions.m_subDisplayAllowAll = 1; envOptions.m_displayVerbosity = 2; envOptions.m_syncVerbosity = 0; envOptions.m_seed = 0; #ifdef QUESO_HAS_MPI QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", &envOptions); #else QUESO::FullEnvironment env("", "", &envOptions); #endif unsigned int dim = 2; QUESO::VectorSpace<> paramSpace(env, "param_", dim, NULL); QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); double min_val = -10.0; double max_val = 10.0; paramMins.cwSet(min_val); paramMaxs.cwSet(max_val); QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<> priorRv("prior_", paramDomain); Likelihood<> lhood("llhd_", paramDomain); QUESO::GenericVectorRV<> postRv("post_", paramSpace); QUESO::SipOptionsValues sipOptions; sipOptions.m_computeSolution = 1; sipOptions.m_dataOutputFileName = "test_outputNoInputFile/sipOutput"; sipOptions.m_dataOutputAllowedSet.clear(); sipOptions.m_dataOutputAllowedSet.insert(0); QUESO::StatisticalInverseProblem<> ip("", &sipOptions, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; paramInitials[1] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); proposalCovMatrix(0, 0) = 1.0; proposalCovMatrix(0, 1) = 0.0; proposalCovMatrix(1, 0) = 0.0; proposalCovMatrix(1, 1) = 1.0; QUESO::MhOptionsValues mhOptions; mhOptions.m_dataOutputFileName = "test_outputNoInputFile/sipOutput"; mhOptions.m_dataOutputAllowAll = 1; mhOptions.m_rawChainGenerateExtra = 0; mhOptions.m_rawChainDisplayPeriod = 50000; mhOptions.m_rawChainMeasureRunTimes = 1; mhOptions.m_rawChainDataOutputFileName = "test_outputNoInputFile/ip_raw_chain"; mhOptions.m_rawChainDataOutputAllowAll = 1; mhOptions.m_displayCandidates = 0; mhOptions.m_tkUseLocalHessian = 0; mhOptions.m_tkUseNewtonComponent = 1; mhOptions.m_filteredChainGenerate = 0; mhOptions.m_rawChainSize = 1000; mhOptions.m_putOutOfBoundsInChain = false; mhOptions.m_drMaxNumExtraStages = 1; mhOptions.m_drScalesForExtraStages.resize(1); mhOptions.m_drScalesForExtraStages[0] = 5.0; mhOptions.m_amInitialNonAdaptInterval = 100; mhOptions.m_amAdaptInterval = 100; mhOptions.m_amEta = (double) 2.4 * 2.4 / dim; // From Gelman 95 mhOptions.m_amEpsilon = 1.e-8; mhOptions.m_doLogitTransform = false; mhOptions.m_algorithm = "random_walk"; mhOptions.m_tk = "random_walk"; ip.solveWithBayesMetropolisHastings(&mhOptions, paramInitials, &proposalCovMatrix); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
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; }
int main(int argc, char **argv) { #ifndef QUESO_HAS_MPI return 77; #else MPI_Init(&argc, &argv); QUESO::EnvOptionsValues options; options.m_numSubEnvironments = 2; options.m_subDisplayFileName = "outputData/test_SequenceOfVectorsMax"; options.m_subDisplayAllowAll = 1; options.m_seed = 1.0; options.m_checkingLevel = 1; options.m_displayVerbosity = 55; QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", &options); // Create a vector space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "", 1, NULL); QUESO::SequenceOfVectors<QUESO::GslVector, QUESO::GslMatrix> pretendChain( paramSpace, 3, "pretendChain"); QUESO::GslVector v(paramSpace.zeroVector()); v[0] = 0.0; // Create a scalar sequence on each processor std::string name = "name"; QUESO::ScalarSequence<double> scalarSequence(env, 3, name); pretendChain.setPositionValues(0, v); pretendChain.setPositionValues(1, v); pretendChain.setPositionValues(2, v); if (env.inter0Rank() == 0) { scalarSequence[0] = 10.0; scalarSequence[1] = 11.0; scalarSequence[2] = 12.0; } else if (env.inter0Rank() == 1) { scalarSequence[0] = 0.0; scalarSequence[1] = 1.0; scalarSequence[2] = 2.0; } else { queso_error_msg("Test should not get here!"); } // Create a sequence of vectors QUESO::SequenceOfVectors<QUESO::GslVector, QUESO::GslMatrix> maxs(paramSpace, 0, "name2"); pretendChain.unifiedPositionsOfMaximum(scalarSequence, maxs); // Should not fail QUESO::GslVector tmpVec(paramSpace.zeroVector()); // The loop should only actually do anything on process zero for (unsigned int i = 0; i < maxs.subSequenceSize(); i++) { maxs.getPositionValues(0, tmpVec); } MPI_Finalize(); return 0; #endif }
int main(int argc, char ** argv) { std::string inputFileName = "test_gaussian_likelihoods/queso_input.txt"; const char * test_srcdir = std::getenv("srcdir"); if (test_srcdir) inputFileName = test_srcdir + ('/' + inputFileName); #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, inputFileName, "", NULL); #else QUESO::FullEnvironment env(inputFileName, "", NULL); #endif QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = -INFINITY; double max_val = INFINITY; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 1, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, 1.0); double lhood_value; double truth_value; QUESO::GslVector point(paramSpace.zeroVector()); point[0] = 0.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = std::exp(-2.0); if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } point[0] = -2.0; lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL); truth_value = 1.0; if (std::abs(lhood_value - truth_value) > TOL) { std::cerr << "Scalar Gaussian test case failure." << std::endl; std::cerr << "Computed likelihood value is: " << lhood_value << std::endl; std::cerr << "Likelihood value should be: " << truth_value << std::endl; queso_error(); } #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
void uqAppl(const QUESO::BaseEnvironment& env) { if (env.fullRank() == 0) { std::cout << "Beginning run of 'uqTgaExample' example\n" << std::endl; } //int iRC; struct timeval timevalRef; struct timeval timevalNow; //****************************************************** // Task 1 of 5: instantiation of basic classes //****************************************************** // Instantiate the parameter space std::vector<std::string> paramNames(2,""); paramNames[0] = "A_param"; paramNames[1] = "E_param"; QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env,"param_",paramNames.size(),¶mNames); // Instantiate the parameter domain QUESO::GslVector paramMinValues(paramSpace.zeroVector()); paramMinValues[0] = 2.40e+11; paramMinValues[1] = 1.80e+05; QUESO::GslVector paramMaxValues(paramSpace.zeroVector()); paramMaxValues[0] = 2.80e+11; paramMaxValues[1] = 2.20e+05; QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues); // Instantiate the qoi space std::vector<std::string> qoiNames(1,""); qoiNames[0] = "TimeFor25PercentOfMass"; QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> qoiSpace(env,"qoi_",qoiNames.size(),&qoiNames); // Instantiate the validation cycle QUESO::ValidationCycle<QUESO::GslVector,QUESO::GslMatrix,QUESO::GslVector,QUESO::GslMatrix> cycle(env, "", // No extra prefix paramSpace, qoiSpace); //******************************************************** // Task 2 of 5: calibration stage //******************************************************** /*iRC = */gettimeofday(&timevalRef, NULL); if (env.fullRank() == 0) { std::cout << "Beginning 'calibration stage' at " << ctime(&timevalRef.tv_sec) << std::endl; } // Inverse problem: instantiate the prior rv QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> calPriorRv("cal_prior_", // Extra prefix before the default "rv_" prefix paramDomain); // Inverse problem: instantiate the likelihood Likelihood<> calLikelihood("cal_like_", paramDomain, "inputData/scenario_5_K_min.dat", "inputData/scenario_25_K_min.dat", "inputData/scenario_50_K_min.dat"); // Inverse problem: instantiate it (posterior rv is instantiated internally) cycle.instantiateCalIP(NULL, calPriorRv, calLikelihood); // Inverse problem: solve it, that is, set 'pdf' and 'realizer' of the posterior rv QUESO::GslVector paramInitialValues(paramSpace.zeroVector()); if (env.numSubEnvironments() == 1) { // For regression test purposes paramInitialValues[0] = 2.41e+11; paramInitialValues[1] = 2.19e+05; } else { calPriorRv.realizer().realization(paramInitialValues); } QUESO::GslMatrix* calProposalCovMatrix = cycle.calIP().postRv().imageSet().vectorSpace().newProposalMatrix(NULL,¶mInitialValues); cycle.calIP().solveWithBayesMetropolisHastings(NULL, paramInitialValues, calProposalCovMatrix); delete calProposalCovMatrix; // Forward problem: instantiate it (parameter rv = posterior rv of inverse problem; qoi rv is instantiated internally) double beta_prediction = 250.; double criticalMass_prediction = 0.; double criticalTime_prediction = 3.9; qoiRoutine_Data calQoiRoutine_Data; calQoiRoutine_Data.m_beta = beta_prediction; calQoiRoutine_Data.m_criticalMass = criticalMass_prediction; calQoiRoutine_Data.m_criticalTime = criticalTime_prediction; cycle.instantiateCalFP(NULL, qoiRoutine, (void *) &calQoiRoutine_Data); // Forward problem: solve it, that is, set 'realizer' and 'cdf' of the qoi rv cycle.calFP().solveWithMonteCarlo(NULL); // no extra user entities needed for Monte Carlo algorithm /*iRC = */gettimeofday(&timevalNow, NULL); if (env.fullRank() == 0) { std::cout << "Ending 'calibration stage' at " << ctime(&timevalNow.tv_sec) << "Total 'calibration stage' run time = " << timevalNow.tv_sec - timevalRef.tv_sec << " seconds\n" << std::endl; } //******************************************************** // Task 3 of 5: validation stage //******************************************************** /*iRC = */gettimeofday(&timevalRef, NULL); if (env.fullRank() == 0) { std::cout << "Beginning 'validation stage' at " << ctime(&timevalRef.tv_sec) << std::endl; } // Inverse problem: no need to instantiate the prior rv (= posterior rv of calibration inverse problem) // Inverse problem: instantiate the likelihood function object Likelihood<> valLikelihood("val_like_", paramDomain, "inputData/scenario_100_K_min.dat", NULL, NULL); // Inverse problem: instantiate it (posterior rv is instantiated internally) cycle.instantiateValIP(NULL,valLikelihood); // Inverse problem: solve it, that is, set 'pdf' and 'realizer' of the posterior rv const QUESO::SequentialVectorRealizer<QUESO::GslVector,QUESO::GslMatrix>* tmpRealizer = dynamic_cast< const QUESO::SequentialVectorRealizer<QUESO::GslVector,QUESO::GslMatrix>* >(&(cycle.calIP().postRv().realizer())); QUESO::GslMatrix* valProposalCovMatrix = cycle.calIP().postRv().imageSet().vectorSpace().newProposalMatrix(&tmpRealizer->unifiedSampleVarVector(), // Use 'realizer()' because post. rv was computed with MH &tmpRealizer->unifiedSampleExpVector()); // Use these values as the initial values cycle.valIP().solveWithBayesMetropolisHastings(NULL, tmpRealizer->unifiedSampleExpVector(), valProposalCovMatrix); delete valProposalCovMatrix; // Forward problem: instantiate it (parameter rv = posterior rv of inverse problem; qoi rv is instantiated internally) qoiRoutine_Data valQoiRoutine_Data; valQoiRoutine_Data.m_beta = beta_prediction; valQoiRoutine_Data.m_criticalMass = criticalMass_prediction; valQoiRoutine_Data.m_criticalTime = criticalTime_prediction; cycle.instantiateValFP(NULL, qoiRoutine, (void *) &valQoiRoutine_Data); // Forward problem: solve it, that is, set 'realizer' and 'cdf' of the qoi rv cycle.valFP().solveWithMonteCarlo(NULL); // no extra user entities needed for Monte Carlo algorithm /*iRC = */gettimeofday(&timevalNow, NULL); if (env.fullRank() == 0) { std::cout << "Ending 'validation stage' at " << ctime(&timevalNow.tv_sec) << "Total 'validation stage' run time = " << timevalNow.tv_sec - timevalRef.tv_sec << " seconds\n" << std::endl; } //******************************************************** // Task 4 of 5: comparison stage //******************************************************** /*iRC = */gettimeofday(&timevalRef, NULL); if (env.fullRank() == 0) { std::cout << "Beginning 'comparison stage' at " << ctime(&timevalRef.tv_sec) << std::endl; } uqAppl_LocalComparisonStage(cycle); if (env.numSubEnvironments() > 1) { uqAppl_UnifiedComparisonStage(cycle); } /*iRC = */gettimeofday(&timevalNow, NULL); if (env.fullRank() == 0) { std::cout << "Ending 'comparison stage' at " << ctime(&timevalNow.tv_sec) << "Total 'comparison stage' run time = " << timevalNow.tv_sec - timevalRef.tv_sec << " seconds\n" << std::endl; } //****************************************************** // Task 5 of 5: release memory before leaving routine. //****************************************************** if (env.fullRank() == 0) { std::cout << "Finishing run of 'uqTgaExample' example" << std::endl; } return; }
int main(int argc, char ** argv) { // Step 0: Set up some variables unsigned int numExperiments = 10; // Number of experiments unsigned int numUncertainVars = 5; // Number of things to calibrate unsigned int numSimulations = 50; // Number of simulations unsigned int numConfigVars = 1; // Dimension of configuration space unsigned int numEta = 1; // Number of responses the model is returning unsigned int experimentSize = 1; // Size of each experiment #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); // Step 1: Set up QUESO environment QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); #else QUESO::FullEnvironment env(argv[1], "", NULL); #endif // Step 2: Set up prior for calibration parameters QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", numUncertainVars, NULL); // Parameter (theta) bounds: // descriptors 'k_tmasl' 'k_xkle' 'k_xkwew' 'k_xkwlx' 'k_cd' // upper_bounds 1.05 1.1 1.1 1.1 1.1 // lower_bounds 0.95 0.9 0.9 0.9 0.9 // // These bounds are dealt with when reading in the data QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMins.cwSet(0.0); paramMaxs.cwSet(1.0); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Step 3: Instantiate the 'scenario' and 'output' spaces for simulation QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> configSpace(env, "scenario_", numConfigVars, NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> nEtaSpace(env, "output_", numEta, NULL); // Step 4: Instantiate the 'output' space for the experiments QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> experimentSpace(env, "experimentspace_", experimentSize, NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> totalExperimentSpace(env, "experimentspace_", experimentSize * numExperiments, NULL); // Step 5: Instantiate the Gaussian process emulator object // // Regarding simulation scenario input values, the user should standardise // them so that they exist inside a hypercube. // // Regarding simulation output data, the user should transform it so that the // mean is zero and the variance is one. // // Regarding experimental scenario input values, the user should standardize // them so that they exist inside a hypercube. // // Regarding experimental data, the user should transformed it so that it has // zero mean and variance one. // GPMSA stores all the information about our simulation // data and experimental data. It also stores default information about the // hyperparameter distributions. QUESO::GPMSAFactory<QUESO::GslVector, QUESO::GslMatrix> gpmsaFactory(env, NULL, priorRv, configSpace, paramSpace, nEtaSpace, experimentSpace, numSimulations, numExperiments); // std::vector containing all the points in scenario space where we have // simulations std::vector<QUESO::GslVector *> simulationScenarios(numSimulations, (QUESO::GslVector *) NULL); // std::vector containing all the points in parameter space where we have // simulations std::vector<QUESO::GslVector *> paramVecs(numSimulations, (QUESO::GslVector *) NULL); // std::vector containing all the simulation output data std::vector<QUESO::GslVector *> outputVecs(numSimulations, (QUESO::GslVector *) NULL); // std::vector containing all the points in scenario space where we have // experiments std::vector<QUESO::GslVector *> experimentScenarios(numExperiments, (QUESO::GslVector *) NULL); // std::vector containing all the experimental output data std::vector<QUESO::GslVector *> experimentVecs(numExperiments, (QUESO::GslVector *) NULL); // The experimental output data observation error covariance matrix QUESO::GslMatrix experimentMat(totalExperimentSpace.zeroVector()); // Instantiate each of the simulation points/outputs for (unsigned int i = 0; i < numSimulations; i++) { simulationScenarios[i] = new QUESO::GslVector(configSpace.zeroVector()); // 'x_{i+1}^*' in paper paramVecs [i] = new QUESO::GslVector(paramSpace.zeroVector()); // 't_{i+1}^*' in paper outputVecs [i] = new QUESO::GslVector(nEtaSpace.zeroVector()); // 'eta_{i+1}' in paper } for (unsigned int i = 0; i < numExperiments; i++) { experimentScenarios[i] = new QUESO::GslVector(configSpace.zeroVector()); // 'x_{i+1}' in paper experimentVecs[i] = new QUESO::GslVector(experimentSpace.zeroVector()); } // Read in data and store the standard deviation of the simulation data. We // will need the standard deviation when we pass the experiment error // covariance matrix to QUESO. double stdsim = readData(simulationScenarios, paramVecs, outputVecs, experimentScenarios, experimentVecs); for (unsigned int i = 0; i < numExperiments; i++) { // Passing in error of experiments (standardised). experimentMat(i, i) = (0.025 / stdsim) * (0.025 / stdsim); } // Add simulation and experimental data gpmsaFactory.addSimulations(simulationScenarios, paramVecs, outputVecs); gpmsaFactory.addExperiments(experimentScenarios, experimentVecs, &experimentMat); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv( "post_", gpmsaFactory.prior().imageSet().vectorSpace()); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, gpmsaFactory, postRv); QUESO::GslVector paramInitials( gpmsaFactory.prior().imageSet().vectorSpace().zeroVector()); // Initial condition of the chain // Have to set each of these by hand, *and* the sampler is sensitive to these // values paramInitials[0] = 0.5; // param 1 paramInitials[1] = 0.5; // param 2 paramInitials[2] = 0.5; // param 3 paramInitials[3] = 0.5; // param 4 paramInitials[4] = 0.5; // param 5 paramInitials[5] = 0.4; // not used. emulator mean paramInitials[6] = 0.4; // emulator precision paramInitials[7] = 0.97; // emulator corr str paramInitials[8] = 0.97; // emulator corr str paramInitials[9] = 0.97; // emulator corr str paramInitials[10] = 0.97; // emulator corr str paramInitials[11] = 0.20; // emulator corr str paramInitials[12] = 0.80; // emulator corr str paramInitials[13] = 10.0; // discrepancy precision paramInitials[14] = 0.97; // discrepancy corr str paramInitials[15] = 8000.0; // emulator data precision QUESO::GslMatrix proposalCovMatrix( gpmsaFactory.prior().imageSet().vectorSpace().zeroVector()); // Setting the proposal covariance matrix by hand. This requires great // forethough, and can generally be referred to as a massive hack. These // values were taken from the gpmsa matlab code and fiddled with. double scale = 600.0; proposalCovMatrix(0, 0) = 3.1646 / 10.0; // param 1 proposalCovMatrix(1, 1) = 3.1341 / 10.0; // param 2 proposalCovMatrix(2, 2) = 3.1508 / 10.0; // param 3 proposalCovMatrix(3, 3) = 0.3757 / 10.0; // param 4 proposalCovMatrix(4, 4) = 0.6719 / 10.0; // param 5 proposalCovMatrix(5, 5) = 0.1 / scale; // not used. emulator mean proposalCovMatrix(6, 6) = 0.4953 / scale; // emulator precision proposalCovMatrix(7, 7) = 0.6058 / scale; // emulator corr str proposalCovMatrix(8, 8) = 7.6032e-04 / scale; // emulator corr str proposalCovMatrix(9, 9) = 8.3815e-04 / scale; // emulator corr str proposalCovMatrix(10, 10) = 7.5412e-04 / scale; // emulator corr str proposalCovMatrix(11, 11) = 0.2682 / scale; // emulator corr str proposalCovMatrix(12, 12) = 0.0572 / scale; // emulator corr str proposalCovMatrix(13, 13) = 1.3417 / scale; // discrepancy precision proposalCovMatrix(14, 14) = 0.3461 / scale; // discrepancy corr str proposalCovMatrix(15, 15) = 495.3 / scale; // emulator data precision // Square to get variances for (unsigned int i = 0; i < 16; i++) { proposalCovMatrix(i, i) = proposalCovMatrix(i, i) * proposalCovMatrix(i, i); } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
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 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; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "test_InterpolationSurrogate/queso_input.txt", "", NULL); int return_flag = 0; std::string vs_prefix = "param_"; // Filename for writing/reading surrogate data std::string filename1 = "test_write_InterpolationSurrogateBuilder_1.dat"; std::string filename2 = "test_write_InterpolationSurrogateBuilder_2.dat"; QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,vs_prefix.c_str(), 4, NULL); // Point at which we will test the surrogate evaluation QUESO::GslVector domainVector(paramSpace.zeroVector()); domainVector[0] = -0.4; domainVector[1] = 3.0; domainVector[2] = 1.5; domainVector[3] = 1.65; double exact_val_1 = four_d_fn_1(domainVector[0],domainVector[1],domainVector[2],domainVector[3]); double exact_val_2 = four_d_fn_2(domainVector[0],domainVector[1],domainVector[2],domainVector[3]); double tol = 2.0*std::numeric_limits<double>::epsilon(); // First test surrogate build directly from the computed values { QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins[0] = -1; paramMins[1] = -0.5; paramMins[2] = 1.1; paramMins[3] = -2.1; QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs[0] = 0.9; paramMaxs[1] = 3.14; paramMaxs[2] = 2.1; paramMaxs[3] = 4.1; QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); std::vector<unsigned int> n_points(4); n_points[0] = 11; n_points[1] = 51; n_points[2] = 31; n_points[3] = 41; // One dataset for each of the two functions const unsigned int n_datasets = 2; QUESO::InterpolationSurrogateDataSet<QUESO::GslVector, QUESO::GslMatrix> data(paramDomain,n_points,n_datasets); MyInterpolationBuilder<QUESO::GslVector,QUESO::GslMatrix> builder( data ); builder.build_values(); QUESO::LinearLagrangeInterpolationSurrogate<QUESO::GslVector,QUESO::GslMatrix> four_d_surrogate_1( data.get_dataset(0) ); QUESO::LinearLagrangeInterpolationSurrogate<QUESO::GslVector,QUESO::GslMatrix> four_d_surrogate_2( data.get_dataset(1) ); double test_val_1 = four_d_surrogate_1.evaluate(domainVector); double test_val_2 = four_d_surrogate_2.evaluate(domainVector); return_flag = return_flag || test_val( test_val_1, exact_val_1, tol, "test_build_1" ) || test_val( test_val_2, exact_val_2, tol, "test_build_2" ); // Write the output to test reading next QUESO::InterpolationSurrogateIOASCII<QUESO::GslVector,QUESO::GslMatrix> data_writer; data_writer.write( filename1, data.get_dataset(0) ); data_writer.write( filename2, data.get_dataset(1) ); } // Now read the data and test { QUESO::InterpolationSurrogateIOASCII<QUESO::GslVector,QUESO::GslMatrix> data_reader_1, data_reader_2; data_reader_1.read( filename1, env, vs_prefix.c_str() ); data_reader_2.read( filename2, env, vs_prefix.c_str() ); // Build a new surrogate QUESO::LinearLagrangeInterpolationSurrogate<QUESO::GslVector,QUESO::GslMatrix> four_d_surrogate_1( data_reader_1.data() ); QUESO::LinearLagrangeInterpolationSurrogate<QUESO::GslVector,QUESO::GslMatrix> four_d_surrogate_2( data_reader_2.data() ); double test_val_1 = four_d_surrogate_1.evaluate(domainVector); double test_val_2 = four_d_surrogate_2.evaluate(domainVector); return_flag = return_flag || test_val( test_val_1, exact_val_1, tol, "test_read_1" ) || test_val( test_val_2, exact_val_2, tol, "test_read_2" ); } return return_flag; }
int main(int argc, char ** argv) { #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); #else QUESO::FullEnvironment env(argv[1], "", NULL); #endif QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL); double min_val = 0.0; double max_val = 1.0; QUESO::GslVector paramMins(paramSpace.zeroVector()); paramMins.cwSet(min_val); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); paramMaxs.cwSet(max_val); QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, 1.0); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 1; i++) { proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; }
int main(int argc, char ** argv) { MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL); QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env, "param_", 2, NULL); double min_val = 0.0; double max_val = 1.0; QUESO::GslVector paramMins(paramSpace.zeroVector()); QUESO::GslVector paramMaxs(paramSpace.zeroVector()); // Model parameter between 0 and 1 paramMins[0] = 0.0; paramMaxs[0] = 1.0; // Hyperparameter (multiplicative coefficient of observational error // covariance matrix) between 0.0 and \infty paramMins[1] = 0.0; paramMaxs[1] = INFINITY; QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_", paramSpace, paramMins, paramMaxs); QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_", paramDomain); // Set up observation space QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env, "obs_", 2, NULL); // Fill up observation vector QUESO::GslVector observations(obsSpace.zeroVector()); observations[0] = 1.0; observations[1] = 1.0; // Fill up covariance 'matrix' QUESO::GslMatrix covariance(obsSpace.zeroVector()); covariance(0, 0) = 1.0; covariance(0, 1) = 0.0; covariance(1, 0) = 0.0; covariance(1, 1) = 1.0; // Pass in observations to Gaussian likelihood object Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain, observations, covariance); QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> postRv("post_", paramSpace); QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("", NULL, priorRv, lhood, postRv); QUESO::GslVector paramInitials(paramSpace.zeroVector()); paramInitials[0] = 0.0; QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector()); for (unsigned int i = 0; i < 1; i++) { proposalCovMatrix(i, i) = 0.1; } ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix); MPI_Finalize(); return 0; }
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; }