doc/html/ROL__BoundConstraint__SimOpt_8hpp_source.html

 // @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

ROL::BoundConstraint_SimOpt::pruneActive
void pruneActive(Vector< Real > &v, const Vector< Real > &x, Real eps=Real(0))
Set variables to zero if they correspond to the -active set.
Definition: ROL_BoundConstraint_SimOpt.hpp:228

ROL::BoundConstraint_SimOpt::~BoundConstraint_SimOpt
~BoundConstraint_SimOpt()
Definition: ROL_BoundConstraint_SimOpt.hpp:44

ROL::BoundConstraint_SimOpt::isFeasible
bool isFeasible(const Vector< Real > &v)
Check if the vector, v, is feasible.
Definition: ROL_BoundConstraint_SimOpt.hpp:260

ROL::Vector_SimOpt::get_2
ROL::Ptr< const Vector< Real > > get_2() const
Definition: ROL_Vector_SimOpt.hpp:144

ROL::BoundConstraint_SimOpt::pruneUpperActive
void pruneUpperActive(Vector< Real > &v, const Vector< Real > &x, Real eps=Real(0))
Set variables to zero if they correspond to the upper -active set.
Definition: ROL_BoundConstraint_SimOpt.hpp:136

ROL::BoundConstraint_SimOpt::pruneLowerActive
void pruneLowerActive(Vector< Real > &v, const Vector< Real > &x, Real eps=Real(0))
Set variables to zero if they correspond to the lower -active set.
Definition: ROL_BoundConstraint_SimOpt.hpp:175

ROL::BoundConstraint_SimOpt::BoundConstraint_SimOpt
BoundConstraint_SimOpt(const Ptr< BoundConstraint< Real >> &bnd, bool optBnd=true)
Constructor for single bound constraint.
Definition: ROL_BoundConstraint_SimOpt.hpp:66

ROL::Vector_SimOpt
Defines the linear algebra or vector space interface for simulation-based optimization.
Definition: ROL_Vector_SimOpt.hpp:23

ROL_Types.hpp
Contains definitions of custom data types in ROL.

ROL::BoundConstraint_SimOpt::BoundConstraint_SimOpt
BoundConstraint_SimOpt(const Ptr< BoundConstraint< Real >> &bnd1, const Ptr< BoundConstraint< Real >> &bnd2)
Default constructor.
Definition: ROL_BoundConstraint_SimOpt.hpp:50

ROL::BoundConstraint_SimOpt::bnd2_
const Ptr< BoundConstraint< Real > > bnd2_
Definition: ROL_BoundConstraint_SimOpt.hpp:41

ROL::Vector
Defines the linear algebra or vector space interface.
Definition: ROL_Vector.hpp:46

ROL::BoundConstraint_SimOpt::pruneActive
void pruneActive(Vector< Real > &v, const Vector< Real > &g, const Vector< Real > &x, Real xeps=Real(0), Real geps=Real(0))
Set variables to zero if they correspond to the -binding set.
Definition: ROL_BoundConstraint_SimOpt.hpp:247

ROL::BoundConstraint_SimOpt::bnd1_
const Ptr< BoundConstraint< Real > > bnd1_
Definition: ROL_BoundConstraint_SimOpt.hpp:41

ROL::BoundConstraint_SimOpt::projectInterior
void projectInterior(Vector< Real > &x)
Project optimization variables into the interior of the feasible set.
Definition: ROL_BoundConstraint_SimOpt.hpp:119

ROL::BoundConstraint_SimOpt::applyScalingFunctionJacobian
void applyScalingFunctionJacobian(Vector< Real > &dv, const Vector< Real > &v, const Vector< Real > &x, const Vector< Real > &g) const
Apply scaling function Jacobian.
Definition: ROL_BoundConstraint_SimOpt.hpp:300

ROL::BoundConstraint_SimOpt::getLowerBound
const Ptr< const Vector< Real > > getLowerBound(void) const
Return the ref count pointer to the lower bound vector.
Definition: ROL_BoundConstraint_SimOpt.hpp:203

ROL_BoundConstraint.hpp

ROL::BoundConstraint_SimOpt::pruneUpperActive
void pruneUpperActive(Vector< Real > &v, const Vector< Real > &g, const Vector< Real > &x, Real xeps=Real(0), Real geps=Real(0))
Set variables to zero if they correspond to the upper -binding set.
Definition: ROL_BoundConstraint_SimOpt.hpp:156

ROL::BoundConstraint
Provides the interface to apply upper and lower bound constraints.
Definition: ROL_BoundConstraint.hpp:39

ROL::BoundConstraint_SimOpt
Definition: ROL_BoundConstraint_SimOpt.hpp:39

ROL::BoundConstraint_SimOpt::pruneLowerActive
void pruneLowerActive(Vector< Real > &v, const Vector< Real > &g, const Vector< Real > &x, Real xeps=Real(0), Real geps=Real(0))
Set variables to zero if they correspond to the lower -binding set.
Definition: ROL_BoundConstraint_SimOpt.hpp:195

ROL::BoundConstraint_SimOpt::applyInverseScalingFunction
void applyInverseScalingFunction(Vector< Real > &dv, const Vector< Real > &v, const Vector< Real > &x, const Vector< Real > &g) const
Apply inverse scaling function.
Definition: ROL_BoundConstraint_SimOpt.hpp:278

ROL::BoundConstraint::deactivate
void deactivate(void)
Turn off bounds.
Definition: ROL_BoundConstraint_Def.hpp:148

ROL::BoundConstraint_SimOpt::project
void project(Vector< Real > &x)
Project optimization variables onto the bounds.
Definition: ROL_BoundConstraint_SimOpt.hpp:103

ROL::BoundConstraint_SimOpt::getUpperBound
const Ptr< const Vector< Real > > getUpperBound(void) const
Return the ref count pointer to the upper bound vector.
Definition: ROL_BoundConstraint_SimOpt.hpp:210

ROL::Vector_SimOpt::get_1
ROL::Ptr< const Vector< Real > > get_1() const
Definition: ROL_Vector_SimOpt.hpp:140

ROL::BoundConstraint_SimOpt::BoundConstraint_SimOpt
BoundConstraint_SimOpt(const Ptr< BoundConstraint< Real >> &bnd, const Vector< Real > &x, bool optBnd=true)
Constructor for single bound constraint.
Definition: ROL_BoundConstraint_SimOpt.hpp:84

ROL_Vector_SimOpt.hpp