ROL_BoundConstraint_SimOpt.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef ROL_BOUND_CONSTRAINT_SIMOPT_H
#define ROL_BOUND_CONSTRAINT_SIMOPT_H
 
#include "ROL_BoundConstraint.hpp"
#include "ROL_Vector_SimOpt.hpp"
#include "ROL_Types.hpp"
#include <iostream>

 
 
namespace ROL {
 
template <class Real>
class BoundConstraint_SimOpt : public BoundConstraint<Real> {
private:
  const Ptr<BoundConstraint<Real>> bnd1_, bnd2_;
 
public:
  ~BoundConstraint_SimOpt() {}

  BoundConstraint_SimOpt(const Ptr<BoundConstraint<Real>> &bnd1,
                         const Ptr<BoundConstraint<Real>> &bnd2)
    : bnd1_(bnd1), bnd2_(bnd2) {
    if ( bnd1_->isActivated() || bnd2_->isActivated() )
      BoundConstraint<Real>::activate();
    else
      BoundConstraint<Real>::deactivate();
  }

  BoundConstraint_SimOpt(const Ptr<BoundConstraint<Real>> &bnd,
                         bool optBnd = true)
    : bnd1_(optBnd ? makePtr<BoundConstraint<Real>>() : bnd),
      bnd2_(optBnd ? bnd : makePtr<BoundConstraint<Real>>()) {
    if ( bnd1_->isActivated() || bnd2_->isActivated() )
      BoundConstraint<Real>::activate();
    else
      BoundConstraint<Real>::deactivate();
  }

  BoundConstraint_SimOpt(const Ptr<BoundConstraint<Real>> &bnd,
                         const Vector<Real> &x,
                         bool optBnd = true)
    : bnd1_(optBnd ? makePtr<BoundConstraint<Real>>(x) : bnd),
      bnd2_(optBnd ? bnd : makePtr<BoundConstraint<Real>>(x)) {
    if ( bnd1_->isActivated() || bnd2_->isActivated() )
      BoundConstraint<Real>::activate();
    else
      BoundConstraint<Real>::deactivate();
  }

  void project( Vector<Real> &x ) {
    Vector_SimOpt<Real> &xs = dynamic_cast<Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->project(*(xs.get_1()));
    if (bnd2_->isActivated()) bnd2_->project(*(xs.get_2()));
  }

  void projectInterior( Vector<Real> &x ) {
    Vector_SimOpt<Real> &xs = dynamic_cast<Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->projectInterior(*(xs.get_1()));
    if (bnd2_->isActivated()) bnd2_->projectInterior(*(xs.get_2()));
  }

  void pruneUpperActive( Vector<Real> &v, const Vector<Real> &x, Real eps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneUpperActive(*(vs.get_1()),*(xs.get_1()),eps);
    if (bnd2_->isActivated()) bnd2_->pruneUpperActive(*(vs.get_2()),*(xs.get_2()),eps);
  }

  void pruneUpperActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real xeps = Real(0), Real geps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &gs = dynamic_cast<const Vector_SimOpt<Real>&>(g);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneUpperActive(*(vs.get_1()),*(gs.get_1()),*(xs.get_1()),xeps,geps);
    if (bnd2_->isActivated()) bnd2_->pruneUpperActive(*(vs.get_2()),*(gs.get_2()),*(xs.get_2()),xeps,geps);
  }

  void pruneLowerActive( Vector<Real> &v, const Vector<Real> &x, Real eps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneLowerActive(*(vs.get_1()),*(xs.get_1()),eps);
    if (bnd2_->isActivated()) bnd2_->pruneLowerActive(*(vs.get_2()),*(xs.get_2()),eps);
  }

