/// Appends element to end of buffer growing its size if necessary
void append(const T &v, double growFactor=2){
if(size() >= capacity()){ // double array size if too small
mElems.resize((size() ? size() : 4)*growFactor);
}
super::construct(elems()+size(), v);
mPos=mSize;
++mSize;
}
void expand(){
size(size()*n);
const int Nd = dup ? n : 1;
for(int i=size()/n-1; i>=0; --i){
const T& v = (*this)[i];
for(int j=0; j<Nd; ++j) Alloc::construct(elems()+n*i+j, v);
}
}
Foam::labelList Foam::polyBoundaryMesh::ident(const label len)
{
labelList elems(len);
forAll(elems, elemI)
{
elems[elemI] = elemI;
}
return elems;
}
vector<Element> Group::elements() const {
vector<Element> elems(table.size(), identity());
vector<Element>::iterator iter = elems.begin();
int i=0;
for (iter++, i++; iter != elems.end(); iter++, i++) {
*iter = Element(this, i);
}
return elems;
}
pstring ppreprocessor::replace_macros(const pstring &line)
{
std::vector<pstring> elems(psplit(line, m_expr_sep));
pstring ret("");
for (auto & elem : elems)
{
define_t *def = get_define(elem);
ret += (def != nullptr) ? def->m_replace : elem;
}
return ret;
}
template <typename Traits> inline void
detector_impl<Traits>::parse(xmlDocPtr doc)
{
xmlNodePtr root = xmlDocGetRootElement(doc);
if (0 == root) {
throw error("got empty browser.xml");
}
xml_elems elems(root, "branch");
for (xml_elems::iterator i = elems.begin(), end = elems.end(); i != end; ++i) {
root_->add_child(parse_branch(*i));
}
}
int main(int argc, char* argv[])
{
boost::scoped_ptr<test::element<int> > elem(new test::element<int>(10));
std::cout << *elem << '\n';
elem.reset(new test::element<int>(20));
std::cout << *elem << '\n';
boost::scoped_array<test::element<int> > elems(new test::element<int>[3]);
elems[0] = test::element<int>(1);
elems[1] = test::element<int>(2);
elems[2] = test::element<int>(3);
std::cout << elems[0] << ' ' << elems[1] << ' ' << elems[2] << '\n';
}
void Graph::toAdjList(int *&adjStart,int *&adjList)
{
int e,i;
adjStart=new int[nelems+1];
adjStart[0]=0;
for (e=0;e<nelems;e++)
adjStart[e+1]=adjStart[e]+elems(e);
adjList=new int[adjStart[nelems]];
int *adjOut=adjList;
for (e=0;e<nelems;e++)
for (i=nbrs[e].getnn()-1;i>=0;i--)
*(adjOut++)=nbrs[e].getelt(i);
}
pstring ppreprocessor::replace_macros(const pstring &line)
{
pstring_vector_t elems(line, m_expr_sep);
pstringbuffer ret = "";
for (auto & elem : elems)
{
define_t *def = get_define(elem);
if (def != nullptr)
ret.cat(def->m_replace);
else
ret.cat(elem);
}
return ret;
}
Element::Group <const VolR> Unstructured::getAdjacentRegion(
const Element::Group<const VolR>& region) const {
std::vector<Element::Face> outer = getExternalBorder(region);
std::size_t nOut = outer.size();
// Removes repeated.
Math::Matrix::Dynamic<std::size_t> aux(nOut,1);
for (std::size_t i = 0; i < nOut; i++) {
aux(i,0) = outer[i].first->getId().toInt();
}
aux.sortAndRemoveRepeatedRows_omp();
// Prepares result.
Element::Group<ElemR> res;
for (std::size_t i = 0; i < aux.nRows(); i++) {
res.add(elems().getId(ElemId(aux(i,0)))->cloneTo<ElemR>());
}
return res;
}
lex_sense parse_lexsn(const string& lexsn_str) {
// lex_sense ::= ss_type:lex_filenum:lex_id:head_word:head_id
pos_t pos;
size_t filenum, lex_id, head_id;
string head_word;
stringstream ss(lexsn_str);
string item;
vector<string> elems(5);
auto i = 0;
while (getline(ss, item, ':') && i<5) {
elems[i++] = item;
}
pos = static_cast<pos_t>(atoi(elems[0].c_str()));
filenum = atoi(elems[1].c_str());
lex_id = atoi(elems[2].c_str());
head_word = elems[3].c_str();
head_id = atoi(elems[4].c_str());
return make_tuple(pos, filenum, lex_id, head_word, head_id);
}
template <typename Traits> inline shared_ptr<typename detector_impl<Traits>::branch_type>
detector_impl<Traits>::parse_branch(xmlNodePtr node) const {
shared_ptr<branch_type> result(new branch_type());
for (xmlNodePtr n = xmlFirstElementChild(node); 0 != n; n = xmlNextElementSibling(n)) {
if (disabled(n)) {
continue;
}
else if (xmlStrncasecmp(n->name, (xmlChar const*) "match", sizeof("match")) == 0) {
xml_elems elems(n, "pattern");
for (xml_elems::iterator i = elems.begin(), end = elems.end(); i != end; ++i) {
if (disabled(*i)) {
continue;
}
char const *type = xml_attr_text(*i, "type");
if (strncasecmp(type, "string", sizeof("string")) == 0) {
result->add_match(xml_node_text(*i));
}
else if (strncasecmp(type, "regex", sizeof("regex")) == 0) {
result->add_regex_match(xml_node_text(*i));
}
else {
resource<xmlChar*, xml_string_traits> path(xmlGetNodePath(*i));
throw error("unknown pattern type %s in [%s]", type, (char const*) path.get());
}
}
}
else if (xmlStrncasecmp(n->name, (xmlChar const*) "branch", sizeof("branch")) == 0) {
result->add_child(parse_branch(n));
}
else if (xmlStrncasecmp(n->name, (xmlChar const*) "define", sizeof("definition")) == 0) {
result->add_definition(parse_definition(n));
}
}
return result;
}
NodePtr fullelem()
{
if (tryConsumeToken(XTT_beginelem)) {
Node_Element *e = new Node_Element();
NodePtr r(e);
{
const std::string& s = getPreviewToken().value;
ElemTagSyntax::Parser(s.substr(1, s.size() - 2), e->tag, e->attris);
}
elems(e->children);
consumeToken(XTT_endelem);
{
const std::string& s = getPreviewToken().value;
std::string tag;
AttriMap m;
ElemTagSyntax::Parser(s.substr(2, s.size() - 3), tag, m);
PARSE_ASSERT(tag == e->tag && m.empty());
}
return r;
}
return NodePtr();
}
BoxR3 Unstructured::getBoundingBox() const {
return elems().getBound();
}
Element::Group<const SurfR> Unstructured::getMaterialBoundary(
const MatId matId,
const LayerId layId) const {
return elems().getMatLayerId(matId, layId).getOf<SurfR>();
}
void TuplePtrn::bind(NameSema& sema) const {
for (auto&& elem : elems()) {
elem->bind(sema);
}
}
vector<vector<Geometry::ElemId>> Volume::getPartitionsIds(
const size_t nDivisions,
const vector<pair<Geometry::ElemId,int>> idWgt,
const Math::Real* taskPower) const {
// Metis v5 manual:
// [...] take as input the element-node array of the mesh and
// compute a k-way partitioning for both its elements and its nodes
// idWgt contains id and weight pairs.
vector<vector<Geometry::ElemId>> res;
res.resize(nDivisions, vector<Geometry::ElemId>());
// Accounts for the one partition case.
if (nDivisions == 1) {
Geometry::ConstElemRGroup physVol = elems();
physVol.removeMatId(MatId(0));
const size_t nK = physVol.sizeOf<Geometry::VolR>();
res[0].resize(nK, Geometry::ElemId(0));
for (size_t i = 0; i < nK; i++) {
res[0][i] = (elems())(i)->getId();
}
return res;
}
#ifdef MESH_ALLOW_PARTITIONING
// Prepares mesh info.
cout << " - Preparing mesh info... " << flush;
idx_t ne = elems().sizeOf<Geometry::VolR>();
idx_t *eptr, *eind;
eptr = new idx_t[ne+1];
eind = new idx_t[ne*4];
size_t counter = 0;
eptr[0] = counter;
for (idx_t i = 0; i < ne; i++) {
const Geometry::VolR* vol = elem_.tet[i];
for (size_t j = 0; j < vol->numberOfVertices(); j++) {
eind[counter++] = vol->getVertex(j)->id - 1;
}
eptr[i+1] = counter;
}
cout << "OK" << endl;
// Relabels ids, needed by quadratic or linearized meshes.
cout << " - Relabeling... " << flush;
DynMatrix<Math::Int> id(ne*4,3);
for (Math::Int i = 0; i < ne*4; i++) {
id(i,0) = i;
id(i,1) = eind[i];
id(i,2) = 0;
}
id.sortRows_omp(1,1);
Math::Int label = 0;
for (Math::Int i = 1; i < ne*4; i++) {
if (id(i,1) == id(i-1,1)) {
id(i,2) = label;
} else {
id(i,2) = ++label;
}
}
id.sortRows_omp(0,0);
for (Math::Int i = 0; i < ne*4; i++) {
eind[i] = id(i,2);
}
idx_t nn = label+1; // Number of vertices.
cout << "OK" << endl;
// Copies weights.
cout << " - Copying weights... " << flush;
idx_t *vwgt;
if (idWgt.size() == 0) {
vwgt = NULL;
} else {
vwgt = new idx_t[ne];
for (Math::Int e = 0; e < ne; e++) {
vwgt[e] = idWgt[e].second;
}
}
idx_t *vsize = NULL;
idx_t nparts = nDivisions;
idx_t objval;
idx_t *epart;
epart = new idx_t[ne];
idx_t *npart;
npart = new idx_t[nn];
cout << "OK" << endl;
// Computes task computational powers.
real_t *tpwgts = NULL;
if (taskPower != NULL) {
tpwgts = new real_t[nDivisions];
real_t sum = 0.0;
for (size_t i = 0; i < nDivisions; i++) {
tpwgts[i] = taskPower[i];
sum += tpwgts[i];
}
assert(std::abs(sum) - 1.0e-16 < 1.0);
}
// METIS options.
cout << " - Setting Options... " << flush;
idx_t options[METIS_NOPTIONS];
Math::Int status;
status = METIS_SetDefaultOptions(options);
options[METIS_OPTION_PTYPE] = METIS_PTYPE_KWAY;
options[METIS_OPTION_OBJTYPE] = METIS_OBJTYPE_CUT;
options[METIS_OPTION_SEED] = (idx_t) 0;
// options[METIS_OPTION_OBJTYPE] = METIS_OBJTYPE_VOL;
// c numbering. Starts from 0.
options[METIS_OPTION_NUMBERING] = 0;
cout << "OK" << endl;
// Calls METIS partition function for meshes.
idx_t ncommon = 3; // Number of common vertices per element.
cout << " - Calling Part Mesh Dual... " << flush;
status = METIS_PartMeshDual(
&ne, &nn, eptr, eind, vwgt, vsize, &ncommon, &nparts,
tpwgts, options, &objval, epart, npart);
if (status != METIS_OK) {
throw Error("METIS_PartMeshDual fn failed with error: " + status);
}
cout << "OK" << endl;
// Converts result.
for (size_t i = 0; i < nDivisions; i++) {
res[i].reserve(ne);
}
for (Math::Int i = 0; i < ne; i++) {
size_t id = elem_.tet[i]->getId();
res[epart[i]].push_back(id);
}
// Frees memory.
delete vwgt;
delete epart;
delete npart;
delete eptr;
delete eind;
// Returns result.
return res;
#else
throw logic_error("Mesh partitioning is not allowed.");
#endif
}
int main(int argc, char *argv[])
{
int numProcs, myRank;
/***********************************************************************************************
* Pre-processing stage:
* Read input files, allocate and initialize arrays, etc.
**********************************************************************************************/
MPI_Init(&argc, &argv);
double time = MPI_Wtime();
MPI_Comm_size(MPI_COMM_WORLD, &numProcs);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
setting stngs; // A setting object is createad.
stngs.readSettings(); // settings.in file and minf file are read.
stngs.setProcs(numProcs);
stngs.setRank(myRank);
/**********************************************************************************************/
size_t nnc, mnc;
mnc = nnc = (stngs.getNn() - 1)/numProcs + 1;
if ((myRank + 1)*mnc > stngs.getNn())
nnc = stngs.getNn() - mnc*myRank;
if (mnc*myRank > stngs.getNn())
nnc = 0;
// printf("Proc # %d from # %d procs with nnLocal = ", myRank, numProcs);
// cout << nnLocal << "\n";
node nodes(nnc); // We create a node object
nodes.createNodes(&stngs); // and read nodal data from file.
/**********************************************************************************************/
size_t nec, mec;
mec = nec = (stngs.getNe() - 1)/numProcs + 1;
if ((myRank + 1)*mec > stngs.getNe())
nec = stngs.getNe() - mec*myRank;
if (mec*myRank > stngs.getNe())
nec = 0;
element elems(nec, nenTri, nefTri, 7); // We create an element object.
// printf("Before\n");
elems.createElements(&stngs, &nodes); // and read element data from file
// printf("After\n");
/**********************************************************************************************/
// Moreover solution independent calculations are made: Jacobian determinant, shape funct.
// derivatives as well as element matrices are calculated.
/***********************************************************************************************
* Solution stage:
* Element matrices are calculated, boundary conditions are applied and system is solved.
**********************************************************************************************/
femSolver solver(&stngs, &nodes, &elems); // We create an femSolver object.
solver.solve(); // and solve the equation system
time = MPI_Wtime() - time;
MPI_Allreduce(MPI_IN_PLACE, &time, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
if (stngs.getRank() == 0) cout << time << endl;
/***********************************************************************************************
* Post-Processing Stage
* Create the output files / visualize the reuslts.
**********************************************************************************************/
// if(!myRank)
// {
postProcessor postP;
postP.postProcessorControl(&stngs, &nodes, &elems);
// }
MPI_Barrier(MPI_COMM_WORLD);
// cout << "# " << myRank << "Ciao :)" << endl;
MPI_Finalize();
return 0;
}
/// Write new element to ring buffer
void write(const T& v){
++mPos; if(pos() == size()){ mPos=0; }
Alloc::construct(elems()+pos(), v);
if(fill() < size()) ++mFill;
}
/// Set element at index with no bounds checking
T& operator[](int i){ return elems()[i];}
void root()
{
elems(m_root);
}
void YumMailJob::process(){try{
int index;
state=JOB_STATE_OK;
for(index=0;index<elems(mails);index++){
if(mails[index].mail==number) break;
}
TASSUME(index!=elems(mails),QString("There is no mail file with number %1 in archive").arg(number));
int count=mails[index].count;
index=mails[index].index;
QByteArray bytes;
QList<int> records;
QRegExp record("^##(.*)");
QString line;
while(!(line=file->readline()).isNull()){
QChar c;
line=chomp(line);
QByteArray arr;
if(record.indexIn(line)!=-1){
records.append(bytes.count());
arr=line.toAscii();
} else{
QString errstr;
arr=text_encode_control_length(line,26,&errstr);
if(!errstr.isEmpty()){
state=JOB_STATE_WARNINGS;
output+=QString("line %1: could not encode text: %2")
.arg(file->line())
.arg(errstr);
}
}
bytes.append(arr);
bytes.append("\r\n",2);
}
TASSUME(records.count()==count,QString("Not enough ## entries in file. Need %1 have %2").arg(records.count()).arg(count));
QString head=QString("//VERSION=1\n//RECORD_NUM=%1\n").arg(count);
QByteArray records_data=head.toAscii();
for(int i=0;i<count;i++){
QString s=QString("//RECORD_POS=%1\n").arg(records.at(i));
QByteArray a=s.toAscii();
records_data.append(a);
}
// rwfile rw("res.txt");
// rw.write(records_data.data(),records_data.count());
Yum y(isofile,number);
TASSUME(y.issue.isEmpty(),y.issue);
y.spit(bytes.data(),bytes.size());
TASSUME(y.issue.isEmpty(),y.issue);
Yum yy(isofile,index);
TASSUME(yy.issue.isEmpty(),QString("Mail index file (%1) - %2").arg(index).arg(yy.issue));
yy.spit(records_data.data(),records_data.size());
TASSUME(yy.issue.isEmpty(),QString("Mail index file (%1) - %2").arg(index).arg(yy.issue));
} catch(QString ss){
state=JOB_STATE_FAILED;
}}
void StructExpr::bind(NameSema& sema) const {
ast_type_app()->bind(sema);
for (auto&& elem : elems())
elem->expr()->bind(sema);
}
// =============================================================================
Teuchos::RCP<VIO::EpetraMesh::Mesh>
VIO::EpetraMesh::Reader::
extractMeshData_( const vtkSmartPointer<vtkUnstructuredGrid> & vtkMesh,
const Teuchos::RCP<const Epetra_Comm> & comm
) const
{
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// create the maps based on the number of points
int numPoints = vtkMesh->GetNumberOfPoints();
Teuchos::RCP<Epetra_Map> nodesMap = Teuchos::rcp( new Epetra_Map( numPoints, 0, *comm ) );
Teuchos::RCP<Epetra_Map> complexValuesMap = createComplexValuesMap_ ( *nodesMap );
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh( nodesMap,
complexValuesMap
)
);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// get points
Teuchos::ArrayRCP<Point> points( numPoints );
for ( unsigned int k=0; k<numPoints; k++ )
vtkMesh->GetPoint( k, points[k].getRawPtr() );
mesh->setNodes( points );
// for ( int k=0; k<points.size(); k++ )
// std::cout << points[k] << std::endl;
// std::cout << "VVV" << std::endl;
// vtkMesh->Print( std::cout );
// determine the boundary points
// transform vtkMesh into vtkPolyData
vtkSmartPointer<vtkDataSetSurfaceFilter> surfaceFilter =
vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
surfaceFilter->SetInput(vtkMesh);
surfaceFilter->Update();
// vtkPolyData* polydata = surfaceFilter->GetOutput();
// filter out the boundary edges
vtkFeatureEdges * pEdges = vtkFeatureEdges::New();
pEdges->SetInput( surfaceFilter->GetOutput() );
pEdges->BoundaryEdgesOn();
pEdges->FeatureEdgesOff();
pEdges->NonManifoldEdgesOff();
pEdges->ManifoldEdgesOff();
pEdges->Update();
vtkPolyData * poly = pEdges->GetOutput();
// pEdges->ColoringOff();
// // pEdges->GetOutput()->BuildCells();
//
// std::cout << "V1" << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfCells() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfLines() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfPieces() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfPolys() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfStrips() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfVerts() << std::endl;
// std::cout << pEdges->GetOutput()->GetNumberOfPoints() << std::endl;
// // std::cout << pEdges->GetOutput()->GetNumberOfElements() << std::endl;
//
// // pEdges->GetOutput()->GetLines()->GetCell(0)->Print( std::cout );
//
// // pEdges->GetOutput()->BuildCells();
// TEUCHOS_ASSERT_EQUALITY( 0, pEdges->GetErrorCode() );
//
// std::cout << "W-1" << std::endl;
// int numLines = poly->GetNumberOfLines();
// vtkIdType * pts;
// // vtkIdList * pts2;
// for ( vtkIdType lineId=0; lineId<numLines; lineId++ )
// {
// vtkIdType numPoints;
// pEdges->GetOutput()->GetLines()->GetCell( lineId, numPoints, pts );
// // pEdges->GetOutput()->GetCellPoints( cellId, pts2 );
//
// if ( numPoints!=2 )
// {
// std::cout << "AAAAAAAAH!" << std::endl;
// continue;
// }
// // make sure we're dealing with an actual *edge* here.
// TEUCHOS_ASSERT_EQUALITY( numPoints, 2 );
// std::cout << pts[0] << " " << pts[1] << std::endl;
// }
// std::cout << "W0" << std::endl;
// poly->GetLines()->Print( std::cout );
//
// std::cout << "W1" << std::endl;
// poly->GetPoints()->Print( std::cout );
//
// std::cout << "W2" << std::endl;
double x[3];
// Teuchos::ArrayRCP<bool> boundaryPoints( numPoints, false );
Teuchos::ArrayRCP<bool> isBoundaryNodes( numPoints );
for ( int k=0; k<poly->GetNumberOfPoints(); k++ )
{
poly->GetPoint( k, x );
vtkIdType ptId = vtkMesh->FindPoint( x );
isBoundaryNodes[ ptId ] = true;
}
mesh->setBoundaryNodes( isBoundaryNodes );
// for ( int k=0; k<boundaryPoints.size(); k++ )
// std::cout << boundaryPoints[k] << std::endl;
// std::cout << "WWW" << std::endl;
// poly->Print( std::cout );
// vtkCellArray * verts = poly->GetVerts();
// verts->Print( std::cout );
// std::cout << "XXX" << std::endl;
// poly->GetData()->Print( std::cout );
// int numBoundaryPoints = poly->GetNumberOfPoints();
// Teuchos::ArrayRCP<Teuchos::Tuple<double,3> > boundaryPoints( numBoundaryPoints );
// for ( unsigned int k=0; k<numBoundaryPoints; k++ )
// poly->GetPoint( k, boundaryPoints[k].getRawPtr() );
// mesh->setBoundaryNodes( boundaryPoints );
// for ( int k=0; k<points.size(); k++ )
// std::cout << boundaryPoints[k] << std::endl;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// get cells
int globalNumElems = vtkMesh->GetNumberOfCells();
// create an appropriate map
Teuchos::RCP<const Epetra_Map> elemsMap =
Teuchos::rcp ( new Epetra_Map ( globalNumElems, 0, *comm ) );
int localNumElems = elemsMap->NumMyElements();
Teuchos::ArrayRCP<Teuchos::ArrayRCP<int> > elems( localNumElems );
Teuchos::ArrayRCP<Mesh::ElementType> elemTypes( localNumElems );
for ( unsigned int k=0; k<localNumElems; k++ )
{
// set the connectivity table
vtkCell * cell = vtkMesh->GetCell( elemsMap->GID(k) );
int numPoints = cell->GetNumberOfPoints();
elems[k] = Teuchos::ArrayRCP<int>( numPoints );
for ( unsigned int l=0; l<numPoints; l++ )
elems[k][l] = cell->GetPointId( l );
// set the element type
switch( cell->GetCellType() )
{
case VTK_LINE:
elemTypes[k] = Mesh::EDGE2;
break;
case VTK_QUADRATIC_EDGE:
elemTypes[k] = Mesh::EDGE3;
break;
case VTK_TRIANGLE:
elemTypes[k] = Mesh::TRI3;
break;
case VTK_QUADRATIC_TRIANGLE:
elemTypes[k] = Mesh::TRI6;
break;
case VTK_QUAD:
elemTypes[k] = Mesh::QUAD4;
break;
case VTK_QUADRATIC_QUAD:
elemTypes[k] = Mesh::QUAD8;
break;
case VTK_BIQUADRATIC_QUAD:
elemTypes[k] = Mesh::QUAD9;
break;
case VTK_TETRA:
elemTypes[k] = Mesh::TET4;
break;
case VTK_QUADRATIC_TETRA:
elemTypes[k] = Mesh::TET10;
break;
case VTK_HEXAHEDRON:
elemTypes[k] = Mesh::HEX8;
break;
case VTK_QUADRATIC_HEXAHEDRON:
elemTypes[k] = Mesh::HEX20;
break;
case VTK_WEDGE:
elemTypes[k] = Mesh::PRISM6;
break;
case VTK_HIGHER_ORDER_WEDGE:
elemTypes[k] = Mesh::PRISM15;
break;
case VTK_PYRAMID:
elemTypes[k] = Mesh::PYRAMID5;
break;
default:
TEST_FOR_EXCEPTION( true,
std::logic_error,
"Unknown type \""<< cell->GetCellType() <<"\"." );
}
}
mesh->setElems( elems );
mesh->setElemTypes( elemTypes );
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
return mesh;
}
/// Get element at index with no bounds checking
const T& operator[](int i) const { return elems()[i]; }
