GmshFormatReader.cpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: GmshFormatReader.cpp,v 1.12 2007/12/15 18:57:58 delpinux Exp $

#include <GmshFormatReader.hpp>

#include <SurfaceMeshOfQuadrangles.hpp>
#include <MeshOfHexahedra.hpp>

#include <SurfaceMeshOfTriangles.hpp>
#include <MeshOfTetrahedra.hpp>

#include <EndianConverter.hpp>

void
GmshFormatReader::__readVertices()
{
  const int numberOfVerices = this->__getInteger();
  ffout(3) << "- Number Of Vertices: " << numberOfVerices << '\n';
  if (numberOfVerices<0) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+this->__fileName
                       +"': number of vertices is negative",
                       ErrorHandler::normal);
  }

  __verticesNumbers.resize(numberOfVerices);
  __vertices = new VerticesSet(numberOfVerices);
  VerticesSet& vertices = *__vertices;

  if (not __binary) {
    for (int i=0; i<numberOfVerices; ++i) {
      __verticesNumbers[i] = this->__getInteger();
      const real_t x = this->__getReal();
      const real_t y = this->__getReal();
      const real_t z = this->__getReal();
      vertices[i] = TinyVector<3, real_t>(x,y,z);
    } 
  } else {
    fseek(__ifh,1L,SEEK_CUR);
    for (int i=0; i<numberOfVerices; ++i) {
      int number = 0;
      fread(reinterpret_cast<char*>(&number),sizeof(int),1,__ifh);
      __verticesNumbers[i] = number;
      TinyVector<3,double> x;
      fread(reinterpret_cast<char*>(&(x[0])),sizeof(double),3,__ifh);
      for (size_t j=0; j<3; ++j) {
        vertices[i][j] = x[j];
      }
    }

    if (__convertEndian) {
      for (int i=0; i<numberOfVerices; ++i) {
        invertEndianess(__verticesNumbers[i]);
        for (size_t j=0; j<3; ++j) {
          invertEndianess(vertices[i][j]);
        }
      }
    }
  }
}

void
GmshFormatReader::__readElements1()
{
  const int numberOfElements = this->__getInteger();
  ffout(3) << "- Number Of Elements: " << numberOfElements << '\n';
  if (numberOfElements<0) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': number of elements is negative",
                       ErrorHandler::normal);
  }

  __elementType.resize(numberOfElements);
  __references.resize(numberOfElements);
  __elementVertices.resize(numberOfElements);

  for (int i=0; i<numberOfElements; ++i) {
    this->__getInteger(); // drops element number
    const int elementType = this->__getInteger()-1;

    if ((elementType < 0) or (elementType > 14)) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "reading file '"+__fileName
                         +"': unknown element type '"+stringify(elementType)+"'",
                         ErrorHandler::normal);
    }
    __elementType[i] = elementType;
    __references[i] = this->__getInteger(); // physical reference
    this->__getInteger(); // drops entity reference

    const int numberOfVertices = this->__getInteger();
    if (numberOfVertices != __numberOfPrimitiveNodes[elementType]) {
      std::stringstream errorMsg;
      errorMsg << "reading file '" <<__fileName
               << "':number of vertices (" << numberOfVertices
               << ") does not match expected ("
               << __numberOfPrimitiveNodes[elementType] << ")" << std::ends;

      throw ErrorHandler(__FILE__,__LINE__,
                         errorMsg.str(),
                         ErrorHandler::normal);
    }
    __elementVertices[i].resize(numberOfVertices);
    for (int j=0; j<numberOfVertices; ++j) {
      __elementVertices[i][j] = this->__getInteger();
    }
  }
}

