void EmbeddedGMap2::splitVertex(Dart d, Dart e) { Dart dd = phi2(d) ; Dart ee = phi2(e) ; GMap2::splitVertex(d, e) ; if (isOrbitEmbedded<VERTEX>()) { unsigned int vEmb = getEmbedding<VERTEX>(d) ; setDartEmbedding<VERTEX>(phi1(dd), vEmb) ; setDartEmbedding<VERTEX>(beta2(phi1(dd)), vEmb) ; setDartEmbedding<VERTEX>(beta0(dd), vEmb) ; setOrbitEmbeddingOnNewCell<VERTEX>(e) ; copyCell<VERTEX>(e, d) ; } if(isOrbitEmbedded<EDGE>()) { initOrbitEmbeddingNewCell<EDGE>(phi1(dd)) ; } if(isOrbitEmbedded<FACE>()) { unsigned int f1Emb = getEmbedding<FACE>(dd) ; copyDartEmbedding<FACE>(phi1(dd), Dart::create(f1Emb)) ; copyDartEmbedding<FACE>(beta0(phi1(dd)), Dart::create(f1Emb)) ; unsigned int f2Emb = getEmbedding<FACE>(ee) ; copyDartEmbedding<FACE>(phi1(ee), Dart::create(f2Emb)) ; copyDartEmbedding<FACE>(beta0(phi1(ee)), Dart::create(f2Emb)) ; } }
Dart EmbeddedGMap2::cutEdge(Dart d) { Dart nd = GMap2::cutEdge(d) ; if(isOrbitEmbedded<VERTEX>()) { Algo::Topo::initOrbitEmbeddingOnNewCell<VERTEX>(*this, nd) ; } if (isOrbitEmbedded<EDGE>()) { unsigned int eEmb = getEmbedding<EDGE>(d) ; setDartEmbedding<EDGE>(phi2(d), eEmb) ; setDartEmbedding<EDGE>(beta0(d), eEmb) ; Algo::Topo::setOrbitEmbeddingOnNewCell<EDGE>(*this, nd) ; Algo::Topo::copyCellAttributes<EDGE>(*this, nd, d) ; } if(isOrbitEmbedded<FACE>()) { unsigned int f1Emb = getEmbedding<FACE>(d) ; setDartEmbedding<FACE>(phi1(d), f1Emb) ; setDartEmbedding<FACE>(beta0(d), f1Emb) ; Dart e = phi2(nd) ; unsigned int f2Emb = getEmbedding<FACE>(d) ; setDartEmbedding<FACE>(phi1(e), f2Emb) ; setDartEmbedding<FACE>(beta0(e), f2Emb) ; } return nd ; }
void EBSDAccessFunctorsTest::test() { RealVectorValue reference_angle(0.1, 0.2, 0.3); Point reference_point1 = Point(9.0, 10.0, 11.0); Point reference_point2 = Point(6.0, 7.0, 8.0); // Test point data access { EBSDPointDataPhi1 phi1; CPPUNIT_ASSERT( phi1(_point) == _point._phi1 ); EBSDPointDataPhi phi; CPPUNIT_ASSERT( phi(_point) == _point._Phi ); EBSDPointDataPhi2 phi2; CPPUNIT_ASSERT( phi2(_point) == _point._phi2 ); EBSDPointDataPhase phase; CPPUNIT_ASSERT( phase(_point) == _point._phase ); EBSDPointDataSymmetry symmetry; CPPUNIT_ASSERT( symmetry(_point) == _point._symmetry ); EBSDPointDataGrain grain; CPPUNIT_ASSERT( grain(_point) == _point._grain ); EBSDPointDataOp op; CPPUNIT_ASSERT( op(_point) == _point._op ); for (unsigned int i = 0; i < 3; ++i) { EBSDPointDataCustom custom(i); CPPUNIT_ASSERT( custom(_point) == _point._custom[i] ); } } // Test average data access { RealVectorValue angle = *(_avg._angles); CPPUNIT_ASSERT( (angle - reference_angle).size() == 0 ); EBSDAvgDataPhi1 phi1; CPPUNIT_ASSERT( phi1(_avg) == angle(0) ); EBSDAvgDataPhi phi; CPPUNIT_ASSERT( phi(_avg) == angle(1) ); EBSDAvgDataPhi2 phi2; CPPUNIT_ASSERT( phi2(_avg) == angle(2) ); EBSDAvgDataPhase phase; CPPUNIT_ASSERT( phase(_avg) == _avg._phase ); EBSDAvgDataSymmetry symmetry; CPPUNIT_ASSERT( symmetry(_avg) == _avg._symmetry ); EBSDAvgDataGrain grain; CPPUNIT_ASSERT( grain(_avg) == _avg._grain ); EBSDAvgDataLocalID local; CPPUNIT_ASSERT( local(_avg) == _avg._local ); for (unsigned int i = 0; i < 3; ++i) { EBSDAvgDataCustom custom(i); CPPUNIT_ASSERT( custom(_avg) == _avg._custom[i] ); } } }
unsigned int EmbeddedGMap2::closeHole(Dart d, bool forboundary) { unsigned int nbE = GMap2::closeHole(d, forboundary) ; Dart dd = phi2(d) ; Dart it = dd ; do { if (isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(it, beta2(it)) ; copyDartEmbedding<VERTEX>(beta0(it), phi2(it)) ; } if (isOrbitEmbedded<EDGE>()) { unsigned int eEmb = getEmbedding<EDGE>(beta2(it)) ; setDartEmbedding<EDGE>(it, eEmb) ; setDartEmbedding<EDGE>(beta0(it), eEmb) ; } it = phi1(it) ; } while(it != dd) ; if(isOrbitEmbedded<FACE>()) { Algo::Topo::initOrbitEmbeddingOnNewCell<FACE>(*this, dd) ; } return nbE ; }
void EmbeddedGMap2::splitVertex(Dart d, Dart e) { Dart dd = phi2(d) ; Dart ee = phi2(e) ; GMap2::splitVertex(d, e) ; if (isOrbitEmbedded<VERTEX>()) { unsigned int vEmb = getEmbedding<VERTEX>(d) ; setDartEmbedding<VERTEX>(phi1(dd), vEmb) ; setDartEmbedding<VERTEX>(beta2(phi1(dd)), vEmb) ; setDartEmbedding<VERTEX>(beta0(dd), vEmb) ; Algo::Topo::setOrbitEmbeddingOnNewCell<VERTEX>(*this, e) ; Algo::Topo::copyCellAttributes<VERTEX>(*this, e, d) ; } if(isOrbitEmbedded<EDGE>()) { Algo::Topo::initOrbitEmbeddingOnNewCell<EDGE>(*this, phi1(dd)) ; } if(isOrbitEmbedded<FACE>()) { unsigned int f1Emb = getEmbedding<FACE>(dd) ; setDartEmbedding<FACE>(phi1(dd), f1Emb) ; setDartEmbedding<FACE>(beta0(phi1(dd)), f1Emb) ; unsigned int f2Emb = getEmbedding<FACE>(ee) ; setDartEmbedding<FACE>(phi1(ee), f2Emb) ; setDartEmbedding<FACE>(beta0(phi1(ee)), f2Emb) ; } }
Dart EmbeddedGMap3::cutEdge(Dart d) { Dart nd = GMap3::cutEdge(d); if(isOrbitEmbedded<EDGE>()) { // embed the new darts created in the cut edge unsigned int eEmb = getEmbedding<EDGE>(d) ; Dart e = d ; do { setDartEmbedding<EDGE>(beta0(e), eEmb) ; e = alpha2(e) ; } while(e != d) ; // embed a new cell for the new edge and copy the attributes' line (c) Lionel setOrbitEmbeddingOnNewCell<EDGE>(phi1(d)) ; copyCell<EDGE>(phi1(d), d) ; } if(isOrbitEmbedded<FACE>()) { Dart f = d; do { unsigned int fEmb = getEmbedding<FACE>(f) ; setDartEmbedding<FACE>(beta0(f), fEmb); setDartEmbedding<FACE>(phi1(f), fEmb); setDartEmbedding<FACE>(phi3(f), fEmb); setDartEmbedding<FACE>(beta1(phi3(f)), fEmb); f = alpha2(f); } while(f != d); } if(isOrbitEmbedded<VOLUME>()) { Dart f = d; do { unsigned int vEmb = getEmbedding<VOLUME>(f) ; setDartEmbedding<VOLUME>(beta0(f), vEmb); setDartEmbedding<VOLUME>(phi1(f), vEmb); setDartEmbedding<VOLUME>(phi2(f), vEmb); setDartEmbedding<VOLUME>(beta1(phi2(f)), vEmb); f = alpha2(f); } while(f != d); } return nd ; }
bool EmbeddedGMap2::edgeCanCollapse(Dart d) { if(isBoundaryVertex(d) || isBoundaryVertex(phi1(d))) return false ; unsigned int val_v1 = vertexDegree(d) ; unsigned int val_v2 = vertexDegree(phi1(d)) ; if(val_v1 + val_v2 < 8 || val_v1 + val_v2 > 14) return false ; if(faceDegree(d) == 3) { if(vertexDegree(phi_1(d)) < 4) return false ; } Dart dd = phi2(d) ; if(faceDegree(dd) == 3) { if(vertexDegree(phi_1(dd)) < 4) return false ; } // Check vertex sharing condition std::vector<unsigned int> vu1 ; vu1.reserve(32) ; Dart vit1 = alpha1(alpha1(d)) ; Dart end = phi1(dd) ; do { unsigned int ve = getEmbedding<VERTEX>(phi2(vit1)) ; vu1.push_back(ve) ; vit1 = alpha1(vit1) ; } while(vit1 != end) ; end = phi1(d) ; Dart vit2 = alpha1(alpha1(dd)) ; do { unsigned int ve = getEmbedding<VERTEX>(phi2(vit2)) ; std::vector<unsigned int>::iterator it = std::find(vu1.begin(), vu1.end(), ve) ; if(it != vu1.end()) return false ; vit2 = alpha1(vit2) ; } while(vit2 != end) ; return true ; }
void EmbeddedMap2::unsewFaces(Dart d) { Dart e = phi2(d) ; Map2::unsewFaces(d) ; if (isOrbitEmbedded<VERTEX>()) { Dart ee = phi1(e) ; if(!sameVertex(d, ee)) { embedNewCell<VERTEX>(ee); copyCell<VERTEX>(ee, d); } Dart dd = phi1(d) ; if(!sameVertex(e, dd)) { embedNewCell<VERTEX>(dd); copyCell<VERTEX>(dd, e); } } if (isOrbitEmbedded<EDGE>()) { embedNewCell<EDGE>(e); copyCell<EDGE>(e, d); } }
bool EmbeddedGMap2::flipBackEdge(Dart d) { if(GMap2::flipBackEdge(d)) { Dart e = phi2(d) ; if (isOrbitEmbedded<VERTEX>()) { unsigned int v1Emb = getEmbedding<VERTEX>(beta1(d)) ; setDartEmbedding<VERTEX>(d, v1Emb) ; setDartEmbedding<VERTEX>(beta2(d), v1Emb) ; unsigned int v2Emb = getEmbedding<VERTEX>(beta1(e)) ; setDartEmbedding<VERTEX>(e, v2Emb) ; setDartEmbedding<VERTEX>(beta2(e), v2Emb) ; } if (isOrbitEmbedded<FACE>()) { unsigned int f1Emb = getEmbedding<FACE>(d) ; setDartEmbedding<FACE>(phi1(d), f1Emb) ; setDartEmbedding<FACE>(beta0(phi1(d)), f1Emb) ; unsigned int f2Emb = getEmbedding<FACE>(e) ; setDartEmbedding<FACE>(phi1(e), f2Emb) ; setDartEmbedding<FACE>(beta0(phi1(e)), f2Emb) ; } return true ; } return false ; }
bool EmbeddedMap2::check() { bool topo = Map2::check() ; if (!topo) return false ; CGoGNout << "Check: embedding begin" << CGoGNendl ; for(Dart d = begin(); d != end(); next(d)) { if (isOrbitEmbedded<VERTEX>()) { if (getEmbedding<VERTEX>(d) != getEmbedding<VERTEX>(alpha1(d))) { CGoGNout << "Check: different embeddings on vertex" << CGoGNendl ; return false ; } } if (isOrbitEmbedded<EDGE>()) { if (getEmbedding<EDGE>(d) != getEmbedding<EDGE>(phi2(d))) { CGoGNout << "Check: different embeddings on edge" << CGoGNendl ; return false ; } } // if (isOrbitEmbedded(ORIENTED_FACE)) // { // if (getEmbedding(ORIENTED_FACE, d) != getEmbedding(ORIENTED_FACE, phi1(d))) // { // CGoGNout << "Check: different embeddings on oriented face" << CGoGNendl ; // return false ; // } // } if (isOrbitEmbedded<FACE>()) { if (getEmbedding<FACE>(d) != getEmbedding<FACE>(phi1(d))) { CGoGNout << "Check: different embeddings on face" << CGoGNendl ; return false ; } } } CGoGNout << "Check: embedding ok" << CGoGNendl ; std::cout << "nb vertex orbits : " << getNbOrbits<VERTEX>() << std::endl ; std::cout << "nb vertex cells : " << m_attribs[VERTEX].size() << std::endl ; std::cout << "nb edge orbits : " << getNbOrbits<EDGE>() << std::endl ; std::cout << "nb edge cells : " << m_attribs[EDGE].size() << std::endl ; std::cout << "nb face orbits : " << getNbOrbits<FACE>() << std::endl ; std::cout << "nb face cells : " << m_attribs[FACE].size() << std::endl ; return true ; }
bool EmbeddedMap2::collapseDegeneratedFace(Dart d) { Dart e = phi2(d) ; bool updateEdgeEmb = false ; if(phi1(d) != d) updateEdgeEmb = true ; if(Map2::collapseDegeneratedFace(d)) { if (isOrbitEmbedded<EDGE>() && updateEdgeEmb) { copyDartEmbedding<EDGE>(phi2(e), e) ; } return true ; } return false ; }
bool EmbeddedGMap2::mergeVolumes(Dart d, Dart e) { std::vector<Dart> darts ; std::vector<unsigned int> vEmb ; std::vector<unsigned int> eEmb ; darts.reserve(32) ; vEmb.reserve(32) ; eEmb.reserve(32) ; Dart fit = d ; do { darts.push_back(phi2(fit)) ; if (isOrbitEmbedded<VERTEX>()) { vEmb.push_back(getEmbedding<VERTEX>(phi2(fit))) ; } if (isOrbitEmbedded<EDGE>()) { eEmb.push_back(getEmbedding<EDGE>(fit)) ; } fit = phi1(fit) ; } while (fit != d) ; if(GMap2::mergeVolumes(d, e)) { for(unsigned int i = 0; i < darts.size(); ++i) { if (isOrbitEmbedded<VERTEX>()) { Algo::Topo::setOrbitEmbedding<VERTEX>(*this, darts[i], vEmb[i]) ; } if (isOrbitEmbedded<EDGE>()) { Algo::Topo::setOrbitEmbedding<EDGE>(*this, darts[i], eEmb[i]) ; } } return true ; } return false ; }
int main() { // Primary Operators AnnihilationOperator A1(0); // 1st freedom NumberOperator N1(0); IdentityOperator Id1(0); AnnihilationOperator A2(1); // 2nd freedom NumberOperator N2(1); IdentityOperator Id2(1); SigmaPlus Sp(2); // 3rd freedom IdentityOperator Id3(2); Operator Sm = Sp.hc(); // Hermitian conjugate Operator Ac1 = A1.hc(); Operator Ac2 = A2.hc(); // Hamiltonian double E = 20.0; double chi = 0.4; double omega = -0.7; double eta = 0.001; Complex I(0.0,1.0); Operator H = (E*I)*(Ac1-A1) + (0.5*chi*I)*(Ac1*Ac1*A2 - A1*A1*Ac2) + omega*Sp*Sm + (eta*I)*(A2*Sp-Ac2*Sm); // Lindblad operators double gamma1 = 1.0; double gamma2 = 1.0; double kappa = 0.1; const int nL = 3; Operator L[nL]={sqrt(2*gamma1)*A1,sqrt(2*gamma2)*A2,sqrt(2*kappa)*Sm}; // Initial state State phi1(50,FIELD); // see paper Section 4.2 State phi2(50,FIELD); State phi3(2,SPIN); State stateList[3] = {phi1,phi2,phi3}; State psiIni(3,stateList); // Trajectory double dt = 0.01; // basic time step int numdts = 100; // time interval between outputs = numdts*dt int numsteps = 5; // total integration time = numsteps*numdts*dt int nOfMovingFreedoms = 2; double epsilon = 0.01; // cutoff probability int nPad = 2; // pad size //ACG gen(38388389); // random number generator with seed //ComplexNormal rndm(&gen); // Complex Gaussian random numbers ComplexNormalTest rndm(899101); // Simple portable random number generator AdaptiveStep stepper(psiIni, H, nL, L); // see paper Section 5 // Output const int nOfOut = 3; Operator outlist[nOfOut]={ Sp*A2*Sm*Sp, Sm*Sp*A2*Sm, A2 }; char *flist[nOfOut]={"X1.out","X2.out","A2.out"}; int pipe[] = {1,5,9,11}; // controls standard output (see `onespin.cc') // Simulate one trajectory (for several trajectories see `onespin.cc') Trajectory traj(psiIni, dt, stepper, &rndm); // see paper Section 5 traj.plotExp( nOfOut, outlist, flist, pipe, numdts, numsteps, nOfMovingFreedoms, epsilon, nPad ); }
unsigned int EmbeddedMap2::closeHole(Dart d, bool forboundary) { unsigned int nbE = Map2::closeHole(d, forboundary) ; Dart dd = phi2(d) ; Dart f = dd ; do { if (isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(f, phi2(phi_1(f))) ; } if (isOrbitEmbedded<EDGE>()) { copyDartEmbedding<EDGE>(f, phi2(f)) ; } f = phi1(f) ; } while(dd != f) ; return nbE ; }
inline Dart GMap2::phi(Dart d) const { assert( (N >0) || !"negative parameters not allowed in template multi-phi"); if (N<10) { switch(N) { case 1 : return phi1(d) ; case 2 : return phi2(d) ; default : assert(!"Wrong multi-phi relation value") ; return d ; } } switch(N%10) { case 1 : return phi1(phi<N/10>(d)) ; case 2 : return phi2(phi<N/10>(d)) ; default : assert(!"Wrong multi-phi relation value") ; return d ; } }
Dart EmbeddedMap2::cutEdge(Dart d) { Dart nd = Map2::cutEdge(d) ; if (isOrbitEmbedded<EDGE>()) { copyDartEmbedding<EDGE>(phi2(d), d) ; embedNewCell<EDGE>(nd) ; copyCell<EDGE>(nd, d) ; } if(isOrbitEmbedded<FACE>()) { copyDartEmbedding<FACE>(nd, d) ; Dart e = phi2(nd) ; copyDartEmbedding<FACE>(phi1(e), e) ; } return nd; }
void RBEC::run() { initialize(); buildMatrixStruct(); initialValue(); FEMFunction <double, DIM> phi2(fem_space); do { stepForward(); for (int i = 0; i < fem_space.n_dof(); ++i) phi2(i) = phi_re(i) * phi_re(i); phi2.writeOpenDXData("phi2.dx"); std::cout << "t = " << t << std::endl; } while (t < 3); };
bool EmbeddedMap2::uncutEdge(Dart d) { if(Map2::uncutEdge(d)) { if(isOrbitEmbedded<EDGE>()) { copyDartEmbedding<EDGE>(phi2(d), d) ; } return true ; } return false ; }
void EmbeddedMap2::splitVertex(Dart d, Dart e) { Dart dd = phi2(d) ; Dart ee = phi2(e) ; Map2::splitVertex(d, e) ; if (isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(phi1(dd), d) ; copyDartEmbedding<VERTEX>(phi1(ee), e) ; embedNewCell<VERTEX>(e) ; copyCell<VERTEX>(e, d) ; } if(isOrbitEmbedded<FACE>()) { copyDartEmbedding<FACE>(phi1(dd), dd) ; copyDartEmbedding<FACE>(phi1(ee), ee) ; } }
bool EmbeddedGMap2::check() const { bool topo = GMap2::check() ; if (!topo) return false ; CGoGNout << "Check: embedding begin" << CGoGNendl ; for(Dart d = begin(); d != end(); next(d)) { if (isOrbitEmbedded<VERTEX>()) { if (getEmbedding<VERTEX>(d) != getEmbedding<VERTEX>(alpha1(d))) { CGoGNout << "Check: different embeddings on vertex" << CGoGNendl ; return false ; } } if (isOrbitEmbedded<EDGE>()) { if (getEmbedding<EDGE>(d) != getEmbedding<EDGE>(phi2(d))) { CGoGNout << "Check: different embeddings on edge" << CGoGNendl ; return false ; } } if (isOrbitEmbedded<FACE>()) { if (getEmbedding<FACE>(d) != getEmbedding<FACE>(phi1(d))) { CGoGNout << "Check: different embeddings on face" << CGoGNendl ; return false ; } } } CGoGNout << "Check: embedding ok" << CGoGNendl ; std::cout << "nb vertex orbits : " << Algo::Topo::getNbOrbits<VERTEX>(*this) << std::endl ; std::cout << "nb vertex cells : " << m_attribs[VERTEX].size() << std::endl ; std::cout << "nb edge orbits : " << Algo::Topo::getNbOrbits<EDGE>(*this) << std::endl ; std::cout << "nb edge cells : " << m_attribs[EDGE].size() << std::endl ; std::cout << "nb face orbits : " << Algo::Topo::getNbOrbits<FACE>(*this) << std::endl ; std::cout << "nb face cells : " << m_attribs[FACE].size() << std::endl ; return true ; }
bool EmbeddedGMap2::uncutEdge(Dart d) { if(GMap2::uncutEdge(d)) { if(isOrbitEmbedded<EDGE>()) { unsigned int eEmb = getEmbedding<EDGE>(d) ; setDartEmbedding<EDGE>(phi2(d), eEmb) ; setDartEmbedding<EDGE>(beta0(d), eEmb) ; } return true ; } return false ; }
bool EmbeddedGMap3::mergeVolumes(Dart d) { Dart d2 = phi2(d); if(GMap3::mergeVolumes(d)) { if (isOrbitEmbedded<VOLUME>()) { setOrbitEmbedding<VOLUME>(d2, getEmbedding<VOLUME>(d2)) ; } return true; } return false; }
bool EmbeddedGMap2::collapseDegeneratedFace(Dart d) { Dart e = beta2(d) ; bool updateEdgeEmb = false ; if(phi1(d) != d) updateEdgeEmb = true ; if(GMap2::collapseDegeneratedFace(d)) { if (isOrbitEmbedded<EDGE>() && updateEdgeEmb) { unsigned int eEmb = getEmbedding<EDGE>(e) ; setDartEmbedding<EDGE>(beta2(e), eEmb) ; setDartEmbedding<EDGE>(phi2(e), eEmb) ; } return true ; } return false ; }
Dart EmbeddedGMap2::newFace(unsigned int nbEdges, bool withBoundary) { Dart d = GMap2::newFace(nbEdges, withBoundary); if(withBoundary) { if (isOrbitEmbedded<VERTEX>()) { Traversor2FV<EmbeddedGMap2> t(*this, d); for(Dart it = t.begin(); it != t.end(); it = t.next()) Algo::Topo::initOrbitEmbeddingOnNewCell<VERTEX>(*this, it) ; } if(isOrbitEmbedded<EDGE>()) { Traversor2FE<EmbeddedGMap2> t(*this, d); for(Dart it = t.begin(); it != t.end(); it = t.next()) Algo::Topo::initOrbitEmbeddingOnNewCell<EDGE>(*this, it) ; } if(isOrbitEmbedded<FACE>()) { Algo::Topo::initOrbitEmbeddingOnNewCell<FACE>(*this, d) ; Algo::Topo::initOrbitEmbeddingOnNewCell<FACE>(*this, phi2(d)) ; } } // else // { // if (isOrbitEmbedded<VERTEX>()) // { // Traversor2FV<EmbeddedGMap2> t(*this, d); // for(Dart it = t.begin(); it != t.end(); it = t.next()) // initOrbitEmbeddingNewCell<VERTEX>(it) ; // } // if(isOrbitEmbedded<FACE>()) // initOrbitEmbeddingNewCell<FACE>(d) ; // } return d ; }
void EmbeddedMap2::splitSurface(std::vector<Dart>& vd, bool firstSideClosed, bool secondSideClosed) { std::vector<Dart> darts ; darts.reserve(vd.size()); // save the edge neighbors darts for(std::vector<Dart>::iterator it = vd.begin() ; it != vd.end() ; ++it) { darts.push_back(phi2(*it)); } assert(darts.size() == vd.size()); Map2::splitSurface(vd, firstSideClosed, secondSideClosed); // follow the edge path a second time to embed the vertex, edge and volume orbits for(unsigned int i = 0; i < vd.size(); ++i) { Dart dit = vd[i]; Dart dit2 = darts[i]; // embed the vertex embedded from the origin volume to the new darts if(isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(phi2(dit), phi1(dit)); copyDartEmbedding<VERTEX>(phi2(dit2), phi1(dit2)); } // embed the edge embedded from the origin volume to the new darts if(isOrbitEmbedded<EDGE>()) { unsigned int eEmb = getEmbedding<EDGE>(dit) ; setDartEmbedding<EDGE>(phi2(dit), eEmb); setDartEmbedding<EDGE>(phi2(dit2), eEmb); } // embed the volume embedded from the origin volume to the new darts if(isOrbitEmbedded<VOLUME>()) { copyDartEmbedding<VOLUME>(phi2(dit), dit); copyDartEmbedding<VOLUME>(phi2(dit2), dit2); } } }
bool EmbeddedMap2::flipBackEdge(Dart d) { if(Map2::flipBackEdge(d)) { Dart e = phi2(d) ; if (isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(d, phi1(e)) ; copyDartEmbedding<VERTEX>(e, phi1(d)) ; } if (isOrbitEmbedded<FACE>()) { copyDartEmbedding<FACE>(phi1(d), d) ; copyDartEmbedding<FACE>(phi1(e), e) ; } return true ; } return false ; }
bool tXMap<DART>::foreach_dart_of_cc(Dart d, FunctorType& f, unsigned int thread) { DartMarkerStore m(*this,thread); bool found = false; std::list<Dart> darts_list; darts_list.push_back(d); m.mark(d); typename std::list<Dart>::iterator prem = darts_list.begin(); while (!found && prem != darts_list.end()) { Dart d1 = *prem; // add phi21 and phi23 successor of they are not yet marked Dart d2 = phi1(d1); // turn in face Dart d3 = phi2(d1); // change volume Dart d4 = phi3(d1); // change volume if (!m.isMarked(d2)) { darts_list.push_back(d2); m.mark(d2); } if (!m.isMarked(d3)) { darts_list.push_back(d2); m.mark(d2); } if (!m.isMarked(d4)) { darts_list.push_back(d4); m.mark(d4); } prem++; found = f(d1); // functor say finish } return found; }
bool ImplicitHierarchicalMap2::edgeCanBeCoarsened(Dart d) { assert(m_dartLevel[d] <= m_curLevel || !"Access to a dart introduced after current level") ; bool subd = false ; bool subdOnce = true ; bool degree2 = false ; if(edgeIsSubdivided(d)) { subd = true ; Dart d2 = phi2(d) ; ++m_curLevel ; if(vertexDegree(phi1(d)) == 2) { degree2 = true ; if(edgeIsSubdivided(d) || edgeIsSubdivided(d2)) subdOnce = false ; } --m_curLevel ; } return subd && degree2 && subdOnce ; }
bool ImplicitHierarchicalMap2::faceIsSubdividedOnce(Dart d) { assert(m_dartLevel[d] <= m_curLevel || !"Access to a dart introduced after current level") ; unsigned int fLevel = faceLevel(d) ; if(fLevel < m_curLevel) // a face whose level in the current level map is lower than return false ; // the current level can not be subdivided to higher levels unsigned int degree = 0 ; bool subd = false ; bool subdOnce = true ; Dart fit = d ; do { ++m_curLevel ; if(m_dartLevel[phi1(fit)] == m_curLevel && m_edgeId[phi1(fit)] != m_edgeId[fit]) { subd = true ; ++m_curLevel ; if(m_dartLevel[phi1(fit)] == m_curLevel && m_edgeId[phi1(fit)] != m_edgeId[fit]) subdOnce = false ; --m_curLevel ; } --m_curLevel ; ++degree ; fit = phi1(fit) ; } while(subd && subdOnce && fit != d) ; if(degree == 3 && subd) { ++m_curLevel ; Dart cf = phi2(phi1(d)) ; ++m_curLevel ; if(m_dartLevel[phi1(cf)] == m_curLevel && m_edgeId[phi1(cf)] != m_edgeId[cf]) subdOnce = false ; --m_curLevel ; --m_curLevel ; } return subd && subdOnce ; }
void EmbeddedMap2::swapEdges(Dart d, Dart e) { Dart d2 = phi2(d); Dart e2 = phi2(e); Map2::swapEdges(d,e); if(isOrbitEmbedded<VERTEX>()) { copyDartEmbedding<VERTEX>(d, phi2(phi_1(d))); copyDartEmbedding<VERTEX>(e, phi2(phi_1(e))); copyDartEmbedding<VERTEX>(d2, phi2(phi_1(d2))); copyDartEmbedding<VERTEX>(e2, phi2(phi_1(e2))); } if(isOrbitEmbedded<EDGE>()) { } if(isOrbitEmbedded<VOLUME>()) embedNewCell<VOLUME>(d); }