bool EmbeddedGMap2::flipEdge(Dart d)
{
if(GMap2::flipEdge(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>(phi_1(d), f1Emb) ;
setDartEmbedding<FACE>(beta1(d), f1Emb) ;
unsigned int f2Emb = getEmbedding<FACE>(e) ;
setDartEmbedding<FACE>(phi_1(e), f2Emb) ;
setDartEmbedding<FACE>(beta1(e), f2Emb) ;
}
return true ;
}
return false ;
}
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::splitFace(Dart d, Dart e)
{
Map2::splitFace(d, e) ;
if (isOrbitEmbedded<VERTEX>())
{
copyDartEmbedding<VERTEX>(phi_1(e), d) ;
copyDartEmbedding<VERTEX>(phi_1(d), e) ;
}
if (isOrbitEmbedded<FACE>())
{
copyDartEmbedding<FACE>(phi_1(d), d) ;
embedNewCell<FACE>(e) ;
copyCell<FACE>(e, d) ;
}
}
bool EmbeddedMap2::flipEdge(Dart d)
{
if(Map2::flipEdge(d))
{
Dart e = phi2(d) ;
if (isOrbitEmbedded<VERTEX>())
{
copyDartEmbedding<VERTEX>(d, phi1(e)) ;
copyDartEmbedding<VERTEX>(e, phi1(d)) ;
}
if (isOrbitEmbedded<FACE>())
{
copyDartEmbedding<FACE>(phi_1(d), d) ;
copyDartEmbedding<FACE>(phi_1(e), e) ;
}
return true ;
}
return false ;
}
void EmbeddedGMap2::splitFace(Dart d, Dart e)
{
GMap2::splitFace(d, e) ;
if (isOrbitEmbedded<VERTEX>())
{
unsigned int v1Emb = getEmbedding<VERTEX>(d) ;
setDartEmbedding<VERTEX>(phi_1(e), v1Emb) ;
setDartEmbedding<VERTEX>(beta1(d), v1Emb) ;
setDartEmbedding<VERTEX>(beta1(phi_1(e)), v1Emb) ;
unsigned int v2Emb = getEmbedding<VERTEX>(e) ;
setDartEmbedding<VERTEX>(phi_1(d), v2Emb) ;
setDartEmbedding<VERTEX>(beta1(e), v2Emb) ;
setDartEmbedding<VERTEX>(beta1(phi_1(d)), v2Emb) ;
}
if(isOrbitEmbedded<EDGE>())
{
Algo::Topo::initOrbitEmbeddingOnNewCell<EDGE>(*this, beta1(d)) ;
}
if (isOrbitEmbedded<FACE>())
{
unsigned int fEmb = getEmbedding<FACE>(d) ;
setDartEmbedding<FACE>(phi_1(d), fEmb) ;
setDartEmbedding<FACE>(beta1(phi_1(d)), fEmb) ;
Algo::Topo::setOrbitEmbeddingOnNewCell<FACE>(*this, e) ;
Algo::Topo::copyCellAttributes<FACE>(*this, e, d) ;
}
}
void EmbeddedGMap2::splitFace(Dart d, Dart e)
{
GMap2::splitFace(d, e) ;
if (isOrbitEmbedded<VERTEX>())
{
unsigned int v1Emb = getEmbedding<VERTEX>(d) ;
setDartEmbedding<VERTEX>(phi_1(e), v1Emb) ;
setDartEmbedding<VERTEX>(beta1(d), v1Emb) ;
setDartEmbedding<VERTEX>(beta1(phi_1(e)), v1Emb) ;
unsigned int v2Emb = getEmbedding<VERTEX>(e) ;
setDartEmbedding<VERTEX>(phi_1(d), v2Emb) ;
setDartEmbedding<VERTEX>(beta1(e), v2Emb) ;
setDartEmbedding<VERTEX>(beta1(phi_1(d)), v2Emb) ;
}
if(isOrbitEmbedded<EDGE>())
{
initOrbitEmbeddingNewCell<EDGE>(beta1(d)) ;
}
if (isOrbitEmbedded<FACE>())
{
unsigned int fEmb = getEmbedding<FACE>(d) ;
setDartEmbedding<FACE>(phi_1(d), fEmb) ;
setDartEmbedding<FACE>(beta1(phi_1(d)), fEmb) ;
setOrbitEmbeddingOnNewCell<FACE>(e) ;
copyCell<FACE>(e, d) ;
}
}
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);
}
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 ;
}
double spline_s(const spline_t * spline, double x)
{
if (spline == NULL)
return NAN;
if (spline->f == NULL || spline->x == NULL || spline->m == NULL)
return NAN;
double res, t;
size_t i = 0;
binary_search(spline->x, x, spline->n, &i);
double h_i = spline->x[i + 1] - spline->x[i];
t = (x - spline->x[i]) / h_i;
#if defined(DEBUG) || (_DEBUG)
fprintf(stderr, "x = %f, i = %zu, t = %f\n", x, i, t);
#endif
res = phi_1(t) * spline->f[i] + phi_2(t) * spline->f[i + 1] + phi_3(t) * h_i * spline->m[i] + phi_4(t) * h_i * spline->m[i + 1];
return res;
}
inline Dart Map3::alpha1(Dart d)
{
return phi3(phi_1(d)) ;
}
void EmbeddedGMap3::unsewVolumes(Dart d)
{
Dart dd = alpha1(d);
unsigned int fEmb = EMBNULL ;
if(isOrbitEmbedded<FACE>())
fEmb = getEmbedding<FACE>(d) ;
GMap3::unsewVolumes(d);
Dart dit = d;
do
{
// embed the unsewn vertex orbit with the vertex embedding if it is deconnected
if(isOrbitEmbedded<VERTEX>())
{
if(!sameVertex(dit, dd))
{
setOrbitEmbedding<VERTEX>(dit, getEmbedding<VERTEX>(dit)) ;
setOrbitEmbeddingOnNewCell<VERTEX>(dd);
copyCell<VERTEX>(dd, dit);
}
else
{
setOrbitEmbedding<VERTEX>(dit, getEmbedding<VERTEX>(dit)) ;
}
}
dd = phi_1(dd);
// embed the unsewn edge with the edge embedding if it is deconnected
if(isOrbitEmbedded<EDGE>())
{
if(!sameEdge(dit, dd))
{
setOrbitEmbedding<EDGE>(dit, getEmbedding<EDGE>(dit)) ;
setOrbitEmbeddingOnNewCell<EDGE>(dd);
copyCell<EDGE>(dd, dit);
}
else
{
setOrbitEmbedding<EDGE>(dit, getEmbedding<EDGE>(dit)) ;
}
}
if(isOrbitEmbedded<FACE>())
{
setDartEmbedding<FACE>(beta3(dit), fEmb) ;
setDartEmbedding<FACE>(beta0(beta3(dit)), fEmb) ;
}
dit = phi1(dit);
} while(dit != d);
// embed the unsewn face with the face embedding
if (isOrbitEmbedded<FACE>())
{
setOrbitEmbeddingOnNewCell<FACE>(dd);
copyCell<FACE>(dd, d);
}
}
int
Stokhos::KLMatrixFreeOperator::
Apply(const Epetra_MultiVector& Input, Epetra_MultiVector& Result) const
{
// We have to be careful if Input and Result are the same vector.
// If this is the case, the only possible solution is to make a copy
const Epetra_MultiVector *input = &Input;
bool made_copy = false;
if (Input.Values() == Result.Values() && !is_stoch_parallel) {
input = new Epetra_MultiVector(Input);
made_copy = true;
}
// Initialize
Result.PutScalar(0.0);
const Epetra_Map* input_base_map = domain_base_map.get();
const Epetra_Map* result_base_map = range_base_map.get();
if (useTranspose == true) {
input_base_map = range_base_map.get();
result_base_map = domain_base_map.get();
}
// Allocate temporary storage
int m = Input.NumVectors();
if (useTranspose == false &&
(tmp == Teuchos::null || tmp->NumVectors() != m*max_num_mat_vec))
tmp = Teuchos::rcp(new Epetra_MultiVector(*result_base_map,
m*max_num_mat_vec));
else if (useTranspose == true &&
(tmp_trans == Teuchos::null ||
tmp_trans->NumVectors() != m*max_num_mat_vec))
tmp_trans = Teuchos::rcp(new Epetra_MultiVector(*result_base_map,
m*max_num_mat_vec));
Epetra_MultiVector *tmp_result;
if (useTranspose == false)
tmp_result = tmp.get();
else
tmp_result = tmp_trans.get();
// Map input into column map
const Epetra_MultiVector *tmp_col;
if (!is_stoch_parallel)
tmp_col = input;
else {
if (useTranspose == false) {
if (input_col == Teuchos::null || input_col->NumVectors() != m)
input_col = Teuchos::rcp(new Epetra_MultiVector(*global_col_map, m));
input_col->Import(*input, *col_importer, Insert);
tmp_col = input_col.get();
}
else {
if (input_col_trans == Teuchos::null ||
input_col_trans->NumVectors() != m)
input_col_trans =
Teuchos::rcp(new Epetra_MultiVector(*global_col_map_trans, m));
input_col_trans->Import(*input, *col_importer_trans, Insert);
tmp_col = input_col_trans.get();
}
}
// Extract blocks
EpetraExt::BlockMultiVector sg_input(View, *input_base_map, *tmp_col);
EpetraExt::BlockMultiVector sg_result(View, *result_base_map, Result);
for (int i=0; i<input_block.size(); i++)
input_block[i] = sg_input.GetBlock(i);
for (int i=0; i<result_block.size(); i++)
result_block[i] = sg_result.GetBlock(i);
int N = result_block[0]->MyLength();
const Teuchos::Array<double>& norms = sg_basis->norm_squared();
int d = sg_basis->dimension();
Teuchos::Array<double> zero(d), one(d);
for(int j = 0; j<d; j++) {
zero[j] = 0.0;
one[j] = 1.0;
}
Teuchos::Array< double > phi_0(expansion_size), phi_1(expansion_size);
sg_basis->evaluateBases(zero, phi_0);
sg_basis->evaluateBases(one, phi_1);
// k_begin and k_end are initialized in the constructor
for (Cijk_type::k_iterator k_it=k_begin; k_it!=k_end; ++k_it) {
Cijk_type::kj_iterator j_begin = Cijk->j_begin(k_it);
Cijk_type::kj_iterator j_end = Cijk->j_end(k_it);
int k = index(k_it);
int nj = Cijk->num_j(k_it);
if (nj > 0) {
Teuchos::Array<double*> j_ptr(nj*m);
Teuchos::Array<int> mj_indices(nj*m);
int l = 0;
for (Cijk_type::kj_iterator j_it = j_begin; j_it != j_end; ++j_it) {
int j = index(j_it);
for (int mm=0; mm<m; mm++) {
j_ptr[l*m+mm] = input_block[j]->Values()+mm*N;
mj_indices[l*m+mm] = l*m+mm;
}
l++;
}
Epetra_MultiVector input_tmp(View, *input_base_map, &j_ptr[0], nj*m);
Epetra_MultiVector result_tmp(View, *tmp_result, &mj_indices[0], nj*m);
(*block_ops)[k].Apply(input_tmp, result_tmp);
l = 0;
for (Cijk_type::kj_iterator j_it = j_begin; j_it != j_end; ++j_it) {
int j = index(j_it);
int j_gid = epetraCijk->GCID(j);
for (Cijk_type::kji_iterator i_it = Cijk->i_begin(j_it);
i_it != Cijk->i_end(j_it); ++i_it) {
int i = index(i_it);
int i_gid = epetraCijk->GRID(i);
double c = value(i_it);
if (k == 0)
c /= phi_0[0];
else {
c /= phi_1[k];
if (i_gid == j_gid)
c -= phi_0[k]/(phi_1[k]*phi_0[0])*norms[i_gid];
}
if (scale_op) {
if (useTranspose)
c /= norms[j_gid];
else
c /= norms[i_gid];
}
for (int mm=0; mm<m; mm++)
(*result_block[i])(mm)->Update(c, *result_tmp(l*m+mm), 1.0);
}
l++;
}
}
}
// Destroy blocks
for (int i=0; i<input_block.size(); i++)
input_block[i] = Teuchos::null;
for (int i=0; i<result_block.size(); i++)
result_block[i] = Teuchos::null;
if (made_copy)
delete input;
return 0;
}