void
GmshFormatReader::__readElements2()
{
  const int numberOfElements = this->__getInteger();
  ffout(3) << "- Number Of Elements: " << numberOfElements << '\n';
  if (numberOfElements<0) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': number of elements is negative",
                       ErrorHandler::normal);
  }

  __elementType.resize(numberOfElements);
  __references.resize(numberOfElements);
  __elementVertices.resize(numberOfElements);

  if (not __binary) {
    for (int i=0; i<numberOfElements; ++i) {
      this->__getInteger(); // drops element number
      const int elementType = this->__getInteger()-1;

      if ((elementType < 0) or (elementType > 14)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': unknown element type '"+stringify(elementType)+"'",
                           ErrorHandler::normal);
      }
      __elementType[i] = elementType;
      const int numberOfTags =  this->__getInteger();
      __references[i] = this->__getInteger(); // physical reference
      for (int tag=1; tag<numberOfTags; ++tag) {
        this->__getInteger(); // drops remaining tags
      }

      const int numberOfVertices = __numberOfPrimitiveNodes[elementType];
      __elementVertices[i].resize(numberOfVertices);
      for (int j=0; j<numberOfVertices; ++j) {
        __elementVertices[i][j] = this->__getInteger();
      }
    }
  } else {
    fseek(__ifh,1L,SEEK_CUR);
    int i=0;
    for (;i<numberOfElements;) {
      int elementType = 0;
      fread(reinterpret_cast<char*>(&elementType),sizeof(int),1,__ifh);
      if (__convertEndian) {
        invertEndianess(elementType);
      }
      --elementType;

      if ((elementType < 0) or (elementType > 14)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': unknown element type '"+stringify(elementType)+"'",
                           ErrorHandler::normal);
      }

      int elementTypeNumber = 0;
      fread(reinterpret_cast<char*>(&elementTypeNumber),sizeof(int),1,__ifh);
      if (__convertEndian) {
        invertEndianess(elementTypeNumber);
      }

      int numberOfTags = 0;
      fread(reinterpret_cast<char*>(&numberOfTags),sizeof(int),1,__ifh);
      if (__convertEndian) {
        invertEndianess(numberOfTags);
      }

      for (int k=0; k<elementTypeNumber; ++k) {
        __elementType[i] = elementType;

        int elementNumber = 0;
        fread(reinterpret_cast<char*>(&elementNumber),sizeof(int),1,__ifh);

        int reference = 0;
        fread(reinterpret_cast<char*>(&reference),sizeof(int),1,__ifh);

        __references[i] = reference; // physical reference
        for (int tag=1; tag<numberOfTags; ++tag) {
          int t;
          fread(reinterpret_cast<char*>(&t),sizeof(int),1,__ifh);
        }

        const int numberOfVertices = __numberOfPrimitiveNodes[elementType];
        __elementVertices[i].resize(numberOfVertices);
        fread(reinterpret_cast<char*>(&(__elementVertices[i][0])),sizeof(int),numberOfVertices,__ifh);
        ++i;
      }
    }

    if (__convertEndian) {
      for (size_t i=0; i<__references.size(); ++i) {
        invertEndianess(__references[i]);
      }
      for (size_t i=0; i<__elementVertices.size(); ++i) {
        for (size_t j=0; j<__elementVertices[i].size(); ++i) {
          invertEndianess(__elementVertices[i][j]);
        }
      }
    }
  }
}

