FLEXSCHE版本19

模块提供的流程

1. Profile信息收集

   请准备运用数据或和其同等的数据。 和运用时进行相同操作，制作该处理的特性和倾向信息（Profile）。 由于包含Profile收集模块，需要事前对用模块替换通常模块。

   ※运行Profile收集模块比较耗时。有可能需要传统方式的10倍。

2. 提出Profile

   向FLEXSCHE Corporation发送收集的Profile。

3. 构建专用模块（FLEXSCHE Corporation）

   基于送来的Profile我公司为客户构建专用模块。

   ※需要数个工作日。

4. 取得专用模块

   完成构建时会以邮件方式通知。可以下载进行高速化处理的模块。

5. 适用专用模块

   用下载的专用模块替换FLEXSCHE的通常模块。

FPTSManager和FPTS服务器

进行上述手续使用FPTSManager工具。 Profile的制作和提出、构建好的专用模块的取得、模块替换的操作都用此工具。 另外我公司运作着FPTS服务器的web服务，由于FPTSManager与该服务器交互信息， 基本上无需和我公司人员直接取得联络。 同时也无需用资源管理器直接操作文件。

维护模式可以进行模块替换和FLEXSCHE的启动。返回适用高速化模块前的状态、可以便于检验或对比基于FPTS高速化的效果。 另外在此也可以进行旧文件的删除等操作。

服务相关的其他补充

• 仅对应维护对象版本的最新发布版本/修订版本。
• 无法承诺可提速的具体数值。
• 由于FLEXSCHE已经高速化处理到了极限，根据数据或处理内容可能无法看出效果。甚至可能出现反而转慢的情况。
• Profile信息只是程序的动作倾向相关的汇总信息。不包含项目固有的信息请放心。
• 导入FLEXSCHE的PC在离线环境的时候，向在线的PC复制FPTSManager可以实施与FPTS服务器的手续部分。
• 在修改版发布后需要对该发布的高速化模块时需要重新进行Profile收集手续。

将其组合，例如对外部的pytest.py文件

import sys
import json
import numpy as np
data = json.loads( sys.argv[1] )
angle = np.deg2rad( data["angle"] )
vec = np.array(data['value'])
cos = np.cos( angle )
sin = np.sin( angle )
matrix = np.array([[cos,-sin],[sin,cos]])
vec = np.dot( matrix, vec.transpose() )
print( json.dumps( vec.tolist() ) )	

如此记述，在FLEXSCHE

$vec := {22, -4},
$data := { "value"=>$vec, "angle"=>45 },
$a1 := "pytest\pconv.py",
$a2 := $data.ToJSON,
$res := Project.ConsoleCommand( "python", { $a1, $a2 } ),
Variant.FromJSON( $res )	

如此进行评估，让外部程序进行矢量计算，FLEXSCHE可以读取其结果。

下面的Add-in脚本是开发根据成品的要求量人为调整中间材料的生产量的UI

// 此Add-in代码可以自由变更利用

// 登记GUI Add-in
function SelfRegistration(addIns) {
  var addin;
  addin = addIns.AddScript("Setup", FLEXSCHE.AddInKeyHookAfterLoadingProject);
  addin = addIns.AddScript("Command", FLEXSCHE.AddInKeyEventFSEventFired);
  addin.LongValue = addIns.Application.Environment.RegisterProjectEvent(
    "gui.tree-node.command.invoked" );
  // 制作加载项目时的DataCubeView的数据立方体
  addin = addIns.AddScript(
    "ObtainDatacube", FLEXSCHE.AddInKeyEventFSEventFired );
  addin.LongValue = addIns.Application.Environment.RegisterProjectEvent(
    "fse.datacube.obtain" );
  // 更新所有
  addin = addIns.AddScript(
    "AfterLoadingData", FLEXSCHE.AddInKeyHookAfterLoadingData );
  addin = addIns.AddScript("Rescheduled", FLEXSCHE.AddInKeyEventFSEventFired);
  addin.LongValue = FLEXSCHE.FSEventRescheduled;
}

// 登记Editor Add-in
function SelfRegistrationForFSEditor(addIns) {
  var addin = addIns.AddScript(
    "ValueChanged", FSEditor.FSEAddInKeyEventOnBodyOnDataCubeEditor );
  // 单元格被编辑 => 仅更新该中间品和其下位产品
  addin.SubKeyID = FSEditor.FSEAddInSubKeyEvent_Edited;
}

