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 infer_slope(const QUESO::FullEnvironment & env) {
// Statistical Inverse Problem: Compute posterior pdf for slope 'm' and y-intercept c
// Step 1: Instantiate the parameter space
QUESO::VectorSpace<> paramSpace(env, "param_", 2, NULL); // 2 since we have a 2D problem
// Step 2: Parameter domain
QUESO::GslVector paramMinValues(paramSpace.zeroVector());
QUESO::GslVector paramMaxValues(paramSpace.zeroVector());
paramMinValues[0] = 2.;
paramMaxValues[0] = 5.;
paramMinValues[1] = 3.;
paramMaxValues[1] = 7.;
QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues);
// Step 3: Instantiate likelihood
Likelihood<> lhood("like_", paramDomain);
// Step 4: Define the prior RV
QUESO::UniformVectorRV<> priorRv("prior_", paramDomain);
// Step 5: Instantiate the inverse problem
QUESO::GenericVectorRV<> postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv);
// Step 6: Solve the inverse problem
// Randomly sample for the initial state?
QUESO::GslVector paramInitials(paramSpace.zeroVector());
priorRv.realizer().realization(paramInitials);
// Initialize the Cov matrix:
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
proposalCovMatrix(0,0) = std::pow(std::abs(paramInitials[0]) / 20.0, 2.0);
proposalCovMatrix(1,1) = std::pow(std::abs(paramInitials[1]) / 20.0, 2.0);
ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix);
// Using the posterior pdfs for m and c, compute 'y' at a given 'x'
// Step 1: Instantiate the qoi space
QUESO::VectorSpace<> qoiSpace(env, "qoi_", 1, NULL);
// Step 2: Instantiate the parameter domain
// Not necessary here because the posterior from SIP is used as the RV for SFP
// Step 3: Instantiate the qoi object to be used by QUESO
Qoi<> qoi("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the posterior as RV
// Step 5: Instantiate the forward problem
QUESO::GenericVectorRV<> qoiRv("qoi_", qoiSpace);
QUESO::StatisticalForwardProblem<> fp("", NULL, postRv, qoi, qoiRv);
// Step 6: Solve the forward problem
std::cout << "Solving the SFP with Monte Carlo" << std::endl << std::endl;
fp.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sfp_lineSlope_qoi_seq_post.txt");
// SENSITIVITY ANALYSIS
// For m
Qoi_m<> qoi_m("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_m("", NULL, priorRv, qoi_m, qoiRv);
// Step 6: Solve the forward problem
fp_m.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_m.txt");
// For c
Qoi_c<> qoi_c("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_c("", NULL, priorRv, qoi_c, qoiRv);
// Step 6: Solve the forward problem
fp_c.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_c.txt");
// For both, m and c
Qoi_mc<> qoi_mc("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_mc("", NULL, priorRv, qoi_mc, qoiRv);
// Step 6: Solve the forward problem
fp_mc.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_mc.txt");
}
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[])
{
#ifndef QUESO_HAS_MPI
// Skip this test if we're not in parallel
return 77;
#else
MPI_Init(&argc, &argv);
std::string inputFileName = argv[1];
const char * test_srcdir = std::getenv("srcdir");
if (test_srcdir)
inputFileName = test_srcdir + ('/' + inputFileName);
// Initialize QUESO environment
QUESO::FullEnvironment env(MPI_COMM_WORLD, inputFileName, "", NULL);
//================================================================
// Statistical inverse problem (SIP): find posterior PDF for 'g'
//================================================================
//------------------------------------------------------
// SIP Step 1 of 6: Instantiate the parameter space
//------------------------------------------------------
QUESO::VectorSpace<> 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<> paramDomain("param_", paramSpace, paramMinValues,
paramMaxValues);
//------------------------------------------------------
// SIP Step 3 of 6: Instantiate the likelihood function
// object to be used by QUESO.
//------------------------------------------------------
Likelihood<> lhood("like_", paramDomain);
//------------------------------------------------------
// SIP Step 4 of 6: Define the prior RV
//------------------------------------------------------
QUESO::UniformVectorRV<> priorRv("prior_", paramDomain);
//------------------------------------------------------
// SIP Step 5 of 6: Instantiate the inverse problem
//------------------------------------------------------
// Extra prefix before the default "rv_" prefix
QUESO::GenericVectorRV<> postRv("post_", paramSpace);
// No extra prefix before the default "ip_" prefix
QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv);
//------------------------------------------------------
// SIP Step 6 of 6: Solve the inverse problem, that is,
// set the 'pdf' and the 'realizer' of the posterior RV
//------------------------------------------------------
QUESO::GslVector paramInitials(paramSpace.zeroVector());
priorRv.realizer().realization(paramInitials);
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
proposalCovMatrix(0,0) = std::pow(std::abs(paramInitials[0]) / 20.0, 2.0);
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.
//================================================================
//------------------------------------------------------
// 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<> 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 object
// to be used by QUESO.
//------------------------------------------------------
Qoi<> qoi("qoi_", paramDomain, qoiSpace);
//------------------------------------------------------
// 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<> qoiRv("qoi_", qoiSpace);
QUESO::StatisticalForwardProblem<> fp("", NULL, postRv, qoi, qoiRv);
//------------------------------------------------------
// SFP Step 6 of 6: Solve the forward problem
//------------------------------------------------------
fp.solveWithMonteCarlo(NULL);
MPI_Finalize();
return 0;
#endif // QUESO_HAS_MPI
}
