compare.C File Reference

Go to the source code of this file.

Functions
void	usage (const std::string &progName)
	how to use this, and command line processor More...
void	process_cmd_line (int argc, char **argv, std::vector< std::string > &names, unsigned char &dim, double &threshold, XdrMODE &format, bool &verbose, bool &quiet)
bool	do_compare (EquationSystems &les, EquationSystems &res, double threshold, bool verbose)
	everything that is identical for the systems, and should not go into EquationSystems::compare(), can go in this do_compare(). More...
int	main (int argc, char **argv)

Function Documentation

do_compare()

bool do_compare	(	EquationSystems &	les,
		EquationSystems &	res,
		double	threshold,
		bool	verbose
	)

everything that is identical for the systems, and should not go into EquationSystems::compare(), can go in this do_compare().

start comparing

Definition at line 230 of file compare.C.

References libMesh::EquationSystems::compare(), libMesh::out, and libMesh::EquationSystems::print_info().

Referenced by main().

{

  if (verbose)
    {
      libMesh::out        << "*********   LEFT SYSTEM    *********" << std::endl;
      les.print_info  ();
      libMesh::out << "*********   RIGHT SYSTEM   *********" << std::endl;
      res.print_info ();
      libMesh::out << "********* COMPARISON PHASE *********" << std::endl
                   << std::endl;
    }

  bool result = les.compare(res, threshold, verbose);
  if (verbose)
    {
      libMesh::out        << "*********     FINISHED     *********" << std::endl;
    }
  return result;
}

main()

int main	(	int	argc,
		char **	argv
	)

build the left and right mesh for left, init them

build EquationSystems objects, read them

let's see what do_compare found out

Definition at line 266 of file compare.C.

References dim, do_compare(), libMesh::TriangleWrapper::init(), libMesh::out, process_cmd_line(), libMesh::READ, libMesh::UnstructuredMesh::read(), libMesh::EquationSystems::read(), and libMesh::TOLERANCE.

{
  LibMeshInit init(argc, argv);

  // these should not be contained in the following braces
  bool quiet = false;
  bool are_equal;

  PerfMon perfmon(argv[0]);

  // default values
  std::vector<std::string> names;
  unsigned char dim               = static_cast<unsigned char>(-1);
  double threshold                = double(TOLERANCE);
  XdrMODE format                  = READ;
  bool verbose                    = false;

  // get commands
  process_cmd_line(argc, argv,
                   names,
                   dim,
                   threshold,
                   format,
                   verbose,
                   quiet);

  libmesh_error_msg_if(dim == static_cast<unsigned char>(-1),
                       "ERROR:  you must specify the dimension on "
                       << "the command line!\n\n"
                       << argv[0]
                       << " -d 3 ... for example");

  if (quiet)
    verbose = false;

  if (verbose)
    {
      libMesh::out << "Settings:" << std::endl
                   << " dimensionality = " << +dim << std::endl
                   << " mesh           = " << names[0] << std::endl
                   << " left system    = " << names[1] << std::endl
                   << " right system   = " << names[2] << std::endl
                   << " threshold      = " << threshold << std::endl
                   << " read format    = " << format << std::endl
                   << std::endl;
    }


  Mesh left_mesh  (init.comm(), dim);
  Mesh right_mesh (init.comm(), dim);


  if (!names.empty())
    {
      left_mesh.read  (names[0]);
      right_mesh.read (names[0]);

      if (verbose)
        left_mesh.print_info();
    }
  else
    {
      libMesh::out << "No input specified." << std::endl;
      return 1;
    }


  EquationSystems left_system  (left_mesh);
  EquationSystems right_system (right_mesh);

  libmesh_error_msg_if(names.size() != 3, "Bad input specified.");

  left_system.read  (names[1], format);
  right_system.read (names[2], format);

  are_equal = do_compare (left_system, right_system, threshold, verbose);


  unsigned int our_result;

  if (are_equal)
    {
      if (!quiet)
        libMesh::out << std::endl
                     << " Congrat's, up to the defined threshold, the two"
                     << std::endl
                     << " are identical."
                     << std::endl;
      our_result=0;
    }
  else
    {
      if (!quiet)
        libMesh::out << std::endl
                     << " Oops, differences occurred!"
                     << std::endl
                     << " Use -v to obtain more information where differences occurred."
                     << std::endl;
      our_result=1;
    }

  //  return libMesh::close();
  return our_result;
}