function _Setup(keyEntity) {
  // 项目面板的“自定义视图”节点
  var project = keyEntity.ParamObject(FLEXSCHE.ParamIDProject);
  var str = "<?xml version='1.0'?>";
  str += "<tree-node str='自定义视图' "
  str += "guid='{41D5879D-EF89-48C1-A681-39D57EEC5423}' type-name='top'>";
  str += "<command str='添加' id='add-view' is-default='true' />";
  str += "</tree-node>";
  var cmd = new ActiveXObject("Microsoft.XMLDOM");
  cmd.loadXML(str);
  project.BehaviorProperty(
    "#gui.project-panel.additional-tree.custom-dc" ) = cmd.documentElement;
  // 添加现有的子节点
  var items = project.ObtainStoredData("jsobject.DCView.Items.1", []);
  for( var i = 0; i < items.length; i++ ) AddView(project, items[i].guid, false);
  return true;
}

// 执行树状项的命令
function _Command(keyEntity) {
  var project = keyEntity.ParamObject(FLEXSCHE.ParamIDProject);
  var nodeType = keyEntity.ParamString(FLEXSCHE.ParamIDVariant1);
  var guid = keyEntity.ParamString(FLEXSCHE.ParamIDVariant2);
  var command = keyEntity.ParamString(FLEXSCHE.ParamIDVariant3);
  if( nodeType == "top" && command == "add-view" ) {
    // 添加
    var sdlUtil = project.Application.CreateCOMInstance("SDLib.SDLUtility");
    var newGuid = sdlUtil.GenerateGUID(true);
    AddView(project, newGuid, true);
    var items = project.ObtainStoredData("jsobject.DCView.Items.1", []);
    items.push({ guid: newGuid });
    project.StoredData("jsobject.DCView.Items.1") = items;
  }
  if( nodeType == "view" && command == "show-view" ) {
    // 显示
    var dc = GetDatacube(project, guid);
    var fseProject = GetFSEditorProject(project);
    if( fseProject != null ) {
      var dcEditor = fseProject.ViewDataCube(dc, true);
    }
  }
}

// 制作加载项目时的DataCubeView的数据立方体
function _ObtainDatacube(keyEntity) {
  var project = keyEntity.ParamObject(FLEXSCHE.ParamIDProject);
  var guid = keyEntity.ParamString(FLEXSCHE.ParamIDVariant2);
  var items = project.ObtainStoredData("jsobject.DCView.Items.1", []);
  for( var i = 0; i < items.length; i++ ) {
    if( items[i].guid != guid ) continue;
    var dc = GetDatacube(project, guid);
    if( dc == null ) break;
    keyEntity.Param(FLEXSCHE.ParamIDVariant3) = dc;
    return true;
  }
  return false;
}