void
GmshFormatReader::__proceedData()
{
  TinyVector<15,int> elementNumber = 0;
  std::vector<std::set<size_t> > elementReferences(15);

  for (size_t i=0; i<__elementType.size(); ++i) {
    const int elementType = __elementType[i];
    elementNumber[elementType]++;
    elementReferences[elementType].insert(__references[i]);
  }

  for (size_t i=0; i<elementNumber.size(); ++i) {
    if (elementNumber[i]>0) {
      ffout(3) << "  - Number of "
               << __primitivesNames[i]
               << ": " << elementNumber[i];
      if (not(__supportedPrimitives[i])) {
        ffout(3) << " [IGNORED]";
      } else {
        ffout(3) << " references: ";
        for(std::set<size_t>::const_iterator iref
              = elementReferences[i].begin();
            iref != elementReferences[i].end(); ++iref) {
          if (iref != elementReferences[i].begin()) ffout(3) << ',';
          ffout(3) << *iref;
        }

        switch (i) {
          // Supported entities
        case 1: { // triangles
          __triangles = new Vector<Triangle>(elementNumber[i]);
          break;
        }
        case  2: { // quadrangles
          __quadrilaterals = new Vector<Quadrangle>(elementNumber[i]);
          break;
        }
        case 3: { // tetrahedra
          __tetrahedra = new Vector<Tetrahedron>(elementNumber[i]);
          break;
        }
        case  4: {// hexahedra
          __hexahedra = new Vector<Hexahedron>(elementNumber[i]);
        }
          // Ignored entities
        case  0:  // edge
        case 14: {// point
          break; 
        }
          // Unsupported entities
        case  5: // prism
        case  6: // pyramid
        case  7: // second order edge
        case  8: // second order triangle
        case  9: // second order quadrangle
        case 10: // second order tetrahedron
        case 11: // second order hexahedron
        case 12: // second order prism
        case 13: // second order pyramid
        default: {
          throw ErrorHandler(__FILE__,__LINE__,
                             "reading file '"+__fileName
                             +"': ff3d cannot read this kind of element",
                             ErrorHandler::normal);
        }
        }
      }
      ffout(3) << '\n';
    }
  }

  ffout(3) << "- Building correspondance table\n";
  int minNumber = std::numeric_limits<int>::max();
  int maxNumber = std::numeric_limits<int>::min();
  for (size_t i=0; i<__verticesNumbers.size(); ++i) {
    const int& vertexNumber = __verticesNumbers[i];
    minNumber = std::min(minNumber,vertexNumber);
    maxNumber = std::max(maxNumber,vertexNumber);
  }

  if (minNumber<0) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': ff3d does not implement negative vertices number",
                       ErrorHandler::normal);
  }

 // A value of -1 means that the vertex is unknown
  __verticesCorrepondance.resize(maxNumber+1,-1);

  for (size_t i=0; i<__verticesNumbers.size(); ++i) {
    
    __verticesCorrepondance[__verticesNumbers[i]] = i;
  }

  // reset element number to count them while filling structures
  elementNumber = 0;  

  VerticesSet& vertices = *__vertices;

  // Element structures filling
  for (size_t i=0; i<__elementType.size(); ++i) {
    std::vector<int>& elementVertices = __elementVertices[i];
    switch (__elementType[i]) {
      // Supported entities
    case 1: { // triangles
      int& triangleNumber = elementNumber[1];

      const size_t a = __verticesCorrepondance[elementVertices[0]];
      const size_t b = __verticesCorrepondance[elementVertices[1]];
      const size_t c = __verticesCorrepondance[elementVertices[2]];
      if ((a<0) or (b<0) or (c<0)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': error reading element "+stringify(i)
                           +" [bad vertices definition]",
                           ErrorHandler::normal);
      }
      (*__triangles)[triangleNumber]
        = Triangle(vertices[a], vertices[b], vertices[c],
                   __references[i]);
      triangleNumber++; // one more triangle
      break;
    }
    case 2: { // quadrangle
      int& quadrilateralNumber = elementNumber[2];

      const size_t a = __verticesCorrepondance[elementVertices[0]];
      const size_t b = __verticesCorrepondance[elementVertices[1]];
      const size_t c = __verticesCorrepondance[elementVertices[2]];
      const size_t d = __verticesCorrepondance[elementVertices[3]];
      if ((a<0) or (b<0) or (c<0) or (d<0)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': error reading element "+stringify(i)
                           +" [bad vertices definition]",
                           ErrorHandler::normal);
      }
      (*__quadrilaterals)[quadrilateralNumber]
        = Quadrangle(vertices[a], vertices[b], vertices[c], vertices[d],
                     __references[i]);
      quadrilateralNumber++; // one more quadrangle
      break;
    }
    case 3: { // tetrahedra
      int& tetrahedronNumber = elementNumber[3];

      const int a = __verticesCorrepondance[elementVertices[0]];
      const int b = __verticesCorrepondance[elementVertices[1]];
      const int c = __verticesCorrepondance[elementVertices[2]];
      const int d = __verticesCorrepondance[elementVertices[3]];
      if ((a<0) or (b<0) or (c<0) or (d<0)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': error reading element "+stringify(i)
                           +" [bad vertices definition]",
                           ErrorHandler::normal);
      }
      (*__tetrahedra)[tetrahedronNumber]
        = Tetrahedron(vertices[a], vertices[b], vertices[c], vertices[d],
                      __references[i]);
      tetrahedronNumber++; // one more tetrahedron
      break;
    }
    case  4: { // hexaredron
      int& hexahedronNumber = elementNumber[4];

      const int a = __verticesCorrepondance[elementVertices[0]];
      const int b = __verticesCorrepondance[elementVertices[1]];
      const int c = __verticesCorrepondance[elementVertices[2]];
      const int d = __verticesCorrepondance[elementVertices[3]];
      const int e = __verticesCorrepondance[elementVertices[4]];
      const int f = __verticesCorrepondance[elementVertices[5]];
      const int g = __verticesCorrepondance[elementVertices[6]];
      const int h = __verticesCorrepondance[elementVertices[7]];
      if ((a<0) or (b<0) or (c<0) or (d<0) or (e<0) or (f<0) or (g<0) or (h<0)) {
        throw ErrorHandler(__FILE__,__LINE__,
                           "reading file '"+__fileName
                           +"': error reading element "+stringify(i)
                           +" [bad vertices definition]",
                           ErrorHandler::normal);
      }
      (*__hexahedra)[hexahedronNumber]
        = Hexahedron(vertices[a], vertices[b], vertices[c], vertices[d],
                     vertices[e], vertices[f], vertices[g], vertices[h],
                     __references[i]);
      hexahedronNumber++; // one more hexahedron
      break;    }
      // Unsupported entities
    case  0: // edge
    case 14:{// point
      break;
    }
    case  5: // prism
    case  6: // pyramid
    case  7: // second order edge
    case  8: // second order triangle
    case  9: // second order quadrangle
    case 10: // second order tetrahedron
    case 11: // second order hexahedron
    case 12: // second order prism
    case 13:{// second order pyramid
    }
    default: {
          throw ErrorHandler(__FILE__,__LINE__,
                             "reading file '"+__fileName
                             +"': ff3d cannot read this kind of element",
                             ErrorHandler::normal);
    }
    }
  }
}

