inks/CompositeOFScalarMultiply.cpp

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      
   
  ***************************************************************** */
#include <math.h>
#include "CompositeOFScalarMultiply.hpp"
#include "MsqTimer.hpp"
#include "MsqError.hpp"
#include "MsqDebug.hpp"
#include "PatchData.hpp"

namespace Mesquite {


CompositeOFScalarMultiply::CompositeOFScalarMultiply(double alp, ObjectiveFunction* Obj){

  set_quality_metric(Obj->get_quality_metric());
  objFunc=Obj;
  mAlpha=alp;
  if(alp<0)
    set_negate_flag(-1);
  else if (alp>0)
    set_negate_flag(1);
  else
    MSQ_DBGOUT(1) << "ObjectiveFunction being scaled by zero.";
  set_gradient_type(ObjectiveFunction::ANALYTICAL_GRADIENT);
}

//Michael:  need to clean up here
CompositeOFScalarMultiply::~CompositeOFScalarMultiply(){

}

bool CompositeOFScalarMultiply::concrete_evaluate(PatchData &patch,
                                                  double &fval, MsqError &err){
    //if invalid return false without calculating fval
  bool b = objFunc->evaluate(patch, fval, err);
  if (MSQ_CHKERR(err) || !b){
    fval = 0.0;
    return false;
    
  }
  fval*=mAlpha;
  return true;
}

msq_std::list<QualityMetric*> CompositeOFScalarMultiply::get_quality_metric_list(){
  return objFunc->get_quality_metric_list();
}
        

bool CompositeOFScalarMultiply::compute_analytical_gradient(PatchData &patch,
                                                            Vector3D *const
                                                            &grad,
                                                            double &OF_val,
                                                            MsqError &err,
                                                            size_t array_size)
{
  MSQ_FUNCTION_TIMER( "CompositeOFScalarMultiply::compute_analytical_gradient" );
  
  double scale_factor=(get_negate_flag()*mAlpha);
  bool rval=objFunc->compute_gradient(patch, grad, OF_val, err, array_size); MSQ_ERRZERO(err);
  int num_vert=patch.num_vertices();
  int i=0;
    //If the objFunc was successful in calculating the gradient
  if(rval){
      //scale the gradient by alpha
    for(i=0;i<num_vert;++i){
      grad[i]*=scale_factor;
    }
    //scale the OF_val
    OF_val*=mAlpha;
  }
  else{
    OF_val=0.0;
  }
  return rval;
}

} // namespace Mesquite