function GetDatacube(project, guid) {
  var cDCs = project.CountOfStockedObjects("datacube");
  for( var iDC = 0; iDC < cDCs; iDC++ ) {
    var dc = project.StockedObject("datacube", iDC);
    if( dc != null && dc.guid == guid ) return dc; // 返回现有的数据立方体
  }
  var sdSpace = project.DataSpace;
  var dc = project.Application.CreateCOMInstance("SDLib.DataCube");
  dc.GUID = guid;
  dc.Name = "PSI-01";
  project.AddStockedObject("datacube", dc);
  // 日期时间维度
  var dimTime = dc.AddDimension("Time", SDLib.DCVTypeTime, "");
  dimTime.DisplayName = "日期";
  var startDate = VBDateToJDate(project.HorizonStartDate);
  var endDate = VBDateToJDate(project.HorizonEndDate);
  var exp = sdSpace.CreateTypedExpression(
    SData.SDVTypeTime, SData.SDVTypeString );
  exp.Parse(".ToString('%^m/%^d')");
  for( var date = startDate; date <= endDate; date.setDate(date.getDate() + 1) ) {
    var _d = VBDateFromJDate(date);
    var elem = dimTime.PrimitiveLayer.AddElement(_d);
    elem.Description = exp.CalculateFor(_d);
  }
  // 品目维度
  var dimItem = dc.AddDimension("Item", SDLib.DCVTypeCustomString, "Item");
  dimItem.DisplayName = "品目";
  var layerItemIntermediate = dimItem.AddLayer("intermediate");
  dimItem.RootLayer.AddChild(layerItemIntermediate);
  layerItemIntermediate.AddChild(dimItem.PrimitiveLayer);
  var intItems = sdSpace.Calculate("Item.Records.Select([.IsIntermediate])");
  var cIntItems = intItems.Count;
  for( var iIntItem = 0; iIntItem < cIntItems; iIntItem++ ) {
    var intItemRec = intItems.ItemRec(iIntItem);
    var layerElem = layerItemIntermediate.AddElement(intItemRec.Code);
    var prodItems = sdSpace.Calculate(
      "Item.Records.Select([.IsFinal and .Comment('mtrl')='" + intItemRec.Code + "'])"
    );
    var cProdItems = prodItems.Count;
    for( var iProdItem = 0; iProdItem < cProdItems; iProdItem++ ) {
      var prodItemRec = prodItems.ItemRec(iProdItem);
      layerElem.AddChild(dimItem.PrimitiveLayer.AddElement(prodItemRec.Code));
    }
  }
  // 定义Major
  var mdefLimit = dc.AddMeasureElementDefinition(SDLib.DCMEDTypeNone, "Limit");
  mdefLimit.ValueType = SDLib.DCVTypeDouble;
  mdefLimit.DisplayName = "要求上限";
  var mdefRequired = dc.AddMeasureElementDefinition(
    SDLib.DCMEDTypeNone, "Required" );
  mdefRequired.ValueType = SDLib.DCVTypeDouble;
  mdefRequired.DisplayName = "要求量";
  var mdefProduce = dc.AddMeasureElementDefinition(
    SDLib.DCMEDTypeNone, "Produce" );
  mdefProduce.ValueType = SDLib.DCVTypeDouble;
  mdefProduce.DisplayName = "生产量";
  var mdefStock = dc.AddMeasureElementDefinition(SDLib.DCMEDTypeNone, "Stock");
  mdefStock.ValueType = SDLib.DCVTypeDouble;
  mdefStock.DisplayName = "残量";
  var mdefVirtual = dc.AddMeasureElementDefinition(
    SDLib.DCMEDTypeNone, "Virtual" );
  mdefVirtual.ValueType = SDLib.DCVTypeDouble;
  mdefVirtual.DisplayName = "虚拟生产量";
  dc.FinishToSetup();
  // 控制只显示·加载
  var iStock = dc.MeasureElementIndexByName("Stock");
  var iProduce = dc.MeasureElementIndexByName("Produce");
  var iLimit = dc.MeasureElementIndexByName("Limit");
  var iVirtual = dc.MeasureElementIndexByName("Virtual");
  layerItemIntermediate.MeasureElementHidden(iLimit) = true;
  dimItem.PrimitiveLayer.MeasureElementHidden(iStock) = true;
  layerItemIntermediate.MeasureElementHidden(iVirtual) = true;
  dimItem.PrimitiveLayer.MeasureElementHidden(iVirtual) = true;
  dc.ReadOnly = false;
  layerItemIntermediate.MeasureElementReadOnly(iStock) = true;
  layerItemIntermediate.MeasureElementReadOnly(iProduce) = true;
  dimItem.PrimitiveLayer.MeasureElementReadOnly(iLimit) = true;
  dimItem.PrimitiveLayer.MeasureElementReadOnly(iProduce) = true;
  // 将过去期间设置为只读
  var roDays = sdSpace.Calculate(
    "TimeList.MakeInRange(project.HorizonStart,Project.SchedulingStartTime)" );
  var cROs = roDays.Count;
  for( var iRO = 0; iRO < cROs; iRO++ )
    dimTime.PrimitiveLayer.ElementByValue( roDays.Value(iRO) )
      .MeasureElementReadOnly(-1) = true;
  UpdateValues(dc, project);
  return dc;
}

// 添加视图的树状项
function AddView(project, guid, diff) {
  var topElem = project.BehaviorProperty(
    "#gui.project-panel.additional-tree.custom-dc" );
  var doc = topElem.ownerDocument;
  if (diff) topElem.setAttribute("sync", "true");
  // <tree-node str='PSI-01' guid='4E16AE33E53440069A71A5083275BA95'
  //   type-name='view' icon='datacube' />
  var viewElem = doc.createElement("tree-node");
  topElem.appendChild(viewElem);
  viewElem.setAttribute("str", "PSI001");
  viewElem.setAttribute("guid", guid);
  viewElem.setAttribute("type-name", "view");
  viewElem.setAttribute("icon", "datacube");
  // <command str='显示' id='show-view' is-default='true' /'>
  var commandElem = doc.createElement("command");
  viewElem.appendChild(commandElem);
  commandElem.setAttribute("str", "显示");
  commandElem.setAttribute("id", "show-view");
  commandElem.setAttribute("is-default", "true");
  project.BehaviorProperty(
    "#gui.project-panel.additional-tree.custom-dc" ) = topElem;
}

