tutorial2.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_TUTORIAL2
      """
      # adding the variables to the model
      self.varl = self.addVariable(0.1, co.Conopt.Infinity, 0.5)
      self.varinp = self.addVariable(0.1, co.Conopt.Infinity, 0.5)
      self.varout = self.addVariable(0.0, co.Conopt.Infinity)
      self.varp = self.addVariable(0.0, co.Conopt.Infinity)
 
      # 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.varout],
         [0, 0, -1],
         [1, 1, 0],
      )
      self.addConstraint(
         co.ConstraintType_Eq, 4.0, [self.varout, self.varp], [1, 2], [0, 0]
      )
 
      # 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, 1, 3], [0, 0, 1, 2])
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @copydoc conopt.ModelData.evaluateNonlinearTerm
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      L = x[self.varl]
      Inp = x[self.varinp]
      Out = x[self.varout]
      P = x[self.varp]
 
      g = 0
      if rowno == self.consobj:
         g = P * Out
      elif rowno == self.consprod:
         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))
 
         g = hold2
 
      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_TUTORIAL2
      """
      L = x[self.varl]
      Inp = x[self.varinp]
      Out = x[self.varout]
      P = x[self.varp]
 
      jac = []
      if rowno == self.consobj:
         jac.append(P)
         jac.append(Out)
      elif rowno == self.consprod:
         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
 
         jac.append(hold3 * self.Al * pow(L, (-self.Rho - 1.0)))
         jac.append(hold3 * self.Ainp * pow(Inp, (-self.Rho - 1.0)))
 
      return jac
 
   def evaluateSDLagrangian(self, x, u, hessianrow, hessiancol):
      """
      @copydoc conopt.ModelData.evaluateSDLagrangian
      @ingroup PYTHON1THREAD_TUTORIAL2
      """
      numhessian = len(hessianrow)
      hessian = [0 for i in range(numhessian)]
 
      hessian[3] = u[self.consobj]
      if u[self.consprod] != 0.0:
         L = x[self.varl]
         Inp = x[self.varinp]
         Out = x[self.varout]
         P = x[self.varp]
         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[self.consprod]
 
      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)