Quintiq file version 2.0
|
#parent: #root
|
StaticMethod InitConstraintsForCapacityUsage (
|
CapacityPlanningSuboptimizer_CapacityPlanningAlgorithm program,
|
MPConstraint minconst,
|
MPConstraint maxconst,
|
const UnitPeriod unitperiod,
|
const RunContextForCapacityPlanning runcontext,
|
const LibOpt_Scope scope,
|
const CapacityPlanningSuboptimizer subopt
|
) const
|
{
|
TextBody:
|
[*
|
// MvE: Apart from the UoM and the closing of units, this method seems like an exact copy of the default InitConstraintsForCapacityUsage on UnitPeriod. Shall I delete this one?
|
// minconst and maxconst UoM: Time
|
|
bound := 0.0; // To prevent infeasible when the unit is closed
|
|
scalefactor_periodtaskqty_maxconst := subopt.ScaleConstraintTerm( typeof( MPPTQtyVariable ), typeofexpression( maxconst ) );
|
scalefactor_periodtaskqty_minconst := subopt.ScaleConstraintTerm( typeof( MPPTQtyVariable ), typeofexpression( minconst ) );
|
scalefactor_tripnewsupply_maxconst := subopt.ScaleConstraintTerm( typeof( MPTripNewSupplyVariable ), typeofexpression( maxconst ) );
|
scalefactor_tripnewsupply_minconst := subopt.ScaleConstraintTerm( typeof( MPTripNewSupplyVariable ), typeofexpression( minconst ) );
|
|
scalefactor_rhs_minconst := subopt.ScaleConstraintRHS( typeofexpression( minconst ), 1.0 );
|
scalefactor_rhs_maxconst := subopt.ScaleConstraintRHS( typeofexpression( maxconst ), 1.0 );
|
|
// Capacity usage = Sum of PTQty * Process.QuantityToProcessFactor
|
// For time based, we need extra logic to convert to duration needed
|
operations := subopt.GetOperationsForUnitPeriod( scope, unitperiod );
|
traverse( operations, Elements, operation )
|
{
|
coeff := operation.GetCapacityUsagePerQuantity( unitperiod );
|
var := program.PTQtyVariables().Get( operation, unitperiod.Period_MP() );
|
|
// Term: coeff * PTQty variable
|
// UoM: [Time / Unit] [Unit]
|
maxconst.NewTerm( coeff * scalefactor_periodtaskqty_maxconst, var );
|
minconst.NewTerm( coeff * scalefactor_periodtaskqty_minconst, var );
|
|
bound := bound + coeff * var.LowerBound();
|
}
|
|
traverse( unitperiod, PeriodTask_MP.astype( PeriodTaskLaneLeg ), ptll,
|
scope.Contains( ptll.Trip().TripInOptimizerRun() ) ) // Only if the trip is part of this optimizer run
|
{
|
traverse( ptll, Trip.ProductInTrip, productintrip,
|
scope.Contains( productintrip.ProductInTripInOptimizerRun() ) ) // Only if the productintrip is part of this optimizer run
|
{
|
uomconversion := productintrip.UnitConversionFactor();
|
factor := ptll.DurationInTrip().DaysAsReal() * ptll.Process_MP().GetCapacityUsagePerQuantity( unitperiod );
|
var := program.TripNewSupplyVariables().Get( productintrip );
|
|
// Term: uomconversion * factor * TripNewSupply variable
|
// UoM: [Output PISP to Unit] * [days * Time / Unit] * [Output PISP] //For transport the capacity is defined per day so the trip duration in days accounts for that
|
maxconst.NewTerm( uomconversion * factor * scalefactor_tripnewsupply_maxconst, var );
|
minconst.NewTerm( uomconversion * factor * scalefactor_tripnewsupply_minconst, var );
|
|
bound := bound + factor * var.LowerBound();
|
}
|
}
|
|
// Put capacity constraints on a higher level unit.
|
traverse( unitperiod, ChildOfUnitDimension, childunitperiod )
|
{
|
operations := subopt.GetOperationsForUnitPeriod( scope, childunitperiod );
|
|
traverse( operations, Elements, operation )
|
{
|
factor := operation.GetCapacityUsagePerQuantity( unitperiod );
|
var := program.PTQtyVariables().Get( operation, unitperiod.Period_MP() );
|
|
// Term: factor * PTQty variable
|
// UoM: [Time / Unit] * [Unit]
|
maxconst.NewTerm( factor * scalefactor_periodtaskqty_maxconst, var );
|
|
bound := bound + factor * var.LowerBound();
|
}
|
}
|
|
varoverload := program.UnitCapacityOverloadedTimeVariables().Get( unitperiod );
|
|
// Term: UnitCapacityOverloaded variable
|
// UoM: [Time]
|
maxconst.NewTerm( -1.0 * subopt.ScaleConstraintTerm( typeof( MPUnitCapacityOverloadedTimeVariable ), typeofexpression( maxconst ) ), varoverload );
|
|
if( unitperiod.NrOfOpen() <= 0 ) // If the unit is closed, it should not be allowed to plan anything, and the overloaded capacity is served as the slack to prevent infeasible
|
{
|
subopt.FreezeVariableUpperBound( varoverload, bound );
|
}
|
|
// Update the RHS based on the trips outside the optimizer horizon
|
traverse( unitperiod, PeriodTask_MP.astype( PeriodTaskLaneLeg ), ptll )
|
{
|
traverse( ptll, Trip.ProductInTrip, pit,
|
not scope.Contains( pit.ProductInTripInOptimizerRun() )
|
and (pit.HasRegularProductForOptimizer() or pit.Product_MP().GetIsInOptimizerRun( runcontext.IsPostProcessing() ) ) )
|
{
|
// The quantity of this product in trip that is outside the horizon times the duration of this trip that occurs during this unit period
|
fixedquantity := pit.QuantityInProcessUOM() * ( ptll.DurationInTrip() / Duration::Days( 1 ) );
|
newrhsminconst := subopt.GetConstraintRHS( minconst, scalefactor_rhs_minconst ) - fixedquantity;
|
minconst.RHSValue( newrhsminconst * scalefactor_rhs_minconst );
|
|
newrhsmaxconst := subopt.GetConstraintRHS( maxconst, scalefactor_rhs_maxconst ) - fixedquantity;
|
maxconst.RHSValue( newrhsmaxconst * scalefactor_rhs_minconst );
|
}
|
}
|
// Update the RHS based on the operations outside the optimizer horizon
|
traverse( unitperiod, PeriodTaskOperation, periodtask, isnull( periodtask.UnitPeriodWhenInScope() ) )
|
{
|
fixedquantity := guard( periodtask.QuantityToProcess() / periodtask.RequiredCapacity(), periodtask.QuantityToProcess() ); // requiredcapacity for trip is zero all the time
|
newrhsminconst := subopt.GetConstraintRHS( minconst, scalefactor_rhs_minconst ) - fixedquantity;
|
minconst.RHSValue( newrhsminconst * scalefactor_rhs_minconst );
|
|
newrhsmaxconst := subopt.GetConstraintRHS( maxconst, scalefactor_rhs_maxconst ) - fixedquantity;
|
maxconst.RHSValue( newrhsmaxconst * scalefactor_rhs_maxconst );
|
}
|
*]
|
InterfaceProperties { Accessibility: 'Module' }
|
}
|