function GetFSEditorProject(project) {
  var fse = project.Environment.AddInManager.InterfaceByProgID(
    "FSEditor.Entries" );
  if( fse == null ) return null;
  var fseEnv = fse.Accessor.Environment;
  if( fseEnv == null ) return null;
  return fseEnv.Project;
}

/***************************************************************************************/

// 单元格的值发生变化
function _ValueChanged(keyEntity) {
  var editor = keyEntity.ParamObject(FSEditor.FSEParamIDDataCubeEditor);
  var row = keyEntity.ParamLong(FSEditor.FSEParamIDRow);
  var col = keyEntity.ParamLong(FSEditor.FSEParamIDCol);
  var locator = keyEntity.ParamObject(FSEditor.FSEParamIDDataCubeLocator);
  var meIndex = keyEntity.ParamLong(FSEditor.FSEParamIDLong);
  var measure = locator.FindMeasure();
  if (measure == null) return false;
  var util = Script.CreateCOMInstance("SDLib.SDLUtility");
  var project = editor.Project.FSProject;
  var sdSpace = project.DataSpace;
  var dc = locator.DataCube;
  var iTime = dc.DimensionByName("Time").IndexInDataCube;
  var iItem = dc.DimensionByName("Item").IndexInDataCube;
  var time = locator.DimensionLayerElement(iTime).Value;
  var itemRec = sdSpace.ItemSet.ItemRecByCode(
    locator.DimensionLayerElement(iItem).Value );
  if (!itemRec.IsBound) return false;
  var meDef = dc.MeasureElementDefinition(meIndex);
  var qty = measure.Value(meIndex);
  if( qty == undefined || !util.IsDoubleNormal(qty) ) {
    qty = 0.0;
    measure.Value(meIndex) = 0.0; // 删除值后强制归0
  }
  // 添加·更新·删除相应订单
  var code = itemRec.Code + "-" + util.FormatTime(time, "%y%m%d");
  var orderRec = sdSpace.OrderSet.OrderRecByCode(code);
  if( orderRec.IsBound ) orderRec.Qty = qty;
  else if( qty > 0.0 ) {
    orderRec = sdSpace.OrderSet.OrderRecByCode(code);
    if (!orderRec.IsBound) {
      orderRec = sdSpace.OrderSet.CreateOrderRec(SData.SDOTypeProduction, code);
      orderRec.ItemRec = itemRec;
      orderRec.AssignmentMethod = SData.SDTDirectionBackward;
      orderRec.Color = itemRec.Color;
      orderRec.LatestEndTime = time;
    }
    orderRec.Qty = qty;
  }
  // 改变相关值
  var code = itemRec.Comment("mtrl");
  if( code != "" ) itemRec = sdSpace.ItemSet.ItemRecByCode(code);
  UpdateValuesForIntermediateItem(dc, project, itemRec);
  // 删除不要的订单
  if( orderRec.IsBound && orderRec.Qty == 0.0 ) orderRec.Delete();
  editor.Project.FireEvent(FSEditor.FSEEventOrderRecsAreUpdated);
}

// 被重排
function _Update(keyEntity) {
  var project = keyEntity.ParamObject(FLEXSCHE.ParamIDProject);
  var views = project.views;
  var c = views.CountOfViews;
  for( var i = 0; i < c; i++ ) {
    var view = views.View(i);
    if( view.ViewType != FSVTypeCtrlView ) continue;
    if( view.SpecificationKey != "FSEditor.DataCubeEditor" ) continue;
    var dc = view.Control.DataCube;
    UpdateValues(dc, project);
  }
}

/***************************************************************************************/

