FLEXSCHEバージョン19

モジュール提供の流れ

1. プロファイル収集

   運用してるデータまたはそれと同等のデータをご準備ください。 運用時と同様の操作を行っていただき、その処理の特性・傾向情報（プロファイル）を作ります。 プロファイル収集用モジュールが同梱されているので、予めそのモジュールに入れ替えておく必要があります。

   ※プロファイル収集モジュールは実行に時間がかかります。従来の10倍程度の所要時間を想定してください。

2. プロファイル提出

   収集されたプロファイル情報をフレクシェ社へお送りいただきます。

3. 専用モジュールをビルド（フレクシェ社）

   送付いただいたプロファイルをもとに弊社内でユーザー専用モジュールをビルドします。

   ※数日程度お時間をいただきます。

4. 専用モジュールの取得

   ビルド完了時にメールでお知らせいたします。高速化が施された専用モジュールをダウンロードすることができます。

5. 専用モジュールの適用

   ダウンロードした専用モジュールをFLEXSCHEの既存モジュールと入れ替えていただけば高速化適用完了です。

FPTSManagerとFPTSサーバー

上記の流れの手続きを行うためにはFPTSManagerというツールを使います。 プロファイル作成や提出、ビルドされた専用モジュールの取得、モジュールの入れ替えなどの操作はこのツールで行います。 また弊社側にはFPTSサーバーというwebサービスが稼働しており、FPTSManagerはこのサーバーとやり取りを行いますので、 基本的に弊社スタッフと直接ご連絡を取っていただく必要はありません。 エクスプローラなどを用いて直接ファイル操作をする必要もありません。

メンテナンスモードでは、取得済みの専用モジュールと、標準モジュールとの入れ替えとFLEXSCHEの起動が行えます。高速化適用前の状態に戻したり、FPTSによる高速化の効果を比較検証するのに便利です。 また古いファイルの削除等もここから行えます。

サービスに関するその他補足

• 対応するのは保守対象バージョンにおける最新リリースバージョン/リビジョンに限ります。
• どれくらい高速化が見込めるかは具体的な数値は確約できません。
• FLEXSCHEはすでに極限まで高速化されているので、データや処理内容によっては効果が出ない場合もあります。ときにはむしろ遅くなることもありえます。
• プロファイル情報はあくまでプログラムの動作傾向に関する集計情報です。プロジェクト固有の情報は含まれませんのでご安心ください。
• FLEXSCHE導入PCがオフライン環境下であっても、オンライン接続された別PCにFPTSManagerをコピーすることでFPTSサーバーとの手続き部分のみを実施することができます。
• 修正リリースに対しても高速化モジュールを希望される場合は、プロファイル収集から手続きをやり直していただく必要があります。

これらを組み合わせると、例えば、外部の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に取り込むことができます。

以下のアドインスクリプトは、完成品の要求量に応じて中間材料の生産量を人が調整するためのUIを実装したものです

// このFLEXSCHEアドインのコードは自由に改変してお使いいただくことができます

// GUIアドインの登録
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アドインの登録
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));
    }
  }
  // メジャーの定義
  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);
}