ObjectiveFunction/CompositeOFMultiply.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 "CompositeOFMultiply.hpp"
#include "MsqTimer.hpp"
#include "PatchData.hpp"

namespace Mesquite {


CompositeOFMultiply::CompositeOFMultiply(ObjectiveFunction* Obj1, ObjectiveFunction* Obj2){
  if(Obj1->get_quality_metric()==Obj2->get_quality_metric()){
    set_quality_metric(Obj1->get_quality_metric());
  }
  else
    set_quality_metric(NULL);
  objFunc1=Obj1;
  objFunc2=Obj2;
    //if both obj1 and ob2 have been negated
  if(Obj1->get_negate_flag()-Obj2->get_negate_flag()==-2)
    set_negate_flag(-1);
  else
    set_negate_flag(1);
  set_gradient_type(ObjectiveFunction::ANALYTICAL_GRADIENT);
}

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

}

msq_std::list<QualityMetric*> CompositeOFMultiply::get_quality_metric_list()
{
  msq_std::list<QualityMetric*> temp_list=objFunc1->get_quality_metric_list();
  msq_std::list<QualityMetric*> temp_list2=objFunc2->get_quality_metric_list();
  temp_list.merge(temp_list2);
  return temp_list;
}


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

bool CompositeOFMultiply::compute_analytical_gradient(PatchData &patch,
                                                      Vector3D *const &grad,
                                                      double &OF_val,
                                                      MsqError &err,
                                                      size_t array_size)
{
  MSQ_FUNCTION_TIMER( "CompositeOFMultiply::compute_analytical_gradient" );
  
  double obj_2_val=0.0;
  //get the first gradient and objective function value
  bool rval=objFunc1->compute_gradient(patch, grad, OF_val,  err, array_size); MSQ_ERRZERO(err);
  //if the above is valid, get the second gradient
  if(rval){
    int num_vert=patch.num_vertices();
    Vector3D* second_grad = new Vector3D[num_vert];
    //get second objective function's gradient
    rval=objFunc2->compute_gradient(patch, second_grad,obj_2_val, 
                                    err, num_vert);
    //if both objective functions gradients were successfully computed, 
    //use the multiplaction rule to get the complete gradient.
    if(rval){
      int i=0;
      for(i=0;i<num_vert;++i){
        grad[i]*=obj_2_val;
        grad[i]+=(second_grad[i]*OF_val);
      }
    }
    //delete the dynamically allocated space for the second gradient
    delete []second_grad;
  }
  
    //true if both gradient and both evaluate were successful.
  //compute the objective function value by mulitiplying
  //OF_val and obj_2_val
  if(rval)
    OF_val*=obj_2_val;
  else
    OF_val=0.0;
  return rval;
}
        
        
} // namespace Mesquite