void
DataSetIO::SaveDataSet(const DataSet& dataSet_, const std::string& filename_){
// Get the relevant params
hsize_t nEntries = dataSet_.GetNEntries();
hsize_t nObs = dataSet_.GetNObservables();
hsize_t nData = nObs * nEntries;
// create colon separated string from list of observables
std::vector<std::string> observableNames = dataSet_.GetObservableNames();
if (observableNames.size() != nObs)
throw HdfIOError("SaveDataSet::Require one name and one name only for each observable");
// Set up files
H5::H5File file(filename_, H5F_ACC_TRUNC);
// Flatten data into 1D array
// HDF5 likes c arrays. Here use a vector and pass pointer to first element
// memory guaranteed to be contiguous
std::vector<double> flattenedData;
std::vector<double> eventData;
flattenedData.reserve(nData);
for(size_t i = 0; i < nEntries; i++){
eventData = dataSet_.GetEntry(i).GetData();
flattenedData.insert(flattenedData.end(), eventData.begin(), eventData.end());
}
// Set up the data set
// 1D, ndata long, called "observations". Saved as native doubles on this computer
H5::DataSpace dataSpace(1, &nData);
H5::DataSet theData(file.createDataSet("observations", H5::PredType::NATIVE_DOUBLE, dataSpace));
// Set up the attributes - the number of obs per event and the names of the observables
// 64 chars max in str to save space
H5::StrType strType(H5::PredType::C_S1, 64);
H5::DataSpace attSpace(H5S_SCALAR);
H5::Attribute obsListAtt = theData.createAttribute("observed_quantities", strType, attSpace);
obsListAtt.write(strType, FlattenStringVector(observableNames, fDelimiter));
H5::Attribute countAtt = theData.createAttribute("n_observables",
H5::PredType::NATIVE_INT,
attSpace);
countAtt.write(H5::PredType::NATIVE_INT, &nObs);
// Write the data
theData.write(&flattenedData.at(0), H5::PredType::NATIVE_DOUBLE);
}
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;
}
size_type DataPage::largestPossibleInlineRecordSize() const
{
return dataSpace(size()) - sizeof(uint16_t);
}
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 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;
}