// 更新添加到数据立方体的所有值
function UpdateValues(dc, project) {
  var sdSpace = project.DataSpace;
  if( dc == null ) return;
  // 清除
  dc.ClearMeasures();
  // 要求量
  UpdateValuesForRequired(dc, project);
  // 生产量
  UpdateValuesForProduction(dc, project, null);
  // 生产量调整 - 要求量调整后暂时反映未排部分
  UpdateValuesForProductionAdjust(dc, project, null);
  // 中间品的残量和产品的要求上限
  var dimItem = dc.DimensionByName("Item");
  var layerItemIntermediate = dimItem.LayerByName("intermediate");
  var cIntermediateElems = layerItemIntermediate.CountOfElements;
  for( var iIntermediateElem = 0;
    iIntermediateElem < cIntermediateElems; iIntermediateElem++ ) {
    var elem = layerItemIntermediate.ElementByIndex(iIntermediateElem);
    var intermediateItemRec = sdSpace.ItemSet.ItemRecByCode(elem.Value);
    if (!intermediateItemRec.IsBound) continue;
    UpdateValuesForStock(dc, project, elem, intermediateItemRec);
  }
}

// 部分更新 - 更新中间品和其相关产品的值
// 为了提效另外实施的
function UpdateValuesForIntermediateItem(dc, project, intermediateItemRec) {
  var sdSpace = project.DataSpace;
  var cItems = sdSpace.ItemSet.CountOfRecords;
  for( var iItem = 0; iItem < cItems; iItem++ ) {
    var itemRec = sdSpace.ItemSet.ItemRec(iItem);
    if( !itemRec.IsBound || itemRec.IsGroup) continue;
    if( (itemRec.Role & SData.SDIRoleIntermediate) == 0 &&
      (itemRec.Role & SData.SDIRoleFinal) == 0 )
      continue;
    if( itemRec.RecordKey != intermediateItemRec.RecordKey &&
      itemRec.Comment("mtrl") != intermediateItemRec.Code )
      continue;
    // 生产量
    UpdateValuesForProduction(dc, project, itemRec);
    // 生产量调整 - 要求量调整后暂时反映未排部分
    UpdateValuesForProductionAdjust(dc, project, itemRec);
  }
  // 中间品的残量和产品的要求上限
  var dimItem = dc.DimensionByName("Item");
  var layerItemIntermediate = dimItem.LayerByName("intermediate");
  var elem = layerItemIntermediate.ElementByValue(intermediateItemRec.Code);
  UpdateValuesForStock(dc, project, elem, intermediateItemRec);
}

// 要求量 - 收集所有的订单的数量
function UpdateValuesForRequired(dc, project) {
  var iRequired = dc.MeasureElementIndexByName("Required");
  var expFloor = project.DataSpace.CreateTypedExpression(
    SData.SDVTypeTime, SData.SDVTypeTime );
  expFloor.Parse(".Floor");
  var layerTime = dc.DimensionByName("Time").PrimitiveLayer;
  var layerIntermediate = dc
    .DimensionByName("Item")
    .LayerByName("intermediate");
  var layerProduct = dc.DimensionByName("Item").PrimitiveLayer;
  var loc = dc.CreateLocator();
  var orderSet = project.DataSpace.OrderSet;
  var cOrders = orderSet.CountOfRecords;
  for( var iOrder = 0; iOrder < cOrders; iOrder++ ) {
    var orderRec = orderSet.OrderRec(iOrder);
    var itemRec = orderRec.ItemRec;
    var qty = orderRec.Qty;
    var time = expFloor.CalculateFor(orderRec.LatestEndTime);
    loc.SetDimensionLayerElement(layerTime.ElementByValue(time));
    var elem = itemRec.Role & SData.SDIRoleIntermediate
        ? layerIntermediate.ElementByValue(itemRec.Code)
        : layerProduct.ElementByValue(itemRec.Code);
    loc.SetDimensionLayerElement(elem);
    loc.ObtainMeasure().Value(iRequired) = qty;
  }
}

