Interface.cxx 20.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
//=============================================================================
//
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//
//=============================================================================
#include "smtk/mesh/json/Interface.h"

T.J. Corona's avatar
T.J. Corona committed
14 15
#include "smtk/mesh/core/MeshSet.h"
#include "smtk/mesh/core/QueryTypes.h"
16
#include "smtk/mesh/core/Resource.h"
17 18

#include "smtk/mesh/moab/CellTypeToType.h"
19
#include "smtk/mesh/moab/HandleRangeToRange.h"
20 21 22

#include <algorithm>
#include <cstring>
23
#include <memory>
24 25
#include <set>

26 27 28 29 30 31
namespace smtk
{
namespace mesh
{
namespace json
{
32 33 34 35

//construct an empty interface instance
smtk::mesh::json::InterfacePtr make_interface()
{
36
  return std::make_shared<smtk::mesh::json::Interface>();
37 38
}

39
Interface::Interface()
40
  : m_associated_model(smtk::common::UUID::null())
41
  , m_modified(false)
42 43 44
{
}

45 46 47 48
Interface::Interface(const std::vector<smtk::mesh::json::MeshInfo>& info)
  : m_meshInfo(info)
  , m_associated_model(smtk::common::UUID::null())
  , m_modified(false)
49 50 51
{
}

52
Interface::~Interface() = default;
53

54 55
bool Interface::isModified() const
{
56
  return m_modified;
57 58
}

59
void Interface::addMeshes(const std::vector<smtk::mesh::json::MeshInfo>& info)
60
{
61
  m_meshInfo.insert(m_meshInfo.end(), info.begin(), info.end());
62 63 64 65 66 67 68
}

smtk::mesh::AllocatorPtr Interface::allocator()
{
  return smtk::mesh::AllocatorPtr();
}

T.J. Corona's avatar
T.J. Corona committed
69 70 71 72 73
smtk::mesh::BufferedCellAllocatorPtr Interface::bufferedCellAllocator()
{
  return smtk::mesh::BufferedCellAllocatorPtr();
}

74 75 76 77 78
smtk::mesh::IncrementalAllocatorPtr Interface::incrementalAllocator()
{
  return smtk::mesh::IncrementalAllocatorPtr();
}

79 80
smtk::mesh::ConnectivityStoragePtr Interface::connectivityStorage(
  const smtk::mesh::HandleRange& /*cells*/)
81
{
82
  return smtk::mesh::ConnectivityStoragePtr();
83 84
}

85
smtk::mesh::PointLocatorImplPtr Interface::pointLocator(const smtk::mesh::HandleRange& /*points*/)
86 87 88 89
{
  return smtk::mesh::PointLocatorImplPtr();
}

90 91
smtk::mesh::PointLocatorImplPtr Interface::pointLocator(std::size_t /*numPoints*/,
  const std::function<std::array<double, 3>(std::size_t)>& /*coordinates*/)
92 93 94
{
  return smtk::mesh::PointLocatorImplPtr();
}
95

96 97 98 99
void Interface::registerQueries(smtk::mesh::Resource&) const
{
}

100 101 102 103 104
smtk::mesh::Handle Interface::getRoot() const
{
  return smtk::mesh::Handle(0);
}

105 106
bool Interface::createMesh(
  const smtk::mesh::HandleRange& /*cells*/, smtk::mesh::Handle& /*meshHandle*/)
107 108 109 110 111 112 113
{
  //this interface can't create new meshes
  return false;
}

std::size_t Interface::numMeshes(smtk::mesh::Handle handle) const
{
114 115
  if (handle != this->getRoot())
  {
116
    return 0;
117
  }
118
  return m_meshInfo.size();
119 120 121 122
}

smtk::mesh::HandleRange Interface::getMeshsets(smtk::mesh::Handle handle) const
{
123 124
  if (handle != this->getRoot())
  {
125
    return smtk::mesh::HandleRange();
126
  }
127 128 129

  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
130
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
131
  {
132
    meshes.insert(i->mesh());
133
  }
134 135 136
  return meshes;
}

137
smtk::mesh::HandleRange Interface::getMeshsets(smtk::mesh::Handle handle, int dimension) const
138
{
139 140
  if (handle != this->getRoot())
  {
141
    return smtk::mesh::HandleRange();
142
  }
143

144
  const smtk::mesh::DimensionType dim = static_cast<smtk::mesh::DimensionType>(dimension);
145 146 147

  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
148
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
149 150
  {
    if (i->types().hasDimension(dim))
151 152 153
    {
      meshes.insert(i->mesh());
    }
154
  }
155 156 157 158
  return meshes;
}

//find all entity sets that have this exact name tag
159 160
smtk::mesh::HandleRange Interface::getMeshsets(
  smtk::mesh::Handle /*handle*/, const std::string& /*name*/) const
161 162 163 164 165
{
  return smtk::mesh::HandleRange();
}

//find all entity sets that have this exact name tag
166 167
smtk::mesh::HandleRange Interface::getMeshsets(
  smtk::mesh::Handle handle, const smtk::mesh::Domain& domain) const
168
{
169 170
  if (handle != this->getRoot())
  {
171
    return smtk::mesh::HandleRange();
172
  }
173 174 175

  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
176
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
177 178
  {
    if (i->has(domain))
179 180 181
    {
      meshes.insert(i->mesh());
    }
182
  }
183 184 185 186
  return meshes;
}

//find all entity sets that have this exact name tag
187 188
smtk::mesh::HandleRange Interface::getMeshsets(
  smtk::mesh::Handle handle, const smtk::mesh::Dirichlet& dirichlet) const
189
{
190 191
  if (handle != this->getRoot())
  {
192
    return smtk::mesh::HandleRange();
193
  }
194

195 196
  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
197
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
198 199
  {
    if (i->has(dirichlet))
200 201 202
    {
      meshes.insert(i->mesh());
    }
203
  }
204 205 206 207
  return meshes;
}

//find all entity sets that have this exact name tag
208 209
smtk::mesh::HandleRange Interface::getMeshsets(
  smtk::mesh::Handle handle, const smtk::mesh::Neumann& neumann) const
210
{
211 212
  if (handle != this->getRoot())
  {
213
    return smtk::mesh::HandleRange();
214
  }
215

216 217
  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
218
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
219 220
  {
    if (i->has(neumann))
221 222 223
    {
      meshes.insert(i->mesh());
    }
224
  }
225 226 227 228
  return meshes;
}

//get all cells held by this range
229
smtk::mesh::HandleRange Interface::getCells(const HandleRange& meshsets) const
230 231
{
  smtk::mesh::HandleRange cells;
232 233
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
234
  {
235
    MeshInfoVecType::const_iterator m = this->find(*i);
236
    if (m != m_meshInfo.end())
237
    {
238
      cells += m->cells();
239
    }
240
  }
241 242 243 244
  return cells;
}

//get all cells held by this range handle of a given cell type
245 246
smtk::mesh::HandleRange Interface::getCells(
  const HandleRange& meshsets, smtk::mesh::CellType cellType) const
247 248
{
  smtk::mesh::HandleRange cells;
249 250
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
251
  {
252
    MeshInfoVecType::const_iterator m = this->find(*i);
253
    if (m != m_meshInfo.end())
254
    {
255
      cells += m->cells(cellType);
256
    }
257
  }
258 259 260 261
  return cells;
}

//get all cells held by this range handle of a given cell type(s)
262 263
smtk::mesh::HandleRange Interface::getCells(
  const smtk::mesh::HandleRange& meshsets, const smtk::mesh::CellTypes& cellTypes) const
264 265
{
  smtk::mesh::HandleRange cells;
266 267
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
268
  {
269
    MeshInfoVecType::const_iterator m = this->find(*i);
270
    if (m != m_meshInfo.end())
271
    {
272
      cells += m->cells(cellTypes);
273
    }
274
  }
275 276 277 278
  return cells;
}

//get all cells held by this range handle of a given dimension
279 280
smtk::mesh::HandleRange Interface::getCells(
  const smtk::mesh::HandleRange& meshsets, smtk::mesh::DimensionType dim) const
281 282
{
  smtk::mesh::HandleRange cells;
283 284
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
285
  {
286
    MeshInfoVecType::const_iterator m = this->find(*i);
287
    if (m != m_meshInfo.end())
288
    {
289
      cells += m->cells(dim);
290
    }
291
  }
292 293 294
  return cells;
}

295
//get all points held by this range handle
296 297
smtk::mesh::HandleRange Interface::getPoints(
  const smtk::mesh::HandleRange& cells, bool boundary_only) const
298
{
299 300 301 302 303 304 305 306
  // We don't support modifying operations via the JSON interface (like meshset
  // construction, point merging, etc.); in keeping with this paradigm, the only
  // point ranges that can be queried are unions of points associated with mesh
  // sets that have already been computed using an alternate backend (e.g.
  // Moab). Any queries involving cells that are not the union of cell sets
  // contained within the meshInfo vector yield a null return value. This is
  // sufficient for relaying server-side information about points to the client.

307 308
  (void)boundary_only;

309 310
  smtk::mesh::HandleRange points;
  smtk::mesh::HandleRange cellsToVisit = cells;
311
  for (const auto& m : m_meshInfo)
312
  {
313
    if (smtk::mesh::rangeContains(cellsToVisit, m.cells()))
314
    {
315 316
      points += m.points();
      cellsToVisit = cellsToVisit - m.cells();
317
    }
318
  }
319
  return cellsToVisit.empty() ? points : smtk::mesh::HandleRange();
320 321
}

322
bool Interface::getCoordinates(const smtk::mesh::HandleRange& /*points*/, double* /*xyz*/) const
323 324 325 326
{
  return false;
}

327
bool Interface::getCoordinates(const smtk::mesh::HandleRange& /*points*/, float* /*xyz*/) const
328 329 330 331
{
  return false;
}

332 333
bool Interface::setCoordinates(
  const smtk::mesh::HandleRange& /*points*/, const double* const /*xyz*/)
334 335 336 337
{
  return false;
}

338 339
bool Interface::setCoordinates(
  const smtk::mesh::HandleRange& /*points*/, const float* const /*xyz*/)
340 341 342
{
  return false;
}
343

344
std::string Interface::name(const smtk::mesh::Handle& /*meshset*/) const
345 346 347 348 349
{
  //TODO
  return std::string();
}

350
bool Interface::setName(const smtk::mesh::Handle& /*meshset*/, const std::string& /*name*/)
351 352 353 354
{
  return false;
}

355
std::vector<std::string> Interface::computeNames(const smtk::mesh::HandleRange& /*meshsets*/) const
356
{
357
  return std::vector<std::string>();
358 359
}

360 361
std::vector<smtk::mesh::Domain> Interface::computeDomainValues(
  const smtk::mesh::HandleRange& meshsets) const
362
{
363
  std::set<smtk::mesh::Domain> domains;
364 365
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
366
  {
367
    MeshInfoVecType::const_iterator m = this->find(*i);
368 369 370
    const std::vector<smtk::mesh::Domain>& t = m->domains();
    domains.insert(t.begin(), t.end());
  }
371 372

  //return a vector of all the unique domains we have
373
  return std::vector<smtk::mesh::Domain>(domains.begin(), domains.end());
374 375
}

376 377
std::vector<smtk::mesh::Dirichlet> Interface::computeDirichletValues(
  const smtk::mesh::HandleRange& meshsets) const
378
{
379
  std::set<smtk::mesh::Dirichlet> boundary;
380 381
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
382
  {
383
    MeshInfoVecType::const_iterator m = this->find(*i);
384 385 386
    const std::vector<smtk::mesh::Dirichlet>& t = m->dirichlets();
    boundary.insert(t.begin(), t.end());
  }
387 388

  //return a vector of all the unique Dirichlet we have
389
  return std::vector<smtk::mesh::Dirichlet>(boundary.begin(), boundary.end());
390 391
}

392 393
std::vector<smtk::mesh::Neumann> Interface::computeNeumannValues(
  const smtk::mesh::HandleRange& meshsets) const
394
{
395
  std::set<smtk::mesh::Neumann> boundary;
396 397
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
398
  {
399
    MeshInfoVecType::const_iterator m = this->find(*i);
400 401 402
    const std::vector<smtk::mesh::Neumann>& t = m->neumanns();
    boundary.insert(t.begin(), t.end());
  }
403 404

  //return a vector of all the unique Neumann we have
405
  return std::vector<smtk::mesh::Neumann>(boundary.begin(), boundary.end());
406 407 408 409 410
}

/**\brief Return the set of all UUIDs set on all entities in the meshsets.
  *
  */
411 412
smtk::common::UUIDArray Interface::computeModelEntities(
  const smtk::mesh::HandleRange& meshsets) const
413 414
{
  smtk::common::UUIDArray uuids;
415 416
  for (auto i = smtk::mesh::rangeElementsBegin(meshsets);
       i != smtk::mesh::rangeElementsEnd(meshsets); ++i)
417
  {
418
    MeshInfoVecType::const_iterator m = this->find(*i);
419
    if (m == m_meshInfo.end())
420
      continue;
421
    const smtk::common::UUIDArray& t = m->modelUUIDS();
422
    if (!t.empty())
423
    {
424 425
      uuids.insert(uuids.end(), t.begin(), t.end());
    }
426
  }
427 428 429 430 431 432 433
  return uuids;
}

smtk::mesh::TypeSet Interface::computeTypes(const smtk::mesh::HandleRange& range) const
{
  typedef ::smtk::mesh::CellType CellEnum;

434 435 436 437
  ::moab::Range moabRange = smtk::mesh::moab::smtkToMOABRange(range);

  ::moab::Range meshes = moabRange.subset_by_type(::moab::MBENTITYSET);
  ::moab::Range cells = ::moab::subtract(moabRange, meshes);
438 439

  smtk::mesh::TypeSet result;
440
  for (::moab::Range::const_iterator i = meshes.begin(); i != meshes.end(); ++i)
441
  {
442 443
    MeshInfoVecType::const_iterator m = this->find(*i);
    result += m->types();
444
  }
445 446 447 448

  smtk::mesh::CellTypes ctypes;

  //compute the type of the cells if we have any
449 450 451
  if (!cells.empty())
  {
    for (std::size_t i = 0; i < ctypes.size(); ++i)
452 453 454 455
    {
      //now we need to convert from CellEnum to MoabType
      const CellEnum ce = static_cast<CellEnum>(i);
      const ::moab::EntityType moabEType =
456
        static_cast< ::moab::EntityType>(smtk::mesh::moab::smtkToMOABCell(ce));
457 458

      //if num_of_type is greater than zero we have cells of that type
459 460 461
      if (cells.num_of_type(moabEType) > 0)
      {
        ctypes[ce] = true;
462 463
      }
    }
464
  }
465 466 467

  const bool hasM = !(meshes.empty());
  const bool hasC = ctypes.any();
468
  smtk::mesh::TypeSet cellResult(ctypes, hasM, hasC);
469 470 471 472 473

  result += cellResult;
  return result;
}

474 475
bool Interface::computeShell(
  const smtk::mesh::HandleRange& /*meshes*/, smtk::mesh::HandleRange& /*shell*/) const
476 477
{
  return false;
478
}
479

480 481
bool Interface::computeAdjacenciesOfDimension(const smtk::mesh::HandleRange& /*meshes*/,
  int /*dimension*/, smtk::mesh::HandleRange& /*adj*/) const
482 483 484 485
{
  return false;
}

486 487
bool Interface::canonicalIndex(
  const smtk::mesh::Handle& /*cell*/, smtk::mesh::Handle& /*parent*/, int& /*index*/) const
488 489 490 491
{
  return false;
}

492 493
bool Interface::mergeCoincidentContactPoints(
  const smtk::mesh::HandleRange& /*meshes*/, double /*tolerance*/)
494 495 496 497
{
  return false;
}

498 499
smtk::mesh::HandleRange Interface::neighbors(const smtk::mesh::Handle& cellId) const
{
David Thompson's avatar
David Thompson committed
500
  (void)cellId;
501 502 503
  return smtk::mesh::HandleRange();
}

504 505
bool Interface::setDomain(
  const smtk::mesh::HandleRange& /*meshsets*/, const smtk::mesh::Domain& /*domain*/) const
506 507 508 509
{
  return false;
}

510 511
bool Interface::setDirichlet(
  const smtk::mesh::HandleRange& /*meshsets*/, const smtk::mesh::Dirichlet& /*dirichlet*/) const
512 513 514 515
{
  return false;
}

516 517
bool Interface::setNeumann(
  const smtk::mesh::HandleRange& /*meshsets*/, const smtk::mesh::Neumann& /*neumann*/) const
518 519 520 521
{
  return false;
}

522
bool Interface::setId(const smtk::mesh::Handle& /*meshset*/, const smtk::common::UUID& /*id*/) const
523 524 525 526 527 528 529 530
{
  return false;
}

smtk::common::UUID Interface::getId(const smtk::mesh::Handle& meshset) const
{
  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
531
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
532 533 534 535 536 537 538 539 540
  {
    if (i->mesh() == meshset)
    {
      return i->id();
    }
  }
  return smtk::common::UUID::null();
}

541 542
bool Interface::findById(const smtk::mesh::Handle& /*root*/, const smtk::common::UUID& id,
  smtk::mesh::Handle& meshset) const
543 544 545
{
  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
546
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
547 548 549 550 551 552 553 554 555 556
  {
    if (i->id() == id)
    {
      meshset = i->mesh();
      return true;
    }
  }
  return false;
}

557 558
/**\brief Set the model entity assigned to each meshset member to \a ent.
  */
559 560
bool Interface::setAssociation(
  const smtk::common::UUID& /*modelUUID*/, const smtk::mesh::HandleRange& /*meshsets*/) const
561 562 563 564 565 566 567 568
{
  return false;
}

/**\brief Find mesh entities associated with the given model entity.
  *
  */
smtk::mesh::HandleRange Interface::findAssociations(
569
  const smtk::mesh::Handle& /*root*/, const smtk::common::UUID& modelUUID) const
570 571 572 573 574 575 576
{
  smtk::mesh::HandleRange result;
  if (!modelUUID)
    return result;

  smtk::mesh::HandleRange meshes;
  MeshInfoVecType::const_iterator i;
577
  for (i = m_meshInfo.begin(); i != m_meshInfo.end(); ++i)
578
  {
579 580
    const smtk::common::UUIDArray& uuids = i->modelUUIDS();
    const bool contains = std::find(uuids.begin(), uuids.end(), modelUUID) != uuids.end();
581 582
    if (contains)
    {
583 584
      meshes.insert(i->mesh());
    }
585
  }
586 587 588
  return meshes;
}

589 590 591
/**\brief Set the model entity assigned to the root of this interface.
  */
bool Interface::setRootAssociation(const smtk::common::UUID& modelUUID) const
592
{
593
  m_associated_model = modelUUID;
594 595
  return true;
}
Ben Boeckel's avatar
Ben Boeckel committed
596

597 598 599 600
/**\brief Get the model entity assigned to the root of this interface.
  */
smtk::common::UUID Interface::rootAssociation() const
{
601
  return m_associated_model;
602 603
}

604 605 606
bool Interface::createCellField(const smtk::mesh::HandleRange& /*meshsets*/,
  const std::string& /*name*/, std::size_t /*dimension*/, const smtk::mesh::FieldType& /*type*/,
  const void* /*data*/)
607 608 609 610
{
  return false;
}

611
int Interface::getCellFieldDimension(const smtk::mesh::CellFieldTag& /*cfTag*/) const
612 613 614 615
{
  return 0;
}

616
smtk::mesh::FieldType Interface::getCellFieldType(const smtk::mesh::CellFieldTag& /*cfTag*/) const
617 618 619 620
{
  return smtk::mesh::FieldType::MaxFieldType;
}

621
smtk::mesh::HandleRange Interface::getMeshsets(
622
  smtk::mesh::Handle /*handle*/, const smtk::mesh::CellFieldTag& /*cfTag*/) const
623 624 625 626
{
  return smtk::mesh::HandleRange();
}

627 628
bool Interface::hasCellField(
  const smtk::mesh::HandleRange& /*meshsets*/, const smtk::mesh::CellFieldTag& /*cfTag*/) const
629 630 631 632
{
  return false;
}

633 634
bool Interface::getCellField(const smtk::mesh::HandleRange& /*meshsets*/,
  const smtk::mesh::CellFieldTag& /*cfTag*/, void* /*data*/) const
635 636 637 638
{
  return false;
}

639 640
bool Interface::setCellField(const smtk::mesh::HandleRange& /*meshsets*/,
  const smtk::mesh::CellFieldTag& /*cfTag*/, const void* const /*data*/)
641 642 643 644
{
  return false;
}

645 646
bool Interface::getField(const smtk::mesh::HandleRange& /*cells*/,
  const smtk::mesh::CellFieldTag& /*cfTag*/, void* /*data*/) const
647 648 649 650
{
  return false;
}

651 652
bool Interface::setField(const smtk::mesh::HandleRange& /*cells*/,
  const smtk::mesh::CellFieldTag& /*cfTag*/, const void* const /*data*/)
653 654 655 656
{
  return false;
}

657 658
std::set<smtk::mesh::CellFieldTag> Interface::computeCellFieldTags(
  const smtk::mesh::Handle& /*handle*/) const
659 660 661 662
{
  return std::set<smtk::mesh::CellFieldTag>();
}

663 664
bool Interface::deleteCellField(
  const smtk::mesh::CellFieldTag& /*dsTag*/, const smtk::mesh::HandleRange& /*meshsets*/)
665 666 667 668
{
  return false;
}

669 670 671
bool Interface::createPointField(const smtk::mesh::HandleRange& /*meshsets*/,
  const std::string& /*name*/, std::size_t /*dimension*/, const smtk::mesh::FieldType& /*type*/,
  const void* /*data*/)
672 673 674 675
{
  return false;
}

676
int Interface::getPointFieldDimension(const smtk::mesh::PointFieldTag& /*pfTag*/) const
677 678 679 680
{
  return 0;
}

681
smtk::mesh::FieldType Interface::getPointFieldType(const smtk::mesh::PointFieldTag& /*pfTag*/) const
682 683 684 685
{
  return smtk::mesh::FieldType::MaxFieldType;
}

686
smtk::mesh::HandleRange Interface::getMeshsets(
687
  smtk::mesh::Handle /*handle*/, const smtk::mesh::PointFieldTag& /*pfTag*/) const
688 689 690 691 692
{
  return smtk::mesh::HandleRange();
}

bool Interface::hasPointField(
693
  const smtk::mesh::HandleRange& /*meshsets*/, const smtk::mesh::PointFieldTag& /*pfTag*/) const
694 695 696 697
{
  return false;
}

698 699
bool Interface::getPointField(const smtk::mesh::HandleRange& /*meshsets*/,
  const smtk::mesh::PointFieldTag& /*pfTag*/, void* /*data*/) const
700 701 702 703
{
  return false;
}

704 705
bool Interface::setPointField(const smtk::mesh::HandleRange& /*meshsets*/,
  const smtk::mesh::PointFieldTag& /*pfTag*/, const void* const /*data*/)
706 707 708 709
{
  return false;
}

710 711
bool Interface::getField(const smtk::mesh::HandleRange& /*points*/,
  const smtk::mesh::PointFieldTag& /*pfTag*/, void* /*data*/) const
712 713 714 715
{
  return false;
}

716 717
bool Interface::setField(const smtk::mesh::HandleRange& /*points*/,
  const smtk::mesh::PointFieldTag& /*pfTag*/, const void* const /*data*/)
718 719 720 721 722
{
  return false;
}

std::set<smtk::mesh::PointFieldTag> Interface::computePointFieldTags(
723
  const smtk::mesh::Handle& /*handle*/) const
724 725 726 727
{
  return std::set<smtk::mesh::PointFieldTag>();
}

728 729
bool Interface::deletePointField(
  const smtk::mesh::PointFieldTag& /*dsTag*/, const smtk::mesh::HandleRange& /*meshsets*/)
730 731 732 733
{
  return false;
}

734 735 736
smtk::mesh::HandleRange Interface::pointIntersect(const smtk::mesh::HandleRange& /*a*/,
  const smtk::mesh::HandleRange& /*b*/, smtk::mesh::PointConnectivity& /*bpc*/,
  smtk::mesh::ContainmentType /*containmentType*/) const
737 738 739 740
{
  return smtk::mesh::HandleRange();
}

741 742 743
smtk::mesh::HandleRange Interface::pointDifference(const smtk::mesh::HandleRange& /*a*/,
  const smtk::mesh::HandleRange& /*b*/, smtk::mesh::PointConnectivity& /*bpc*/,
  smtk::mesh::ContainmentType /*containmentType*/) const
744 745 746 747
{
  return smtk::mesh::HandleRange();
}

748 749
void Interface::pointForEach(
  const HandleRange& /*points*/, smtk::mesh::PointForEach& /*filter*/) const
750 751 752
{
}

753 754
void Interface::cellForEach(const HandleRange& /*cells*/, smtk::mesh::PointConnectivity& /*a*/,
  smtk::mesh::CellForEach& /*filter*/) const
755 756 757
{
}

758 759
void Interface::meshForEach(
  const smtk::mesh::HandleRange& /*meshes*/, smtk::mesh::MeshForEach& /*filter*/) const
760 761 762
{
}

763
bool Interface::deleteHandles(const smtk::mesh::HandleRange& /*toDel*/)
764 765 766 767
{
  return false;
}

768
Interface::MeshInfoVecType::const_iterator Interface::find(smtk::mesh::Handle handle) const
769
{
770
  MeshInfoVecType::const_iterator result = std::find(m_meshInfo.begin(), m_meshInfo.end(), handle);
771 772 773 774 775
  return result;
}
}
}
}