tutorial2r.py

Go to the documentation of this file.

 
import os
import sys
 
import conopt as co
 
sys.path.append('../common/')
import std
 
 
class TutModelData(co.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_TUTORIAL2r
      """
      # initial values
      initL = 0.5
      initInp = 0.5
 
      # adding the variables to the model
      self.varl = self.addVariable(0.1, co.Conopt.Infinity, initL)
      self.varinp = self.addVariable(0.1, co.Conopt.Infinity, initInp)
      self.varout = self.addVariable(0.0, co.Conopt.Infinity)
      self.varp = self.addVariable(0.0, co.Conopt.Infinity)
      self.varint = self.addVariable(
         0.0,
         co.Conopt.Infinity,
         self.Al * pow(initL, -self.Rho)
         + self.Ak * pow(self.K, -self.Rho)
         + self.Ainp * pow(initInp, -self.Rho),
      )
 
      # adding the constraints to the model
      self.consobj = self.addConstraint(
         co.ConstraintType_Free,
         -0.1,
         [self.varl, self.varinp, self.varout, self.varp],
         [-1, -1, 0, 0],
         [0, 0, 1, 1],
      )
      self.consprod = self.addConstraint(
         co.ConstraintType_Eq,
         0.0,
         [self.varl, self.varinp, self.varint],
         [0, 0, -1],
         [1, 1, 0],
      )
      self.addConstraint(
         co.ConstraintType_Eq, 4.0, [self.varout, self.varp], [1, 2], [0, 0]
      )
      self.consnew = self.addConstraint(
         co.ConstraintType_Eq,
         0.0,
         [self.varout, self.varint],
         [-1, 0],
         [0, 1],
      )
 
      # setting the objective constraint
      self.setObjectiveElement(co.ObjectiveElement_Constraint, 0)
 
      # setting the optimisation direction
      self.setOptimizationSense(co.Sense_Maximize)
 
      # setting the structure of the second derivative of the Lagrangian
      self.setSDLagrangianStructure([0, 1, 3, 4], [0, 1, 2, 4])
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @copydoc conopt.ModelData.evaluateNonlinearTerm
      @ingroup PYTHON1THREAD_TUTORIAL2r
      """
      L = x[self.varl]
      Inp = x[self.varinp]
      Out = x[self.varout]
      P = x[self.varp]
      Int = x[self.varint]
 
      g = 0
      if rowno == self.consobj:
         g = P * Out
      elif rowno == self.consprod:
         g = (
            self.Al * pow(L, (-self.Rho))
            + self.Ak * pow(self.K, (-self.Rho))
            + self.Ainp * pow(Inp, (-self.Rho))
         )
      elif rowno == self.consnew:
         g = pow(Int, (-1.0 / self.Rho))
 
      return g
 
   def evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread):
      """
      @copydoc conopt.ModelData.evaluateNonlinearJacobian
 
      NOTE: The jacobian is returned as a list of length jacnum. In this
      example, the returned list is constructed using `append`. It is also
      possible to initially create a list of length jacnum containing only 0s,
      then update the values by the variable indices.
 
      @ingroup PYTHON1THREAD_TUTORIAL2r
      """
      L = x[self.varl]
      Inp = x[self.varinp]
      Out = x[self.varout]
      P = x[self.varp]
      Int = x[self.varint]
 
      jac = []
      if rowno == self.consobj:
         jac.append(P)
         jac.append(Out)
      elif rowno == self.consprod:
         jac.append(self.Al * (-self.Rho) * pow(L, (-self.Rho - 1.0)))
         jac.append(self.Ainp * (-self.Rho) * pow(Inp, (-self.Rho - 1.0)))
      elif rowno == self.consnew:
         jac.append((-1.0 / self.Rho) * pow(Int, (-1.0 / self.Rho - 1.0)))
 
      return jac
 
   def evaluateSDLagrangian(self, x, u, hessianrow, hessiancol):
      """
      @copydoc conopt.ModelData.evaluateSDLagrangian
      @ingroup PYTHON1THREAD_TUTORIAL2r
      """
      numhessian = len(hessianrow)
      hessian = [0 for i in range(numhessian)]
 
      hessian[2] = u[self.consobj]
      if u[self.consprod] != 0.0:
         L = x[self.varl]
         Inp = x[self.varinp]
         hessian[0] = (
            (-self.Rho)
            * (-self.Rho - 1.0)
            * self.Al
            * pow(L, -self.Rho - 2.0)
            * u[self.consprod]
         )
         hessian[1] = (
            (-self.Rho)
            * (-self.Rho - 1.0)
            * self.Ainp
            * pow(Inp, -self.Rho - 2.0)
            * u[self.consprod]
         )
 
      if u[self.consnew] != 0.0:
         hessian[3] = (
            (-1.0 / self.Rho)
            * (-1.0 / self.Rho - 1.0)
            * pow(x[self.varint], -1.0 / self.Rho - 2.0)
         )
 
      return hessian
 
 
if __name__ == '__main__':
   name = os.path.basename(__file__)[:-3]
 
   conopt = co.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('CONOPT_LICENSE_INT_1', None)
   license_int_2 = os.environ.get('CONOPT_LICENSE_INT_2', None)
   license_int_3 = os.environ.get('CONOPT_LICENSE_INT_3', None)
   license_text = os.environ.get('CONOPT_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)