src/ObjectiveFunction/ObjectiveFunction.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 OBJECTIVE_FUNCTION_HPP
#define OBJECTIVE_FUNCTION_HPP

#include "Mesquite.hpp"
#include "MsqError.hpp"
#include "MsqVertex.hpp"

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

namespace Mesquite
{
   class PatchData;
   class MsqHessian;
   class QualityMetric;
   
  class ObjectiveFunction
  {
   public:
    ObjectiveFunction ():
        useLocalGradient(false)
       {}
    
    
      // virtual destructor ensures use of polymorphism during destruction
    virtual ~ObjectiveFunction()
       {};
    
    virtual bool concrete_evaluate(PatchData &patch, double &fval,
                                   MsqError &err)=0;

    bool evaluate(PatchData &patch, double &fval, MsqError &err)
       {
         bool return_bool = concrete_evaluate(patch, fval, err);
         fval *= negateFlag;
         return return_bool;
       }
    
    enum GRADIENT_TYPE
    {
       NUMERICAL_GRADIENT,  
       ANALYTICAL_GRADIENT  
    };

    void set_gradient_type(GRADIENT_TYPE grad)
    { gradType = grad; }


    bool compute_gradient(PatchData &patch, Vector3D *const &grad,
                          double &OF_val, MsqError &err, size_t array_size=0);          
              
    bool compute_hessian(PatchData &patch, MsqHessian &hessian,
                         Vector3D *const &grad,
                         double &OF_val,
                         MsqError &err);          
              
    QualityMetric*  get_quality_metric(){
         return qMetric;
       }
    
    virtual msq_std::list<QualityMetric*> get_quality_metric_list()
       {
         msq_std::list<QualityMetric*> temp_list;
         temp_list.push_front(qMetric);
         return temp_list;
       }

    void set_quality_metric(QualityMetric* qm)
       {
         qMetric=qm;
       }
    
    void set_negate_flag(int neg)
       {
         negateFlag=neg;
       }

    int get_negate_flag()
       {
         return negateFlag;
       }
    
   protected:

    bool compute_numerical_gradient(PatchData &patch, Vector3D *const &grad,
                                    double &OF_val,
                                    MsqError &err, size_t array_size);

    virtual bool compute_analytical_gradient(PatchData &patch,
                                             Vector3D *const &grad,
                                             double &OF_val,
                                             MsqError &err, size_t array_size);
    
    virtual bool compute_analytical_hessian(PatchData &/*patch*/,
                                            MsqHessian &/*hessian*/,
                                            Vector3D *const &/*grad*/,
                                            double &/*OF_val*/,
                                            MsqError &/*err*/);
    
    inline double get_eps(PatchData &pd, double &local_val,
                          int k,MsqVertex* vertex, MsqError &err);
    
    void set_use_local_gradient(bool new_bool)
       {
         useLocalGradient=new_bool;
       }
       
    
 private:
      
    enum GRADIENT_TYPE gradType;
      
    QualityMetric* qMetric;
      
    int negateFlag; 
    bool useLocalGradient;
  };

//BEGIN INLINE

   inline bool ObjectiveFunction::compute_gradient(PatchData &patch,
                                                   Vector3D *const &grad,
                                                   double &OF_val,
                                                   MsqError &err,
                                                   size_t array_size)
   {
     bool obj_bool = false;
     switch(gradType){
       case NUMERICAL_GRADIENT:
          obj_bool=compute_numerical_gradient(patch, grad, OF_val,
                                              err, array_size);
          break;
       case ANALYTICAL_GRADIENT:
          obj_bool=compute_analytical_gradient(patch, grad, OF_val,
                                               err, array_size);
          break;
     }
     return !MSQ_CHKERR(err) && obj_bool;
   }


   inline bool ObjectiveFunction::compute_hessian(PatchData &patch,
                                                  MsqHessian &hessian,
                                                  Vector3D *const &grad,
                                                  double &OF_val,
                                                  MsqError &err)
   {
     bool result = compute_analytical_hessian(patch, hessian,
                                       grad, OF_val, err);
     return !MSQ_CHKERR(err) && result;
   }


  inline double ObjectiveFunction::get_eps(PatchData &pd, double &local_val,
                                           int k,MsqVertex* vertex, MsqError& err)
  {
    double eps = 1.e-07;
    //  double rho=.5;
    int imax=20;
    int i=0;
    bool feasible=false;
    double tmp_var=0.0;
    while (i<imax && !feasible)
      {
        i++;
        //perturb kth coord val and check feas if needed
        tmp_var=(*vertex)[k];
        (*vertex)[k]+=eps;
        feasible = evaluate(pd,local_val,err); MSQ_ERRZERO(err);
        //if step was too big, shorten it         
        if(!feasible)
          eps*=0.5;
        //revert kth coord val
        (*vertex)[k]=tmp_var;
      }//end while looking for feasible eps
    return eps;
  }//end function get_eps

  
} //namespace


#endif // ObjectiveFunction_hpp