GmshFormatReader::Keyword
GmshFormatReader::__nextKeyword()
{
  GmshFormatReader::Keyword kw;

  char pKeyword[256];
  int retval = fscanf(__ifh,"%255s",pKeyword);
  const std::string aKeyword = pKeyword;

  if (retval < 0)  {
    kw.second = EndOfFile;
    return kw;
  } else if (retval == 0) {
    kw.second = Unknown;
    return kw;
  }

  KeywordList::iterator i = __keywordList.find(aKeyword.c_str());

  if (i != __keywordList.end()) {
    kw.first = (*i).first;
    kw.second = (*i).second;
    return kw;
  }

  throw ErrorHandler(__FILE__,__LINE__,
                     "reading file '"+__fileName
                     +"': unknown keyword '"+aKeyword+"'",
                     ErrorHandler::normal);

  kw.first = aKeyword;
  kw.second = Unknown;
  return kw;
}

GmshFormatReader::GmshFormatReader(const std::string & s)
  : MeshReader(s)
{
  // gmsh 1.0 format keywords
  __keywordList["$NOD"]    = NOD;
  __keywordList["$ENDNOD"] = ENDNOD;
  __keywordList["$ELM"]    = ELM;
  __keywordList["$ENDELM"] = ENDELM;

  // gmsh 2.0 format keywords
  __keywordList["$MeshFormat"]    = MESHFORMAT;
  __keywordList["$EndMeshFormat"] = ENDMESHFORMAT;
  __keywordList["$Nodes"]         = NODES;
  __keywordList["$EndNodes"]      = ENDNODES;
  __keywordList["$Elements"]      = ELEMENTS;
  __keywordList["$EndElements"]   = ENDELEMENTS;

  __numberOfPrimitiveNodes.resize(16);
  __numberOfPrimitiveNodes[ 0] =  2; // edge
  __numberOfPrimitiveNodes[ 1] =  3; // triangle
  __numberOfPrimitiveNodes[ 2] =  4; // quadrangle
  __numberOfPrimitiveNodes[ 3] =  4; // Tetrahedron
  __numberOfPrimitiveNodes[ 4] =  8; // Hexaredron
  __numberOfPrimitiveNodes[ 5] =  6; // Prism
  __numberOfPrimitiveNodes[ 6] =  5; // Pyramid
  __numberOfPrimitiveNodes[ 7] =  3; // second order edge
  __numberOfPrimitiveNodes[ 8] =  6; // second order triangle
  __numberOfPrimitiveNodes[ 9] =  9; // second order quadrangle
  __numberOfPrimitiveNodes[10] = 10; // second order tetrahedron
  __numberOfPrimitiveNodes[11] = 27; // second order hexahedron
  __numberOfPrimitiveNodes[12] = 18; // second order prism
  __numberOfPrimitiveNodes[13] = 14; // second order pyramid
  __numberOfPrimitiveNodes[14] =  1; // point                    

  __primitivesNames[0]     = "edges";
  __supportedPrimitives[0] = false;
  __primitivesNames[1]     = "triangles";
  __supportedPrimitives[1] = true;
  __primitivesNames[2]     = "quadrangles";
  __supportedPrimitives[2] = true;
  __primitivesNames[3]     = "tetrahedra";
  __supportedPrimitives[3] = true;
  __primitivesNames[4]     = "hexahedra";
  __supportedPrimitives[4] = true;
  __primitivesNames[5]     = "prisms";
  __supportedPrimitives[5] = false;
  __primitivesNames[6]     = "pyramids";
  __supportedPrimitives[6] = false;
  __primitivesNames[7]     = "second order edges";
  __supportedPrimitives[7] = false;
  __primitivesNames[8]     = "second order triangles";
  __supportedPrimitives[8] = false;
  __primitivesNames[9]     = "second order quadrangles";
  __supportedPrimitives[9] = false;
  __primitivesNames[10]    = "second order tetrahedra";
  __supportedPrimitives[10]= false;
  __primitivesNames[11]    = "second order hexahedra";
  __supportedPrimitives[11]= false;
  __primitivesNames[12]    = "second order prisms";
  __supportedPrimitives[12]= false;
  __primitivesNames[13]    = "second order pyramids";
  __supportedPrimitives[13]= false;
  __primitivesNames[14]    = "point";
  __supportedPrimitives[14]= false;

  ffout(3) << "\n";
  ffout(3) << "Reading file '" << s << "'\n";

  // Getting vertices list
  GmshFormatReader::Keyword kw = this->__nextKeyword();
  switch(kw.second) {
  case NOD: {
    this->__readGmshFormat1();
    break;
  }
  case MESHFORMAT: {
    real_t fileVersion = this->__getReal();
    if (fileVersion != 2) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "Cannot read Gmsh format '"+stringify(fileVersion)+"'",
                         ErrorHandler::normal);
    }
    int fileType = this->__getInteger();
    __binary = (fileType == 1);
    if ((fileType < 0) or (fileType > 1)) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "Cannot read Gmsh file type '"+stringify(fileType)+"'",
                         ErrorHandler::normal);
    }

    int dataSize = this->__getInteger();
    if (dataSize != sizeof(double)) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "Data size not supported '"+stringify(dataSize)+"'",
                         ErrorHandler::normal);
    }

    if (__binary) {
      int one=0;

      fseek(__ifh,1L,SEEK_CUR);
      fread(reinterpret_cast<char*>(&one),sizeof(int),1,__ifh);

      if (one == 1) {
        __convertEndian = false;
      } else {
        invertEndianess(one);

        if (one == 1) {
          __convertEndian = true;
        } else {
          throw ErrorHandler(__FILE__,__LINE__,
                             "Cannot determine endianess",
                             ErrorHandler::normal);
        }
      }

      ffout(3) << "- Binary format: ";
#ifdef    WORDS_BIGENDIAN
      if (not __convertEndian) {
        ffout(3) << "big endian\n";
      } else {
        ffout(3) << "little endian\n";
      }
#else  // WORDS_BIGENDIAN
      if (not __convertEndian) {
        ffout(3) << "little endian\n";
      } else {
        ffout(3) << "big endian\n";
      }
#endif // WORDS_BIGENDIAN
    }

    kw = this->__nextKeyword();
    if (kw.second != ENDMESHFORMAT) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "reading file '"+__fileName
                         +"': expecting $EndMeshFormat, '"+kw.first+"' was found",
                         ErrorHandler::normal);
    }

    this->__readGmshFormat2();

    break;
  }
  default: {
    throw ErrorHandler(__FILE__,__LINE__,
                       "cannot determine format version of '"+__fileName+"'",
                       ErrorHandler::normal);
  }
  }
  
  this->__proceedData();
  this->__createMesh();
}

