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 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;
}
int main(int argc, char **argv) {
MPI_Init(&argc, &argv);
QUESO::EnvOptionsValues options;
options.m_numSubEnvironments = 1;
options.m_subDisplayFileName = "debug_output";
options.m_seed = 1.0;
options.m_checkingLevel = 1;
options.m_platformName = "my_platform";
options.m_displayVerbosity = 20;
/* std::set<unsigned int> subDisplayAllowed; */
/* subDisplayAllowed.insert(0); */
/* options.m_subDisplayAllowedSet = subDisplayAllowed; */
/* options.m_subDisplayAllowAll = 0; */
QUESO::FullEnvironment *env = new QUESO::FullEnvironment(MPI_COMM_WORLD, "", "", &options);
if (!env->fullEnvIsReady()) {
std::cerr << "Full env ready test failed" << std::endl;
return 1;
}
if (env->displayVerbosity() > 10) {
std::cout << "have high enough display verbosity" << std::endl;
}
else {
std::cout << "not high enough" << std::endl;
}
if (env->worldRank() != 0) {
std::cerr << "World rank test failed" << std::endl;
return 1;
}
if (env->subDisplayFileName() != "debug_output") {
std::cerr << "subDisplayFileName test failed" << std::endl;
return 1;
}
env->setOptionsInputFileAccessState(false);
if (env->optionsInputFileName() != "") {
std::cerr << "Input file acces state test failed" << std::endl;
return 1;
}
env->setOptionsInputFileAccessState(true);
if (env->checkingLevel() != options.m_checkingLevel) {
std::cerr << "Checking level test failed" << std::endl;
return 1;
}
if (env->seed() != options.m_seed) {
std::cerr << "Seed test failed" << std::endl;
return 1;
}
#ifdef QUESO_USES_NEW_RNG_CLASS
env->resetSeed(2);
if (env->seed() != 2) {
std::cerr << "Second seed test failed" << std::endl;
return 1;
}
env->resetSeed(-2);
if (env->seed() != (2 + env->worldRank())) {
std::cerr << "Third seed test failed" << std::endl;
return 1;
}
#else
env->resetGslSeed(2);
if (gsl_rng_default_seed != 2) {
std::cerr << "Second seed test failed" << std::endl;
return 1;
}
env->resetGslSeed(-2);
if (gsl_rng_default_seed != (2 + env->worldRank())) {
std::cerr << "Third seed test failed" << std::endl;
return 1;
}
#endif
if (env->platformName() != options.m_platformName) {
std::cerr << "Platform name test failed" << std::endl;
return 1;
}
env->resetIdentifyingString("my_identifying_string");
if (env->identifyingString() != "my_identifying_string") {
std::cerr << "Identifying string test failed" << std::endl;
return 1;
}
delete env;
MPI_Finalize();
/*
* This code should never get here. If it does, the bash script that wraps
* around it negates the return value, making this a failure
*/
return 0;
}
//------------------------------------------------------
//------------------------------------------------------
//------------------------------------------------------
void debug_hyst(const QUESO::FullEnvironment& env) {
unsigned int numFloors = 4;
unsigned int numTimeSteps = 401;
std::vector<double> accel(numTimeSteps,0.);
FILE *inp;
inp = fopen("an.txt","r");
unsigned int numObservations = 0;
double tmpA;
while (fscanf(inp,"%lf",&tmpA) != EOF) {
UQ_FATAL_TEST_MACRO((numObservations >= accel.size()),
env.fullRank(),
"debug_hyst()",
"input file has too many lines");
accel[numObservations] = tmpA;
numObservations++;
}
UQ_FATAL_TEST_MACRO((numObservations != accel.size()),
env.fullRank(),
"debug_hyst()",
"input file has a smaller number of observations than expected");
QUESO::VectorSpace<> floorSpace(env, "floor_", numFloors, NULL);
QUESO::GslVector kVec(floorSpace.zeroVector());
kVec[0] = 2.20e+7;
kVec[1] = 2.00e+7;
kVec[2] = 1.70e+7;
kVec[3] = 1.45e+7;
QUESO::GslVector rVec(floorSpace.zeroVector());
rVec[0] = 0.1;
rVec[1] = 0.1;
rVec[2] = 0.1;
rVec[3] = 0.1;
QUESO::GslVector uVec(floorSpace.zeroVector());
uVec[0] = 0.008;
uVec[1] = 0.008;
uVec[2] = 0.007;
uVec[3] = 0.007;
double rho = 7.959e-1 ;//0.1976;
double gamma = 2.500e-3 ; //0.0038;
std::vector<double> t(numTimeSteps,0.);
QUESO::SequenceOfVectors<> u (floorSpace,numTimeSteps,""); // absolute displacement
QUESO::SequenceOfVectors<> ud (floorSpace,numTimeSteps,""); // velocity
QUESO::SequenceOfVectors<> udd (floorSpace,numTimeSteps,""); // acceleration
QUESO::SequenceOfVectors<> resfor(floorSpace,numTimeSteps,""); // restoring force
QUESO::SequenceOfVectors<> ru (floorSpace,numTimeSteps,""); // relative displacement
u.setPositionValues (0,floorSpace.zeroVector());
ud.setPositionValues (0,floorSpace.zeroVector());
udd.setPositionValues (0,floorSpace.zeroVector());
resfor.setPositionValues(0,floorSpace.zeroVector());
ru.setPositionValues (0,floorSpace.zeroVector());
QUESO::GslVector massVec(floorSpace.zeroVector());
massVec.cwSet(2.0e+4);
hystereticModel(env,
massVec,
kVec,
rVec,
uVec,
rho,
gamma,
accel,
t, // output
u,
ud,
udd,
resfor,
ru);
std::set<unsigned int> auxSet;
auxSet.insert(0);
// Writing some data to the file 'outputData/cpp_output.m'
std::ofstream myFile;
myFile.open ("outputData/cpp_output.m");
// Write 't_cpp'
myFile << "t_cpp = zeros(" << 1 << "," << numTimeSteps << ");\n"
<< "t_cpp = [";
for (unsigned int j = 0; j < numTimeSteps; ++j) {
myFile << t[j] << " ";
}
myFile << "];" << std::endl;
// Write 'a_cpp'
myFile << "a_cpp = zeros(" << 1 << "," << numTimeSteps << ");\n"
<< "a_cpp = [";
for (unsigned int j = 0; j < numTimeSteps; ++j) {
myFile << accel[j] << " ";
}
myFile << "];" << std::endl;
QUESO::GslVector auxVec(floorSpace.zeroVector());
// Write 'u_cpp'
myFile << "u_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
<< "u_cpp = [";
for (unsigned int i = 0; i < numFloors; ++i) {
for (unsigned int j = 0; j < numTimeSteps; ++j) {
u.getPositionValues(j,auxVec);
myFile << auxVec[i] << " ";
}
myFile << std::endl;
}
myFile << "];" << std::endl;
// Write 'ud_cpp'
myFile << "ud_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
<< "ud_cpp = [";
for (unsigned int i = 0; i < numFloors; ++i) {
for (unsigned int j = 0; j < numTimeSteps; ++j) {
ud.getPositionValues(j,auxVec);
myFile << auxVec[i] << " ";
}
myFile << std::endl;
}
myFile << "];" << std::endl;
// Write 'udd_cpp'
myFile << "udd_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
<< "udd_cpp = [";
for (unsigned int i = 0; i < numFloors; ++i) {
for (unsigned int j = 0; j < numTimeSteps; ++j) {
udd.getPositionValues(j,auxVec);
myFile << auxVec[i] << " ";
}
myFile << std::endl;
}
myFile << "];" << std::endl;
// Write 'resfor_cpp'
myFile << "resfor_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
<< "resfor_cpp = [";
for (unsigned int i = 0; i < numFloors; ++i) {
for (unsigned int j = 0; j < numTimeSteps; ++j) {
resfor.getPositionValues(j,auxVec);
myFile << auxVec[i] << " ";
}
myFile << std::endl;
}
myFile << "];" << std::endl;
// Write 'ru_cpp'
myFile << "ru_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
<< "ru_cpp = [";
for (unsigned int i = 0; i < numFloors; ++i) {
for (unsigned int j = 0; j < numTimeSteps; ++j) {
ru.getPositionValues(j,auxVec);
myFile << auxVec[i] << " ";
}
myFile << std::endl;
}
myFile << "];" << std::endl;
myFile.close();
return;
}
