MOAB: Mesh Oriented datABase  (version 5.2.1)
QualityAssessor.hpp
Go to the documentation of this file.
00001 /* *****************************************************************
00002     MESQUITE -- The Mesh Quality Improvement Toolkit
00003 
00004     Copyright 2004 Sandia Corporation and Argonne National
00005     Laboratory.  Under the terms of Contract DE-AC04-94AL85000
00006     with Sandia Corporation, the U.S. Government retains certain
00007     rights in this software.
00008 
00009     This library is free software; you can redistribute it and/or
00010     modify it under the terms of the GNU Lesser General Public
00011     License as published by the Free Software Foundation; either
00012     version 2.1 of the License, or (at your option) any later version.
00013 
00014     This library is distributed in the hope that it will be useful,
00015     but WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017     Lesser General Public License for more details.
00018 
00019     You should have received a copy of the GNU Lesser General Public License
00020     (lgpl.txt) along with this library; if not, write to the Free Software
00021     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023     diachin2@llnl.gov, djmelan@sandia.gov, mbrewer@sandia.gov,
00024     pknupp@sandia.gov, tleurent@mcs.anl.gov, tmunson@mcs.anl.gov
00025 
00026     (2006) kraftche@cae.wisc.edu
00027 
00028   ***************************************************************** */
00029 // -*- Mode : c++; tab-width: 3; c-tab-always-indent: t; indent-tabs-mode: nil; c-basic-offset: 3
00030 // -*-
00031 
00032 /*! \file QualityAssessor.hpp
00033 
00034 Header file for the MBMesquite::QualityAssessor class
00035 
00036   \author Thomas Leurent
00037   \date   2002-05-01
00038   \author Jason Kraftcheck
00039   \date   2005-03-09
00040  */
00041 
00042 #ifndef MSQ_QUALITYASSESSOR_HPP
00043 #define MSQ_QUALITYASSESSOR_HPP
00044 
00045 #include "Mesquite.hpp"
00046 #include "Instruction.hpp"
00047 #include "MeshInterface.hpp"
00048 
00049 #include <list>
00050 #include <string>
00051 #include <vector>
00052 #include <iosfwd>
00053 
00054 namespace MBMesquite
00055 {
00056 
00057 class QualityMetric;
00058 class MsqError;
00059 class ParallelHelper;
00060 
00061 /*! \class QualityAssessor
00062 
00063     \brief A QualityAssessor instance can be inserted into an
00064     InstructionQueue to calculate and summarize registered
00065     QualityMetric or QualityMetrics for the mesh.
00066 
00067     QualityAssessor provides a summary of the mesh quality.  An
00068     instance of QualityAssessor may be inserted in the InstructionQueue
00069     at any point to print a summary of the mesh quality at that
00070     time during the optimization.  The application is expected to
00071     register QualityMetric instances to be used in assessing the
00072     mesh quality.  If no QualityMetrics are registered, the only
00073     assessment that will be performed is a simple count of inverted
00074     elements.
00075 
00076     The "stopping assessor" and "stopping function", if set,
00077     determinte the value reported to Mesquite for the overall
00078     run of of the QualityAssessor.
00079 
00080     All summary data except the histogram and custom power-means is
00081     accumulated for all registered metrics.  QualityAssessment data
00082     can be obtained through three different mechanisms:
00083       - QualityAssessor can print a summary to std::out or a specified
00084         output stream after they are calculated.
00085       - The get_results and get_all_results methods can be used to
00086         obtain the sumary data programatically.
00087       - Quality measures for element-based or vertex-based metrics can
00088         be stored on the corresponding entities using "tags".
00089 
00090 */
00091 class QualityAssessor : public Instruction
00092 {
00093   public:
00094     /**\brief Simple consturctor.  Metrics registered separately.
00095      *\param print_summary_to_std_out If true, summary of mesh quality
00096      *                will be written to std::out.  If false, quality
00097      *                assessment will be available via the get_results
00098      *                and get_all_results methods, but will not be printed.
00099      *\param free_elements_only If true, only quality values that depend
00100      *                on at least one free vertex will be uses.
00101      *\param  inverted_element_tag_name  If a non-null value is specified,
00102      *                an integer tag with the specified name will be used
00103      *                it store value of 0 for normal elements and 1 for
00104      *                inverted elements.
00105      *\param  name    Name to include in output.  Useful if several QualityAssessors
00106      *                are in use at the same time.
00107      */
00108     MESQUITE_EXPORT
00109     QualityAssessor( bool print_summary_to_std_out = true, bool free_elements_only = true,
00110                      const char* inverted_element_tag_name = 0, std::string name = std::string() );
00111 
00112     /**\brief Simple consturctor.  Metrics registered separately.
00113      *\param output_stream IO stream to which to write a summary of the
00114      *                mesh quality.
00115      *\param free_elements_only If true, only quality values that depend
00116      *                on at least one free vertex will be uses.
00117      *\param  inverted_element_tag_name  If a non-null value is specified,
00118      *                an integer tag with the specified name will be used
00119      *                it store value of 0 for normal elements and 1 for
00120      *                inverted elements.
00121      *\param  name    Name to include in output.  Useful if several QualityAssessors
00122      *                are in use at the same time.
00123      */
00124     MESQUITE_EXPORT
00125     QualityAssessor( std::ostream& output_stream, bool free_elements_only = true,
00126                      const char* inverted_element_tag_name = 0, std::string name = std::string() );
00127 
00128     /**\brief Construct and register a QualityMetric
00129      *\param output_stream IO stream to which to write a summary of the
00130      *                mesh quality.
00131      *\param metric   QualtiyMetric to register for use in assessing mesh
00132      *                quality.  Will also be used as the "stopping assessment".
00133      *\param historgram_intervals If non-zero, a histogram of quality metric
00134      *                values composed of the specified number of intervals
00135      *                will be generated.
00136      *\param power_mean If non-zero, in addition to the normal summary
00137      *                statistics for the quality metric, an additional
00138      *                general power mean with the specified power will
00139      *                be calculated.
00140      *\param metric_value_tag_name  If a non-null value is specified,
00141      *                a tag with the specified name will be populated
00142      *                with quality values for individual elements or
00143      *                vertices if metric is an element-based or vertex-
00144      *                based metric.  If metric is not element-based or
00145      *                vertex-based, this argument has no effect.
00146      *\param free_elements_only If true, only quality values that depend
00147      *                on at least one free vertex will be uses.
00148      *\param inverted_element_tag_name  If a non-null value is specified,
00149      *                an integer tag with the specified name will be used
00150      *                it store value of 0 for normal elements and 1 for
00151      *                inverted elements.
00152      *\param  name    Name to include in output.  Useful if several QualityAssessors
00153      *                are in use at the same time.
00154      */
00155     MESQUITE_EXPORT
00156     QualityAssessor( std::ostream& output_stream, QualityMetric* metric, int histogram_intervals = 0,
00157                      double power_mean = 0.0, bool free_elements_only = true, const char* metric_value_tag_name = 0,
00158                      const char* inverted_element_tag_name = 0, std::string name = std::string() );
00159 
00160     /**\brief Construct and register a QualityMetric
00161      *\param print_summary_to_std_out If true, summary of mesh quality
00162      *                will be written to std::out.  If false, quality
00163      *                assessment will be available via the get_results
00164      *                and get_all_results methods, but will not be printed.
00165      *\param metric   QualtiyMetric to register for use in assessing mesh
00166      *                quality.  Will also be used as the "stopping assessment".
00167      *\param historgram_intervals If non-zero, a histogram of quality metric
00168      *                values composed of the specified number of intervals
00169      *                will be generated.
00170      *\param power_mean If non-zero, in addition to the normal summary
00171      *                statistics for the quality metric, an additional
00172      *                general power mean with the specified power will
00173      *                be calculated.
00174      *\param metric_value_tag_name  If a non-null value is specified,
00175      *                a tag with the specified name will be populated
00176      *                with quality values for individual elements or
00177      *                vertices if metric is an element-based or vertex-
00178      *                based metric.  If metric is not element-based or
00179      *                vertex-based, this argument has no effect.
00180      *\param free_elements_only If true, only quality values that depend
00181      *                on at least one free vertex will be uses.
00182      *\param  inverted_element_tag_name  If a non-null value is specified,
00183      *                an integer tag with the specified name will be used
00184      *                it store value of 0 for normal elements and 1 for
00185      *                inverted elements.
00186      *\param  name    Name to include in output.  Useful if several QualityAssessors
00187      *                are in use at the same time.
00188      */
00189     MESQUITE_EXPORT
00190     QualityAssessor( QualityMetric* metric, int histogram_intervals = 0, double power_mean = 0.0,
00191                      bool free_elements_only = true, const char* metric_value_tag_name = 0,
00192                      bool print_summary_to_std_out = true, const char* inverted_element_tag_name = 0,
00193                      std::string name = std::string() );
00194 
00195     MESQUITE_EXPORT virtual ~QualityAssessor();
00196 
00197     //! Provides a name to the QualityAssessor (use it for default name in constructor).
00198     MESQUITE_EXPORT void set_name( std::string name )
00199     {
00200         qualityAssessorName = name;
00201     };
00202     //! Retrieves the QualityAssessor name. A default name should be set in the constructor.
00203     MESQUITE_EXPORT virtual std::string get_name() const
00204     {
00205         return qualityAssessorName;
00206     }
00207 
00208     /**\brief All elements or only improvable ones.
00209      *
00210      * If set to true, the quality assessment results will include
00211      * quality values only for those elements (or more precisely metric
00212      * sample points) which are influenced by at least one free vertex.
00213      * That is, quality for elements (or sample points) that the sovler
00214      * cannot improve (e.g. an element with all vertices fixed) will not
00215      * be included in the quality assessment.
00216      *
00217      * If set to false, quality for all elements will be assessed.
00218      */
00219     MESQUITE_EXPORT void measure_free_samples_only( bool yesno )
00220     {
00221         skipFixedSamples = yesno;
00222     }
00223 
00224     /**\brief All elements or only improvable ones.
00225      *
00226      * If set to true, the quality assessment results will include
00227      * quality values only for those elements (or more precisely metric
00228      * sample points) which are influenced by at least one free vertex.
00229      * That is, quality for elements (or sample points) that the sovler
00230      * cannot improve (e.g. an element with all vertices fixed) will not
00231      * be included in the quality assessment.
00232      *
00233      * If set to false, quality for all elements will be assessed.
00234      */
00235     MESQUITE_EXPORT bool measuring_free_samples_only() const
00236     {
00237         return skipFixedSamples;
00238     }
00239 
00240     /**\brief Register a QualityMetric for use in quality assessment.
00241      *
00242      * Add a quality metric to the list of metrics used to assess
00243      * the quality of the mesh.
00244      *
00245      *\param metric   QualtiyMetric to register for use in assessing mesh
00246      *                quality.  Will also be used as the "stopping assessment".
00247      *\param historgram_intervals If non-zero, a histogram of quality metric
00248      *                values composed of the specified number of intervals
00249      *                will be generated.
00250      *\param power_mean If non-zero, in addition to the normal summary
00251      *                statistics for the quality metric, an additional
00252      *                general power mean with the specified power will
00253      *                be calculated.
00254      *\param metric_value_tag_name  If a non-null value is specified,
00255      *                a tag with the specified name will be populated
00256      *                with quality values for individual elements or
00257      *                vertices if metric is an element-based or vertex-
00258      *                based metric.  If metric is not element-based or
00259      *                vertex-based, this argument has no effect.
00260      *\param  inverted_element_tag_name  If a non-null value is specified,
00261      *                an integer tag with the specified name will be used
00262      *                it store value of 0 for normal elements and 1 for
00263      *                inverted elements.
00264      */
00265     MESQUITE_EXPORT
00266     void add_quality_assessment( QualityMetric* metric, int histogram_intervals = 0, double power_mean = 0.0,
00267                                  const char* metric_value_tag_name = 0, const char* metric_label = 0 );
00268 
00269     /**\brief Same as add_quality_assessment, except that the average
00270      *        metric value is also used as the return value from loop_over_mesh.
00271      *        Specify a power_mean value to control which average is used.
00272      */
00273     MESQUITE_EXPORT
00274     void set_stopping_assessment( QualityMetric* metric, int histogram_intervals = 0, double power_mean = 0.0,
00275                                   const char* metric_value_tag_name = 0, const char* metric_label = 0 );
00276 
00277     /**\brief Register a QualityMetric for use in quality assessment.
00278      *
00279      * Add a quality metric to the list of metrics used to assess
00280      * the quality of the mesh.  Specify more parameters controlling
00281      * histogram.
00282      *
00283      *\param metric   QualtiyMetric to register for use in assessing mesh
00284      *                quality.  Will also be used as the "stopping assessment".
00285      *\param min      Minimum of histogram rnage.
00286      *\param max      Maximum of histogram range.
00287      *\param intervals Histogram intervals.
00288      *\param power_mean If non-zero, in addition to the normal summary
00289      *                statistics for the quality metric, an additional
00290      *                general power mean with the specified power will
00291      *                be calculated.
00292      *\param metric_value_tag_name  If a non-null value is specified,
00293      *                a tag with the specified name will be populated
00294      *                with quality values for individual elements or
00295      *                vertices if metric is an element-based or vertex-
00296      *                based metric.  If metric is not element-based or
00297      *                vertex-based, this argument has no effect.
00298      *\param  inverted_element_tag_name  If a non-null value is specified,
00299      *                an integer tag with the specified name will be used
00300      *                it store value of 0 for normal elements and 1 for
00301      *                inverted elements.
00302      */
00303     MESQUITE_EXPORT
00304     void add_histogram_assessment( QualityMetric* qm, double min, double max, int intervals, double power_mean = 0.0,
00305                                    const char* metric_value_tag_name = 0, const char* metric_label = 0 );
00306 
00307     virtual MESQUITE_EXPORT void initialize_queue( MeshDomainAssoc* mesh_and_domain, const Settings* settings,
00308                                                    MsqError& err );
00309 
00310     //! Does one sweep over the mesh and assess the quality with the metrics previously added.
00311     virtual MESQUITE_EXPORT double loop_over_mesh( MeshDomainAssoc* mesh_and_domain, const Settings* settings,
00312                                                    MsqError& err );
00313 
00314     //! Does one sweep over the mesh and assess the quality with the metrics previously added.
00315     virtual MESQUITE_EXPORT double loop_over_mesh( ParallelMesh* mesh, MeshDomain* domain, const Settings* settings,
00316                                                    MsqError& err );
00317 
00318     //! Do not print results of assessment.
00319     MESQUITE_EXPORT void disable_printing_results()
00320     {
00321         printSummary = false;
00322     }
00323 
00324     //! Print accumulated summary data to specified stream.
00325     MESQUITE_EXPORT void print_summary( std::ostream& stream ) const;
00326 
00327     //! True if any metric evaluated to an invalid value
00328     //! for any element
00329     MESQUITE_EXPORT bool invalid_elements() const;
00330 
00331     //! Provides the number of inverted elements, inverted_elmes,
00332     //!  and the number of elements whose orientation can not be
00333     //!  determined, undefined_elems.
00334     //! Returns false if this information is not yet available.
00335     //! Returns true, otherwise.
00336     MESQUITE_EXPORT bool get_inverted_element_count( int& inverted_elems, int& inverted_samples, MsqError& err );
00337 
00338     //! Reset calculated data
00339     MESQUITE_EXPORT void reset_data();
00340 
00341     //! Produces two historgrams on a single scale from a before
00342     //! optimization histogram and an after optimization histogram.
00343     //! The histogram intervals are adjusted to include the enitre
00344     //! range of both histograms, the horizontal interval value bars
00345     //! are adjusted to be on the same scale, and the metric quality
00346     //! values are placed in the correct quality value 'bin' based
00347     //! on the new interval scale.
00348 
00349     MESQUITE_EXPORT void scale_histograms( QualityAssessor* optimal );
00350 
00351     MESQUITE_EXPORT void tag_inverted_elements( std::string tagname )
00352     {
00353         invertedTagName = tagname;
00354     }
00355     MESQUITE_EXPORT void dont_tag_inverted_elements()
00356     {
00357         invertedTagName.clear();
00358     }
00359     MESQUITE_EXPORT bool tagging_inverted_elements() const
00360     {
00361         return !invertedTagName.empty();
00362     }
00363 
00364     MESQUITE_EXPORT void tag_fixed_elements( std::string tagname )
00365     {
00366         fixedTagName = tagname;
00367     }
00368     MESQUITE_EXPORT void dont_tag_fixed_elements()
00369     {
00370         fixedTagName.clear();
00371     }
00372     MESQUITE_EXPORT bool tagging_fixed_elements() const
00373     {
00374         return !fixedTagName.empty();
00375     }
00376 
00377     /** \brief Per-metric QualityAssessor data
00378      *
00379      * The Assessor class holds QualityAssessor data for
00380      * each metric added by the calling application, including
00381      * a pointer to the metric instance, QAFunction flags
00382      * dictating what is to be calculated and output, histogram
00383      * parameters, and the variables used to accumulate results as
00384      * the QualityAssessor is running.  It also provides
00385      * methods to access the calculated data once the QualityAssessor
00386      * pass is completed.
00387      */
00388     class Assessor
00389     {
00390       public:
00391         MESQUITE_EXPORT Assessor( QualityMetric* metric, const char* name = 0 );
00392 
00393         MESQUITE_EXPORT double get_average() const;
00394         MESQUITE_EXPORT double get_maximum() const
00395         {
00396             return maximum;
00397         }
00398         MESQUITE_EXPORT double get_minimum() const
00399         {
00400             return minimum;
00401         }
00402         MESQUITE_EXPORT double get_rms() const;
00403         MESQUITE_EXPORT double get_stddev() const;
00404         MESQUITE_EXPORT double get_power_mean() const;
00405         MESQUITE_EXPORT double get_power() const
00406         {
00407             return pMean;
00408         }
00409         MESQUITE_EXPORT int get_count() const
00410         {
00411             return count;
00412         }
00413 
00414         MESQUITE_EXPORT bool have_power_mean() const
00415         {
00416             return 0.0 != pMean;
00417         }
00418 
00419         MESQUITE_EXPORT int get_invalid_element_count() const
00420         {
00421             return numInvalid;
00422         }
00423 
00424         /** Get historgram of data, if calculated.
00425          *\param lower_bound_out  The lower bound of the histogram
00426          *\param upper_bound_out  The upper bound of the histogram
00427          *\param counts_out       An array of counts of elements where
00428          *              the first entry is the number of elements for
00429          *              which the metric is below the lower bound, the
00430          *              last entry is the number of elements above the
00431          *              upper bound, and all other values are the counts
00432          *              for histogram intervals between the lower and
00433          *              upper bounds.
00434          */
00435         MESQUITE_EXPORT
00436         void get_histogram( double& lower_bound_out, double& upper_bound_out, std::vector< int >& counts_out,
00437                             MsqError& err ) const;
00438 
00439         /** Reset all calculated data */
00440         MESQUITE_EXPORT void reset_data();
00441 
00442         /** Print the histogram */
00443         MESQUITE_EXPORT void print_histogram( std::ostream&, int width = 0 ) const;
00444 
00445         /** Get the QualityMetric */
00446         MESQUITE_EXPORT QualityMetric* get_metric() const
00447         {
00448             return qualMetric;
00449         }
00450 
00451         MESQUITE_EXPORT const std::string& get_label() const
00452         {
00453             return mLabel;
00454         }
00455 
00456         /** Add a value to the running counts */
00457         MESQUITE_EXPORT void add_value( double metric_value );
00458 
00459         /** Add a value to the hisogram data */
00460         MESQUITE_EXPORT void add_hist_value( double metric_value );
00461 
00462         /** Note invalid result */
00463         MESQUITE_EXPORT void add_invalid_value();
00464 
00465         MESQUITE_EXPORT bool have_histogram() const
00466         {
00467             return !histogram.empty();
00468         }
00469 
00470         /** If range of histogram has not yet been determined,
00471          * calculate it from the min/max values.
00472          */
00473         MESQUITE_EXPORT void calculate_histogram_range();
00474 
00475         MESQUITE_EXPORT bool write_to_tag() const
00476         {
00477             return !tagName.empty();
00478         }
00479 
00480         MESQUITE_EXPORT void set_stopping_function( bool value )
00481         {
00482             stoppingFunction = value;
00483         }
00484 
00485         MESQUITE_EXPORT bool stopping_function() const
00486         {
00487             return stoppingFunction;
00488         }
00489 
00490         MESQUITE_EXPORT double stopping_function_value() const;
00491 
00492       private:
00493         friend class QualityAssessor;
00494 
00495         QualityMetric* const qualMetric;  //< The quality metric
00496         std::string mLabel;
00497 
00498         unsigned long count;  //< The total number of times the metric was evaluated
00499 
00500         double sum;                //< The sum of the metric over all elements
00501         double maximum;            //< The maximum of the metric
00502         double minimum;            //< The minimum value of the metric
00503         double sqrSum;             //< The sum of the square of the metric values
00504         double pSum;               //< The sum of the metric values raised to the pMean power
00505         unsigned long numInvalid;  //< Count of invalid metric values
00506 
00507         double pMean;  //< Power for general power-mean.
00508 
00509         /** The histogram counts, where the first and last values are
00510          * counts of values below the lower bound and above the upper
00511          * bound, respectively.  The remaining values are the histogram
00512          * counts.
00513          */
00514         bool haveHistRange;
00515         double histMin;  //< Lower bound of histogram
00516         double histMax;  //< Upper bound of histogram
00517         std::vector< int > histogram;
00518 
00519         std::string tagName;  //< Tag to which to write metric values.
00520         /** Cached tag handle */
00521         TagHandle tagHandle;
00522 
00523         /** Value is return value for all of QualityAssessor */
00524         bool stoppingFunction;
00525 
00526         int referenceCount;
00527 
00528         enum AssessSchemes assessScheme;
00529     };
00530 
00531     typedef std::list< Assessor* > list_type;
00532 
00533     /** \brief Request summary data for a specific QualityMetric
00534      * This method allows the application to request the summary
00535      * data for a metric it has registered with the QualityAssessor.
00536      * If the passed QualityMetric has not been registered with the
00537      * QualityAssessor instance, NULL is returned.
00538      */
00539     MESQUITE_EXPORT
00540     const Assessor* get_results( QualityMetric* metric ) const;
00541 
00542     /** \brief Request summary data for a specific QualityMetric
00543      * This method allows the application to request the summary
00544      * data for a metric it has registered with the QualityAssessor.
00545      * If the passed QualityMetric has not been registered with the
00546      * QualityAssessor instance, NULL is returned.
00547      */
00548     MESQUITE_EXPORT
00549     const Assessor* get_results( const char* metric_name ) const;
00550 
00551     /** \brief Get list of all summary data.
00552      *  Return a const reference to the internal list of
00553      *  calculated data.
00554      */
00555     const list_type& get_all_results() const
00556     {
00557         return assessList;
00558     }
00559 
00560     MESQUITE_EXPORT
00561     QualityAssessor( const QualityAssessor& copy );
00562 
00563     MESQUITE_EXPORT
00564     QualityAssessor& operator=( const QualityAssessor& copy );
00565 
00566   private:
00567     struct Data
00568     {
00569         /** Count of inverted elements. */
00570         int invertedElementCount;
00571 
00572         /** Count of inverted Jacobians within elements.*/
00573         int invertedSampleCount;
00574 
00575         /** Number of elements */
00576         size_t elementCount;
00577 
00578         /** Total number of element Jacobians tested for inversion */
00579         size_t sampleCount;
00580 
00581         /** Number of elements with at least one free vertex */
00582         size_t freeElementCount;
00583 
00584         int referenceCount;
00585 
00586         Data() : referenceCount( 1 )
00587         {
00588             clear();
00589         }
00590 
00591         void clear()
00592         {
00593             invertedElementCount = invertedSampleCount = -1;
00594             elementCount = sampleCount = freeElementCount = 0;
00595         }
00596     };
00597 
00598     Data* myData;
00599 
00600     //! Common code for serial and parallel loop_over_mesh
00601     double loop_over_mesh_internal( MeshDomainAssoc* mesh_and_domain, const Settings* settings, ParallelHelper* helper,
00602                                     MsqError& err );
00603 
00604     /** Find an Assessor corresponding to the passed
00605      *  QualityMetric, or create it if is not found in
00606      *  the list.
00607      */
00608     list_type::iterator find_or_add( QualityMetric* qm, const char* label = 0 );
00609 
00610     /** Find an Assessor corresponding to the passed
00611      *  QualityMetric, or create it if is not found in
00612      *  the list.
00613      */
00614     list_type::iterator find_stopping_assessment();
00615 
00616     /** Find or create tag */
00617     TagHandle get_tag( Mesh* mesh, std::string name, Mesh::TagType type, unsigned size, MsqError& err );
00618 
00619     /** Try to determine if output stream is a terminal and if so,
00620         the width of that terminal.  Returns zero if width cannot
00621         be determined. */
00622     int get_terminal_width() const;
00623 
00624     static std::string element_name_as_string( int enum_name );
00625 
00626     static double round_to_3_significant_digits( double number );
00627 
00628     /** Name */
00629     std::string qualityAssessorName;
00630 
00631     /** List of quality metrics and corresponding data */
00632     list_type assessList;
00633 
00634     /** Stream to which to write summary of metric data */
00635     std::ostream& outputStream;
00636     /** Disable printing */
00637     bool printSummary;
00638 
00639     std::string invertedTagName, fixedTagName;
00640 
00641     bool skipFixedSamples;
00642 
00643     int elementTypeCount[MIXED - POLYGON + 1];
00644 
00645     bool invalid_values;  // set to true when a target metric contains inverted elements
00646 };
00647 
00648 }  // namespace MBMesquite
00649 
00650 #endif  // QualityAssessor_hpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines