tutorial2.py

Go to the documentation of this file.

 
import os
import sys
 
import pyconopt
 
sys.path.append('../common/')
import std
 
 
class TutModelData(pyconopt.ModelData):
   """
   """
   def __init__(self):
      self.Al   = 0.16
      self.Ak   = 2.0
      self.Ainp = 0.16
      self.Rho  = 1.0
      self.K    = 4.0
      super().__init__()
 
   def buildModel(self):
      """
      adding the variables and constraints to the model
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      # adding the variables to the model
      self.addVariable(0.1, pyconopt.CONOPT_INF, 0.5)
      self.addVariable(0.1, pyconopt.CONOPT_INF, 0.5)
      self.addVariable(0.0, pyconopt.CONOPT_INF)
      self.addVariable(0.0, pyconopt.CONOPT_INF)
 
      # adding the constraints to the model
      self.addConstraint(pyconopt.ConstraintType_Free, -0.1, [0, 1, 2, 3],
                    [-1, -1, 0, 0], [0, 0, 1, 1])
      self.addConstraint(pyconopt.ConstraintType_Eq, 0.0, [0, 1, 2], [0, 0, -1],
                    [1, 1, 0])
      self.addConstraint(pyconopt.ConstraintType_Eq, 4.0, [2, 3], [1, 2],
                    [0, 0])
 
      # setting the objective constraint
      self.setObjectiveElement(pyconopt.ObjectiveElement_Constraint, 0)
 
      # setting the optimisation direction
      self.setOptimizationSense(pyconopt.Sense_Maximize)
 
      # setting the structure of the second derivative of the Lagrangian
      self.setSDLagrangianStructure([0, 1, 1, 3], [0, 0, 1, 2])
 
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      L   = x[0]
      Inp = x[1]
      Out = x[2]
      P   = x[3]
 
      g = 0
      if rowno == 0:
         g = P * Out
      elif rowno == 1:
         hold1 = (self.Al*pow(L,(-self.Rho)) + self.Ak*pow(self.K,(-self.Rho)) + self.Ainp*pow(Inp,(-self.Rho)))
         hold2 = pow(hold1,( -1./self.Rho ))
 
         g = hold2
 
      return g
 
   def evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread):
      """
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      L   = x[0]
      Inp = x[1]
      Out = x[2]
      P   = x[3]
 
      jac = []
      if rowno == 0:
         jac.append(P)
         jac.append(Out)
      elif rowno == 1:
         hold1 = (self.Al*pow(L,(-self.Rho)) + self.Ak*pow(self.K,(-self.Rho)) + self.Ainp*pow(Inp,(-self.Rho)))
         hold2 = pow(hold1,( -1./self.Rho ))
         hold3  = hold2 / hold1
 
         jac.append(hold3 * self.Al   * pow(L  ,(-self.Rho-1.)))
         jac.append(hold3 * self.Ainp * pow(Inp,(-self.Rho-1.)))
 
      return jac
 
 
   def evaluateSDLagrangian(self, x, u, hessianrow, hessiancol):
      """
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      numhessian = len(hessianrow)
      hessian = [0 for i in range(numhessian)]
 
      hessian[3] = u[0]
      if u[1] != 0.0:
         L   = x[0]
         Inp = x[1]
         Out = x[2]
         P   = x[3]
         hold1 = (self.Al*pow(L,-self.Rho) + self.Ak*pow(self.K,-self.Rho) + self.Ainp*pow(Inp,-self.Rho))
         hold2 = pow( hold1,-1.0/self.Rho)
         hold3 = hold2 / hold1
 
         hold4 = hold3 / hold1 * (-1.0/self.Rho-1.0)
 
         hessian[0] = hold4 * (-self.Rho) * pow(self.Al*pow(L,-self.Rho-1.0),2) \
               + hold3 * self.Al * (-self.Rho-1.0)*pow(L,-self.Rho-2.0)
         hessian[1] = hold4 * (-self.Rho) * (self.Al*pow(L,-self.Rho-1.0)) * \
                                    (self.Ainp*pow(Inp,-self.Rho-1.0))
         hessian[2] = hold4 * (-self.Rho) * \
               pow(self.Ainp*pow(Inp,-self.Rho-1.0),2) + \
               hold3 * self.Ainp * (-self.Rho-1.0)*pow(Inp,-self.Rho-2.0)
 
         for i in range(numhessian):
            hessian[i] = hessian[i] * u[1]
 
      return hessian
 
if __name__ == "__main__":
   name = os.path.basename(__file__)[:-3]
 
   conopt = pyconopt.Conopt(name)
   model = TutModelData()
   msghdlr = std.TutMessageHandler(name)
 
   model.buildModel()
 
   conopt.loadModel(model)
   conopt.setMessageHandler(msghdlr)
 
   # getting the license variables
   license_int_1 = os.environ.get('LICENSE_INT_1', None)
   license_int_2 = os.environ.get('LICENSE_INT_2', None)
   license_int_3 = os.environ.get('LICENSE_INT_3', None)
   license_text = os.environ.get('LICENSE_TEXT', None)
   if license_int_1 is not None and license_int_2 is not None \
         and license_int_3 is not None and license_text is not None:
      conopt.setLicense(int(license_int_1), int(license_int_2),
                        int(license_int_3), license_text)
 
   coi_error = conopt.solve()
 
   retcode = std.checkSolve(conopt, 0.572943, coi_error)
 
   sys.exit(retcode)