// 生产量 - 无法特定品目时对全品目
function UpdateValuesForProduction(dc, project, targetItemRec) {
  var sdSpace = project.DataSpace;
  var itemSet = sdSpace.ItemSet;
  var cItems = itemSet.CountOfRecords;
  var layerTime = dc.DimensionByName("Time").PrimitiveLayer;
  var layerIntermediate = dc.DimensionByName("Item").LayerByName("intermediate");
  var layerProduct = dc.DimensionByName("Item").PrimitiveLayer;
  var iProduce = dc.MeasureElementIndexByName("Produce");
  var loc = dc.CreateLocator();
  var exp = project.DataSpace.CreateTypedExpression(
    SData.SDVTypeItemRec, SData.SDVTypeVariantList );
  exp.Parse(
    "TimeList.MakeInRange(Project.HorizonStart,Project.HorizonEnd)"
    + ".Convert([$$_object.InventorySubtotalQty(InventoryPCType"
    +".Produce,$_object,$_object+#P1D#,false)])" );
  for( var iItem = 0; iItem < cItems; iItem++ ) {
    var itemRec =
      targetItemRec == null ? itemSet.ItemRec(iItem) : targetItemRec;
    if( itemRec.IsGroup ) continue;
    var layer = itemRec.Role & SData.SDIRoleIntermediate
        ? layerIntermediate : layerProduct;
    var itemElem = layer.ElementByValue(itemRec.Code);
    if( itemElem == null ) continue;
    loc.SetDimensionLayerElement(itemElem);
    var qtyList = exp.CalculateFor(itemRec);
    // 保存在数据立方体
    var c = qtyList.Count;
    for( var i = 0; i < c; i++ ) {
      loc.SetDimensionLayerElement(layerTime.ElementByIndex(i));
      loc.ObtainMeasure().Value(iProduce) = qtyList.Value(i);
    }
    if( targetItemRec != null ) break;
  }
}

// 生产量调整 - 要求量调整后暂时反映未排部分
function UpdateValuesForProductionAdjust(dc, project, targetItemRec) {
  var sdSpace = project.DataSpace;
  var orderSet = sdSpace.OrderSet;
  var cOrders = orderSet.CountOfRecords;
  var expQty = sdSpace.CreateTypedExpression( SData.SDVTypeOrderRec, SData.SDVTypeDouble );
  expQty.Parse( ".Qty"
    + " - ( ( .Operation.DoesExist and .Operation.IsAssigned ) ? .Operation.LinkQty : 0.0 )" );
  var expIndex = sdSpace.CreateTypedExpression(
    SData.SDVTypeOrderRec, SData.SDVTypeLong );
  expIndex.Parse("( .LatestEndTime - Project.HorizonStart ).Days");
  var loc = dc.CreateLocator();
  var layerTime = dc.DimensionByName("Time").PrimitiveLayer;
  var layerIntermediate = dc.DimensionByName("Item").LayerByName("intermediate");
  var layerProduct = dc.DimensionByName("Item").PrimitiveLayer;
  var iProduce = dc.MeasureElementIndexByName("Produce");
  var iVirtual = dc.MeasureElementIndexByName("Virtual");
  // 指定品目时清楚虚拟生产量
  if( targetItemRec != null ) {
    var layer = targetItemRec.Role & SData.SDIRoleIntermediate
        ? layerIntermediate : layerProduct;
    loc.SetDimensionLayerElement(layer.ElementByValue(targetItemRec.Code));
    loc.SetMeasureValues(iVirtual, 0.0); // まとめてクリア
  }
  // 扫描订单
  for (var iOrder = 0; iOrder < cOrders; iOrder++) {
    var orderRec = orderSet.OrderRec(iOrder);
    if( !orderRec.IsBound ) continue;
    var itemRec = orderRec.ItemRec;
    if( targetItemRec != null && itemRec.RecordKey != targetItemRec.RecordKey )
      continue;
    var qty = expQty.CalculateFor(orderRec);
    if( qty == 0.0 ) continue;
    var index = expIndex.CalculateFor(orderRec);
    if( index < 0 ) continue;
    var layer = itemRec.Role & SData.SDIRoleIntermediate
        ? layerIntermediate : layerProduct;
    var itemElem = layer.ElementByValue(itemRec.Code);
    if( itemElem == null ) continue;
    loc.SetDimensionLayerElement(itemElem);
    loc.SetDimensionLayerElement(layerTime.ElementByIndex(index));
    loc.ObtainMeasure().Value(iVirtual) = qty;
    var v = loc.ObtainMeasure().Value(iProduce);
    loc.ObtainMeasure().Value(iProduce) = v == undefined ? qty : qty + v;
  }
}

