includeLinks/QualityAssessor.hpp

Go to the documentation of this file.

/* ***************************************************************** 
    MESQUITE -- The Mesh Quality Improvement Toolkit

    Copyright 2004 Sandia Corporation and Argonne National
    Laboratory.  Under the terms of Contract DE-AC04-94AL85000 
    with Sandia Corporation, the U.S. Government retains certain 
    rights in this software.

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

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License 
    (lgpl.txt) along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    diachin2@llnl.gov, djmelan@sandia.gov, mbrewer@sandia.gov, 
    pknupp@sandia.gov, tleurent@mcs.anl.gov, tmunson@mcs.anl.gov      
   
  ***************************************************************** */
// -*- Mode : c++; tab-width: 3; c-tab-always-indent: t; indent-tabs-mode: nil; c-basic-offset: 3 -*-

#ifndef MSQ_QUALITYASSESSOR_HPP
#define MSQ_QUALITYASSESSOR_HPP

#include <math.h>

#include "Mesquite.hpp"
#include "PatchDataUser.hpp"

#ifdef MSQ_USE_OLD_STD_HEADERS
#  include <list.h>
#  include <string.h>
#else
#  include <list>
#  include <string>
#endif

#ifdef MSQ_USE_OLD_IO_HEADERS
#  include <ostream.h>
#else
#  include <iosfwd>
#endif


namespace Mesquite 
{

   class QualityMetric;
   class MsqError;
   class MeshSet;

  class QualityAssessor : public PatchDataUser
  {
  public:
    
    
    enum QAFunction {
       NO_FUNCTION = 0,
       AVERAGE=1,
       HISTOGRAM=2,
       MAXIMUM=4, 
       MINIMUM=8,
       RMS=16,
       STDDEV=32,
       ALL_MEASURES=255
    };
    
    static msq_std::string get_QAFunction_name(enum QualityAssessor::QAFunction);
    
    QualityAssessor( msq_std::string name = "QualityAssessor" );
    
    QualityAssessor( msq_stdio::ostream& output_stream,
                     msq_std::string name = "QualityAssessor" );
                     
    QualityAssessor( QualityMetric* metric, QAFunction function,
                     msq_stdio::ostream& output_stream,
                     MsqError& err,
                     msq_std::string name = "QualityAssessor" );

                     
    QualityAssessor( QualityMetric* metric, QAFunction function,
                     MsqError& err,
                     msq_std::string name = "QualityAssessor" );

    ~QualityAssessor();
    
    void set_name(msq_std::string name) { qualityAssessorName = name; };
    virtual msq_std::string get_name()  { return qualityAssessorName; }

    virtual AlgorithmType get_algorithm_type() { return QUALITY_ASSESSOR; }
    
    void add_quality_assessment( QualityMetric* qm, 
                                 int function_flags, 
                                 MsqError &err);

    void set_stopping_assessment( QualityMetric* qm, 
                                  QAFunction func,
                                  MsqError &err );

    void add_histogram_assessment( QualityMetric* qm, 
                                   double min, 
                                   double max,
                                   int intervals,
                                   MsqError& err );
    
    virtual double loop_over_mesh(MeshSet &ms, MsqError &err);

    void disable_printing_results()
       {
         printSummary = false;
       }
      
    void print_summary( msq_stdio::ostream& stream ) const;
    
    bool invalid_elements() const;
       
    void reset_data();
    
    class Assessor
    {
      public:
      
        Assessor( QualityMetric* metric );
        
        double get_average() const ;
        double get_maximum() const { return maximum; }
        double get_minimum() const { return minimum; }
        double get_rms()     const ;
        double get_stddev()  const ;
        int get_count() const { return count; }
        
        int get_invalid_element_count() const { return numInvalid; }
        
        void get_histogram( double& lower_bound_out,
                            double& upper_bound_out,
                            msq_std::vector<int>& counts_out,
                            MsqError& err ) const;
                            
        void reset_data();
       
        void print_histogram( msq_stdio::ostream& ) const;

        QualityMetric* get_metric() const { return qualMetric; }
        
        void add_value( double metric_value );
        
        void add_hist_value( double metric_value );
        
        void add_invalid_value() ;
        
        void calculate_histogram_range();
        
      private:
      
        friend class QualityAssessor;
        
        QualityMetric *const qualMetric; //< The quality metric
        unsigned funcFlags;             //< What to calculate
        
        unsigned long count;  //< The total number of times the metric was evaluated
        
        double sum;       //< The sum of the metric over all elements
        double maximum;   //< The maximum of the metric
        double minimum;   //< The minimum value of the metric
        double sqrSum;    //< The sum of the square of the metric values
        unsigned long numInvalid;  //< Count of invalid metric values
        
        bool haveHistRange;
        double histMin;   //< Lower bound of histogram
        double histMax;   //< Upper bound of histogram
        msq_std::vector<int> histogram;
    };    
        
    const Assessor* get_results( QualityMetric* metric ) const;
    
   const msq_std::list<Assessor>& get_all_results() const
      { return assessList; }
      
  private:
  
    msq_std::list<Assessor>::iterator find_or_add( QualityMetric* qm );
   
    msq_std::string qualityAssessorName;  
    
    msq_std::list<Assessor> assessList;
   
    msq_stdio::ostream& outputStream;
    bool printSummary;
    
    msq_std::list<Assessor>::iterator stoppingMetric;
    QAFunction stoppingFunction;
  };

  
} //namespace


#endif // QualityAssessor_hpp