DLLEXPORT void vclAbs(const int n, const ScalarType a[], const int aOffset, ScalarType b[], const int bOffset)
{
auto aPtr = &(a[0]) + aOffset;
auto bPtr = &(b[0]) + bOffset;
viennacl::vector<ScalarType> aVec((ScalarType*)aPtr, viennacl::MAIN_MEMORY, n);
viennacl::vector<ScalarType> bVec(bPtr, viennacl::MAIN_MEMORY, n);
bVec = viennacl::linalg::element_abs(aVec);
};
DLLEXPORT void vclSubstract(const int n, const ScalarType a[], const int aOffset, ScalarType b[], const int bOffset)
{
auto aPtr = &(a[0]) + aOffset;
auto bPtr = &(b[0]) + bOffset;
viennacl::vector<ScalarType> aVec((ScalarType*)aPtr, viennacl::MAIN_MEMORY, n);
viennacl::vector<ScalarType> bVec(bPtr, viennacl::MAIN_MEMORY, n);
bVec = aVec - bVec;
};
void Ground::makeHole(b2Vec2 epicenter, float radius)
{
std::list<b2Vec2>::iterator first,second, firstToDel, lastToDel, circleStart, circleEnd, itr, leftCircleBorder, rightCircleBorder;
b2Vec2 leftBorder, rightBorder;
bool leftFound(false), rightFound(false);
//find left border
first = this->edges.begin();
for (second=++(this->edges.begin()); second!=this->edges.end(); first++,second++)
{
if (distance(*second, epicenter) <= radius)
{
leftBorder = (*first);
circleStart = first;
leftFound = true;
firstToDel = second;
break;
}
}
//find right border
first = --(this->edges.end());
for (second= --(--this->edges.end()); second!=this->edges.begin(); first--,second--)
{
if (distance(*second, epicenter) <= radius)
{
rightBorder = (*first);
circleEnd = first;
rightFound = true;
lastToDel = second;
break;
}
}
if ( !(leftFound && rightFound) )
return;
leftBorder = getBorder(*circleStart, *firstToDel, epicenter, radius);
leftCircleBorder = circleStart;
leftCircleBorder++;
this->edges.insert(leftCircleBorder,leftBorder);
leftCircleBorder--;
rightBorder = getBorder(*circleEnd, *lastToDel, epicenter, radius);
rightCircleBorder = circleEnd;
this->edges.insert(rightCircleBorder,rightBorder);
rightCircleBorder--;
this->edges.erase(firstToDel, ++lastToDel);
b2Vec2 aVec(leftBorder.x-epicenter.x, leftBorder.y-epicenter.y), bVec(rightBorder.x-epicenter.x, rightBorder.y-epicenter.y);
positiveAngle ab = getPositiveAngle(aVec,bVec);
positiveAngle step = 1/57.296;
b2Vec2 toInsert = rotateVec(aVec, step);
positiveAngle rotated(step);
for (itr = ++leftCircleBorder; rotated < ab; rotated+=step)
{
this->edges.insert(itr,epicenter + toInsert);
toInsert = rotateVec(toInsert,step);
}
}
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;
}
double likelihoodRoutine(
const uqGslVectorClass& paramValues,
const uqGslVectorClass* paramDirection,
const void* functionDataPtr,
uqGslVectorClass* gradVector,
uqGslMatrixClass* hessianMatrix,
uqGslVectorClass* hessianEffect)
{
struct timeval timevalBegin;
gettimeofday(&timevalBegin, NULL);
likelihoodCounter++;
const uqBaseEnvironmentClass& env = paramValues.env();
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 3)) {
*env.subDisplayFile() << "Entering likelihoodRoutine()..."
<< ": likelihoodCounter = " << likelihoodCounter
<< ", params = " << paramValues
<< ", env.subComm().NumProc() = " << env.subComm().NumProc()
<< ", my subRank = " << env.subRank()
<< std::endl;
}
if (env.subRank() == 0) {
#if 0
std::cout << "Entering likelihoodRoutine()"
<< ", likelihoodCounter = " << likelihoodCounter
<< std::endl;
#endif
}
//////////////////////////////////////////////////
// Begin actual likelihood routine
//////////////////////////////////////////////////
double totalLnLikelihood = 0.;
if (paramDirection &&
functionDataPtr &&
gradVector &&
hessianMatrix &&
hessianEffect) {
// Just to eliminate INTEL compiler warnings
}
struct likelihoodDataStruct* likelihoodData = (likelihoodDataStruct *) functionDataPtr;
uqGslVectorClass bVec(*(likelihoodData->bVec));
unsigned int p = bVec.sizeLocal();
double sigmaTotal = likelihoodData->sigmaTotal;
uqGslVectorClass ySamples(*(likelihoodData->ySamples));
unsigned int n = ySamples.sizeLocal();
UQ_FATAL_TEST_MACRO(paramValues.sizeLocal() != p,
env.fullRank(),
"likelihoodRoutine()",
"invalid parameter vector size");
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 4)) {
*env.subDisplayFile() << "In likelihoodRoutine()"
<< ": likelihoodCounter = " << likelihoodCounter
<< ", params = " << paramValues
<< ", p = " << p
<< ", bVec = " << bVec
<< ", sigmaTotal = " << sigmaTotal
<< ", n = " << n
<< ", ySamples = " << ySamples
<< std::endl;
}
//******************************************************************************
// Compute likelihood
//******************************************************************************
for (unsigned int i = 0; i < n; ++i) {
double diff = (ySamples[i] - (bVec[0]*paramValues[0]))/sigmaTotal;
totalLnLikelihood -= 0.5 * diff * diff;
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 4)) {
*env.subDisplayFile() << "In likelihoodRoutine()"
<< ": likelihoodCounter = " << likelihoodCounter
<< ", params = " << paramValues
<< ", diff = " << diff
<< std::endl;
}
}
//******************************************************************************
// Prepare to return
//******************************************************************************
double totalTime = uqMiscGetEllapsedSeconds(&timevalBegin);
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 3)) {
*env.subDisplayFile() << "Leaving likelihoodRoutine()"
<< ": likelihoodCounter = " << likelihoodCounter
<< ", params = " << paramValues
<< ", totalLnLikelihood = " << totalLnLikelihood
<< " after " << totalTime
<< " seconds"
<< std::endl;
}
if (env.subRank() == 0) {
#if 0
std::cout << "Leaving likelihoodRoutine()"
<< ": likelihoodCounter = " << likelihoodCounter
<< ", params = " << paramValues
<< ", totalLnLikelihood = " << totalLnLikelihood
<< " after " << totalTime
<< " seconds"
<< std::endl;
#endif
}
env.subComm().Barrier();
//exit(1);
return totalLnLikelihood;
}
/**
* @param A coefficient matrix
* @param b right-hand side
* @param[out] x solution of the linear system
* @return whether all went well (false if errors occurred)
*/
bool solveInternal(const gmm::csr_matrix<float_t>& A, base::DataVector& b, base::DataVector& x) {
// allow warnings
gmm::warning_level::level(1);
const size_t n = b.getSize();
std::vector<float_t> bVec(b.getPointer(), b.getPointer() + n);
std::vector<float_t> xVec(n, 0.0);
// ILU preconditioning
Printer::getInstance().printStatusUpdate("constructing preconditioner");
gmm::ilu_precond<gmm::csr_matrix<float_t>> P(A);
Printer::getInstance().printStatusNewLine();
Printer::getInstance().printStatusUpdate("solving with Gmm++");
gmm::iteration iter(1e-6, 0, 10000);
iter.set_callback(&callback);
try {
// call GMRES
gmm::gmres(A, xVec, bVec, P, 50, iter);
float_t res = iter.get_res();
if (iter.converged() && (res < 1e3)) {
// GMRES converged
x = base::DataVector(xVec);
Printer::getInstance().printStatusUpdate("solving with Gmm++ (k = " +
std::to_string(iter.get_iteration()) +
", residual norm = " + std::to_string(res) + ")");
Printer::getInstance().printStatusEnd();
return true;
} else {
// GMRES didn't converge ==> try again without preconditioner
gmm::identity_matrix P;
Printer::getInstance().printStatusNewLine();
Printer::getInstance().printStatusUpdate(
"solving with preconditioner failed, trying again without one");
Printer::getInstance().printStatusNewLine();
// call GMRES again
gmm::gmres(A, xVec, bVec, P, 50, iter);
res = iter.get_res();
if (iter.converged() && (res < 1e3)) {
x = base::DataVector(xVec);
Printer::getInstance().printStatusUpdate("solving with Gmm++ (k = " +
std::to_string(iter.get_iteration()) +
", residual norm = " + std::to_string(res) + ")");
Printer::getInstance().printStatusEnd();
return true;
} else {
Printer::getInstance().printStatusEnd(
"error: Could not solve linear system, "
"method didn't converge");
return false;
}
}
} catch (std::exception& e) {
Printer::getInstance().printStatusEnd("error: Could not solve linear system, what(): " +
std::string(e.what()));
return false;
}
}
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;
}
