void
Qoi_mc<P_V, P_M, Q_V, Q_M>::compute(const P_V & domainVector,
const P_V * domainDirection,
Q_V & imageVector, QUESO::DistArray<P_V *> * gradVectors,
QUESO::DistArray<P_M *> * hessianMatrices,
QUESO::DistArray<P_V *> * hessianEffects) const
{
if (domainVector.sizeLocal() != 2) {
queso_error_msg("domainVector does not have size 2");
}
if (imageVector.sizeLocal() != 1) {
queso_error_msg("imageVector does not have size 1");
}
qoi_samples.open ("c_qoi_samplesAi.txt", std::fstream::in | std::fstream::out | std::fstream::app);
// ----Generate Qoi using samples from a text files -------------
count++;
samples.open ("./files_sense/c_samples_Ai.txt", std::fstream::in | std::fstream::out | std::fstream::app);
int cou = 1;
while (samples >> mf >> cf){
if (cou == count){
m = mf;
c = cf;
break;
}
cou++;
}
// ------- Generate Qoi using pseudo-random MC samples ------------
// std::cout << "m = " << domainVector[0] << std::endl;
// m = domainVector[0]; // Sample of the RV 'line slope'
// c = domainVector[1]; // Sample of the RV 'y-intercept'
double y_obs = 0.0;
y_obs = m*x_loc + c;
qoi_samples << std::setprecision(4) << y_obs << "\t\t" << m << "\t\t" << c << std::endl;
imageVector[0] = y_obs;
qoi_samples.close();
samples.close();
}
void
Qoi_m<P_V, P_M, Q_V, Q_M>::compute(const P_V & domainVector,
const P_V * domainDirection,
Q_V & imageVector, QUESO::DistArray<P_V *> * gradVectors,
QUESO::DistArray<P_M *> * hessianMatrices,
QUESO::DistArray<P_V *> * hessianEffects) const
{
if (domainVector.sizeLocal() != 2) {
queso_error_msg("domainVector does not have size 2");
}
if (imageVector.sizeLocal() != 1) {
queso_error_msg("imageVector does not have size 1");
}
// std::cout << "m = " << domainVector[0] << std::endl;
double m = domainVector[0]; // Sample of the RV 'line slope'
double c = 5.0; // Sample of the RV 'y-intercept'
double y_obs = 0.0;
y_obs = m*x_loc + c;
imageVector[0] = y_obs;
}
void
StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings(
const MhOptionsValues* alternativeOptionsValues, // dakota
const P_V& initialValues,
const P_M* initialProposalCovMatrix)
{
//grvy_timer_begin("BayesMetropolisHastings"); TODO: revisit timing output
//std::cout << "proc " << m_env.fullRank() << ", HERE sip 000" << std::endl;
m_env.fullComm().Barrier();
//std::cout << "proc " << m_env.fullRank() << ", HERE sip 001" << std::endl;
m_env.fullComm().syncPrintDebugMsg("Entering StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()",1,3000000);
if (m_optionsObj->m_computeSolution == false) {
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()"
<< ": avoiding solution, as requested by user"
<< std::endl;
}
return;
}
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()"
<< ": computing solution, as requested by user"
<< std::endl;
}
queso_require_equal_to_msg(m_priorRv.imageSet().vectorSpace().dimLocal(), initialValues.sizeLocal(), "'m_priorRv' and 'initialValues' should have equal dimensions");
if (initialProposalCovMatrix) {
queso_require_equal_to_msg(m_priorRv.imageSet().vectorSpace().dimLocal(), initialProposalCovMatrix->numRowsLocal(), "'m_priorRv' and 'initialProposalCovMatrix' should have equal dimensions");
queso_require_equal_to_msg(initialProposalCovMatrix->numCols(), initialProposalCovMatrix->numRowsGlobal(), "'initialProposalCovMatrix' should be a square matrix");
}
if (m_mlSampler ) delete m_mlSampler;
if (m_mhSeqGenerator ) delete m_mhSeqGenerator;
if (m_solutionRealizer) delete m_solutionRealizer;
if (m_subSolutionCdf ) delete m_subSolutionCdf;
if (m_subSolutionMdf ) delete m_subSolutionMdf;
if (m_solutionPdf ) delete m_solutionPdf;
if (m_solutionDomain ) delete m_solutionDomain;
P_V numEvaluationPointsVec(m_priorRv.imageSet().vectorSpace().zeroVector());
numEvaluationPointsVec.cwSet(250.);
// Compute output pdf up to a multiplicative constant: Bayesian approach
m_solutionDomain = InstantiateIntersection(m_priorRv.pdf().domainSet(),m_likelihoodFunction.domainSet());
m_solutionPdf = new BayesianJointPdf<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
m_priorRv.pdf(),
m_likelihoodFunction,
1.,
*m_solutionDomain);
m_postRv.setPdf(*m_solutionPdf);
m_chain = new SequenceOfVectors<P_V,P_M>(m_postRv.imageSet().vectorSpace(),0,m_optionsObj->m_prefix+"chain");
// Decide whether or not to create a MetropolisHastingsSG instance from the
// user-provided initial seed, or use the user-provided seed for a
// deterministic optimisation instead and seed the chain with the result of
// the optimisation
if (this->m_seedWithMAPEstimator) {
// Do optimisation before sampling
GslOptimizer optimizer(*m_solutionPdf);
optimizer.setInitialPoint(dynamic_cast<const GslVector &>(initialValues));
optimizer.minimize();
// Compute output realizer: Metropolis-Hastings approach
m_mhSeqGenerator = new MetropolisHastingsSG<P_V, P_M>(
m_optionsObj->m_prefix.c_str(), alternativeOptionsValues,
m_postRv, optimizer.minimizer(), initialProposalCovMatrix);
}
else {
// Compute output realizer: Metropolis-Hastings approach
m_mhSeqGenerator = new MetropolisHastingsSG<P_V, P_M>(
m_optionsObj->m_prefix.c_str(), alternativeOptionsValues, m_postRv,
initialValues, initialProposalCovMatrix);
}
m_logLikelihoodValues = new ScalarSequence<double>(m_env, 0,
m_optionsObj->m_prefix +
"logLike");
m_logTargetValues = new ScalarSequence<double>(m_env, 0,
m_optionsObj->m_prefix +
"logTarget");
// m_logLikelihoodValues and m_logTargetValues may be NULL
m_mhSeqGenerator->generateSequence(*m_chain, m_logLikelihoodValues,
m_logTargetValues);
m_solutionRealizer = new SequentialVectorRealizer<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
*m_chain);
m_postRv.setRealizer(*m_solutionRealizer);
m_env.fullComm().syncPrintDebugMsg("In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings(), code place 1",3,3000000);
//m_env.fullComm().Barrier();
// Compute output mdf: uniform sampling approach
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
m_subMdfGrids = new ArrayOfOneDGrids <P_V,P_M>((m_optionsObj->m_prefix+"Mdf_").c_str(),m_postRv.imageSet().vectorSpace());
m_subMdfValues = new ArrayOfOneDTables<P_V,P_M>((m_optionsObj->m_prefix+"Mdf_").c_str(),m_postRv.imageSet().vectorSpace());
m_chain->subUniformlySampledMdf(numEvaluationPointsVec, // input
*m_subMdfGrids, // output
*m_subMdfValues); // output
m_subSolutionMdf = new SampledVectorMdf<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
*m_subMdfGrids,
*m_subMdfValues);
m_postRv.setMdf(*m_subSolutionMdf);
if ((m_optionsObj->m_dataOutputFileName != UQ_SIP_FILENAME_FOR_NO_FILE ) &&
(m_optionsObj->m_dataOutputAllowedSet.find(m_env.subId()) != m_optionsObj->m_dataOutputAllowedSet.end())) {
if (m_env.subRank() == 0) {
// Write data output file
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "Opening data output file '" << m_optionsObj->m_dataOutputFileName
<< "' for calibration problem with problem with prefix = " << m_optionsObj->m_prefix
<< std::endl;
}
// Open file
// Always write at the end of an eventual pre-existing file
std::ofstream* ofsvar = new std::ofstream((m_optionsObj->m_dataOutputFileName+"_sub"+m_env.subIdString()+".m").c_str(), std::ofstream::out | std::ofstream::in | std::ofstream::ate);
if ((ofsvar == NULL ) ||
(ofsvar->is_open() == false)) {
delete ofsvar;
ofsvar = new std::ofstream((m_optionsObj->m_dataOutputFileName+"_sub"+m_env.subIdString()+".m").c_str(), std::ofstream::out | std::ofstream::trunc);
}
queso_require_msg((ofsvar && ofsvar->is_open()), "failed to open file");
m_postRv.mdf().print(*ofsvar);
// Close file
//ofsvar->close();
delete ofsvar;
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "Closed data output file '" << m_optionsObj->m_dataOutputFileName
<< "' for calibration problem with problem with prefix = " << m_optionsObj->m_prefix
<< std::endl;
}
}
}
#endif
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << std::endl;
}
m_env.fullComm().syncPrintDebugMsg("Leaving StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()",1,3000000);
m_env.fullComm().Barrier();
// grvy_timer_end("BayesMetropolisHastings"); TODO: revisit timers
return;
}