  void pruneLowerActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real xeps = Real(0), Real geps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &gs = dynamic_cast<const Vector_SimOpt<Real>&>(g);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneLowerActive(*(vs.get_1()),*(gs.get_1()),*(xs.get_1()),xeps,geps);
    if (bnd2_->isActivated()) bnd2_->pruneLowerActive(*(vs.get_2()),*(gs.get_2()),*(xs.get_2()),xeps,geps);
  }
 
  const Ptr<const Vector<Real>> getLowerBound( void ) const {
    const Ptr<const Vector<Real>> l1 = bnd1_->getLowerBound();
    const Ptr<const Vector<Real>> l2 = bnd2_->getLowerBound();
    return makePtr<Vector_SimOpt<Real>>( constPtrCast<Vector<Real>>(l1),
                                         constPtrCast<Vector<Real>>(l2) );
  }
 
  const Ptr<const Vector<Real>> getUpperBound(void) const {
    const Ptr<const Vector<Real>> u1 = bnd1_->getUpperBound();
    const Ptr<const Vector<Real>> u2 = bnd2_->getUpperBound();
    return makePtr<Vector_SimOpt<Real>>( constPtrCast<Vector<Real>>(u1),
                                         constPtrCast<Vector<Real>>(u2) );
  }

  void pruneActive( Vector<Real> &v, const Vector<Real> &x, Real eps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneActive(*(vs.get_1()),*(xs.get_1()),eps);
    if (bnd2_->isActivated()) bnd2_->pruneActive(*(vs.get_2()),*(xs.get_2()),eps);
  }

  void pruneActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real xeps = Real(0), Real geps = Real(0) ) {
    Vector_SimOpt<Real> &vs = dynamic_cast<Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &gs = dynamic_cast<const Vector_SimOpt<Real>&>(g);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    if (bnd1_->isActivated()) bnd1_->pruneActive(*(vs.get_1()),*(gs.get_1()),*(xs.get_1()),xeps,geps);
    if (bnd2_->isActivated()) bnd2_->pruneActive(*(vs.get_2()),*(gs.get_2()),*(xs.get_2()),xeps,geps);
  }

  bool isFeasible( const Vector<Real> &v ) {
    const Vector_SimOpt<Real> &vs = dynamic_cast<const Vector_SimOpt<Real>&>(v);
    return (bnd1_->isFeasible(*(vs.get_1()))) && (bnd2_->isFeasible(*(vs.get_2())));
  }

  void applyInverseScalingFunction(Vector<Real> &dv, const Vector<Real> &v, const Vector<Real> &x, const Vector<Real> &g) const{
    Vector_SimOpt<Real> &dvs = dynamic_cast<Vector_SimOpt<Real>&>(dv);
    const Vector_SimOpt<Real> &vs = dynamic_cast<const Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    const Vector_SimOpt<Real> &gs = dynamic_cast<const Vector_SimOpt<Real>&>(g);
    if (bnd1_->isActivated()) bnd1_->applyInverseScalingFunction(*(dvs.get_1()),*(vs.get_1()),*(xs.get_1()),*(gs.get_1()));
    if (bnd2_->isActivated()) bnd2_->applyInverseScalingFunction(*(dvs.get_2()),*(vs.get_2()),*(xs.get_2()),*(gs.get_2()));
  }

  void applyScalingFunctionJacobian(Vector<Real> &dv, const Vector<Real> &v, const Vector<Real> &x, const Vector<Real> &g) const {
    Vector_SimOpt<Real> &dvs = dynamic_cast<Vector_SimOpt<Real>&>(dv);
    const Vector_SimOpt<Real> &vs = dynamic_cast<const Vector_SimOpt<Real>&>(v);
    const Vector_SimOpt<Real> &xs = dynamic_cast<const Vector_SimOpt<Real>&>(x);
    const Vector_SimOpt<Real> &gs = dynamic_cast<const Vector_SimOpt<Real>&>(g);
    if (bnd1_->isActivated()) bnd1_->applyScalingFunctionJacobian(*(dvs.get_1()),*(vs.get_1()),*(xs.get_1()),*(gs.get_1()));
    if (bnd2_->isActivated()) bnd2_->applyScalingFunctionJacobian(*(dvs.get_2()),*(vs.get_2()),*(xs.get_2()),*(gs.get_2()));
  }
 
}; // class BoundConstraint_SimOpt
 
} // namespace ROL
 
#endif