tutoriali.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.L    = 0
      self.Inp  = 0
      self.Out  = 0
      self.P    = 0
      self.Al   = 0.16
      self.Ak   = 2.0
      self.Ainp = 0.16
      self.Rho  = 1.0
      self.K    = 4.0
 
      # declaring place holder variables used for the evaluation of the first
      # derivative
      self.hold = [0, 0, 0]
 
      super().__init__()
 
   def buildModel(self):
      """
      adding the variables and constraints to the model
      @ingroup PYTHON1THREAD_TUTORIALI
      """
      # 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 initFDEvaluation(self, x, rowlist, mode, numthread, ignerr):
      """
      @ingroup PYTHON1THREAD_TUTORIALI
      """
      self.L   = x[0]
      self.Inp = x[1]
      self.Out = x[2]
      self.P   = x[3]
 
      self.hold1 = (self.Al*pow(self.L, (-self.Rho)) + \
            self.Ak*pow(self.K, (-self.Rho)) + \
            self.Ainp*pow(self.Inp, (-self.Rho)))
      self.hold2 = pow(self.hold1,( -1./self.Rho ))
      self.hold3  = self.hold2 / self.hold1
 
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @ingroup PYTHON1THREAD_TUTORIALI
      """
      g = 0
      if rowno == 0:
         g = self.P * self.Out
      elif rowno == 1:
         g = self.hold2
 
      return g
 
   def evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread):
      """
      @ingroup PYTHON1THREAD_TUTORIALI
      """
      jac = []
      if rowno == 0:
         jac.append(self.P)
         jac.append(self.Out)
      elif rowno == 1:
         jac.append(self.hold3 * self.Al   * pow(self.L  ,(-self.Rho-1.)))
         jac.append(self.hold3 * self.Ainp * pow(self.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)