tutorial.py

Go to the documentation of this file.

 
import sys
import os
 
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_TUTORIAL
      """
      # adding the variables to the model
      self.addVariable(0.1, co.Conopt.Infinity, 0.5)
      self.addVariable(0.1, co.Conopt.Infinity, 0.5)
      self.addVariable(0.0, co.Conopt.Infinity)
      self.addVariable(0.0, co.Conopt.Infinity)
 
      # adding the constraints to the model
      self.addConstraint(co.ConstraintType_Free, -0.1, [0, 1, 2, 3],
                    [-1, -1, 0, 0], [0, 0, 1, 1])
      self.addConstraint(co.ConstraintType_Eq, 0.0, [0, 1, 2], [0, 0, -1],
                    [1, 1, 0])
      self.addConstraint(co.ConstraintType_Eq, 4.0, [2, 3], [1, 2],
                    [0, 0])
 
      # setting the objective constraint
      self.setObjectiveElement(co.ObjectiveElement_Constraint, 0)
 
      # setting the optimisation direction
      self.setOptimizationSense(co.Sense_Maximize)
 
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @ingroup PYTHON1THREAD_TUTORIAL
      """
      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_TUTORIAL
      """
      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
 
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)