process_cmd_line()

void process_cmd_line	(	int	argc,
		char **	argv,
		std::vector< std::string > &	names,
		unsigned char &	dim,
		double &	threshold,
		XdrMODE &	format,
		bool &	verbose,
		bool &	quiet
	)

Get mesh file name

Get the mesh dimension

Get left file name

Get right file name

Get the comparison threshold

Use ascii format

Use binary format

Be verbose

Be totally quiet, no matter what -v says

Definition at line 88 of file compare.C.

References libMesh::DECODE, dim, libMesh::READ, and usage().

Referenced by main().

{
  char optionStr[] =
    "d:m:l:r:t:abvq?h";

  int opt;

  bool format_set    = false;
  bool left_name_set = false;

  if (argc < 3)
    usage(std::string(argv[0]));


  while ((opt = getopt(argc, argv, optionStr)) != -1)
    {
      switch (opt)
        {

        case 'm':
          {
            libmesh_error_msg_if(!names.empty(), "ERROR: Mesh file name must precede left file name!");

            names.push_back(optarg);
            break;
          }

        case 'd':
          {
            dim = cast_int<unsigned char>(atoi(optarg));
            break;
          }

        case 'l':
          {
            libmesh_error_msg_if(left_name_set, "ERROR: Mesh file name must precede right file name!");

            names.push_back(optarg);
            left_name_set = true;
            break;
          }

        case 'r':
          {
            libmesh_error_msg_if(names.empty() || !left_name_set,
                                 "ERROR: Mesh file name and left file name must precede right file name!");

            names.push_back(optarg);
            break;
          }

        case 't':
          {
            threshold = atof(optarg);
            break;
          }

        case 'a':
          {
            libmesh_error_msg_if(format_set, "ERROR: Equation system file format already set!");

            format = READ;
            format_set = true;
            break;
          }

        case 'b':
          {
            libmesh_error_msg_if(format_set, "ERROR: Equation system file format already set!");

            format = DECODE;
            format_set = true;
            break;
          }


        case 'v':
          {
            verbose = true;
            break;
          }

        case 'q':
          {
            quiet = true;
            break;
          }

        case 'h':
        case '?':
          usage(argv[0]);

        default:
          return;
        }
    }

}

usage()

void usage

(

const std::string &

progName

)

how to use this, and command line processor

Definition at line 48 of file compare.C.

Referenced by process_cmd_line().

{
  std::ostringstream helpList;
  helpList << "usage:\n"
           << "        "
           << progName
           << " [options] ...\n"
           << "\n"
           << "options:\n"
           << "    -d <dim>                      <dim>-dimensional mesh\n"
           << "    -m <string>                   Mesh file name\n"
           << "    -l <string>                   Left Equation Systems file name\n"
           << "    -r <string>                   Right Equation Systems file name\n"
           << "    -t <float>                    threshold\n"
           << "    -a                            ASCII format (default)\n"
           << "    -b                            binary format\n"
           << "    -v                            Verbose\n"
           << "    -q                            really quiet\n"
           << "    -h                            Print help menu\n"
           << "\n"
           << "\n"
           << " This program is used to compare equation systems to a user-specified\n"
           << " threshold.  Equation systems are imported in the libMesh format\n"
           << " provided through the read and write methods in class EquationSystems.\n"
           << " \n"
           << "  ./compare -d 3 -m grid.xda -l leftfile.dat -r rightfile.dat -b -t 1.e-8\n"
           << "\n"
           << " will read in the mesh grid.xda, the equation systems leftfile.dat and\n"
           << " rightfile.dat in binary format and compare systems, and especially the\n"
           << " floats stored in vectors.  The comparison is said to be passed when the\n"
           << " floating point values agree up to the given threshold.  When no threshold\n"
           << " is set the default libMesh tolerance is used.  If neither -a or -b are set,\n"
           << " ASCII format is assumed.\n"
           << "\n";

  libmesh_error_msg(helpList.str());
}