square2.py

Go to the documentation of this file.

 
import sys
import os
 
import conopt as co
 
sys.path.append('../common/')
import std
 
 
class SquareModelData(co.ModelData):
   def __init__(self):
      super().__init__()
 
   def buildModel(self):
      """
      adding the variables and constraints to the model
      @ingroup PYTHON1THREAD_SQUARE2
      """
      #   Model  x0 + x1 = 10
      #          x0 - x1 = 0
      #          x0 + x1 <= 9
      # adding the variables to the model
      self.x0 = self.addVariable(-co.Conopt.Infinity, co.Conopt.Infinity, 0.0)
      self.x1 = self.addVariable(-co.Conopt.Infinity, co.Conopt.Infinity, 0.0)
 
      # adding the constraints to the model
      self.cons1 = self.addConstraint(
         co.ConstraintType_Eq, 10.0, [self.x0, self.x1], [1, 1], [0, 0]
      )
      self.cons2 = self.addConstraint(
         co.ConstraintType_Eq, 0.0, [self.x0, self.x1], [0, 0], [1, 1]
      )
      self.cons3 = self.addConstraint(
         co.ConstraintType_LtEq, 9.0, [self.x0, self.x1], [0, 0], [1, 1]
      )
 
   def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
      """
      @copydoc conopt.ModelData.evaluateNonlinearTerm
      @ingroup PYTHON1THREAD_SQUARE2
      """
      g = 0
      if rowno == self.cons1:
         pass
 
      elif rowno == self.cons2:
         g = x[self.x0] - x[self.x1]
 
      elif rowno == self.cons3:
         g = x[self.x0] + x[self.x1]
 
      return g
 
   def evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread):
      """
      @copydoc conopt.ModelData.evaluateNonlinearJacobian
      @ingroup PYTHON1THREAD_SQUARE2
      """
      jac = []
      if rowno == self.cons1:
         pass
 
      elif rowno == self.cons2:
         jac.append(1)
         jac.append(-1)
 
      elif rowno == self.cons3:
         jac.append(1)
         jac.append(1)
 
      return jac
 
 
if __name__ == '__main__':
   name = os.path.basename(__file__)[:-3]
 
   conopt = co.Conopt(name)
   model = SquareModelData()
   msghdlr = std.TutMessageHandler(name)
 
   model.buildModel()
 
   conopt.loadModel(model)
   conopt.setMessageHandler(msghdlr)
 
   # tell conopt this is a square system
   conopt.squareModel(1)
 
   # 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()
 
   if coi_error:
      std.python_log(conopt, 'Errors encountered during solution')
 
   elif (
      (conopt.solutionStatus() != 1)
      or (conopt.modelStatus() < 4)
      or (conopt.modelStatus() > 5)
   ):
      std.python_log(
         conopt, 'Solver or Model status not as expected (1,4) or (1,5)'
      )
 
   # printing the final status of the optimisation
   conopt.printStatus()
 
   std.python_log(conopt, 'Successful Solve')