QPointF intersects(const LineWrapper &other)/* const */{
KisVector2D n0 = m_lineEquation.normal();
KisVector2D n1 = other.m_lineEquation.normal();
// Ensure vectors have the same direction
if((n0(0) > 0) != (n1(0) > 0)) {
n1 = -n1;
}
if(qFuzzyCompare(n0(0), n1(0)) &&
qFuzzyCompare(n0(1), n1(1))) {
const KisVector2D nearPoint(0,0);
const KisVector2D farPoint(1e10,1e10);
KisVector2D otherPt = other.m_lineEquation.projection(nearPoint);
KisVector2D otherPtProj = m_lineEquation.projection(otherPt);
KisVector2D newOffset = otherPt + 0.5 * (otherPtProj - otherPt);
LineEquation tempLine(n0, newOffset);
// Just throw it somewhere towards infinity...
return toQPointF(tempLine.projection(farPoint));
}
return toQPointF(m_lineEquation.intersection(other.m_lineEquation));
}
int main(int argc, char const *argv[])
{
// 0
// / \
// 1 2
// / \ \
// 3 4 7
// \ /
// 5 8
// \
// 6
TreeNode<int> n0(0);
TreeNode<int> n1(1);
TreeNode<int> n2(2);
TreeNode<int> n3(3);
TreeNode<int> n4(4);
TreeNode<int> n5(5);
TreeNode<int> n6(6);
TreeNode<int> n7(7);
TreeNode<int> n8(8);
n0.left = &n1;
n0.right = &n2;
n1.left = &n3;
n1.right = &n4;
n4.right = &n5;
n5.right = &n6;
n2.right = &n7;
n7.left = &n8;
bool* matrix = solve(&n0);
delete[] matrix;
return 0;
}
// Computes the point where three planes intersect. Returns whether or not the point exists.
static inline bool PlaneIntersection( SVector3* intersectPt, const SPlane& p0, const SPlane& p1, const SPlane& p2 )
{
SVector3 n0( p0.a, p0.b, p0.c );
SVector3 n1( p1.a, p1.b, p1.c );
SVector3 n2( p2.a, p2.b, p2.c );
SVector3 n1_n2, n2_n0, n0_n1;
D3DXVec3Cross( &n1_n2, &n1, &n2 );
D3DXVec3Cross( &n2_n0, &n2, &n0 );
D3DXVec3Cross( &n0_n1, &n0, &n1 );
float cosTheta = n0.dot(n1_n2);
if( FLT_ALMOST_ZERO(cosTheta) || FLT_IS_SPECIAL(cosTheta) )
return false;
float secTheta = 1.0f / cosTheta;
n1_n2 = n1_n2 * p0.d;
n2_n0 = n2_n0 * p1.d;
n0_n1 = n0_n1 * p2.d;
*intersectPt = -(n1_n2 + n2_n0 + n0_n1) * secTheta;
return true;
}
/** Calculates the normalization constant for the exponential decay
* @param ws :: [input] Workspace containing the spectra to remove exponential
* from
* @return :: Vector containing the normalization constants, N0, for each
* spectrum
*/
std::vector<double>
PhaseQuadMuon::getExponentialDecay(const API::MatrixWorkspace_sptr &ws) {
size_t nspec = ws->getNumberHistograms();
size_t npoints = ws->blocksize();
// Muon life time in microseconds
double muLife = PhysicalConstants::MuonLifetime * 1e6;
std::vector<double> n0(nspec, 0.);
for (size_t h = 0; h < ws->getNumberHistograms(); h++) {
const auto &X = ws->getSpectrum(h).x();
const auto &Y = ws->getSpectrum(h).y();
const auto &E = ws->getSpectrum(h).e();
double s, sx, sy;
s = sx = sy = 0;
for (size_t i = 0; i < npoints; i++) {
if (Y[i] > 0) {
double sig = E[i] * E[i] / Y[i] / Y[i];
s += 1. / sig;
sx += (X[i] - X[0]) / sig;
sy += log(Y[i]) / sig;
}
}
n0[h] = exp((sy + sx / muLife) / s);
}
return n0;
}
TEST(removeNthFromEnd, caseTest) {
Solution s;
ListNode n0(0);
EXPECT_EQ(NULL, s.removeNthFromEnd(&n0, 1));
ListNode n1(1);
ListNode n2(2);
n1.next = &n2;
ListNode* n3 = s.removeNthFromEnd(&n1, 2);
EXPECT_EQ(&n2, n3);
EXPECT_EQ(NULL, n3->next);
ListNode n4(4);
ListNode n5(5);
ListNode n6(6);
ListNode n7(7);
n4.next = &n5;
n5.next = &n6;
n6.next = &n7;
ListNode *n8 = s.removeNthFromEnd(&n4, 4);
EXPECT_EQ(5, n8->val);
EXPECT_EQ(6, n8->next->val);
}
bool PNS_DIFF_PAIR::CheckConnectionAngle( const PNS_DIFF_PAIR& aOther, int aAllowedAngles ) const
{
bool checkP, checkN;
if( m_p.SegmentCount() == 0 || aOther.m_p.SegmentCount() == 0 )
checkP = true;
else
{
DIRECTION_45 p0( m_p.CSegment( -1 ) );
DIRECTION_45 p1( aOther.m_p.CSegment( 0 ) );
checkP = ( p0.Angle( p1 ) & aAllowedAngles ) != 0;
}
if( m_n.SegmentCount() == 0 || aOther.m_n.SegmentCount() == 0 )
checkN = true;
else
{
DIRECTION_45 n0( m_n.CSegment( -1 ) );
DIRECTION_45 n1( aOther.m_n.CSegment( 0 ) );
checkN = ( n0.Angle( n1 ) & aAllowedAngles ) != 0;
}
return checkP && checkN;
}
END_TEST
START_TEST(test_recover_reservation)
{
numa_node n0("../../../../test/test_files", 0);
numa_node n1("../../../../test/test_files", 1);
std::vector<numa_node> nodes;
nodes.push_back(n0);
nodes.push_back(n1);
node_internals ni(nodes);
recover_mode = 0;
recover_called = 0;
ni.recover_reservation(2, 2048, "1.napali");
fail_unless(recover_called == 1);
recover_called = 0;
reserve_called = 0;
recover_mode = 1;
ni.recover_reservation(2, 2048, "1.napali");
fail_unless(recover_called == 2);
recover_called = 0;
reserve_called = 0;
recover_mode = 1;
char buf[1024];
fail_unless(reserve_called == 0);
ni.recover_reservation(3, 2049, "1.napali");
fail_unless(recover_called == 2);
snprintf(buf, sizeof(buf), "reserve has been called %d times", reserve_called);
fail_unless(reserve_called > 0, buf);
}
main()
{
P1DIR = 0xFF;
while(1)
{
n1();
delay(65000);
n2();
delay(65000);
n3();
delay(65000);
n4();
delay(65000);
n5();
delay(65000);
n6();
delay(65000);
n7();
delay(65000);
n8();
delay(65000);
n9();
delay(65000);
n0();
delay(65000);
}
}
TEST_F(P237_DeleteNodeInALinkedList_Test, example_case) {
ListNode n3(4);
ListNode n2(3);
n2.next = &n3;
ListNode n1(2);
n1.next = &n2;
ListNode n0(1);
n0.next = &n1;
s.deleteNode(&n2);
ASSERT_EQ(4, n2.next->val);
}
int main() {
// init data
TreeNode n6(6);
TreeNode n2(2);
TreeNode n8(8);
TreeNode n0(0);
TreeNode n4(4);
TreeNode n7(7);
TreeNode n9(9);
TreeNode n3(3);
TreeNode n5(5);
n6.left = &n2;
n6.right = &n8;
n2.left = &n0;
n2.right = &n4;
n8.left = &n7;
n8.right = &n9;
n4.left = &n3;
n4.right = &n5;
// 测试 fillMapParents
Solution sol;
map<TreeNode*, TreeNode*> mapParents;
sol.fillMapParents(&n6, mapParents);
sol.printMapParents(mapParents);
// 测试 depth
sol.printAllNodesDepth(mapParents, &n6);
// 测试 traverseUpward
TreeNode* tempNode = &n2;
sol.traverseUpward(tempNode, 1, mapParents);
// 测试 lowestCommonAncestor
TreeNode* v = &n2;
TreeNode* w = &n4;
TreeNode* lca = sol.lowestCommonAncestor(&n6, v, w);
cout << endl << v->val << ", " << w->val << " 的 LCA 是 " << lca->val << endl << endl;
v = &n2;
w = &n8;
lca = sol.lowestCommonAncestor(&n6, v, w);
cout << endl << v->val << ", " << w->val << " 的 LCA 是 " << lca->val << endl << endl;
return 0;
}
int main(){
TreeNode n0(10);
TreeNode n1(5);
TreeNode n2(15);
TreeNode n3(6);
TreeNode n4(20);
n0.left = &n1;
n0.right = &n2;
n2.left = &n3;
n2.right = &n4;
bool res = isValidBST(&n0);
printf("%s\n", res?"true":"false");
return 0;
}
int main() {
typedef DAG::Node<const idpair> INode;
// create a set of nodes
// the nodes will be kept track of in the Node children and parent collections so
// shared_ptr is used.
INode n0(idpair(0, 2));
INode n1(idpair(1, 3));
INode n2(idpair(2, 3));
INode n3(idpair(3, 2));
INode n4(idpair(4, 2));
INode n5(idpair(5, 2));
INode n6(idpair(6, 2));
// and now define the polytree
// add the directed (parent -> child) branches of the polytree
// each link requires an addChild and an addParent
n0.addChild(n1); // link between n0 and n1
n1.addChild(n2); // link between n0 and n2 etc
n1.addChild(n3);
n3.addChild(n6);
n3.addChild(n4);
n4.addChild(n5);
n5.addChild(n6);
DAG::BFSRecurseVisitor<INode> bfs;
// Start at node 0 for the following examples
// Example 1
// BFSVisitor uses an iterative method to traverse
// output the Datatype of all children
std::cout << std::endl << "TRAVERSE CHILDREN (start Node 0) 1 level" << std::endl;
for (auto n : bfs.traverseChildren(n0, 1)) {
std::cout << n->value().itype << ":" << n->value().ivalue << std::endl;
}
std::cout << std::endl << "TRAVERSE UNDIRECTED (start Node 5) 2 levels " << std::endl;
for (auto n : bfs.traverseUndirected(n5, 2)) {
std::cout << n->value().itype << ":" << n->value().ivalue << std::endl;
}
std::cout << std::endl << "TRAVERSE CHILDREN (start Node 0) all levels" << std::endl;
for (auto n : bfs.traverseChildren(n0)) {
std::cout << n->value().itype << ":" << n->value().ivalue << std::endl;
}
return 0;
}
Segment Segment::getShortestConnection(const Segment & other) const {
const Node & n0 = getA();
const Node & n1 = getB();
const Node & n2 = other.getA();
const Node & n3 = other.getB();
float d0232 = glm::dot(n0() - n2(), n3() - n2());
float d3210 = glm::dot(n3() - n2(), n1() - n0());
float d3232 = glm::pow(other.getLength(), 2.f);
float d0210 = glm::dot(n0() - n2(), n1() - n0());
float d1010 = glm::pow(getLength(), 2.f);
float d0 = (d0232 * d3210 - d0210 * d3232) / (d1010 * d3232 - d3210 * d3210);
float d1 = (d0232 + d0 * d3210) / d3232;
d0 = glm::clamp(d0, 0.f, 1.f);
d1 = glm::clamp(d1, 0.f, 1.f);
Node ni0 = n0 + d0 * (n1 - n0);
Node ni1 = n2 + d1 * (n3 - n2);
return Segment(ni0, ni1);
}
void TurbulentMagneticField::initialize() {
if (lMin >= lMax)
throw std::runtime_error("crpropa::TurbulentMagneticField: lMin >= lMax");
double lkMin = log10(2 * M_PI / lMax);
double lkMax = log10(2 * M_PI / lMin);
double dlk = (lkMax - lkMin) / (nModes - 1);
double Lc = getCorrelationLength();
Mode mode;
Vector3f ek, e1, e2; // orthogonal base
Vector3f n0(1, 1, 1); // arbitrary vector to construct orthogonal base
double sumGk = 0;
for (int i = 0; i < nModes; i++) {
// construct an orthogonal base ek, e1, e2
ek = random.randVector();
if (ek.getAngleTo(n0) < 1e-3) {
// ek parallel to (1,1,1)
e1.setXYZ(-1., 1., 0);
e2.setXYZ(1., 1., -2.);
} else {
// ek not parallel to (1,1,1)
e1 = n0.cross(ek);
e2 = ek.cross(e1);
}
double k = pow(10, lkMin + i * dlk);
mode.k = ek * k;
// amplitude (this seems to be wrong)
double dk = k * dlk;
double Gk = k * k * dk / (1 + pow(k * Lc, -spectralIndex));
sumGk += Gk;
mode.amplitude = Brms * sqrt(Gk);
// random orientation of b
double alpha = random.rand(2 * M_PI);
mode.e1 = e1 / e1.getR() * cos(alpha);
mode.e2 = e2 / e2.getR() * sin(alpha);
// random phase
mode.phase = random.rand(2 * M_PI);
modes.push_back(mode);
}
for (int i = 0; i < nModes; i++)
modes[i].amplitude /= sumGk;
}
int main(){
TreeNode n0(0);
TreeNode n1(1);
TreeNode n2(2);
TreeNode n3(3);
TreeNode n4(4);
TreeNode n5(5);
n0.left = &n1;
n0.right = &n2;
n1.left = &n3;
n1.right = &n4;
n4.left = &n5;
int res = maxDepth(&n0);
printf("%d\n", res);
return 0;
}
END_TEST
START_TEST(test_remove)
{
numa_node n0("../../../../test/test_files", 0);
numa_node n1("../../../../test/test_files", 1);
std::vector<numa_node> nodes;
nodes.push_back(n0);
nodes.push_back(n1);
node_internals ni(nodes);
remove_called = 0;
ni.remove_job("1.napali");
fail_unless(remove_called == 2);
}
int
DynamicsTrappenberg::initilize_x(
const arma::Mat< double > u,
const mxArray *theta,
const mxArray *ptheta,
arma::Mat< double >& nx)
{
mxArray *mx0 = mxGetField(theta, 0, "x0");
arma::Mat< double > n0(mxGetPr(mx0), mxGetDimensions(mx0)[0],
DIM_X_1_TRAPP, 1);
nx = n0;
return 0;
}
void tst_model2expr() {
ast_manager m;
m.register_decl_plugins();
arith_util a(m);
ptr_vector<sort> ints;
ints.push_back(a.mk_int());
ints.push_back(a.mk_int());
ints.push_back(a.mk_int());
func_decl_ref p(m), q(m), x(m);
p = m.mk_func_decl(symbol("p"), 2, ints.c_ptr(), a.mk_int());
q = m.mk_func_decl(symbol("q"), 2, ints.c_ptr(), a.mk_int());
x = m.mk_const_decl(symbol("x"), a.mk_int());
expr_ref n0(m), n1(m), n2(m);
n0 = a.mk_numeral(rational(0), true);
n1 = a.mk_numeral(rational(1), true);
n2 = a.mk_numeral(rational(2), true);
model_ref md = alloc(model, m);
func_interp* fip = alloc(func_interp, m, 2);
func_interp* fiq = alloc(func_interp, m, 2);
expr_ref_vector args(m);
args.push_back(n1);
args.push_back(n2);
fip->insert_entry(args.c_ptr(), n1);
fiq->insert_entry(args.c_ptr(), n1);
args[0] = n0;
args[1] = n1;
fip->insert_entry(args.c_ptr(), n2);
fiq->insert_entry(args.c_ptr(), n2);
fip->set_else(n0);
md->register_decl(x, a.mk_numeral(rational(0), true));
md->register_decl(p, fip); // full
md->register_decl(q, fiq); // partial
expr_ref result(m);
model2expr(md, result);
model_smt2_pp(std::cout, m, *md, 0);
std::cout << mk_pp(result, m) << "\n";
}
void arahant()
{
aaa(xnxt,ynxt,h,wa);
rrr(xnxt,ynxt,h,wr);
aaa(xnxt,ynxt,h,wa);
hhh(xnxt,ynxt,h,wh);
aaa(xnxt,ynxt,h,wa);
nnn(xnxt,ynxt,h,wn);
ttt(xnxt,ynxt,h,wt);
xnxt+=s/2;
aaa(xnxt,ynxt,h,wa);
xnxt+=s/2;
n1(xnxt,ynxt,h,w1);
n1(xnxt,ynxt,h,w1);
iii(xnxt,ynxt,h,wi);
ttt(xnxt,ynxt,h,wt);
n1(xnxt,ynxt,h,w1);
n0(xnxt,ynxt,h,w0);
}
END_TEST
START_TEST(test_getting_indices)
{
numa_node n0("../../../../test/test_files", 0);
numa_node n1("../../../../test/test_files", 1);
std::vector<numa_node> nodes;
nodes.push_back(n0);
nodes.push_back(n1);
node_internals ni(nodes);
get_job_indices_called = 0;
ni.get_cpu_indices("1.napali");
fail_unless(get_job_indices_called == 2);
get_job_indices_called = 0;
ni.get_memory_indices("1.napali");
fail_unless(get_job_indices_called == 2);
}
END_TEST
START_TEST(test_reserve)
{
numa_node n0("../../../../test/test_files", 0);
numa_node n1("../../../../test/test_files", 1);
std::vector<numa_node> nodes;
nodes.push_back(n0);
nodes.push_back(n1);
node_internals ni(nodes);
does_it_fit = false;
reserve_called = 0;
ni.reserve(6, 100000, "1.napali");
fail_unless(reserve_called == 2);
does_it_fit = true;
reserve_called = 0;
ni.reserve(6, 100000, "1.napali");
fail_unless(reserve_called == 1);
}
PView *GMSH_CVTRemeshPlugin::execute(PView *v)
{
//TODO normalization
GModel* m = GModel::current() ;
std::vector<double> vertices ;
std::vector<unsigned int> faces ;
unsigned int offset = 0 ;
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
(*it)->buildSTLTriangulation() ;
for(unsigned int i = 0; i < (*it)->stl_vertices.size(); ++i) {
GPoint p = (*it)->point((*it)->stl_vertices[i]) ;
vertices.push_back(p.x()) ;
vertices.push_back(p.y()) ;
vertices.push_back(p.z()) ;
}
for(unsigned int i = 0; i < (*it)->stl_triangles.size(); ++i) {
faces.push_back((*it)->stl_triangles[i]+offset) ;
}
offset += (*it)->stl_vertices.size() ;
}
Revoropt::MeshBuilder<3> mesh ;
mesh.swap_vertices(vertices) ;
mesh.swap_faces(faces) ;
double mesh_center[3] ;
double mesh_scale ;
Revoropt::normalize_mesh(&mesh, mesh_center, &mesh_scale) ;
double nradius = (double)CVTRemeshOptions_Number[5].def ;
//normals
std::vector<double> normals(3*mesh.vertices_size()) ;
Revoropt::full_robust_vertex_normals(&mesh,nradius,normals.data()) ;
//lifted vertices
std::vector<double> lifted_vertices(6*mesh.vertices_size(), 0) ;
for(unsigned int vertex = 0; vertex < mesh.vertices_size(); ++vertex) {
std::copy( mesh.vertex(vertex),
mesh.vertex(vertex)+3,
lifted_vertices.data()+6*vertex
) ;
std::copy( normals.data()+3*vertex,
normals.data()+3*vertex+3,
lifted_vertices.data()+6*vertex+3
) ;
}
//setup lifted mesh
Revoropt::ROMeshWrapper<3,6> lifted_mesh(
lifted_vertices.data(),
lifted_vertices.size()/6,
&mesh
) ;
//triangle weight factor
double twfactor = (double)CVTRemeshOptions_Number[3].def ;
//face ratios
std::vector<double> triangle_weights(lifted_mesh.faces_size()) ;
if(twfactor > 0) {
for(unsigned int f = 0; f < lifted_mesh.faces_size(); ++f) {
//vertices of the initial triangle
const unsigned int* fverts = mesh.face(f) ;
//positions
const double* x[3] ;
for(int i=0; i<3; ++i) {
x[i] = lifted_mesh.vertex(fverts[i]) ;
}
//ratio
double ratio = 1 ;
//vectors
typedef Eigen::Matrix<double,3,1> Vector3 ;
Eigen::Map<const Vector3> v0(x[0]) ;
Eigen::Map<const Vector3> v1(x[1]) ;
Eigen::Map<const Vector3> v2(x[2]) ;
//triangle frame
Vector3 U = (v1-v0) ;
const double U_len = U.norm() ;
if(U_len > 0) {
U /= U_len ;
Vector3 H = (v2-v0) ;
H = H - H.dot(U)*U ;
const double H_len = H.norm() ;
if(H_len > 0) {
//we know that the triangle is not flat
H /= H_len ;
//gradient of the barycentric weights in the triangle
Eigen::Matrix<double,3,2> bar_grads ;
bar_grads(2,0) = 0 ;
bar_grads(2,1) = 1/H_len ;
//gradient norms of every normal component
for(int i = 0; i < 2; ++i) {
//reference frame for the vertex
Eigen::Map<const Vector3> vi0(x[(i+1)%3]) ;
Eigen::Map<const Vector3> vi1(x[(i+2)%3]) ;
Eigen::Map<const Vector3> vi2(x[ i ]) ;
Vector3 Ui = (vi1-vi0) ;
Ui /= Ui.norm() ;
Vector3 Hi = (vi2-vi0) ;
Hi = Hi - Hi.dot(Ui)*Ui ;
const double Hi_invlen = 1/Hi.norm() ;
Hi *= Hi_invlen ;
bar_grads(i,0) = Hi.dot(U)*Hi_invlen ;
bar_grads(i,1) = Hi.dot(H)*Hi_invlen ;
}
//gradient of each component of the normal
Eigen::Map<const Vector3> n0(x[0]+3) ;
Eigen::Map<const Vector3> n1(x[1]+3) ;
Eigen::Map<const Vector3> n2(x[2]+3) ;
Eigen::Matrix<double,3,2> n_grads = Eigen::Matrix<double,3,2>::Zero() ;
n_grads = n0*bar_grads.row(0) ;
n_grads += n1*bar_grads.row(1) ;
n_grads += n2*bar_grads.row(2) ;
//maximal gradient norm
double g_max = n_grads.row(0).dot(n_grads.row(0)) ;
double g_other = n_grads.row(1).dot(n_grads.row(1)) ;
g_max = g_max > g_other ? g_max : g_other ;
g_other = n_grads.row(2).dot(n_grads.row(2)) ;
g_max = g_max > g_other ? g_max : g_other ;
if(g_max == g_max) { //prevent nan
ratio += g_max ;
}
}
}
triangle_weights[f] = pow(ratio,twfactor) ;
}
}
//normal factor
double nfactor = (double)CVTRemeshOptions_Number[2].def ; ;
//weight the normal component by the provided factor
for(unsigned int i = 0; i<lifted_mesh.vertices_size(); ++i) {
double* v = lifted_vertices.data() + 6*i ;
v[3]*= nfactor ;
v[4]*= nfactor ;
v[5]*= nfactor ;
}
//number of sites
unsigned int nsites = (unsigned int)CVTRemeshOptions_Number[0].def ;
//lifted sites
std::vector<double> lifted_sites(6*nsites) ;
if(twfactor > 0) {
Revoropt::generate_random_sites< Revoropt::ROMesh<3,6> >(
&lifted_mesh, nsites, lifted_sites.data(), triangle_weights.data()
) ;
} else {
Revoropt::generate_random_sites< Revoropt::ROMesh<3,6> >(
&lifted_mesh, nsites, lifted_sites.data()
) ;
}
//setup the cvt minimizer
Revoropt::CVT::DirectMinimizer< Revoropt::ROMesh<3,6> > cvt ;
cvt.set_sites(lifted_sites.data(), nsites) ;
cvt.set_mesh(&lifted_mesh) ;
if(twfactor > 0) {
cvt.set_triangle_weights(triangle_weights.data()) ;
}
//setup the callback
SolverCallback callback ;
//number of iterations
unsigned int niter = (unsigned int)CVTRemeshOptions_Number[1].def ; ;
unsigned int aniso_niter = std::min<unsigned int>(10,niter) ;
//solver status
int status = 0 ;
//isotropic iterations
if(niter > 10) {
aniso_niter = std::max(aniso_niter,niter*10/100) ;
cvt.set_anisotropy(1) ;
status = cvt.minimize<Revoropt::Solver::AlgLBFGS>(niter-aniso_niter, &callback) ;
}
//anisotropic iterations
if(niter > 0) {
//tangent space anisotropy
double tanisotropy = (double)CVTRemeshOptions_Number[4].def ; ;
//anisotropic iterations
cvt.set_anisotropy(tanisotropy) ;
status = cvt.minimize<Revoropt::Solver::AlgLBFGS>(aniso_niter, &callback) ;
}
//rdt
std::vector<unsigned int> rdt_triangles ;
Revoropt::RDTBuilder< Revoropt::ROMesh<3,6> > build_rdt(rdt_triangles) ;
Revoropt::RVD< Revoropt::ROMesh<3,6> > rvd ;
rvd.set_sites(lifted_sites.data(), nsites) ;
rvd.set_mesh(&lifted_mesh) ;
rvd.compute(build_rdt) ;
GFace* res_face = new discreteFace(m, m->getMaxElementaryNumber(2)+1) ;
m->add(res_face) ;
//scale back and transfer to gmsh
std::vector<MVertex*> m_verts(nsites) ;
for(unsigned int i = 0; i < nsites; ++i) {
m_verts[i] = new MVertex(
lifted_sites[6*i ]*mesh_scale + mesh_center[0],
lifted_sites[6*i+1]*mesh_scale + mesh_center[1],
lifted_sites[6*i+2]*mesh_scale + mesh_center[2]
) ;
res_face->addMeshVertex(m_verts[i]) ;
}
for(unsigned int i = 0; i < rdt_triangles.size()/3; ++i) {
res_face->addTriangle(
new MTriangle(
m_verts[rdt_triangles[3*i ]],
m_verts[rdt_triangles[3*i+1]],
m_verts[rdt_triangles[3*i+2]]
)
) ;
}
res_face->setAllElementsVisible(true) ;
return v ;
}
R404AClass::R404AClass()
{
static const double a[]={
7.00407, //[0]
7.98695, //[1]
-18.8664, //[2]
0.63078, //[3]
3.5979, //[4]
5.0335 //[5]
};
static const double b[]={
0, //[0]
0, //[1]
-0.3, //[2]
1.19617, //[3]
2.32861, //[4]
5.00188 //[5]
};
static const double N[]={
0.0, //[0]
6.10984, //[1]
-7.79453, //[2]
0.0183377, //[3]
0.262270, //[4]
-0.00351688, //[5]
0.0116181, //[6]
0.00105992, //[7]
0.850922, //[8]
-0.520084, //[9]
-0.0464225, //[10]
0.621190, //[11]
-0.195505, //[12]
0.336159, //[13]
-0.0376062, //[14]
-0.00636579, //[15]
-0.0758262, //[16]
-0.0221041, //[17]
0.0310441, //[18]
0.0132798, //[19]
0.0689437, //[20]
-0.0507525, //[21]
0.0161382, //[22]
};
static const double t[]={
0.0, //[0]
0.67, //[1]
0.91, //[2]
5.96, //[3]
0.7, //[4]
6.0, //[5]
0.3, //[6]
0.7, //[7]
1.7, //[8]
3.3, //[9]
7.0, //[10]
2.05, //[11]
4.3, //[12]
2.7, //[13]
1.8, //[14]
1.25, //[15]
12.0, //[16]
6.0, //[17]
8.7, //[18]
11.6, //[19]
13.0, //[20]
17.0, //[21]
16.0 //[22]
};
static const int d[]={
0, //[0]
1, //[1]
1, //[2]
1, //[3]
2, //[4]
2, //[5]
4, //[6]
6, //[7]
1, //[8]
1, //[9]
1, //[10]
2, //[11]
2, //[12]
3, //[13]
4, //[14]
7, //[15]
2, //[16]
3, //[17]
4, //[18]
4, //[19]
2, //[20]
3, //[21]
5 //[22]
};
static const int l[]={
0, //[0]
0, //[1]
0, //[2]
0, //[3]
0, //[4]
0, //[5]
0, //[6]
0, //[7]
1, //[8]
1, //[9]
1, //[10]
1, //[11]
1, //[12]
1, //[13]
1, //[14]
1, //[15]
2, //[16]
2, //[17]
2, //[18]
2, //[19]
3, //[20]
3, //[21]
3 //[22]
};
std::vector<double> n_v(N,N+sizeof(N)/sizeof(double));
std::vector<double> d_v(d,d+sizeof(d)/sizeof(int));
std::vector<double> t_v(t,t+sizeof(t)/sizeof(double));
std::vector<double> l_v(l,l+sizeof(l)/sizeof(int));
std::vector<double> a0(a,a+sizeof(a)/sizeof(double));
std::vector<double> n0(b,b+sizeof(b)/sizeof(double));
phi_BC * phir_ = new phir_power(n_v,d_v,t_v,l_v,1,22);
phirlist.push_back(phir_);
/*
sum=log(delta)-log(tau)+a[0]+a[1]*tau+a[2]*pow(tau,b[2]);
for(k=3;k<=5;k++)
{
sum+=a[k]*log(1.0-exp(-b[k]*tau));
}
*/
phi_BC * phi0_lead_ = new phi0_lead(a0[0],a0[1]);
phi_BC * phi0_logtau_ = new phi0_logtau(-1.0);
phi_BC * phi0_power_ = new phi0_power(a0[2],n0[2]);
phi_BC * phi0_Planck_Einstein_ = new phi0_Planck_Einstein(a0,n0,3,5);
phi0list.push_back(phi0_lead_);
phi0list.push_back(phi0_logtau_);
phi0list.push_back(phi0_power_);
phi0list.push_back(phi0_Planck_Einstein_);
// Critical parameters (max condensing temperature)
crit.rho = 482.162772;
crit.p = PressureUnit(3734.8,UNIT_KPA);
crit.T = 345.27;
crit.v = 1.0/crit.rho;
// Other fluid parameters
params.molemass = 97.6038;
params.Ttriple = 200.0;
params.ptriple = 21.2656766151;
params.accentricfactor = 0.293;
params.R_u = 8.314472;
isPure = false;
// Limits of EOS
limits.Tmin = params.Ttriple;
limits.Tmax = 500.0;
limits.pmax = 50000.0;
limits.rhomax = 14.21*params.molemass;
EOSReference.assign("E.W. Lemmon, \"Pseudo-pure fluid Equations of State for the Refrigerant Blends R410A, R404A, R507C and R407C\""
",Int. J. Thermophys. v. 24, n4, 2003");
TransportReference.assign("Viscosity: V. Geller, \"Viscosity of Mixed Refrigerants R404A,R407C,"
"R410A, and R507A\", 2000 Purdue Refrigeration conferences\n\n"
"Thermal Conductivity: V.Z. Geller, B.Z. Nemzer, and U.V. Cheremnykh \"Thermal Conductivity "
"of the Refrigerant mixtures R404A,R407C,R410A, and R507A\" "
"Int. J. Thermophysics, v. 22, n 4 2001\n\n"
"Surface Tension: R. Heide, \"The surface tension of HFC refrigerants and mixtures\", Int J. Refrig. Vol. 20, No. 7, pp. 496-503, 1997");
name.assign("R404A");
aliases.push_back("R404a");
BibTeXKeys.EOS = "Lemmon-IJT-2003";
BibTeXKeys.VISCOSITY = "Geller-PURDUE-2000";
BibTeXKeys.CONDUCTIVITY = "Geller-IJT-2001";
BibTeXKeys.SURFACE_TENSION ="Heide-IJR-1997";
}
void test_Polygon(int &failed_test_count, int &disabled_test_count)
{
const std::string GROUP = "Polygon";
const double EQT = 1.0e-15;
//-----------------------------------------------------------------------------
{
Test t(GROUP, "set_get_my_zone", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon;
size_t expected = 7;
f->set_my_zone(expected);
size_t actual = f->get_my_zone();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "set_get_my_id", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon;
short int expected = 7;
f->set_my_id(expected);
short int actual = f->get_my_id();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "ctor_check_my_zone", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
size_t mz = 6;
short int mi = 9;
Face *f = new Polygon(mz, mi);
size_t expected = mz;
size_t actual = f->get_my_zone();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "ctor_check_my_id", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
size_t mz = 6;
short int mi = 9;
Face *f = new Polygon(mz, mi);
short int expected = mi;
short int actual = f->get_my_id();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "size0", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon;
size_t expected = 0;
size_t actual = f->size();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "size", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Vector3d v(1.0, 2.0, 3.0);
Node n0(3, v);
Node n1(5, v, v);
Face *f = new Polygon;
f->add_node(n0.geti());
f->add_node(n1.geti());
size_t expected = 2;
size_t actual = f->size();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "is_curved", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Grid g;
Face *f = new Polygon;
Vector3d v(1.0, 2.0, 3.0);
Node n0(3, v);
f->add_node(n0.geti());
f->add_node(n0.geti());
f->add_node(n0.geti());
bool expected = false;
bool actual = f->is_curved(g);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "is_flat", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Grid g;
Face *f = new Polygon;
Vector3d v(1.0, 2.0, 3.0);
Node n0(3, v);
f->add_node(n0.geti());
f->add_node(n0.geti());
f->add_node(n0.geti());
bool expected = true;
bool actual = f->is_flat(g);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "get_node_id", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Vector3d v(1.0, 2.0, 3.0);
Node n0(3, v);
Node n1(5, v, v);
Face *f = new Polygon;
f->add_node(n0.geti());
f->add_node(n1.geti());
size_t expected = 5;
size_t actual = f->get_node(1);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "get_node_id_out_of_range", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Vector3d v(1.0, 2.0, 3.0);
Node n0(3, v);
Node n1(5, v, v);
Face *f = new Polygon;
f->add_node(n0.geti());
f->add_node(n1.geti());
std::string expected = "out of range exception";
std::string actual = UNCAUGHT_EXCEPTION;
try
{
size_t n = f->get_node(2);
std::cout << n;
}
catch (const std::out_of_range &oor)
{
actual = "out of range exception";
}
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "abs_diff", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
Face *g = new Polygon(4, 5);
f->add_node(6);
g->add_node(2);
g->add_node(9);
g->add_node(4);
double expected = 37.0;
double actual = f->abs_diff(*g);
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
delete g;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "to_string", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
f->add_node(98765);
f->add_node(98766);
f->add_node(98767);
f->add_node(98768);
f->add_node(98769);
std::string expected = "Polygon\n 5\n";
expected += " 3 1\n";
expected += " 98765 98766 98767 98768 98769";
expected += "\n neighbors 0";
std::string actual = f->to_string();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "ctor0", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *expected = new Polygon(0, -2);
Face *actual = new Polygon;
failed_test_count += t.check_equal_real_obj(*expected, *actual, EQT);
delete expected;
delete actual;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "assignment", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *expected = new Polygon(4, 5);
expected->add_node(2);
expected->add_node(9);
expected->add_node(4);
Face *actual = new Polygon;
*actual = *expected;
failed_test_count += t.check_equal_real_obj(*expected, *actual, EQT);
delete expected;
delete actual;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "add_get_neighboring_zone", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
f->add_neighbor(2, 4);
f->add_neighbor(9, 5);
size_t expected = 9;
size_t actual = f->get_neighbor(1).my_zone;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "add_get_neighboring_Polygon", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
f->add_neighbor(2, 4);
f->add_neighbor(9, 5);
short int expected = 5;
short int actual = f->get_neighbor(1).my_id;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "neighbor_count", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
f->add_neighbor(2, 4);
f->add_neighbor(9, 5);
size_t expected = 2;
size_t actual = f->num_nbr();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "add_get_neighbor_out_of_range", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
Face *f = new Polygon(3, 1);
f->add_neighbor(2, 4);
f->add_neighbor(9, 5);
std::string expected = "out of range exception";
std::string actual = UNCAUGHT_EXCEPTION;
try
{
FaceID n = f->get_neighbor(5);
std::cout << n.my_zone << " " << n.my_id;
}
catch (const std::out_of_range &oor)
{
actual = "out of range exception";
}
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area2_normal_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d expected(4.0, 3.0, 12.0);
Vector3d actual = f->area2_normal_center(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area2_normal_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
Vector3d expected(0.0, 0.0, 12.0);
Vector3d actual = f->area2_normal_center(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area2_normal_trapezoid", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "trapezoid.inc"
Vector3d expected(0.0, 0.0, 8.0);
Vector3d actual = f->area2_normal_center(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area2_normal_hexagon", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "hexagon.inc"
Vector3d expected = Vector3d(0.0, 0.0, -6.0*r*s);
Vector3d actual = f->area2_normal_center(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, 10*EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "center_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d expected(1.0, 4.0/3.0, 1.0/3.0);
Vector3d actual;
f->area2_normal_center(g, actual);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "center_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
Vector3d expected(2.0, 2.5, 5.0);
Vector3d actual;
f->area2_normal_center(g, actual);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "center_trapezoid", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "trapezoid.inc"
Vector3d expected(13.0/12.0, 5.0/6.0, 0.0);
Vector3d actual;
f->area2_normal_center(g, actual);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "center_hexagon", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "hexagon.inc"
Vector3d expected = center;
Vector3d actual;
f->area2_normal_center(g, actual);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "normal_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d expected(4.0/13.0, 3.0/13.0, 12.0/13.0);
Vector3d actual = f->normal(g);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "normal_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
Vector3d expected(0.0, 0.0, 1.0);
Vector3d actual = f->normal(g);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
double expected = 6.5;
double actual = f->area(g);
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "area_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
double expected = 6.0;
double actual = f->area(g);
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "signed_distance_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d c;
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5;
double expected = 2.6;
double actual = f->distance(g, v);
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "signed_distance_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(7.0, 6.0, -4.0);
double expected = -9.0;
double actual = f->distance(g, v);
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "subpoint_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d expected = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
Vector3d c;
v = expected + f->area2_normal_center(g, c)/5;
Vector3d actual = f->subpoint(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "subpoint_rectangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(7.0, 6.0, -4.0);
Vector3d expected = Vector3d(7.0, 6.0, 5.0);
Vector3d actual = f->subpoint(g, v);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_has_point_above", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d c;
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5;
bool expected = true;
bool actual = f->has_above(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_has_point_above", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(7.0, 6.0, -4.0);
bool expected = false;
bool actual = f->has_above(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_has_point_below", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
Vector3d c;
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5;
bool expected = false;
bool actual = f->has_below(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_has_point_below", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(7.0, 6.0, -4.0);
bool expected = true;
bool actual = f->has_below(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_contains_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "triangle.inc"
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
bool expected = true;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_contains_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(2.0, 3.0, 5.0);
bool expected = true;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_misses_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(7.0, 6.0, 5.0);
bool expected = false;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_first_edge_contains_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(2.0, 1.0, 5.0);
bool expected = true;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_first_edge_misses_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(4.0, 1.0, 5.0);
bool expected = false;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_another_edge_contains_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(2.0, 4.0, 5.0);
bool expected = true;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_another_edge_misses_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "rectangle.inc"
v = Vector3d(4.0, 4.0, 5.0);
bool expected = false;
bool actual = f->contains(g, v);
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_distance", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
Vector3d w;
double expected = 1.0;
double actual = f->intercept(g, r, v, EQT, fid).t;
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_point", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
Vector3d expected = v;
Vector3d actual = f->intercept(g, r, v, EQT, fid).w;
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_face", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
FaceID expected = FaceID(2, 1);
FaceID actual = f->intercept(g, r, v, EQT, fid).fid;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_found", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
bool expected = true;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_found_same_face", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(2, 1); // difference from triangle_intercept_found
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(1.0, 4.0/3.0, 1.0/3.0);
bool expected = false; // difference from triangle_intercept_found
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_distance_negative", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
Vector3d w;
double expected = -1.0;
double actual = f->intercept(g, r, v, EQT, fid).t;
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_point_negative", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
Vector3d expected = -v;
Vector3d actual = f->intercept(g, r, v, EQT, fid).w;
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_found_negative", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
bool expected = false;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_distance_0", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(1.0, 4.0/3.0, 1.0/3.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
Vector3d w;
double expected = 0.0;
double actual = f->intercept(g, r, v, EQT, fid).t;
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_point_0", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(1.0, 4.0/3.0, 1.0/3.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
Vector3d expected = -v;
Vector3d actual = f->intercept(g, r, v, EQT, fid).w;
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_found_0", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(1.0, 4.0/3.0, 1.0/3.0);
v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0);
bool expected = false;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_distance_parallel", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane
Vector3d w;
double expected = -Vector3d::get_big();
double actual = f->intercept(g, r, v, EQT, fid).t;
failed_test_count += t.check_equal_real_num(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_point_parallel", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane
double big = -Vector3d::get_big();
Vector3d expected(big, big, big);
Vector3d actual = f->intercept(g, r, v, EQT, fid).w;
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "triangle_intercept_found_parallel", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "triangle.inc"
Vector3d r(0.0, 0.0, 0.0);
v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane
bool expected = false;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_contains_intercept", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "rectangle.inc"
Vector3d r(2.0, 2.0, 0.0);
v = Vector3d(0.0, 0.0, 1.0);
bool expected = true;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "rectangle_does_not_contain_intercept", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
FaceID fid(9, 8);
#include "rectangle.inc"
Vector3d r(-2.0, -2.0, 0.0);
v = Vector3d(0.0, 0.0, 1.0);
bool expected = false;
bool actual = f->intercept(g, r, v, EQT, fid).is_found;
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "velocity_triangle", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
Vector3d c(1.0, 4.0/3.0, 1.0/3.0);
Vector3d expected(4.3677256019137740,
1.4401036616521570,
0.8384202999809531);
Vector3d actual = f->velocity(g, c);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "velocity_triangle_at_x", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
Vector3d c(3.0, 0.0, 0.0);
Vector3d expected(4.0, -3.0, 2.0);
Vector3d actual = f->velocity(g, c);
failed_test_count += t.check_equal_real_obj(expected, actual, EQT);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_get_size", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
size_t expected = 0;
size_t actual = f->size();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_get_Node", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
std::string expected("out of range exception");
std::string actual = UNCAUGHT_EXCEPTION;
try
{
f->get_node(0);
}
catch (const std::out_of_range &oor)
{
actual = "out of range exception";
}
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_num_nbr", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
size_t expected = 0;
size_t actual = f->num_nbr();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_get_Neighbor", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
std::string expected("out of range exception");
std::string actual = UNCAUGHT_EXCEPTION;
try
{
f->get_neighbor(0);
}
catch (const std::out_of_range &oor)
{
actual = "out of range exception";
}
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_get_my_zone", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
size_t expected = 0;
size_t actual = f->get_my_zone();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "clear_get_my_id", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
#include "velocity_triangle.inc"
f->clear();
short int expected = -2;
short int actual = f->get_my_id();
failed_test_count += t.check_equal(expected, actual);
delete f;
}
}
//-----------------------------------------------------------------------------
{
Test t(GROUP, "load_Hydro1_Mesh0_1st_Polygon", "fast");
check_to_disable_test(t, disabled_test_count);
if (t.is_enabled())
{
std::string path(cnst::PATH + "UniTest/Hydro1/");
std::string tlabel("0");
std::string fname = path + "mesh_" + tlabel + ".txt";
std::ifstream infile(fname.c_str());
utils::find_line(infile, "Polygon");
Polygon f(infile);
infile.close();
infile.clear();
std::string expected("Polygon\n 4\n 0 -1\n");
expected += " 0 1 5 4\n";
expected += " neighbors 1\n 1 0";
std::string actual = f.to_string();
failed_test_count += t.check_equal(expected, actual);
}
}
//-----------------------------------------------------------------------------
}
bool UnitCylinder::intersect( Ray3D& ray, const Matrix4x4& worldToModel,
const Matrix4x4& modelToWorld ) {
Ray3D r;
r.origin = worldToModel * ray.origin;
r.dir = worldToModel * ray.dir;
Point3D cylinder(0,0,0);
double int0, int1, int2, int3, t, t1;
double a = r.dir[0] * r.dir[0] + r.dir[1] * r.dir[1];
double b = r.origin[0] * r.dir[0] + r.origin[1] * r.dir[1];
double c = r.origin[0] * r.origin[0] + r.origin[1] * r.origin[1] - 1;
double d = b * b - a * c;
if (d < 0) return false;
int0 = (-b + sqrt(d)) / a;
int1 = (-b - sqrt(d)) / a;
if (int0 < 0 && int1 < 0) return false;
else if (int0 > 0 && int1 < 0) t = int0;
else t = int1;
int2 = ( -0.5 - r.origin[2])/r.dir[2];
int3 = ( 0.5 - r.origin[2])/r.dir[2];
t1 = int2 < int3 ? int2 : int3;
if (t1 * t1 < 0.001) return false;
if (t * t < 0.001) return false;
Point3D n0(0,0,1);
Point3D n1(0,0,-1);
Vector3D tn0;
if (int2 < int3) tn0 = n1 - cylinder;
else tn0 = n0 - cylinder;
tn0.normalize();
Point3D pint = r.origin + t1 * r.dir;
if (pint[0]* pint[0] + pint[1] * pint[1] <= 1) {
if (ray.intersection.none || ray.intersection.t_value > int3) {
ray.intersection.t_value = t1;
ray.intersection.point = pint;
ray.intersection.none = false;
ray.intersection.normal = tn0;
return true;
}
}
pint = r.origin + t * r.dir;
Vector3D tn1(pint[0], pint[1], 0);
tn1.normalize();
if (pint[2] < 0.5 && pint[2] > -0.5) {
if (ray.intersection.none || ray.intersection.t_value > int3) {
ray.intersection.t_value = t;
ray.intersection.point = modelToWorld * pint;
ray.intersection.none = false;
ray.intersection.normal = modelToWorld * tn1;
return true;
}
}
return false;
}
R507AClass::R507AClass()
{
std::vector<double> n_v(N,N+sizeof(N)/sizeof(double));
std::vector<double> d_v(d,d+sizeof(d)/sizeof(int));
std::vector<double> t_v(t,t+sizeof(t)/sizeof(double));
std::vector<double> l_v(l,l+sizeof(l)/sizeof(int));
std::vector<double> a0(a,a+sizeof(a)/sizeof(double));
std::vector<double> n0(b,b+sizeof(b)/sizeof(double));
phi_BC * phir_ = new phir_power(n_v,d_v,t_v,l_v,1,22);
phirlist.push_back(phir_);
/*
sum=log(delta)-log(tau)+a[0]+a[1]*tau+a[2]*pow(tau,b[2]);
for(k=3;k<=5;k++)
{
sum+=a[k]*log(1.0-exp(-b[k]*tau));
}
*/
phi_BC * phi0_lead_ = new phi0_lead(a0[0],a0[1]);
phi_BC * phi0_logtau_ = new phi0_logtau(-1.0);
phi_BC * phi0_power_ = new phi0_power(a0[2],n0[2]);
phi_BC * phi0_Planck_Einstein_ = new phi0_Planck_Einstein(a0,n0,3,5);
phi0list.push_back(phi0_lead_);
phi0list.push_back(phi0_logtau_);
phi0list.push_back(phi0_power_);
phi0list.push_back(phi0_Planck_Einstein_);
// Critical parameters (max condensing temperature)
crit.rho = 490.74;
crit.p = PressureUnit(3704.9,UNIT_KPA);
crit.T = 343.765;
crit.v = 1.0/crit.rho;
// Other fluid parameters
params.molemass = 98.8592;
params.Ttriple = 200.0;
params.ptriple = 23.2234432758;
params.accentricfactor = 0.286;
params.R_u = 8.314472;
isPure = false;
// Limits of EOS
limits.Tmin = params.Ttriple;
limits.Tmax = 500.0;
limits.pmax = 50000.0;
limits.rhomax = 14.13*params.molemass;
EOSReference.assign("E.W. Lemmon, \"Pseudo-pure fluid Equations of State for the Refrigerant Blends R410A, R404A, R507C and R407C\""
",Int. J. Thermophys. v. 24, n4, 2003");
TransportReference.assign("Viscosity: V. Geller, \"Viscosity of Mixed Refrigerants R404A,R407C,"
"R410A, and R507A\", 2000 Purdue Refrigeration conferences\n\n"
"Thermal Conductivity: V.Z. Geller, B.Z. Nemzer, and U.V. Cheremnykh \"Thermal Conductivity "
"of the Refrigerant mixtures R404A,R407C,R410A, and R507A\" "
"Int. J. Thermophysics, v. 22, n 4 2001");
name.assign("R507A");
aliases.push_back("R507a");
BibTeXKeys.EOS = "Lemmon-IJT-2003";
BibTeXKeys.VISCOSITY = "Geller-PURDUE-2000";
BibTeXKeys.CONDUCTIVITY = "Geller-IJT-2001";
}
void sctensdigit(int a) //ten's place
{
s=30;
xnxt=400-45;
ynxt=100;
w9=w8=w4=w6=w5=w2=w3=w7=w0=wk=we=wf=wj=wl=wp=wr=ws=s/2;//1/2
w1=wi=s/4;
wg=wc=wh=wn=wb=wu=wt=wv=wx=wy=2*s/3;//2/3
ww=wm=wa=wd=wo=wq=wz=3*s/4;//3/4
h=s;//1
glColor3f(0,0,0);
glPointSize(2.0);
switch(a)
{
case 0:n0(xnxt,ynxt,h,w0);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 1:n1(xnxt,ynxt,h,w1);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 2: n2(xnxt,ynxt,h,w2);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 3: n3(xnxt,ynxt,h,w3);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 4: n4(xnxt,ynxt,h,w4);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 5: n5(xnxt,ynxt,h,w5);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 6: n6(xnxt,ynxt,h,w6);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 7: n7(xnxt,ynxt,h,w7);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 8: n8(xnxt,ynxt,h,w8);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
case 9: n9(xnxt,ynxt,h,w9);
xnxt-=(w1+sp);
ynxt-=3*s/2;
break;
default: break;
}
glFlush();
return ;
}
// Collide and edge and polygon. This uses the SAT and clipping to produce up to 2 contact points.
// Edge adjacency is handle to produce locally valid contact points and normals. This is intended
// to allow the polygon to slide smoothly over an edge chain.
//
// Algorithm
// 1. Classify front-side or back-side collision with edge.
// 2. Compute separation
// 3. Process adjacent edges
// 4. Classify adjacent edge as convex, flat, null, or concave
// 5. Skip null or concave edges. Concave edges get a separate manifold.
// 6. If the edge is flat, compute contact points as normal. Discard boundary points.
// 7. If the edge is convex, compute it's separation.
// 8. Use the minimum separation of up to three edges. If the minimum separation
// is not the primary edge, return.
// 9. If the minimum separation is the primary edge, compute the contact points and return.
void b2CollideEdgeAndPolygon( b2Manifold* manifold,
const b2EdgeShape* edgeA, const b2Transform& xfA,
const b2PolygonShape* polygonB_in, const b2Transform& xfB)
{
manifold->pointCount = 0;
b2Transform xf = b2MulT(xfA, xfB);
// Create a polygon for edge shape A
b2PolygonShape polygonA;
polygonA.SetAsEdge(edgeA->m_vertex1, edgeA->m_vertex2);
// Build polygonB in frame A
b2PolygonShape polygonB;
polygonB.m_radius = polygonB_in->m_radius;
polygonB.m_vertexCount = polygonB_in->m_vertexCount;
polygonB.m_centroid = b2Mul(xf, polygonB_in->m_centroid);
for (int32 i = 0; i < polygonB.m_vertexCount; ++i)
{
polygonB.m_vertices[i] = b2Mul(xf, polygonB_in->m_vertices[i]);
polygonB.m_normals[i] = b2Mul(xf.R, polygonB_in->m_normals[i]);
}
float32 totalRadius = polygonA.m_radius + polygonB.m_radius;
// Edge geometry
b2Vec2 v1 = edgeA->m_vertex1;
b2Vec2 v2 = edgeA->m_vertex2;
b2Vec2 e = v2 - v1;
b2Vec2 edgeNormal(e.y, -e.x);
edgeNormal.Normalize();
// Determine side
bool isFrontSide = b2Dot(edgeNormal, polygonB.m_centroid - v1) >= 0.0f;
if (isFrontSide == false)
{
edgeNormal = -edgeNormal;
}
// Compute primary separating axis
b2EPAxis edgeAxis = b2EPEdgeSeparation(v1, v2, edgeNormal, &polygonB, totalRadius);
if (edgeAxis.separation > totalRadius)
{
// Shapes are separated
return;
}
// Classify adjacent edges
b2EdgeType types[2] = {b2_isolated, b2_isolated};
if (edgeA->m_hasVertex0)
{
b2Vec2 v0 = edgeA->m_vertex0;
float32 s = b2Dot(edgeNormal, v0 - v1);
if (s > 0.1f * b2_linearSlop)
{
types[0] = b2_concave;
}
else if (s >= -0.1f * b2_linearSlop)
{
types[0] = b2_flat;
}
else
{
types[0] = b2_convex;
}
}
if (edgeA->m_hasVertex3)
{
b2Vec2 v3 = edgeA->m_vertex3;
float32 s = b2Dot(edgeNormal, v3 - v2);
if (s > 0.1f * b2_linearSlop)
{
types[1] = b2_concave;
}
else if (s >= -0.1f * b2_linearSlop)
{
types[1] = b2_flat;
}
else
{
types[1] = b2_convex;
}
}
if (types[0] == b2_convex)
{
// Check separation on previous edge.
b2Vec2 v0 = edgeA->m_vertex0;
b2Vec2 e0 = v1 - v0;
b2Vec2 n0(e0.y, -e0.x);
n0.Normalize();
if (isFrontSide == false)
{
n0 = -n0;
}
b2EPAxis axis1 = b2EPEdgeSeparation(v0, v1, n0, &polygonB, totalRadius);
if (axis1.separation > edgeAxis.separation)
{
// The polygon should collide with previous edge
return;
}
}
if (types[1] == b2_convex)
{
// Check separation on next edge.
b2Vec2 v3 = edgeA->m_vertex3;
b2Vec2 e2 = v3 - v2;
b2Vec2 n2(e2.y, -e2.x);
n2.Normalize();
if (isFrontSide == false)
{
n2 = -n2;
}
b2EPAxis axis2 = b2EPEdgeSeparation(v2, v3, n2, &polygonB, totalRadius);
if (axis2.separation > edgeAxis.separation)
{
// The polygon should collide with the next edge
return;
}
}
b2EPAxis polygonAxis = b2EPPolygonSeparation(v1, v2, edgeNormal, &polygonB, totalRadius);
if (polygonAxis.separation > totalRadius)
{
return;
}
// Use hysteresis for jitter reduction.
const float32 k_relativeTol = 0.98f;
const float32 k_absoluteTol = 0.001f;
b2EPAxis primaryAxis;
if (polygonAxis.separation > k_relativeTol * edgeAxis.separation + k_absoluteTol)
{
primaryAxis = polygonAxis;
}
else
{
primaryAxis = edgeAxis;
}
b2PolygonShape* poly1;
b2PolygonShape* poly2;
b2ClipVertex incidentEdge[2];
if (primaryAxis.type == b2EPAxis::e_edgeA)
{
poly1 = &polygonA;
poly2 = &polygonB;
if (isFrontSide == false)
{
primaryAxis.index = 1;
}
manifold->type = b2Manifold::e_faceA;
}
else
{
poly1 = &polygonB;
poly2 = &polygonA;
manifold->type = b2Manifold::e_faceB;
}
int32 edge1 = primaryAxis.index;
b2FindIncidentEdge(incidentEdge, poly1, primaryAxis.index, poly2);
int32 count1 = poly1->m_vertexCount;
const b2Vec2* vertices1 = poly1->m_vertices;
int32 iv1 = edge1;
int32 iv2 = edge1 + 1 < count1 ? edge1 + 1 : 0;
b2Vec2 v11 = vertices1[iv1];
b2Vec2 v12 = vertices1[iv2];
b2Vec2 tangent = v12 - v11;
tangent.Normalize();
b2Vec2 normal = b2Cross(tangent, 1.0f);
b2Vec2 planePoint = 0.5f * (v11 + v12);
// Face offset.
float32 frontOffset = b2Dot(normal, v11);
// Side offsets, extended by polytope skin thickness.
float32 sideOffset1 = -b2Dot(tangent, v11) + totalRadius;
float32 sideOffset2 = b2Dot(tangent, v12) + totalRadius;
// Clip incident edge against extruded edge1 side edges.
b2ClipVertex clipPoints1[2];
b2ClipVertex clipPoints2[2];
int np;
// Clip to box side 1
np = b2ClipSegmentToLine(clipPoints1, incidentEdge, -tangent, sideOffset1, iv1);
if (np < b2_maxManifoldPoints)
{
return;
}
// Clip to negative box side 1
np = b2ClipSegmentToLine(clipPoints2, clipPoints1, tangent, sideOffset2, iv2);
if (np < b2_maxManifoldPoints)
{
return;
}
// Now clipPoints2 contains the clipped points.
if (primaryAxis.type == b2EPAxis::e_edgeA)
{
manifold->localNormal = normal;
manifold->localPoint = planePoint;
}
else
{
manifold->localNormal = b2MulT(xf.R, normal);
manifold->localPoint = b2MulT(xf, planePoint);
}
int32 pointCount = 0;
for (int32 i = 0; i < b2_maxManifoldPoints; ++i)
{
float32 separation;
separation = b2Dot(normal, clipPoints2[i].v) - frontOffset;
if (separation <= totalRadius)
{
b2ManifoldPoint* cp = manifold->points + pointCount;
if (primaryAxis.type == b2EPAxis::e_edgeA)
{
cp->localPoint = b2MulT(xf, clipPoints2[i].v);
cp->id = clipPoints2[i].id;
}
else
{
cp->localPoint = clipPoints2[i].v;
cp->id.cf.typeA = clipPoints2[i].id.cf.typeB;
cp->id.cf.typeB = clipPoints2[i].id.cf.typeA;
cp->id.cf.indexA = clipPoints2[i].id.cf.indexB;
cp->id.cf.indexB = clipPoints2[i].id.cf.indexA;
}
if (cp->id.cf.typeA == b2ContactFeature::e_vertex && types[cp->id.cf.indexA] == b2_flat)
{
continue;
}
++pointCount;
}
}
manifold->pointCount = pointCount;
}
// Compute allowable normal ranges based on adjacency.
// A normal n is allowable iff:
// cross(n, n1) >= 0.0f && cross(n2, n) >= 0.0f
// n points from A to B (edge to polygon)
void b2EPCollider::ComputeAdjacency()
{
b2Vec2 v0 = m_edgeA.v0;
b2Vec2 v1 = m_edgeA.v1;
b2Vec2 v2 = m_edgeA.v2;
b2Vec2 v3 = m_edgeA.v3;
// Determine allowable the normal regions based on adjacency.
// Note: it may be possible that no normal is admissable.
b2Vec2 centerB = m_proxyB.centroid;
if (m_edgeA.hasVertex0)
{
b2Vec2 e0 = v1 - v0;
b2Vec2 e1 = v2 - v1;
b2Vec2 n0(e0.y, -e0.x);
b2Vec2 n1(e1.y, -e1.x);
n0.Normalize();
n1.Normalize();
bool convex = b2Cross(n0, n1) >= 0.0f;
bool front0 = b2Dot(n0, centerB - v0) >= 0.0f;
bool front1 = b2Dot(n1, centerB - v1) >= 0.0f;
if (convex)
{
if (front0 || front1)
{
m_limit11 = n1;
m_limit12 = n0;
}
else
{
m_limit11 = -n1;
m_limit12 = -n0;
}
}
else
{
if (front0 && front1)
{
m_limit11 = n0;
m_limit12 = n1;
}
else
{
m_limit11 = -n0;
m_limit12 = -n1;
}
}
}
else
{
m_limit11.SetZero();
m_limit12.SetZero();
}
if (m_edgeA.hasVertex3)
{
b2Vec2 e1 = v2 - v1;
b2Vec2 e2 = v3 - v2;
b2Vec2 n1(e1.y, -e1.x);
b2Vec2 n2(e2.y, -e2.x);
n1.Normalize();
n2.Normalize();
bool convex = b2Cross(n1, n2) >= 0.0f;
bool front1 = b2Dot(n1, centerB - v1) >= 0.0f;
bool front2 = b2Dot(n2, centerB - v2) >= 0.0f;
if (convex)
{
if (front1 || front2)
{
m_limit21 = n2;
m_limit22 = n1;
}
else
{
m_limit21 = -n2;
m_limit22 = -n1;
}
}
else
{
if (front1 && front2)
{
m_limit21 = n1;
m_limit22 = n2;
}
else
{
m_limit21 = -n1;
m_limit22 = -n2;
}
}
}
else
{
m_limit21.SetZero();
m_limit22.SetZero();
}
}
// This is test for onedAST.py
int main(int argc, char** argv)
{
int npt = 20; // No. points to sample on test printing
int k = 5; // order of wavelet
double thresh = 1e-12; // truncation threshold
// Step. 1 (Done!!!!)
FunctionAST f1(k, thresh, test1);
FunctionAST f2(k, thresh, test2);
FunctionAST f4(k, thresh, sinn);
// Step. 2
f1.func->compress(0, 0);
f2.func->compress(0, 0);
//dic_print_tree(f1.func->s, "f1");
//dic_print_tree(f2.func->s, "f2");
//dic_print_tree(f4.func->s, "f4");
// Step. 3
FunctionAST resultAST(k, thresh, NULL);
FunctionAST newresult(k, thresh, NULL);
// Step. 4
Node n0(&f1, 0, 0, 0, 0, 0, 0);
Node n1(&f2, 0, 0, 0, 0, 0, 0);
Node n2(&f2, 0, 0, 0, 0, 0, 0);
Node n4(&f4, 0, 0, 0, 0, 0, 0);
Node n6(&f4, 0, 0, 0, 0, 0, 0);
// Step. 5
// Reconstruct ASTs n1, n2, n22, n3
AST* ast01 = ast_create_item(2, NULL, NULL);
AST* ast02 = ast_create_item(0, &n0, NULL);
ast_insert_item(ast02, ast01);
AST* ast11 = ast_create_item(2, NULL, NULL);
AST* ast12 = ast_create_item(0, &n1, NULL);
ast_insert_item(ast12, ast11);
AST* ast21 = ast_create_item(2, NULL, NULL);
AST* ast22 = ast_create_item(0, &n2, NULL);
ast_insert_item(ast22, ast21);
// Step. 6
AST* ast51 = ast_create_item(3, NULL, NULL);
AST* ast52 = ast_create_item(0, &n6, NULL);
ast_insert_item(ast52, ast51);
// Create a full AST that computes (f1 + f2) * (f2 + f4 + diff(f4))
// AST_ADD0 = [0, AST0, AST2]
AST* add01 = ast_create_item(0, NULL, NULL);
AST* add02 = ast_create_item(0, NULL, ast01);
AST* add03 = ast_create_item(0, NULL, ast21);
ast_insert_item(add02, add01);
ast_insert_item(add03, add01);
// AST_ADD1 = [0, AST1, n4, AST5]
AST* add11 = ast_create_item(0, NULL, NULL);
AST* add12 = ast_create_item(0, NULL, ast11);
AST* add13 = ast_create_item(0, &n4, NULL);
AST* add14 = ast_create_item(0, NULL, ast51);
ast_insert_item(add12, add11);
ast_insert_item(add13, add11);
ast_insert_item(add14, add11);
// AST_MUL = [1, AST_ADD0, AST_ADD1]
AST* mul1 = ast_create_item(1, NULL, NULL);
AST* mul2 = ast_create_item(0, NULL, add01);
AST* mul3 = ast_create_item(0, NULL, add11);
ast_insert_item(mul2, mul1);
ast_insert_item(mul3, mul1);
// Compute using onsedAST
resultAST.traverse_tree(mul1, 0, 0);
printf ("\nAfter computing using onsedAST\n");
//dic_print_tree_python(resultAST.func->s, 0, 0);
// Compute (f1 + f2) * (f2 + f4 + diff(f4)) using original madpy without AST
FunctionAST* r_add0;
FunctionAST* r_add1;
FunctionAST* r_diff = new FunctionAST(k, thresh, NULL);
FunctionAST* r_add5;
FunctionAST* r_prod;
FunctionAST* df;
//dic_print_tree_python(f4.func->s, 0, 0);
r_add0 = f1 + &f2;
r_add1 = f2 + &f4;
r_diff->func = f4.func->diff(0, 0, NULL);
r_add5 = *r_add1 + r_diff;
r_prod = *r_add0 * r_add5;
r_prod->func->reconstruct(0, 0);
df = resultAST - r_prod;
printf ("Norm of Difference is %12.8f\n", df->func->norm2());
}
