void TestNonlinearEquationPde()
{
ChastePoint<1> zero1(0);
ChastePoint<2> zero2(0,0);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
NonlinearEquationPde<1> heat_equation1;
NonlinearEquationPde<2> heat_equation2;
NonlinearEquationPde<3> heat_equation3;
TS_ASSERT_DELTA(heat_equation1.ComputeNonlinearSourceTerm(zero1,u),0.0,1e-12);
TS_ASSERT_DELTA(heat_equation2.ComputeNonlinearSourceTerm(zero2,u),0.0,1e-12);
TS_ASSERT_DELTA(heat_equation3.ComputeNonlinearSourceTerm(zero3,u),0.0,1e-12);
// Diffusion matrices should be equal to identity * u;
c_matrix<double, 1, 1> diff1 = heat_equation1.ComputeDiffusionTerm(zero1,u);
c_matrix<double, 2, 2> diff2 = heat_equation2.ComputeDiffusionTerm(zero2,u);
c_matrix<double, 3, 3> diff3 = heat_equation3.ComputeDiffusionTerm(zero3,u);
TS_ASSERT_DELTA(diff1(0,0),u,1e-12);
TS_ASSERT_DELTA(diff2(0,0),u,1e-12);
TS_ASSERT_DELTA(diff2(1,1),u,1e-12);
TS_ASSERT_DELTA(diff2(0,1),0,1e-12);
TS_ASSERT_DELTA(diff3(0,0),u,1e-12);
TS_ASSERT_DELTA(diff3(1,1),u,1e-12);
TS_ASSERT_DELTA(diff3(2,2),u,1e-12);
TS_ASSERT_DELTA(diff3(0,1),0,1e-12);
TS_ASSERT_DELTA(diff3(0,2),0,1e-12);
TS_ASSERT_DELTA(diff3(1,2),0,1e-12);
}
ExecStatus
ReEq<View0,View1>::propagate(Space& home, const ModEventDelta&) {
if (b.one())
GECODE_REWRITE(*this,(Eq<View0,View1>::post(home(*this),x0,x1)));
if (b.zero())
GECODE_REWRITE(*this,(Distinct<View0,View1>::post(home(*this),x0,x1)));
if (x0.assigned() && x1.assigned()) {
// directly test x0==x1
GlbRanges<View0> x0lb(x0);
GlbRanges<View1> x1lb(x1);
for (; x0lb() && x1lb(); ++x0lb, ++x1lb) {
if (x0lb.min() != x1lb.min() ||
x0lb.max() != x1lb.max()) {
GECODE_ME_CHECK(b.zero_none(home));
return home.ES_SUBSUMED(*this);
}
}
if (!x0lb() && !x1lb()) {
GECODE_ME_CHECK(b.one_none(home));
return home.ES_SUBSUMED(*this);
} else {
GECODE_ME_CHECK(b.zero_none(home));
return home.ES_SUBSUMED(*this);
}
}
// check whether cardinalities still allow equality
if (x0.cardMin() > x1.cardMax() ||
x1.cardMin() > x0.cardMax()) {
GECODE_ME_CHECK(b.zero_none(home));
return home.ES_SUBSUMED(*this);
}
// check glb(x0) subset lub(x1)
GlbRanges<View0> x0lb(x0);
LubRanges<View1> x1ub(x1);
Iter::Ranges::Diff<GlbRanges<View0>, LubRanges<View1> > diff1(x0lb, x1ub);
if ( diff1() ) {
GECODE_ME_CHECK(b.zero_none(home));
return home.ES_SUBSUMED(*this);
}
// check glb(x1) subset lub(x0)
GlbRanges<View1> x1lb(x1);
LubRanges<View0> x0ub(x0);
Iter::Ranges::Diff<GlbRanges<View1>, LubRanges<View0> > diff2(x1lb, x0ub);
if ( diff2() ) {
GECODE_ME_CHECK(b.zero_none(home));
return home.ES_SUBSUMED(*this);
}
return ES_FIX;
}
int main ()
{
REAL res;
REAL tol = 1E-5;
//Testing central diff
printf("Central diff\n");
res = diff(1, *x1);
assert(is_equal(1, res, tol));
printf("%.8f \n", res);
res = diff(1, *x3x2);
assert(is_equal(5, res, tol));
printf("%.8f \n", res);
//Testing forward diff
printf("Forward diff\n");
res = diff_forward(1, x1(1), *x1);
assert(is_equal(1, res, tol));
printf("%.8f \n", res);
res = diff_forward(1, x3x2(1), *x3x2);
assert(is_equal(5, res, tol));
printf("%.8f \n", res);
//Testing backward diff
printf("Backward diff\n");
res = diff_backward(1, 1, *x1);
assert(is_equal(1, res, tol));
printf("%.8f \n", res);
res = diff_backward(1, 2, *x3x2);
assert(is_equal(5, res, tol));
printf("%.8f \n", res);
//Testing central diff2
printf("Central diff2\n");
res = diff2(1, 1, *x1);
assert(is_equal(0, res, tol));
printf("%.8f \n", res);
res = diff2(1, 2, *x3x2);
assert(is_equal(8.0, res, 0.01));
printf("%.8f \n", res);
//Testing PNRB
printf("Root by PNRB\n");
res = PNRB(1513123.131533, *x1_0001);
assert(is_equal(1E-4, res, tol));
printf("%.8f \n", res);
res = PNRB(1514563.123124, *x2_0025);
assert(is_equal(0.0005, res, tol));
printf("%.8f \n", res);
return 0;
}
KDevelop::VcsJob* KDevSvnPlugin::diff(const QUrl &fileOrDirectory,
const KDevelop::VcsRevision& srcRevision,
const KDevelop::VcsRevision& dstRevision,
KDevelop::VcsDiff::Type diffType,
KDevelop::IBasicVersionControl::RecursionMode recurse)
{
KDevelop::VcsLocation loc(fileOrDirectory);
return diff2(loc, loc, srcRevision, dstRevision, diffType, recurse);
}
void
CMathGeom3D::
FaceNormal(const CPoint3D &point1, const CPoint3D &point2,
const CPoint3D &point3, CNPlane3D &normal)
{
CVector3D diff1(point1, point2);
CVector3D diff2(point2, point3);
normal.setDirection(CVector3D::crossProduct(diff1, diff2));
normal.setScalar(CVector3D::dotProduct(normal.getDirection(), point1.x, point1.y, point1.z));
}
void
CMathGeom3D::
FaceNormal(double x1, double y1, double z1, double x2, double y2, double z2,
double x3, double y3, double z3, CNPlane3D &normal)
{
CVector3D diff1(x2 - x1, y2 - y1, z2 - z1);
CVector3D diff2(x3 - x2, y3 - y2, z3 - z2);
normal.setDirection(CVector3D::crossProduct(diff1, diff2));
normal.setScalar(CVector3D::dotProduct(normal.getDirection(), x1, y1, z1));
}
void TestHeatEquation()
{
ChastePoint<1> zero1(0);
ChastePoint<2> zero2(0,0);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
HeatEquation<1> pde1;
HeatEquation<2> pde2;
HeatEquation<3> pde3;
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde1.ComputeDuDtCoefficientFunction(zero1), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeDuDtCoefficientFunction(zero2), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeDuDtCoefficientFunction(zero3), 1.0, 1e-12);
// Diffusion matrices should be equal to identity
c_matrix<double, 1, 1> diff1 = pde1.ComputeDiffusionTerm(zero1);
c_matrix<double, 2, 2> diff2 = pde2.ComputeDiffusionTerm(zero2);
c_matrix<double, 3, 3> diff3 = pde3.ComputeDiffusionTerm(zero3);
TS_ASSERT_DELTA(diff1(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff3(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff3(2,2), 1, 1e-12);
TS_ASSERT_DELTA(diff3(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,2), 0, 1e-12);
TS_ASSERT_DELTA(diff3(1,2), 0, 1e-12);
Node<1> node(0, zero1);
TS_ASSERT_DELTA(pde1.ComputeSourceTermAtNode(node,u), 0.0, 1e-12);
}
void csWaterDemo::generateNormals ()
{
csVector3 *vbuf = gFactState->GetVertices ();
csVector3 *nbuf = gFactState->GetNormals ();
csColor *cbuf = gFactState->GetColors ();
csTriangle *ibuf = gFactState->GetTriangles ();
int numVerts = gFactState->GetVertexCount ();
int numTris = gFactState->GetTriangleCount ();
int i;
//zeroout the normals
for(i=0;i<numVerts;i++)
{
nbuf[i] = csVector3(0,0,0);
}
//accumulate facenormals
for(i=0;i<numTris;i++)
{
int a, b, c;
a=ibuf[i].a;
b=ibuf[i].b;
c=ibuf[i].c;
csVector3 v0(vbuf[a]);
csVector3 v1(vbuf[b]);
csVector3 v2(vbuf[c]);
csVector3 diff1 (v2-v1);
csVector3 diff2 (v0-v1);
csVector3 n = diff1 % diff2;
nbuf[a] += n;
nbuf[b] += n;
nbuf[c] += n;
}
//normalize
for(i=0;i<numVerts;i++)
{
nbuf[i].Normalize ();
cbuf[i].red = nbuf[i].x;
cbuf[i].green = nbuf[i].y;
cbuf[i].blue = nbuf[i].z;
}
}
ExecStatus
ElementUnion<SView,RView>::propagate(Space& home, const ModEventDelta&) {
Region r(home);
int n = iv.size();
bool loopVar;
do {
loopVar = false;
// Cache the upper bound iterator, as we have to
// modify the upper bound while iterating
LubRanges<RView> x1ub(x1);
Iter::Ranges::Cache<LubRanges<RView> > x1ubc(r,x1ub);
Iter::Ranges::ToValues<Iter::Ranges::Cache<LubRanges<RView> > >
vx1ub(x1ubc);
GlbRanges<RView> x1lb(x1);
Iter::Ranges::Cache<GlbRanges<RView> > x1lbc(r,x1lb);
Iter::Ranges::ToValues<Iter::Ranges::Cache<GlbRanges<RView> > >
vx1(x1lbc);
// In the first iteration, compute in before[i] the union
// of all the upper bounds of the x_i. At the same time,
// exclude inconsistent x_i from x1 and remove them from
// the list, cancel their dependencies.
GLBndSet sofarBefore(home);
LUBndSet selectedInter(home, IntSet (Limits::min,
Limits::max));
GLBndSet* before =
static_cast<GLBndSet*>(r.ralloc(sizeof(GLBndSet)*n));
int j = 0;
int i = 0;
unsigned int maxCard = 0;
unsigned int minCard = Limits::card;
while ( vx1ub() ) {
// Remove vars at indices not in the upper bound
if (iv[i].idx < vx1ub.val()) {
iv[i].view.cancel(home,*this, PC_SET_ANY);
++i;
continue;
}
assert(iv[i].idx == vx1ub.val());
iv[j] = iv[i];
SView candidate = iv[j].view;
int candidateInd = iv[j].idx;
// inter = glb(candidate) & complement(lub(x0))
GlbRanges<SView> candlb(candidate);
LubRanges<SView> x0ub(x0);
Iter::Ranges::Diff<GlbRanges<SView>,
LubRanges<SView> > diff(candlb, x0ub);
bool selectSingleInconsistent = false;
if (x1.cardMax() <= 1) {
GlbRanges<SView> x0lb(x0);
LubRanges<SView> candub(candidate);
Iter::Ranges::Diff<GlbRanges<SView>,
LubRanges<SView> > diff2(x0lb, candub);
selectSingleInconsistent = diff2() || candidate.cardMax() < x0.cardMin();
}
// exclude inconsistent x_i
// an x_i is inconsistent if
// * at most one x_i can be selected and there are
// elements in x_0 that can't be in x_i
// (selectSingleInconsistent)
// * its min cardinality is greater than maxCard of x0
// * inter is not empty (there are elements in x_i
// that can't be in x_0)
if (selectSingleInconsistent ||
candidate.cardMin() > x0.cardMax() ||
diff()) {
ModEvent me = (x1.exclude(home,candidateInd));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
iv[j].view.cancel(home,*this, PC_SET_ANY);
++i;
++vx1ub;
continue;
} else {
// if x_i is consistent, check whether we know
// that its index is in x1
if (vx1() && vx1.val()==candidateInd) {
// x0 >= candidate, candidate <= x0
GlbRanges<SView> candlb(candidate);
ModEvent me = x0.includeI(home,candlb);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
LubRanges<SView> x0ub(x0);
me = candidate.intersectI(home,x0ub);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
++vx1;
}
new (&before[j]) GLBndSet(home);
before[j].update(home,sofarBefore);
LubRanges<SView> cub(candidate);
sofarBefore.includeI(home,cub);
GlbRanges<SView> clb(candidate);
selectedInter.intersectI(home,clb);
maxCard = std::max(maxCard, candidate.cardMax());
minCard = std::min(minCard, candidate.cardMin());
}
++vx1ub;
++i; ++j;
}
// cancel the variables with index greater than
// max of lub(x1)
for (int k=i; k<n; k++) {
iv[k].view.cancel(home,*this, PC_SET_ANY);
}
n = j;
iv.size(n);
if (x1.cardMax()==0) {
// Selector is empty, hence the result must be empty
{
GECODE_ME_CHECK(x0.cardMax(home,0));
}
for (int i=n; i--;)
before[i].dispose(home);
return home.ES_SUBSUMED(*this);
}
if (x1.cardMin() > 0) {
// Selector is not empty, hence the intersection of the
// possibly selected lower bounds is contained in x0
BndSetRanges si(selectedInter);
ModEvent me = x0.includeI(home, si);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
me = x0.cardMin(home, minCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
selectedInter.dispose(home);
if (x1.cardMax() <= 1) {
ModEvent me = x0.cardMax(home, maxCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
{
// x0 <= sofarBefore
BndSetRanges sfB(sofarBefore);
ModEvent me = x0.intersectI(home,sfB);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
sofarBefore.dispose(home);
GLBndSet sofarAfter(home);
// In the second iteration, this time backwards, compute
// sofarAfter as the union of all lub(x_j) with j>i
for (int i=n; i--;) {
// TODO: check for size of universe here?
// if (sofarAfter.size() == 0) break;
// extra = inter(before[i], sofarAfter) - lub(x0)
BndSetRanges b(before[i]);
BndSetRanges s(sofarAfter);
GlbRanges<SView> x0lb(x0);
Iter::Ranges::Union<BndSetRanges, BndSetRanges> inter(b,s);
Iter::Ranges::Diff<GlbRanges<SView>,
Iter::Ranges::Union<BndSetRanges,BndSetRanges> > diff(x0lb, inter);
if (diff()) {
ModEvent me = (x1.include(home,iv[i].idx));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
// candidate != extra
me = iv[i].view.includeI(home,diff);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
LubRanges<SView> iviub(iv[i].view);
sofarAfter.includeI(home,iviub);
before[i].dispose(home);
}
sofarAfter.dispose(home);
} while (loopVar);
// Test whether we determined x1 without determining x0
if (x1.assigned() && !x0.assigned()) {
int ubsize = static_cast<int>(x1.lubSize());
if (ubsize > 2) {
assert(ubsize==n);
ViewArray<SView> is(home,ubsize);
for (int i=n; i--;)
is[i]=iv[i].view;
GECODE_REWRITE(*this,(RelOp::UnionN<SView, SView>
::post(home(*this),is,x0)));
} else if (ubsize == 2) {
assert(n==2);
SView a = iv[0].view;
SView b = iv[1].view;
GECODE_REWRITE(*this,(RelOp::Union<SView, SView, SView>
::post(home(*this),a,b,x0)));
} else if (ubsize == 1) {
assert(n==1);
GECODE_REWRITE(*this,(Rel::Eq<SView,SView>::post(home(*this),x0,iv[0].view)));
} else {
GECODE_ME_CHECK(x0.cardMax(home, 0));
return home.ES_SUBSUMED(*this);
}
}
bool allAssigned = true;
for (int i=iv.size(); i--;) {
if (!iv[i].view.assigned()) {
allAssigned = false;
break;
}
}
if (x0.assigned() && x1.assigned() && allAssigned) {
return home.ES_SUBSUMED(*this);
}
return ES_FIX;
}
TEST(WorldDiff, SetWorld)
{
collision_detection::WorldPtr world1(new collision_detection::World);
collision_detection::WorldPtr world2(new collision_detection::World);
collision_detection::WorldDiff diff1(world1);
collision_detection::WorldDiff diff1b(world1);
collision_detection::WorldDiff diff2(world2);
collision_detection::WorldDiff::const_iterator it;
shapes::ShapePtr ball(new shapes::Sphere(1.0));
shapes::ShapePtr box(new shapes::Box(1,2,3));
shapes::ShapePtr cyl(new shapes::Cylinder(4,5));
world1->addToObject("objA1",
ball,
Eigen::Affine3d::Identity());
world1->addToObject("objA2",
ball,
Eigen::Affine3d::Identity());
world1->addToObject("objA3",
ball,
Eigen::Affine3d::Identity());
world2->addToObject("objB1",
box,
Eigen::Affine3d::Identity());
world2->addToObject("objB2",
box,
Eigen::Affine3d::Identity());
world2->addToObject("objB3",
box,
Eigen::Affine3d::Identity());
EXPECT_EQ(3, diff1.getChanges().size());
EXPECT_EQ(3, diff1b.getChanges().size());
EXPECT_EQ(3, diff2.getChanges().size());
diff1b.clearChanges();
EXPECT_EQ(3, diff1.getChanges().size());
EXPECT_EQ(0, diff1b.getChanges().size());
EXPECT_EQ(3, diff2.getChanges().size());
diff1.setWorld(world2);
EXPECT_EQ(6, diff1.getChanges().size());
EXPECT_EQ(0, diff1b.getChanges().size());
EXPECT_EQ(3, diff2.getChanges().size());
it = diff1.getChanges().find("objA1");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1.getChanges().find("objA2");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1.getChanges().find("objA2");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1.getChanges().find("objB1");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
it = diff1.getChanges().find("objB2");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
it = diff1.getChanges().find("objB3");
EXPECT_NE(diff1.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
diff1b.setWorld(world2);
EXPECT_EQ(6, diff1.getChanges().size());
EXPECT_EQ(6, diff1b.getChanges().size());
EXPECT_EQ(3, diff2.getChanges().size());
it = diff1b.getChanges().find("objA1");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1b.getChanges().find("objA2");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1b.getChanges().find("objA2");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::DESTROY,
it->second);
it = diff1b.getChanges().find("objB1");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
it = diff1b.getChanges().find("objB2");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
it = diff1b.getChanges().find("objB3");
EXPECT_NE(diff1b.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE,
it->second);
world1->addToObject("objC",
box,
Eigen::Affine3d::Identity());
EXPECT_EQ(6, diff1.getChanges().size());
EXPECT_EQ(6, diff1b.getChanges().size());
EXPECT_EQ(3, diff2.getChanges().size());
world2->addToObject("objC",
box,
Eigen::Affine3d::Identity());
EXPECT_EQ(7, diff1.getChanges().size());
EXPECT_EQ(7, diff1b.getChanges().size());
EXPECT_EQ(4, diff2.getChanges().size());
diff2.setWorld(world1);
EXPECT_EQ(7, diff1.getChanges().size());
EXPECT_EQ(7, diff1b.getChanges().size());
EXPECT_EQ(7, diff2.getChanges().size());
it = diff2.getChanges().find("objC");
EXPECT_NE(diff2.end(), it);
EXPECT_EQ(collision_detection::World::CREATE |
collision_detection::World::ADD_SHAPE |
collision_detection::World::DESTROY,
it->second);
world1->addToObject("objD",
box,
Eigen::Affine3d::Identity());
EXPECT_EQ(7, diff1.getChanges().size());
EXPECT_EQ(7, diff1b.getChanges().size());
EXPECT_EQ(8, diff2.getChanges().size());
world2->addToObject("objE",
box,
Eigen::Affine3d::Identity());
EXPECT_EQ(8, diff1.getChanges().size());
EXPECT_EQ(8, diff1b.getChanges().size());
EXPECT_EQ(8, diff2.getChanges().size());
}
void TestHeatEquationWithElementDependentSourceTerm()
{
// The PDE is set to give elements with index = 0 a source of zero
// and a source of 1 otherwise.
std::vector<Node<1>*> one_d_nodes;
one_d_nodes.push_back(new Node<1>(0, false, 2.0));
one_d_nodes.push_back(new Node<1>(1, false, 2.5));
Element<1,1> one_d_element(0u, one_d_nodes);
ChastePoint<1> zero1(0);
std::vector<Node<2>*> two_d_nodes;
two_d_nodes.push_back(new Node<2>(0, false, 0.0, 0.0));
two_d_nodes.push_back(new Node<2>(1, false, 1.0, 0.0));
two_d_nodes.push_back(new Node<2>(2, false, 0.0, 1.0));
Element<2,2> two_d_element(0u, two_d_nodes);
ChastePoint<2> zero2(0,0);
std::vector<Node<3>*> three_d_nodes;
three_d_nodes.push_back(new Node<3>(0, false, 0.0, 0.0, 0.0));
three_d_nodes.push_back(new Node<3>(1, false, 1.0, 0.0, 0.0));
three_d_nodes.push_back(new Node<3>(2, false, 0.0, 1.0, 0.0));
three_d_nodes.push_back(new Node<3>(3, false, 0.0, 0.0, 1.0));
Element<3,3> three_d_element(0u, three_d_nodes);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
HeatEquationWithElementDependentSourceTerm<1> pde1;
HeatEquationWithElementDependentSourceTerm<2> pde2;
HeatEquationWithElementDependentSourceTerm<3> pde3;
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1, u, &one_d_element), 0.0, 1e-12);
one_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1, u, &one_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2, u, &two_d_element), 0.0, 1e-12);
two_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2, u, &two_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3, u, &three_d_element), 0.0, 1e-12);
three_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3, u, &three_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde1.ComputeDuDtCoefficientFunction(zero1), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeDuDtCoefficientFunction(zero2), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeDuDtCoefficientFunction(zero3), 1.0, 1e-12);
// Diffusion matrices should be equal to identity
c_matrix<double, 1, 1> diff1 = pde1.ComputeDiffusionTerm(zero1);
c_matrix<double, 2, 2> diff2 = pde2.ComputeDiffusionTerm(zero2);
c_matrix<double, 3, 3> diff3 = pde3.ComputeDiffusionTerm(zero3);
TS_ASSERT_DELTA(diff1(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff3(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff3(2,2), 1, 1e-12);
TS_ASSERT_DELTA(diff3(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,2), 0, 1e-12);
TS_ASSERT_DELTA(diff3(1,2), 0, 1e-12);
delete one_d_nodes[0];
delete one_d_nodes[1];
delete two_d_nodes[0];
delete two_d_nodes[1];
delete two_d_nodes[2];
delete three_d_nodes[0];
delete three_d_nodes[1];
delete three_d_nodes[2];
delete three_d_nodes[3];
}
// divide and conquer algorithm of the sequencing
void CompNovoIdentificationCID::getDecompositionsDAC_(set<String> & sequences, Size left, Size right, DoubleReal peptide_weight, const PeakSpectrum & CID_spec, Map<DoubleReal, CompNovoIonScoringCID::IonScore> & ion_scores)
{
static DoubleReal oxonium_mass = EmpiricalFormula("H2O+").getMonoWeight();
DoubleReal offset_suffix(CID_spec[left].getPosition()[0] - oxonium_mass);
DoubleReal offset_prefix(peptide_weight - CID_spec[right].getPosition()[0]);
#ifdef DAC_DEBUG
static Int depth_(0);
++depth_;
String tabs_(depth_, '\t');
cerr << tabs_ << "void getDecompositionsDAC(sequences[" << sequences.size() << "], " << left << ", " << right << ") ";
cerr << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " diff=";
#endif
DoubleReal diff = CID_spec[right].getPosition()[0] - CID_spec[left].getPosition()[0];
#ifdef DAC_DEBUG
cerr << diff << endl;
cerr << "offset_prefix=" << offset_prefix << ", offset_suffix=" << offset_suffix << endl;
#endif
if (subspec_to_sequences_.has(left) && subspec_to_sequences_[left].has(right))
{
sequences = subspec_to_sequences_[left][right];
#ifdef DAC_DEBUG
depth_--;
cerr << tabs_ << "from cache DAC: " << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " " << sequences.size() << " " << left << " " << right << endl;
#endif
return;
}
// no further solutions possible?
if (diff < min_aa_weight_)
{
#ifdef DAC_DEBUG
depth_--;
#endif
return;
}
// no further division needed?
if (diff <= max_decomp_weight_)
{
vector<MassDecomposition> decomps;
// if we are at the C-terminus use precursor_mass_tolerance_
if (offset_prefix < precursor_mass_tolerance_)
{
Param decomp_param(mass_decomp_algorithm_.getParameters());
decomp_param.setValue("tolerance", precursor_mass_tolerance_);
mass_decomp_algorithm_.setParameters(decomp_param);
getDecompositions_(decomps, diff);
decomp_param.setValue("tolerance", fragment_mass_tolerance_);
mass_decomp_algorithm_.setParameters(decomp_param);
}
else
{
getDecompositions_(decomps, diff);
}
//filterDecomps_(decomps);
#ifdef DAC_DEBUG
cerr << tabs_ << "Found " << decomps.size() << " decomps" << endl;
cerr << tabs_ << "Permuting...";
#endif
//static Map<String, set<String> > permute_cache;
for (vector<MassDecomposition>::const_iterator it = decomps.begin(); it != decomps.end(); ++it)
{
#ifdef DAC_DEBUG
cerr << it->toString() << endl;
#endif
String exp_string = it->toExpandedString();
if (!permute_cache_.has(exp_string))
{
permute_("", exp_string, sequences);
permute_cache_[exp_string] = sequences;
}
else
{
sequences = permute_cache_[exp_string];
}
}
#ifdef DAC_DEBUG
cerr << tabs_ << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " " << peptide_weight << endl;
if (sequences.size() > max_subscore_number_)
{
cerr << tabs_ << "Reducing #sequences from " << sequences.size() << " to " << max_subscore_number_ << "(prefix=" << offset_prefix << ", suffix=" << offset_suffix << ")...";
}
#endif
// C-terminus
if (offset_suffix <= precursor_mass_tolerance_)
{
filterPermuts_(sequences);
}
// reduce the sequences
reducePermuts_(sequences, CID_spec, offset_prefix, offset_suffix);
#ifdef DAC_DEBUG
cerr << "Writing to cache " << left << " " << right << endl;
#endif
subspec_to_sequences_[left][right] = sequences;
#ifdef DAC_DEBUG
cerr << "ended" << endl;
cerr << tabs_ << "DAC: " << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " " << sequences.size() << endl;
depth_--;
#endif
return;
}
// select suitable pivot peaks
vector<Size> pivots;
if (offset_suffix < precursor_mass_tolerance_ && offset_prefix < precursor_mass_tolerance_)
{
selectPivotIons_(pivots, left, right, ion_scores, CID_spec, peptide_weight, true);
}
else
{
selectPivotIons_(pivots, left, right, ion_scores, CID_spec, peptide_weight, false);
}
// run divide step
#ifdef DAC_DEBUG
cerr << tabs_ << "Selected " << pivots.size() << " pivot ions: ";
for (vector<Size>::const_iterator it = pivots.begin(); it != pivots.end(); ++it)
{
cerr << *it << "(" << CID_spec[*it].getPosition()[0] << ") ";
}
cerr << endl;
#endif
for (vector<Size>::const_iterator it = pivots.begin(); it != pivots.end(); ++it)
{
set<String> seq1, seq2, new_sequences;
// the smaller the 'gap' the greater the chance of not finding anything
// so we we compute the smaller gap first
DoubleReal diff1(CID_spec[*it].getPosition()[0] - CID_spec[left].getPosition()[0]);
DoubleReal diff2(CID_spec[right].getPosition()[0] - CID_spec[*it].getPosition()[0]);
if (diff1 < diff2)
{
getDecompositionsDAC_(seq1, left, *it, peptide_weight, CID_spec, ion_scores);
if (seq1.empty())
{
#ifdef DAC_DEBUG
cerr << tabs_ << "first call produced 0 candidates (" << diff1 << ")" << endl;
#endif
continue;
}
getDecompositionsDAC_(seq2, *it, right, peptide_weight, CID_spec, ion_scores);
}
else
{
getDecompositionsDAC_(seq2, *it, right, peptide_weight, CID_spec, ion_scores);
if (seq2.empty())
{
#ifdef DAC_DEBUG
cerr << tabs_ << "second call produced 0 candidates (" << diff2 << ")" << endl;
#endif
continue;
}
getDecompositionsDAC_(seq1, left, *it, peptide_weight, CID_spec, ion_scores);
}
#ifdef DAC_DEBUG
cerr << tabs_ << "Found " << seq1.size() << " solutions (1) " << diff1 << endl;
cerr << tabs_ << "Found " << seq2.size() << " solutions (2) " << diff2 << endl;
cerr << tabs_ << "inserting " << seq1.size() * seq2.size() << " sequences" << endl;
#endif
// C-terminus
if (offset_suffix <= fragment_mass_tolerance_)
{
filterPermuts_(seq1);
}
// test if we found enough sequence candidates
if (seq1.empty() || seq2.empty())
{
continue;
}
for (set<String>::const_iterator it1 = seq1.begin(); it1 != seq1.end(); ++it1)
{
for (set<String>::const_iterator it2 = seq2.begin(); it2 != seq2.end(); ++it2)
{
new_sequences.insert(*it2 + *it1);
}
}
if (seq1.size() * seq2.size() > max_subscore_number_ /* && (offset_prefix > fragment_mass_tolerance_ || offset_suffix > fragment_mass_tolerance_)*/)
{
#ifdef DAC_DEBUG
cerr << tabs_ << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " " << peptide_weight << endl;
cerr << tabs_ << "Reducing #sequences from " << new_sequences.size() << " to " << max_subscore_number_ << "(prefix=" << offset_prefix << ", suffix=" << offset_suffix << ")...";
#endif
if (offset_prefix > precursor_mass_tolerance_ || offset_suffix > precursor_mass_tolerance_)
{
reducePermuts_(new_sequences, CID_spec, offset_prefix, offset_suffix);
}
#ifdef DAC_DEBUG
for (set<String>::const_iterator it1 = new_sequences.begin(); it1 != new_sequences.end(); ++it1)
{
cerr << tabs_ << *it1 << endl;
}
cerr << endl;
#endif
}
for (set<String>::const_iterator sit = new_sequences.begin(); sit != new_sequences.end(); ++sit)
{
sequences.insert(*sit);
}
}
#ifdef DAC_DEBUG
cerr << tabs_ << "Found sequences for " << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << endl;
for (set<String>::const_iterator sit = sequences.begin(); sit != sequences.end(); ++sit)
{
cerr << tabs_ << *sit << endl;
}
#endif
// reduce the permuts once again to reduce complexity
if (offset_prefix > precursor_mass_tolerance_ || offset_suffix > precursor_mass_tolerance_)
{
reducePermuts_(sequences, CID_spec, offset_prefix, offset_suffix);
}
#ifdef DAC_DEBUG
cerr << "Writing to cache " << left << " " << right << endl;
#endif
subspec_to_sequences_[left][right] = sequences;
#ifdef DAC_DEBUG
depth_--;
cerr << tabs_ << "DAC: " << CID_spec[left].getPosition()[0] << " " << CID_spec[right].getPosition()[0] << " " << sequences.size() << endl;
#endif
return;
}
ExecStatus
ElementUnionConst<SView,RView>::propagate(Space& home, const ModEventDelta&) {
Region r(home);
bool* stillSelected = r.alloc<bool>(n_iv);
bool loopVar;
do {
loopVar = false;
for (int i=n_iv; i--;)
stillSelected[i] = false;
// Cache the upper bound iterator, as we have to
// modify the upper bound while iterating
LubRanges<RView> x1ub(x1);
Iter::Ranges::Cache x1ubc(r,x1ub);
Iter::Ranges::ToValues<Iter::Ranges::Cache>
vx1ub(x1ubc);
GlbRanges<RView> x1lb(x1);
Iter::Ranges::Cache x1lbc(r,x1lb);
Iter::Ranges::ToValues<Iter::Ranges::Cache>
vx1(x1lbc);
// In the first iteration, compute in before[i] the union
// of all the upper bounds of the x_i. At the same time,
// exclude inconsistent x_i from x1.
GLBndSet sofarBefore(home);
LUBndSet selectedInter(home, IntSet (Limits::min,
Limits::max));
GLBndSet* before =
static_cast<GLBndSet*>(r.ralloc(sizeof(GLBndSet)*n_iv));
unsigned int maxCard = 0;
unsigned int minCard = Limits::card;
while (vx1ub()) {
int i = vx1ub.val();
IntSetRanges candCardR(iv[i]);
unsigned int candidateCard = Iter::Ranges::size(candCardR);
IntSetRanges candlb(iv[i]);
LubRanges<SView> x0ub(x0);
Iter::Ranges::Diff<IntSetRanges,
LubRanges<SView> > diff(candlb, x0ub);
bool selectSingleInconsistent = false;
if (x1.cardMax() <= 1) {
GlbRanges<SView> x0lb(x0);
IntSetRanges candub(iv[i]);
Iter::Ranges::Diff<GlbRanges<SView>,
IntSetRanges > diff2(x0lb, candub);
selectSingleInconsistent = diff2() || candidateCard < x0.cardMin();
}
// exclude inconsistent x_i
// an x_i is inconsistent if
// * at most one x_i can be selected and there are
// elements in x_0 that can't be in x_i
// (selectSingleInconsistent)
// * its min cardinality is greater than maxCard of x0
// * inter is not empty (there are elements in x_i
// that can't be in x_0)
if (selectSingleInconsistent ||
candidateCard > x0.cardMax() ||
diff()) {
ModEvent me = (x1.exclude(home,i));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
} else {
stillSelected[i] = true;
// if x_i is consistent, check whether we know
// that its index is in x1
if (vx1() && vx1.val()==i) {
// x0 >= candidate, candidate <= x0
// GlbRanges<SView> candlb(candidate);
IntSetRanges candlb(iv[i]);
ModEvent me = x0.includeI(home,candlb);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
++vx1;
}
new (&before[i]) GLBndSet(home);
before[i].update(home,sofarBefore);
IntSetRanges cub(iv[i]);
sofarBefore.includeI(home,cub);
IntSetRanges clb(iv[i]);
selectedInter.intersectI(home,clb);
maxCard = std::max(maxCard, candidateCard);
minCard = std::min(minCard, candidateCard);
}
++vx1ub;
}
if (x1.cardMax()==0) {
// Selector is empty, hence the result must be empty
{
GECODE_ME_CHECK(x0.cardMax(home,0));
}
for (int i=n_iv; i--;)
if (stillSelected[i])
before[i].dispose(home);
selectedInter.dispose(home);
sofarBefore.dispose(home);
return home.ES_SUBSUMED(*this);
}
if (x1.cardMin() > 0) {
// Selector is not empty, hence the intersection of the
// possibly selected lower bounds is contained in x0
BndSetRanges si(selectedInter);
ModEvent me = x0.includeI(home, si);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
me = x0.cardMin(home, minCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
selectedInter.dispose(home);
if (x1.cardMax() <= 1) {
ModEvent me = x0.cardMax(home, maxCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
{
// x0 <= sofarBefore
BndSetRanges sfB(sofarBefore);
ModEvent me = x0.intersectI(home,sfB);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
sofarBefore.dispose(home);
GLBndSet sofarAfter(home);
// In the second iteration, this time backwards, compute
// sofarAfter as the union of all lub(x_j) with j>i
for (int i=n_iv; i--;) {
if (!stillSelected[i])
continue;
BndSetRanges b(before[i]);
BndSetRanges s(sofarAfter);
GlbRanges<SView> x0lb(x0);
Iter::Ranges::Union<BndSetRanges, BndSetRanges> inter(b,s);
Iter::Ranges::Diff<GlbRanges<SView>,
Iter::Ranges::Union<BndSetRanges,BndSetRanges> > diff(x0lb, inter);
if (diff()) {
ModEvent me = (x1.include(home,i));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
// candidate != extra
IntSetRanges ivi(iv[i]);
if (!Iter::Ranges::subset(diff, ivi))
GECODE_ME_CHECK(ME_SET_FAILED);
}
IntSetRanges iviub(iv[i]);
sofarAfter.includeI(home,iviub);
before[i].dispose(home);
}
sofarAfter.dispose(home);
} while (loopVar);
if (x1.assigned()) {
assert(x0.assigned());
return home.ES_SUBSUMED(*this);
}
return ES_FIX;
}
void CudaConjugateGradientSolver::solve(void * X,
CudaCSRMatrix * A,
void * fixed,
float * error)
{
// cglg.writeVec3(m_rhs, m_dimension, "cg b", CudaDbgLog::FAlways);
//cglg.writeMat33(A->valueBuf(),
// A->numNonZero(),
// " cg A ", CudaDbgLog::FAlways);
cuConjugateGradient_prevresidual((float3 *)previous(),
(float3 *)residual(),
(mat33 *)A->deviceValue(),
(uint *)A->deviceRowPtr(),
(uint *)A->deviceColInd(),
(uint *)fixed,
(float3 *)X,
(float3 *)rightHandSide(),
m_dimension);
for(int i=0; i<FemGlobal::CGSolverMaxNumIterations; i++) {
cuConjugateGradient_Ax((float3 *)previous(),
(float3 *)updated(),
(float3 *)residual(),
(float *)diff(),
(float *)diff2(),
(mat33 *)A->deviceValue(),
(uint *)A->deviceRowPtr(),
(uint *)A->deviceColInd(),
(uint *)fixed,
m_dimension);
float d =0;
float d2=0;
m_reduce->sum<float>(d, (float *)diff(), m_dimension);
m_reduce->sum<float>(d2, (float *)diff2(), m_dimension);
if(fabs(d2)< 1e-10f)
d2 = 1e-10f;
float d3 = d/d2;
cuConjugateGradient_addX((float3 *)X,
(float3 *)residual(),
(float *)diff(),
(float3 *)previous(),
(float3 *)updated(),
d3,
(uint *)fixed,
m_dimension);
float d1 = 0.f;
m_reduce->sum<float>(d1, (float *)diff(), m_dimension);
if(error) *error = d1;
if(d1 < 0.01f)
break;
if(fabs(d)<1e-10f)
d = 1e-10f;
float d4 = d1/d;
cuConjugateGradient_addResidual((float3 *)previous(),
(float3 *)residual(),
d4,
(uint *)fixed,
m_dimension);
}
}
void QgsGeometryOverlapCheck::fixError( QgsGeometryCheckError *error, int method, const QMap<QString, int> & /*mergeAttributeIndices*/, Changes &changes ) const
{
QString errMsg;
QgsGeometryOverlapCheckError *overlapError = static_cast<QgsGeometryOverlapCheckError *>( error );
QgsFeaturePool *featurePoolA = mContext->featurePools[ overlapError->layerId() ];
QgsFeaturePool *featurePoolB = mContext->featurePools[ overlapError->overlappedFeature().first ];
QgsFeature featureA;
QgsFeature featureB;
if ( !featurePoolA->get( overlapError->featureId(), featureA ) ||
!featurePoolB->get( overlapError->overlappedFeature().second, featureB ) )
{
error->setObsolete();
return;
}
// Check if error still applies
QgsGeometryCheckerUtils::LayerFeature layerFeatureA( featurePoolA, featureA, true );
QgsGeometryCheckerUtils::LayerFeature layerFeatureB( featurePoolB, featureB, true );
std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureA.geometry(), mContext->reducedTolerance );
if ( !geomEngineA->overlaps( layerFeatureB.geometry() ) )
{
error->setObsolete();
return;
}
std::unique_ptr< QgsAbstractGeometry > interGeom( geomEngineA->intersection( layerFeatureB.geometry(), &errMsg ) );
if ( !interGeom )
{
error->setFixFailed( tr( "Failed to compute intersection between overlapping features: %1" ).arg( errMsg ) );
return;
}
// Search which overlap part this error parametrizes (using fuzzy-matching of the area and centroid...)
QgsAbstractGeometry *interPart = nullptr;
for ( int iPart = 0, nParts = interGeom->partCount(); iPart < nParts; ++iPart )
{
QgsAbstractGeometry *part = QgsGeometryCheckerUtils::getGeomPart( interGeom.get(), iPart );
if ( std::fabs( part->area() - overlapError->value().toDouble() ) < mContext->reducedTolerance &&
QgsGeometryCheckerUtils::pointsFuzzyEqual( part->centroid(), overlapError->location(), mContext->reducedTolerance ) )
{
interPart = part;
break;
}
}
if ( !interPart || interPart->isEmpty() )
{
error->setObsolete();
return;
}
// Fix error
if ( method == NoChange )
{
error->setFixed( method );
}
else if ( method == Subtract )
{
std::unique_ptr< QgsAbstractGeometry > diff1( geomEngineA->difference( interPart, &errMsg ) );
if ( !diff1 || diff1->isEmpty() )
{
diff1.reset();
}
else
{
QgsGeometryCheckerUtils::filter1DTypes( diff1.get() );
}
std::unique_ptr< QgsGeometryEngine > geomEngineB = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureB.geometry(), mContext->reducedTolerance );
std::unique_ptr< QgsAbstractGeometry > diff2( geomEngineB->difference( interPart, &errMsg ) );
if ( !diff2 || diff2->isEmpty() )
{
diff2.reset();
}
else
{
QgsGeometryCheckerUtils::filter1DTypes( diff2.get() );
}
double shared1 = diff1 ? QgsGeometryCheckerUtils::sharedEdgeLength( diff1.get(), interPart, mContext->reducedTolerance ) : 0;
double shared2 = diff2 ? QgsGeometryCheckerUtils::sharedEdgeLength( diff2.get(), interPart, mContext->reducedTolerance ) : 0;
if ( !diff1 || !diff2 || shared1 == 0. || shared2 == 0. )
{
error->setFixFailed( tr( "Could not find shared edges between intersection and overlapping features" ) );
}
else
{
if ( shared1 < shared2 )
{
diff1->transform( featurePoolA->getLayerToMapTransform(), QgsCoordinateTransform::ReverseTransform );
featureA.setGeometry( QgsGeometry( std::move( diff1 ) ) );
changes[error->layerId()][featureA.id()].append( Change( ChangeFeature, ChangeChanged ) );
featurePoolA->updateFeature( featureA );
}
else
{
diff2->transform( featurePoolB->getLayerToMapTransform(), QgsCoordinateTransform::ReverseTransform );
featureB.setGeometry( QgsGeometry( std::move( diff2 ) ) );
changes[overlapError->overlappedFeature().first][featureB.id()].append( Change( ChangeFeature, ChangeChanged ) );
featurePoolB->updateFeature( featureB );
}
error->setFixed( method );
}
}
else
{
error->setFixFailed( tr( "Unknown method" ) );
}
}
ExecStatus
SuperOfInter<View0,View1,View2>::propagate(Space& home, const ModEventDelta& med) {
bool allassigned = x0.assigned() && x1.assigned() && x2.assigned();
ModEvent me0 = View0::me(med);
ModEvent me1 = View1::me(med);
ModEvent me2 = View2::me(med);
bool modified = false;
do {
// glb(x2) >= glb(x0) ^ glb(x1)
if ( modified || Rel::testSetEventLB(me0,me1)) {
GlbRanges<View0> lb0(x0);
GlbRanges<View1> lb1(x1);
Iter::Ranges::Inter<GlbRanges<View0>,GlbRanges<View1> >
is(lb0, lb1);
GECODE_ME_CHECK_MODIFIED(modified,x2.includeI(home,is));
}
// lub(x0) -= glb(x1)-lub(x2)
// lub(x1) -= glb(x0)-lub(x2)
if ( modified || Rel::testSetEventAnyB(me0,me1,me2)) {
modified = false;
GlbRanges<View1> lb12(x1);
LubRanges<View2> ub22(x2);
Iter::Ranges::Diff<GlbRanges<View1>, LubRanges<View2> >
diff1(lb12, ub22);
GECODE_ME_CHECK_MODIFIED(modified, x0.excludeI(home,diff1));
GlbRanges<View0> lb01(x0);
LubRanges<View2> ub23(x2);
Iter::Ranges::Diff<GlbRanges<View0>, LubRanges<View2> >
diff2(lb01, ub23);
GECODE_ME_CHECK_MODIFIED(modified, x1.excludeI(home,diff2));
} else {
modified = false;
}
// Cardinality propagation
if ( modified ||
Rel::testSetEventCard(me0,me1,me2) ||
Rel::testSetEventUB(me0,me1)
) {
LubRanges<View0> ub0(x0);
LubRanges<View1> ub1(x1);
Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u(ub0,ub1);
unsigned int m = Iter::Ranges::size(u);
if (m < x0.cardMin() + x1.cardMin()) {
GECODE_ME_CHECK_MODIFIED(modified,
x2.cardMin( home,
x0.cardMin()+x1.cardMin() - m ) );
}
if (m + x2.cardMax() > x1.cardMin()) {
GECODE_ME_CHECK_MODIFIED(modified,
x0.cardMax( home,
m+x2.cardMax()-x1.cardMin() ) );
}
if (m + x2.cardMax() > x0.cardMin()) {
GECODE_ME_CHECK_MODIFIED(modified,
x1.cardMax( home,
m+x2.cardMax()-x0.cardMin() ) );
}
}
} while (modified);
if (shared(x0,x1,x2)) {
if (allassigned) {
return home.ES_SUBSUMED(*this);
} else {
return ES_NOFIX;
}
} else {
if (x0.assigned() + x1.assigned() + x2.assigned() >= 2) {
return home.ES_SUBSUMED(*this);
} else {
return ES_FIX;
}
}
}
void
CartesianCellDoubleConservativeLinearRefine::refine(
hier::Patch& fine,
const hier::Patch& coarse,
const int dst_component,
const int src_component,
const hier::Box& fine_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, fine_box, ratio);
std::shared_ptr<pdat::CellData<double> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
coarse.getPatchData(src_component)));
std::shared_ptr<pdat::CellData<double> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
fine.getPatchData(dst_component)));
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Box cgbox(cdata->getGhostBox());
const hier::Index& cilo = cgbox.lower();
const hier::Index& cihi = cgbox.upper();
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
TBOX_ASSERT(cgeom);
TBOX_ASSERT(fgeom);
const hier::Box coarse_box = hier::Box::coarsen(fine_box, ratio);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
const hier::Index& ifirstf = fine_box.lower();
const hier::Index& ilastf = fine_box.upper();
const hier::IntVector tmp_ghosts(dim, 0);
std::vector<double> diff0(cgbox.numberCells(0) + 1);
pdat::CellData<double> slope0(cgbox, 1, tmp_ghosts);
for (int d = 0; d < fdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartclinrefcelldoub1d, CARTCLINREFCELLDOUB1D) (ifirstc(0),
ilastc(0),
ifirstf(0), ilastf(0),
cilo(0), cihi(0),
filo(0), fihi(0),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer());
} else if ((dim == tbox::Dimension(2))) {
std::vector<double> diff1(cgbox.numberCells(1) + 1);
pdat::CellData<double> slope1(cgbox, 1, tmp_ghosts);
SAMRAI_F77_FUNC(cartclinrefcelldoub2d, CARTCLINREFCELLDOUB2D) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer(),
&diff1[0], slope1.getPointer());
} else if ((dim == tbox::Dimension(3))) {
std::vector<double> diff1(cgbox.numberCells(1) + 1);
pdat::CellData<double> slope1(cgbox, 1, tmp_ghosts);
std::vector<double> diff2(cgbox.numberCells(2) + 1);
pdat::CellData<double> slope2(cgbox, 1, tmp_ghosts);
SAMRAI_F77_FUNC(cartclinrefcelldoub3d, CARTCLINREFCELLDOUB3D) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer(),
&diff1[0], slope1.getPointer(),
&diff2[0], slope2.getPointer());
} else {
TBOX_ERROR("CartesianCellDoubleConservativeLinearRefine error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
