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 ;
}
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 ;
}
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)) ;
}
}
void EmbeddedGMap2::unsewFaces(Dart d)
{
Dart e = beta2(d);
GMap2::unsewFaces(d);
if (isOrbitEmbedded<VERTEX>())
{
if(!sameVertex(d,e))
{
Algo::Topo::setOrbitEmbeddingOnNewCell<VERTEX>(*this, e);
Algo::Topo::copyCellAttributes<VERTEX>(*this, e, d);
}
d = beta0(d);
e = beta0(e);
if(!sameVertex(d,e))
{
Algo::Topo::setOrbitEmbeddingOnNewCell<VERTEX>(*this, e);
Algo::Topo::copyCellAttributes<VERTEX>(*this, e, d);
}
}
if (isOrbitEmbedded<EDGE>())
{
Algo::Topo::setOrbitEmbeddingOnNewCell<EDGE>(*this, e);
Algo::Topo::copyCellAttributes<EDGE>(*this, e, d);
}
}
void EmbeddedGMap2::unsewFaces(Dart d)
{
Dart e = beta2(d);
GMap2::unsewFaces(d);
if (isOrbitEmbedded<VERTEX>())
{
if(!sameVertex(d,e))
{
setOrbitEmbeddingOnNewCell<VERTEX>(e);
copyCell<VERTEX>(e, d);
}
d = beta0(d);
e = beta0(e);
if(!sameVertex(d,e))
{
setOrbitEmbeddingOnNewCell<VERTEX>(e);
copyCell<VERTEX>(e, d);
}
}
if (isOrbitEmbedded<EDGE>())
{
setOrbitEmbeddingOnNewCell<EDGE>(e);
copyCell<EDGE>(e, d);
}
}
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) ;
}
}
void EmbeddedGMap3::splitVolume(std::vector<Dart>& vd)
{
GMap3::splitVolume(vd);
// follow the edge path a second time to embed the vertex, edge and volume orbits
for(std::vector<Dart>::iterator it = vd.begin() ; it != vd.end() ; ++it)
{
Dart dit = *it;
// embed the vertex embedded from the origin volume to the new darts
if(isOrbitEmbedded<VERTEX>())
{
unsigned int vEmb = getEmbedding<VERTEX>(dit) ;
setDartEmbedding<VERTEX>(beta2(dit), vEmb);
setDartEmbedding<VERTEX>(beta3(beta2(dit)), vEmb);
setDartEmbedding<VERTEX>(beta1(beta2(dit)), vEmb);
setDartEmbedding<VERTEX>(beta3(beta1(beta2(dit))), vEmb);
}
// embed the edge embedded from the origin volume to the new darts
if(isOrbitEmbedded<EDGE>())
{
unsigned int eEmb = getEmbedding<EDGE>(dit) ;
setDartEmbedding<EDGE>(beta2(dit), eEmb);
setDartEmbedding<EDGE>(beta3(beta2(dit)), eEmb);
setDartEmbedding<EDGE>(beta0(beta2(dit)), eEmb);
setDartEmbedding<EDGE>(beta0(beta3(beta2(dit))), eEmb);
}
// embed the volume embedded from the origin volume to the new darts
if(isOrbitEmbedded<VOLUME>())
{
unsigned int vEmb = getEmbedding<VOLUME>(dit) ;
setDartEmbedding<VOLUME>(beta2(dit), vEmb);
setDartEmbedding<VOLUME>(beta0(beta2(dit)), vEmb);
}
}
if(isOrbitEmbedded<VOLUME>())
{
Dart v = vd.front() ;
Dart v23 = alpha2(v) ;
setOrbitEmbeddingOnNewCell<VOLUME>(v23) ;
copyCell<VOLUME>(v23, v) ;
}
}
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 ;
}
inline Dart GMap2::beta(const Dart d) const
{
assert( (N > 0) || !"negative parameters not allowed in template multi-beta");
if (N<10)
{
switch(N)
{
case 0 : return beta0(d) ;
case 1 : return beta1(d) ;
case 2 : return beta2(d) ;
default : assert(!"Wrong multi-beta relation value") ;
}
}
switch(N%10)
{
case 0 : return beta0(beta<N/10>(d)) ;
case 1 : return beta1(beta<N/10>(d)) ;
case 2 : return beta2(beta<N/10>(d)) ;
default : assert(!"Wrong multi-beta relation value") ;
}
}
unsigned int EmbeddedGMap3::closeHole(Dart d, bool forboundary)
{
unsigned int nbF = GMap3::closeHole(d, forboundary) ;
DartMarkerStore mark(*this); // Lock a marker
std::vector<Dart> visitedFaces; // Faces that are traversed
visitedFaces.reserve(1024) ;
visitedFaces.push_back(beta3(d));// Start with the face of d
mark.markOrbit<FACE>(beta3(d)) ;
// For every face added to the list
for(unsigned int i = 0; i < visitedFaces.size(); ++i)
{
Dart f = visitedFaces[i] ;
do
{
if(isOrbitEmbedded<VERTEX>())
{
unsigned int vEmb = getEmbedding<VERTEX>(beta3(f)) ;
setDartEmbedding<VERTEX>(f, vEmb) ;
setDartEmbedding<VERTEX>(beta1(f), vEmb) ;
}
if(isOrbitEmbedded<EDGE>())
{
unsigned int eEmb = getEmbedding<EDGE>(beta3(f)) ;
setDartEmbedding<EDGE>(f, eEmb) ;
setDartEmbedding<EDGE>(beta0(f), eEmb) ;
}
if(isOrbitEmbedded<FACE>())
{
unsigned int fEmb = getEmbedding<FACE>(beta3(f)) ;
setDartEmbedding<FACE>(f, fEmb) ;
setDartEmbedding<FACE>(beta0(f), fEmb) ;
}
Dart adj = beta2(f); // Get adjacent face
if (!mark.isMarked(adj))
{
visitedFaces.push_back(adj); // Add it
mark.markOrbit<FACE>(adj) ;
}
f = phi1(f) ;
} while(f != visitedFaces[i]) ;
}
return nbF ;
}
inline Dart GMap2::alpha0(Dart d) const
{
return beta2(beta0(d)) ;
}
inline Dart GMap2::alpha1(Dart d)
{
return beta2(beta1(d)) ;
}
Mssm calc_beta() const { return beta2(); }
inline Dart GMap2::phi2(Dart d) const
{
return beta2(beta0(d)) ;
}
inline bool GMap2::sameVolume(Dart d, Dart e) const
{
return sameOrientedVolume(d, e) || sameOrientedVolume(beta2(d), e) ;
}
inline bool GMap2::isBoundaryEdge(Dart d) const
{
return isBoundaryMarked2(d) || isBoundaryMarked2(beta2(d));
}
inline bool GMap2::sameEdge(Dart d, Dart e) const
{
return d == e || beta2(d) == e || beta0(d) == e || beta2(beta0(d)) == e ;
}
inline bool GMap2::sameVertex(Dart d, Dart e) const
{
return sameOrientedVertex(d, e) || sameOrientedVertex(beta2(d), e) ;
}
inline Dart GMap3::alpha_2(Dart d)
{
return beta2(beta3(d)) ;
}
void EmbeddedGMap3::splitFace(Dart d, Dart e)
{
Dart dd = beta1(beta3(d));
Dart ee = beta1(beta3(e));
GMap3::splitFace(d, e);
if(isOrbitEmbedded<VERTEX>())
{
unsigned int vEmb1 = getEmbedding<VERTEX>(d) ;
unsigned int vEmb2 = getEmbedding<VERTEX>(e) ;
setDartEmbedding<VERTEX>(beta1(d), vEmb1);
setDartEmbedding<VERTEX>(beta2(beta1(d)), vEmb1);
setDartEmbedding<VERTEX>(beta1(beta2(beta1(d))), vEmb1);
setDartEmbedding<VERTEX>(beta1(dd), vEmb1);
setDartEmbedding<VERTEX>(beta2(beta1(dd)), vEmb1);
setDartEmbedding<VERTEX>(beta1(beta2(beta1(dd))), vEmb1);
setDartEmbedding<VERTEX>(beta1(e), vEmb2);
setDartEmbedding<VERTEX>(beta2(beta1(e)), vEmb2);
setDartEmbedding<VERTEX>(beta1(beta2(beta1(e))), vEmb2);
setDartEmbedding<VERTEX>(beta1(ee), vEmb2);
setDartEmbedding<VERTEX>(beta2(beta1(ee)), vEmb2);
setDartEmbedding<VERTEX>(beta1(beta2(beta1(ee))), vEmb2);
}
if(isOrbitEmbedded<EDGE>())
{
setOrbitEmbedding<EDGE>(beta1(d), getEmbedding<EDGE>(beta1(d))) ;
setOrbitEmbedding<EDGE>(beta1(e), getEmbedding<EDGE>(beta1(e))) ;
setOrbitEmbedding<EDGE>(d, getEmbedding<EDGE>(d)) ;
setOrbitEmbedding<EDGE>(e, getEmbedding<EDGE>(e)) ;
setOrbitEmbedding<EDGE>(beta1(beta2(beta1(d))), getEmbedding<EDGE>(beta1(beta2(beta1(d))))) ;
setOrbitEmbedding<EDGE>(beta1(beta2(beta1(e))), getEmbedding<EDGE>(beta1(beta2(beta1(e))))) ;
}
if(isOrbitEmbedded<FACE>())
{
unsigned int fEmb = getEmbedding<FACE>(d) ;
setDartEmbedding<FACE>(beta1(d), fEmb) ;
setDartEmbedding<FACE>(beta0(beta1(d)), fEmb) ;
setDartEmbedding<FACE>(beta1(beta0(beta1(d))), fEmb) ;
setDartEmbedding<FACE>(beta1(ee), fEmb) ;
setDartEmbedding<FACE>(beta0(beta1(ee)), fEmb) ;
setDartEmbedding<FACE>(beta1(beta0(beta1(ee))), fEmb) ;
setOrbitEmbeddingOnNewCell<FACE>(e);
copyCell<FACE>(e, d);
}
if(isOrbitEmbedded<VOLUME>())
{
unsigned int vEmb1 = getEmbedding<VOLUME>(d) ;
setDartEmbedding<VOLUME>(beta1(d), vEmb1);
setDartEmbedding<VOLUME>(beta0(beta1(d)), vEmb1);
setDartEmbedding<VOLUME>(beta1(beta0(beta1(d))), vEmb1) ;
setDartEmbedding<VOLUME>(beta1(e), vEmb1);
setDartEmbedding<VOLUME>(beta0(beta1(e)), vEmb1);
setDartEmbedding<VOLUME>(beta1(beta0(beta1(e))), vEmb1) ;
unsigned int vEmb2 = getEmbedding<VOLUME>(dd) ;
setDartEmbedding<VOLUME>(beta1(dd), vEmb2);
setDartEmbedding<VOLUME>(beta0(beta1(dd)), vEmb2);
setDartEmbedding<VOLUME>(beta1(beta0(beta1(dd))), vEmb2) ;
setDartEmbedding<VOLUME>(beta1(ee), vEmb2);
setDartEmbedding<VOLUME>(beta0(beta1(ee)), vEmb2);
setDartEmbedding<VOLUME>(beta1(beta0(beta1(ee))), vEmb2) ;
}
}
RcppExport SEXP nsem3b(SEXP data,
SEXP theta,
SEXP Sigma,
SEXP modelpar,
SEXP control
) {
// srand ( time(NULL) ); /* initialize random seed: */
Rcpp::NumericVector Theta(theta);
Rcpp::NumericMatrix D(data);
unsigned nobs = D.nrow(), k = D.ncol();
mat Data(D.begin(), nobs, k, false); // Avoid copying
Rcpp::NumericMatrix V(Sigma);
mat S(V.begin(), V.nrow(), V.ncol());
S(0,0) = 1;
mat iS = inv(S);
double detS = det(S);
Rcpp::List Modelpar(modelpar);
// Rcpp::IntegerVector _nlatent = Modelpar["nlatent"]; unsigned nlatent = _nlatent[0];
Rcpp::IntegerVector _ny0 = Modelpar["nvar0"]; unsigned ny0 = _ny0[0];
Rcpp::IntegerVector _ny1 = Modelpar["nvar1"]; unsigned ny1 = _ny1[0];
Rcpp::IntegerVector _ny2 = Modelpar["nvar2"]; unsigned ny2 = _ny2[0];
Rcpp::IntegerVector _npred0 = Modelpar["npred0"]; unsigned npred0 = _npred0[0];
Rcpp::IntegerVector _npred1 = Modelpar["npred1"]; unsigned npred1 = _npred1[0];
Rcpp::IntegerVector _npred2 = Modelpar["npred2"]; unsigned npred2 = _npred2[0];
Rcpp::List Control(control);
Rcpp::NumericVector _lambda = Control["lambda"]; double lambda = _lambda[0];
Rcpp::NumericVector _niter = Control["niter"]; double niter = _niter[0];
Rcpp::NumericVector _Dtol = Control["Dtol"]; double Dtol = _Dtol[0];
rowvec mu0(ny0), lambda0(ny0);
rowvec mu1(ny1), lambda1(ny1);
rowvec mu2(ny2), lambda2(ny2);
rowvec beta0(npred0);
rowvec beta1(npred1);
rowvec beta2(npred2);
rowvec gamma(2);
rowvec gamma2(2);
unsigned pos=0;
for (unsigned i=0; i<ny0; i++) {
mu0(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<ny1; i++) {
mu1(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<ny2; i++) {
mu2(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<ny0; i++) {
lambda0(i) = Theta[pos];
pos++;
}
lambda1(0) = 1;
for (unsigned i=1; i<ny1; i++) {
lambda1(i) = Theta[pos];
pos++;
}
lambda2(0) = 1;
for (unsigned i=1; i<ny2; i++) {
lambda2(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<npred0; i++) {
beta0(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<npred1; i++) {
beta1(i) = Theta[pos];
pos++;
}
for (unsigned i=0; i<npred2; i++) {
beta2(i) = Theta[pos];
pos++;
}
gamma(0) = Theta[pos]; gamma(1) = Theta[pos+1];
gamma2(0) = Theta[pos+2]; gamma2(1) = Theta[pos+3];
// cerr << "mu0=" << mu0 << endl;
// cerr << "mu1=" << mu1 << endl;
// cerr << "mu2=" << mu2 << endl;
// cerr << "lambda0=" << lambda0 << endl;
// cerr << "lambda1=" << lambda1 << endl;
// cerr << "lambda2=" << lambda2 << endl;
// cerr << "beta0=" << beta0 << endl;
// cerr << "beta1=" << beta1 << endl;
// cerr << "beta2=" << beta2 << endl;
// cerr << "gamma=" << gamma << endl;
// cerr << "gamma2=" << gamma2 << endl;
mat lap(nobs,4);
for (unsigned i=0; i<nobs; i++) {
rowvec newlap = laNRb(Data.row(i), iS, detS,
mu0, mu1, mu2,
lambda0, lambda1, lambda2,
beta0,beta1, beta2, gamma, gamma2,
Dtol,niter,lambda);
lap.row(i) = newlap;
}
List res;
res["indiv"] = lap;
res["logLik"] = sum(lap.col(0)) + (3-V.nrow())*log(2.0*datum::pi)*nobs/2;
res["norm0"] = (3-V.nrow())*log(2*datum::pi)/2;
return res;
}
bool EmbeddedGMap3::check()
{
bool topo = GMap3::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>(beta1(d)) ||
getEmbedding<VERTEX>(d) != getEmbedding<VERTEX>(beta2(d)) ||
getEmbedding<VERTEX>(d) != getEmbedding<VERTEX>(beta3(d)) )
{
std::cout << "Embedding Check : different embeddings on vertex" << std::endl ;
return false ;
}
}
if(isOrbitEmbedded<EDGE>())
{
if( getEmbedding<EDGE>(d) != getEmbedding<EDGE>(beta0(d)) ||
getEmbedding<EDGE>(d) != getEmbedding<EDGE>(beta2(d)) ||
getEmbedding<EDGE>(d) != getEmbedding<EDGE>(beta3(d)) )
{
std::cout << "Embedding Check : different embeddings on edge" << std::endl ;
return false ;
}
}
if (isOrbitEmbedded<FACE>())
{
if( getEmbedding<FACE>(d) != getEmbedding<FACE>(beta0(d)) ||
getEmbedding<FACE>(d) != getEmbedding<FACE>(beta1(d)) ||
getEmbedding<FACE>(d) != getEmbedding<FACE>(beta3(d)) )
{
CGoGNout << "Check: different embeddings on face" << CGoGNendl ;
return false ;
}
}
if (isOrbitEmbedded<VOLUME>())
{
if( getEmbedding<VOLUME>(d) != getEmbedding<VOLUME>(beta0(d)) ||
getEmbedding<VOLUME>(d) != getEmbedding<VOLUME>(beta1(d)) ||
getEmbedding<VOLUME>(d) != getEmbedding<VOLUME>(beta2(d)) )
{
CGoGNout << "Check: different embeddings on volume" << 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 ;
std::cout << "nb volume orbits : " << getNbOrbits<VOLUME>() << std::endl ;
std::cout << "nb volume cells : " << m_attribs[VOLUME].size() << std::endl ;
return true ;
}
inline Dart GMap2::alpha_1(Dart d) const
{
return beta1(beta2(d)) ;
}
SoftsusyMSSM calc_beta() const { return beta2(); }