void GmshFormatReader::
__readGmshFormat1()
{
  ffout(3) << "- Reading Gmsh format 1.0\n";
  this->__readVertices();

  GmshFormatReader::Keyword kw;
  kw = this->__nextKeyword();
  if (kw.second != ENDNOD) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $ENDNOD, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }

  // Getting elements list
  kw = this->__nextKeyword();
  if (kw.second != ELM) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $ELM, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }

  this->__readElements1();

  kw = this->__nextKeyword();
  if (kw.second != ENDELM) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $ENDELM, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }
}

void GmshFormatReader::
__readGmshFormat2()
{
  ffout(3) << "- Reading Gmsh format 2.0\n";
  GmshFormatReader::Keyword kw;
  kw = this->__nextKeyword();
  if (kw.second != NODES) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $Nodes, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }

  this->__readVertices();

  kw = this->__nextKeyword();
  if (kw.second != ENDNODES) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $EndNodes, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }

  // Getting elements list
  kw = this->__nextKeyword();
  if (kw.second != ELEMENTS) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $Elements, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }

  this->__readElements2();

  kw = this->__nextKeyword();
  if (kw.second != ENDELEMENTS) {
    throw ErrorHandler(__FILE__,__LINE__,
                       "reading file '"+__fileName
                       +"': expecting $EndElements, '"+kw.first+"' was found",
                       ErrorHandler::normal);
  }
}

---