// 中间品的残量和产品的要求上限
function UpdateValuesForStock( dc, project, intermediateElem, intermediateItemRec ) {
  var sdSpace = project.DataSpace;
  var sdlUtil = project.Application.CreateCOMInstance("SDLib.SDLUtility");
  var exp = sdSpace.CreateTypedExpression( SData.SDVTypeItemRec, SData.SDVTypeVariantList );
  exp.Parse( "TimeList.MakeInRange(Project.HorizonStart,Project.HorizonEnd)"
    + ".Convert([$$_object.InventoryQty($_object,false)])" );
  var qtyList = exp.CalculateFor(intermediateItemRec);
  var layerTime = dc.DimensionByName("Time").PrimitiveLayer;
  var cTimes = layerTime.CountOfElements;
  var loc = dc.CreateLocator();
  var iStock = dc.MeasureElementIndexByName("Stock");
  var iVirtual = dc.MeasureElementIndexByName("Virtual");
  var iLimit = dc.MeasureElementIndexByName("Limit");
  var iRequired = dc.MeasureElementIndexByName("Required");
  // 子产品列表
  var children = [];
  var cChildren = intermediateElem.CountOfChildren;
  for( var iChild = 0; iChild < cChildren; iChild++ ) {
    var child = intermediateElem.Child(iChild);
    var itemRec = sdSpace.ItemSet.ItemRecByCode(child.Value);
    var ratio = itemRec.SpecCollection.NumSpec("ratio");
    ratio = sdlUtil.IsDoubleNormal(ratio) ? ratio : 1.0;
    children.push({ child: child, ratio: ratio });
  }
  // 中间品残量
  var virtualQty = 0.0;
  loc.SetDimensionLayerElement(intermediateElem);
  var locChild = dc.CreateLocator();
  for( var iTime = 0; iTime < cTimes; iTime++ ) {
    var timeElem = layerTime.ElementByIndex(iTime);
    loc.SetDimensionLayerElement(timeElem);
    locChild.SetDimensionLayerElement(timeElem);
    virtualQty += loc.ObtainMeasure().Value(iVirtual);
    var cChildren = children.length;
    for (var iChild = 0; iChild < cChildren; iChild++) {
      var v = children[iChild];
      locChild.SetDimensionLayerElement(v.child);
      virtualQty -= locChild.ObtainMeasure().Value(iVirtual) * v.ratio;
    }
    loc.ObtainMeasure().Value(iStock) = qtyList.Value(iTime) + virtualQty;
  }
  // 产品的要求上限
  var cChildren = children.length;
  for( var iChild = 0; iChild < cChildren; iChild++ ) {
    var v = children[iChild];
    locChild.SetDimensionLayerElement(v.child);
    var futureMin = 9999999.9;
    for( var iTime = cTimes - 1; iTime >= 0; iTime-- ) {
      var timeElem = layerTime.ElementByIndex(iTime);
      loc.SetDimensionLayerElement(timeElem);
      locChild.SetDimensionLayerElement(timeElem);
      var qty = loc.MeasureValue(iStock);
      if( futureMin > qty ) futureMin = qty;
      var req = locChild.MeasureValue(iRequired);
      var q = Math.floor(futureMin / v.ratio) + req;
      locChild.ObtainMeasure().Value(iLimit) = q < 0.0 ? 0.0 : q;
    }
  }
}

/***************************************************************************************/
// generated by WSCGEN

function Setup(keyEntity) {
  ret = _Setup(keyEntity);
  CollectGarbage();
  return ret;
}
function Command(keyEntity) {
  ret = _Command(keyEntity);
  CollectGarbage();
  return ret;
}
function ObtainDatacube(keyEntity) {
  ret = _ObtainDatacube(keyEntity);
  CollectGarbage();
  return ret;
}
function ValueChanged(keyEntity) {
  ret = _ValueChanged(keyEntity);
  CollectGarbage();
  return ret;
}
function Rescheduled(keyEntity) {
  ret = _Update(keyEntity);
  CollectGarbage();
  return ret;
}
function AfterLoadingData(keyEntity) {
  ret = _Update(keyEntity);
  CollectGarbage();
  return ret;
}
function VBDateFromJDate(d) {
  return Script.VBDateFromSeconds(
    d.getTime() / 1000 - d.getTimezoneOffset() * 60
  );
}
function VBDateFromLiteral(str) {
  var d = new Date(str);
  return Script.VBDateFromSeconds(
    d.getTime() / 1000 - d.getTimezoneOffset() * 60
  );
}
function VBDateToJDate(t) {
  d = new Date();
  d.setTime(Script.VBDateToSeconds(t) * 1000 + d.getTimezoneOffset() * 60000);
  return d;
}
function alert(msg) {
  Script.ShowMessageBox(msg, "FLEXSCHE", AIM.MBTOk);
}