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);
}
