Change History Change History contains sequence of assembly work on the scene and allows you to undo/redo previous actions.   Alarms Displays any alarms in the system and the connection they are related to.   Nodes Nodes displays information about action-points in model: Name, if they are on a connected route and whether or not they are visible. Only available in Discrete Events Mode.   Loads Displays information about loads in the system, their route and destination.   Schedule Add timed events to the model, such as Pauses, Resets and Termination events.   Log File Log File displays log information throughout the model runtime.   Routes The Routes window shows the routing for the system. It will show the possible routes for loads moving from action point to action point. This panel is only available in Discrete Events Mode.   Controller Controller allows the user to create custom Controllers for the model. This window is only available in Discrete Events Mode.   Build a Controller   Script The scripting window will only appear in Physics Mode, a similar controller window will appear in Discrete Event Mode.   Script allows you to build script with functionality to support model testing.   Monitor Monitor displays information about I/O assigned to a particular part or parts.   For example, right click on a Motor and select Monitor to display all the I/O related to that motor and watch the states change for the active I/O.   Statistics Statistics displays information about the current number of loads in the system/model.   For example, right click on a sensor and select Observe to add it to the list. This will give you information about the number of loads passing through the sensor.    

Step 1:   Make a C# project where the main class extends the Experior.Core.Controller or Experior.Core.Logic class. Experior.Core.Controller is for making controllers that interacts with a model running in the discrete event engine and Experior.Core.Logic is for controllers interacting with a model running in the physics engine.     Step 2:   To start Experior directly within Visual Studio set Start external program. Then you can insert break points in the controller code and debug the source code.     Step 3:   Make sure the output path is the same as Experior     Step 4:     Now build the model you want to control and link the compiled controller with the model.   You can add multiple controllers disable/enable a linked controller or unload an existing controller.  

Loads in Experior are used to model pallets, boxes, bags, that are transported by material handling equipment like conveyors and lifts.   The main namespace for loads is Experior.Core.Loads and the Experior.Core.Loads.Load contains some factory methods for creating loads with different load types.   The Experior.Core.Loads.Load class derives from the RigidPart class and hence inherits a lot of its interaction with the PhysX engine from it.   Note that there are some important differences related to loads depending on whether Experior is running in physics mode or discrete mode. In physics mode a load is considered a dynamic object (unless you disable the load or make it Kinematic). This implies that the position of the load and its orientation is determined by the underlying nVidia Physx engine who calculates this by applying all the forces/torques on it. In discrete mode no physics engine is used. There it is important to know that, unless a load is made undeletable, it will always be on a Route (Experior.Core.Routes.Route) or an Action Point (Experior.Core.Routes.ActionPoint). So, by default, if a load is no longer on a Route/Action Point then it will be deleted by the underlying engine.   Below we will illustrate a set of the main methods/properties of the Experior.Core.Loads.Load class.   Some methods/properties related to the interaction of the loads with the physics engine Sleep(): This is used in the physics mode to make the load unresponsive to the physics engine. The load will no longer respond to the forces applied to it. Note that you can WakeUp/Enable a load by clicking on it in the working area.   WakeUp(): This is used in the physics mode to “wakeup” a sleeping load and make it respond again to the physics engine. The load will again respond to the forces applied to it.   Vector3 CenterOfMassOffsetLocalPosition: When the physics engine applies a force to a load to make it moving it applies this force into the center of mass of a load. By default a loads density is equally distributed over the whole volume of the load and hence the center of mass of the load is also the geometrical center of the load. By providing the CenterOfMassOffsetLocalPosition you make it possible to move this center of mass and e.g. put the center of mass lower than the geometrical center to decrease the collapsing of a load.   NOTE: The value provided to this property is an absolute value. The CenterOfMassOffsetLocalPosition property provided in the property window of a feed is a relative one where 1 represents 100%.   Example and illustration. In the example below the CenterOfMassOffsetLocalPosition of the loads with dimensions (0.5f,0,5f,0.5f) is set to (0, -0.2f, 0) when the load enters a sensor: So the force will be applied 200mm below the geometrical center of the load. myLoad.CenterOfMassOffsetLocalPosition = new Vector3(0, -0.2f, 0);   You can clearly see that the force on the load is applied lower than before it entered the sensor.   bool Gravity: This indicates whether a load is subject to gravitational force. If you set it to false a load will not fall, but will remain subject to other forces like the force applied to it on a conveyor.   float Density: This represents the (uniform) density of the load. It is used to calculate the weight of the load ( Volume calculates as length times width times height multiplied with the Density).   bool Embedded: This indicates whether the load is embedded in another entity and hence whether it should be saved when saving the model. When the Embedded property is true the load is not saved. (In discrete mode loads are never saved).   bool Enabled: Setting Enabled to false is similar to calling Sleep() and setting Enabled to True is similar to calling WakeUp().   bool Kinematic: By default a load is a dynamic object by the PhysX engine which implies that its position and orientation will be determined by the physics engine by calculating all forces/torques applied to the load. By setting the Kinematic property to true, the load is made a kinematic object instead of a dynamic one. This implies that the load will no longer respond to the forces applied to it and the position and orientation of the load is controlled by the user. (Using the Methods/properties related to positioning of a load described below).   bool Rigid: Returns true when the load is a rigid body for the PhysX engine.   bool Sleeping : Returns true when the load has been “put to sleep” and is longer taken into account by the physics engine.   DeSelect(): Deselects the load.   Select(): Selects the load. The properties of the load will be shown in the properties window and the load will get the Select color.   HighLight(Color color): Highlights the load by changing the highlight color to the given color. This is only a temporary change. When the load is UnHighLighted is restores its original color (given by the Color property.   UnHighLight(). UnHighlights the load, as a result it will get the color back as defined by the Color property.   Color Color: Returns/sets the normal color of the load (when not selected or highlighted).   bool Selectable: Indicates whether a load can be selected by the user. If you set this property to False the user will not be able to select the load.   bool Selected: Returns True when the load is currently selected, False otherwise.   bool Transparent: Returns True when the color of the load is transparent.   Methods/properties related to deleting of a load Dispose(): Called when deleting the load   bool Deletable : Property to indicate whether the load can be deleted. If this property is set to False, trying to delete the load will fail (e.g. when resetting the model, which normally deletes all loads in the model)   bool UserDeletable: Property to indicate whether the user can delete the load (e.g.by selecting it and pressing the Delete button)   event DisposeEvent OnDisposed : This event is called when the load is completely disposed (deleted)   event DisposeEvent OnDisposing : This event is called beginning to dispose a load   Methods/properties related to grouping/deleting of a load Remark: In discrete mode the grouping/ungrouping of loads happens instantaneously and immediately after calling the Group/UnGroup methods the grouped load or ungrouped loads are available. Due to the nature of the physics engine this is postponed until the physics engine has finished its cycle of applying forces to loads. So in physics mode the grouped load is available when the OnGrouped event is raised.   Group(List<Load> loads): The current load will be grouped with all loads from the given list. They loads are grouped at their current relative position and the current load becomes the master load.   Group(Load load): The current load will be grouped with the given load. Both loads keep their relative position.   Group(Load load, Vector3 localposition): The given load will be grouped with the current load. It will be positioned given the relative position.    Group(List<Load> loads, List<Vector3> positions, List<Matrix> orientations): The given load is grouped with all loads from the given list of loads. Each load of the list is positioned according to the given relative position as provided in the positions list and with the orientation as described in the given orientations list of orientation matrices.   Group(Load load, Vector3 localposition, Matrix localorientation): The given load will be grouped with the current load. It will be positioned given the relative position and with the relative orientation as defined in the given orientation matrix.   Group(Load load, Vector3 localposition, float localyaw, float localpitch, float localroll): The given load will be grouped with the current load. It will be positioned given the relative position and with the relative orientation as defined by the relative Euler angles : localyaw, localpitch, localroll.   UnGroup(List<Load> loads): ungroups all loads from the given list of loads from the current load (masterload).   UnGroup(int loads): this will ungroup the given amount of loads from the current load. If the given number is larger then the total number of grouped loads it will ungroup all of them. If the number is smaller it will ungoup the given amount. The sequence of ungrouping is as follows: the last one grouped will be ungrouped first.   UnGroup(Load load): UnGroups the given load from the current load (masterload).   UnGroup(): UnGroups all loads that form the current load (masterload).   Collection Grouped: Returns the collection of loads that are grouped with the current load (the masterload). The Grouped collection allows to request the Length, Width, Height of the combined grouped load and you can iterate over all slave loads using the Items property of the Grouped property of the master load.   bool IsGrouped: Returns true for a load that has been grouped with a masterload. The materload itself will return false for this IsGrouped property.   event GroupedEvent OnGrouped: Is called when the load has been grouped. (See remark above concerning physics/discrete mode). The delegate has as argument the sender (masterload) and the result.   Below you find an example and screenshots of grouping: int createdloads=1;int totalnumber=10; Core.Resources.Mesh mesh=Common.Meshes.Get("Tote_Red"); Load ld1 = Load.Create(mesh, Length, Height, Width); ld1.Switch(linkedactionpoint); while (createdloads < totalnumber) { // create 4 more loads of given mesh and group them Load ld = Load.Create(mesh, Length, Height, Width); ld1.Group(ld,new Vector3(0,(Height-0.01f)*createdloads,0));//have totes slightly overlap // ld1.Group(ld,new Vector3(0,(Height+0.05f)*createdloads,0)) // create empty space between loads createdloads++; }   Above example results in the following stacks of totes being created depending whether we had loads overlapping or with empty space between them: Example of iterating over the grouped loads:   Experior.Core.Environment.Log.Write("Total dimensions are " + ld1.Grouped.Length + "; " + ld1.Grouped.Height + "; " + ld1.Grouped.Width); foreach (Load grl in ld1.Grouped.Items) { Experior.Core.Environment.Log.Write(" " + grl.Length + "; " + grl.Height + "; " + grl.Width); }   Methods/properties related to movement of a load in discrete mode MoveTo(string destination): This method will initiate a load traveling on its current route to the actionpoint with the name equal to the given destination. If the destination actionpoint is not reachable through routes connected to the current route then a message will be logged :  ‘Can’t continue: “destination” is unreachable (“current actionpoint name“)’   MoveTo(string source, string destination): This method will initiate a load traveling on its current route from the source actionpoint to the actionpoint with the name equal to the given destination.   Release(): This method will release a load that is stopped.   Release(float delay): This method will release a load that is stopped after the given delay has passed. The delay is given in seconds.   Stop(): This method will stop a load on its Route/ActionPoint. The load will wait there until it is released.   Switch(Route to): This method  will instantaneously take the load and put it at the start of the given route.   Switch(Route to, float distance): This method  will instantaneously take the load and put it at the given distance from the start of the given route.   Switch(Route to, bool keepGlobalOrientation): This method  will instantaneously take the load and put it at the start of the given route. When the keepGlobalOrientation argument is true than the load will keep its current global orientation (Yaw, Pitch, Roll), otherwise it will use the properties of the route.   Switch(Route to, float distance, bool keepGlobalOrientation): This method  will instantaneously take the load and put it at the given distance from the start of the given route. When the keepGlobalOrientation argument is true than the load will keep its current global orientation (Yaw, Pitch, Roll), otherwise it will use the properties of the route.   Switch(string actionpoint, bool keepGlobalOrientation): This method will put the load on the actionpoint with the given name.When the keepGlobalOrientation argument is true than the load will keep its current global orientation (Yaw, Pitch, Roll), otherwise it will use the properties of the actionpoint. If no actionpoint can be found with the given name the call is ignored.   Switch(ActionPoint ap, bool keepGlobalOrientation): this method will put the load on the given actionpoint. When the keepGlobalOrientation argument is true than the load will keep its current global orientation (Yaw, Pitch, Roll), otherwise it will use the properties of the actionpoint. In the illustrations below you can see the difference between switching a load (to AP6) with the keepGlobalOrientation argument true or false:       Switch(string actionpoint): This method will put the load on the actionpoint with the given name. If no actionpoint can be found with the given name the call is ignored.   Switch(ActionPoint ap, ActionPoint.Edges edge): This method will put the load on the actionpoint. The edge argument has 3 possible values ActionPoint.Edges.Leading, ActionPoint.Edges.Trailing and the defaultActionPoint.Edges.Center. If its value is Edges.Trailing then the load will be put on the actionpoint in such a way that the position of the actionpoint matches the trailing back of the load. If its value is Edges.Leading then the load will be put on the actionpoint in such a way that the position of the actionpoint matches the leading front of the load.   Note: This assumes that there is sufficient room on the route to do the switch, meaning that the center of the load should be on the route. Suppose you have an ActionPoint at the start of a route. In that case it is only possible to do the switch with edge ActionPoint.Edges.Center or ActionPoint.Edges.Trailing because using ActionPoint.Edges.Leading implies that the center of the load would not fit on the route.   Switch(ActionPoint ap): This method will put the load on the given actionpoint.   ActionPoint ActionPoint: This getter property returns the current actionpoint of the load or null if the load is on a route and not at an actionpoint.   string GoTo: This property allows to get of the name of the current final destination actionpoint. By setting this property to the name of an actionpoint the load will set it as its final destination and travel towards it.   Vector3 RouteOffset: Normally a load travels on the route with the center of the load moving over the route. By using the RouteOffset property you can chnage this and have the center of the load moving at the given relative position from the route.   Below you see an illustration of loads moving where load.RouteOffset = new Vector3(1.2f, 0.3f, 0f);   bool Stopped: This getter property returns True when the load is currently stopped, False otherwise.   float WaitingTime: Setting this property makes a load wait at its current position. The waiting time is provided in seconds. When this waiting time is elapsed the load will trigger the FinishedWaiting event and continue.   FinishedWaiting FinishedWaitingEvent: This event is triggered by a load when its WaitingTime has elapsed.   Methods/properties related to attaching a load to a RigidPart public bool IsAttached: This getter property returns true when the load is currently attached to a RigidPart and hence if following the movement of this part.   event AttachedEvent OnUnAttached: This event is triggered when the load gets unattached of the RigidPart it was attached to.   event AttachedEvent OnAttached: This event is triggered when the load gets attached to a RigidPart was attached to.   Attaching loads is done using one of the Attach methods of the Experior.Core.Parts.RigidPart class.   Custom Data object UserData: The developer can add custom data to a load by using this UserData property. E.g you can create you own TransportOrder class containing data from the WMS like PurchaseOrder,Customer, Source, Destination, DueDate,… and attach it to the load: myload.UserData = aTransportOrder;   You can inspect the data again by casting the UserData back to the class it was given: string customer = (myload.UserData as TransportOrder).Customer;   Methods/properties related to prositioning of a load float Yaw: This getter/setter property reflects the rotation angle (in radians) of the load around the Y-axis   float Pitch: This getter/setter property reflects the rotation angle (in radians) of the load around the X-axis   float Roll: This getter/setter property reflects the rotation angle (in radians) of the load around the Z-axis   Vector3 Position: This property returns the global 3 dimensional coordinates of the center of the load. In the physics mode the position is determined by the physics engine or its movement on tracks and in discrete mode by its movement on the routes. When the load is made Kinematic or Disabled then it makes sense to directly set the position of the load.   Matrix Orientation: This property returns or sets the orientation of the load as defined in the Microsoft.DirectX.Matrix structure.   Translate(Vector3 distance, float time): This will translate a stopped load over the given vector during the given time. After the given time the load remains at its position after the translation until it is released. In case the load continues moving on a route it will jump back to its position on the route. So note that the load should not be moving on a route when calling this translate method otherwise you get some strange wave movement during the given time where the load is trying to translate over the given vector but is pulled back by it having to move on the route.   Translate(Action action, Vector3 distance, float time): This method is similar to the Translate method above except that at the end of the translation of the load over the given vector distance the given action will be executed. The given System.Action is a delegate that you can use to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate.This means that the encapsulated method must have no parameters and no return value.   In the example below a load is translated over 3 meter in the Y-direction in 2 seconds and at the end of the movement the load is switched to actionpoint  “AP10” and then released : currentload.Translate(()=>SwitchToAP10(), new Vector3(0, 3.0f, 0), 2f);   where: public void SwitchToAP10() { if(currentload != null) { currentload.Switch("AP10"); currentload.Release(); } }

A plugin can be used to add custom functionality to Experior and you can also use it to extend the GUI by adding menu items and/or adding your own forms. A plugin is a dll that will be automatically loaded by Experior (provided the dll can be found in the installation directory of Experior). You can create your own plugin by creating a separate Visual Studio project where your plugin class derives from Experior.Core.Plugin.    Toolbar.Button To extend the GUI you can create a Button (Core.Environment.UI.Toolbar.Button) and add it to a toolbar.   In the example below a button is created and added to Model Toolbar in a Tab with name TestPlugin : Core.Environment.UI.Toolbar.Button IOButton = new Core.Environment.UI.Toolbar.Button("SensorOutputs", btnIOToggle_Click); IOButton.Tooltip = "Show outputs from sensors"; // add the button to the Model toolbar in a Tab with name "TestPlugin" Core.Environment.UI.Toolbar.Add(IOButton, "TestPlugin");   This will look as follows:   When the example SensorOutputs button is clicked it will trigger the associated btnIOToggle_Click method.   In this example this will update a custom form.   Experior.Core.Forms.Form Experior allows to add your own forms. You create your form similar to a normal System.Windows.Forms.Form.   However if you want to have a form that behaves similar to other Experior forms and is dockable, the created form should derive from Experior.Core.Forms.Form instead.   Also the FormType property has to be overridden. public override Core.Forms.Docking.DockContent.FormTypes FormType { get { return Core.Forms.Docking.DockContent.FormTypes.Permanent; } }   In attached example is a custom form that contains a datagrid will info of all Outputs for the sensors in your model. The form looks as follows when it is docked:   You can download the complete plugin attached to this article

RigidSensorPart The class Experior.Core.Parts.Sensors.RigidSensorPart derives from the abstract class Experior.Core.Parts.RigidPart. RigidSensorPart objects are used in the PhysX environment to detect and manage collisions with RigidParts such as Loads and Assemblies. Since they rely on the collision detection of the PhysX engine they have no functionality in the discrete mode. RigidSensorParts are available in different shapes (Experior.Core.Parts.Sensors.Cube, Experior.Core.Parts.Sensors.Sphere, Experior.Core.Parts.Sensors.Cylinder) and with different functionality (Experior.Core.Parts.Sensors.LoadMagnet and Experior.Core.Parts.Sensors.EaterCube). All sensor assemblies of the Sensor catalog contain at least one RigidSensorPart.   An example of the creation and usage of a RigidSensorPart can be found here.   Events event EnterEvent Enter; This event is called when the sensorpart collides with a part it should detect according to its Collision property. The delegate it will call has two arguments, the activated sensorpart and the triggering object (can be cast to Load or Assembly).   event LeaveEvent Leave; This event is called when the sensorpart collides with a part it should detect according to its Collision property. The delegate it will call has two arguments, the activated sensorpart and the triggering object (can be cast to Load or Assembly).   Properties virtual bool Active This property returns true when the sensorpart collides with a part it should detect according to its Collision property, false otherwise.   Experior.Core.Environment.Collisions Collision The Collision property has 3 possible values : Core.Environment.Collisions.Both, Core.Environment.Collisions.Loads and Core.Environment.Collisions.Equipment. Core.Environment.Collisions.Both: in this case the sensorpart will detect loads as well as assemblies Core.Environment.Collisions.Loads: in this case the sensorpart only detects loads Core.Environment.Collisions.Equipment: in this case the sensorpart detects rigidparts of an assembly   List<Load> Loads This property returns the list of all loads that are currently colliding with the sensorpart.

Experior provides some methods to read data from an Excel file and to write data into an Excel file.   To do this you can use the Experior.Core.Data.Excel class with the following methods. public static List<List<string>> Read(string filename, string sheetname); public void Write(string filename, string sheetname, List<List<string>> records);   There is also the possibility to verify whether a worksheet exists in a an Excel file with a given name. public static bool Exists(string filename, string sheetname);   By using the classes Excel, ExcelWorkbook, ExcelWorkSheet, from the namespace Experior.Core.Data.OfficeOpenXml you can obtain even more direct control.   For example. string filePath = Experior.Core.Directories.Model + "\\Simulation_results_" + DateTime.Now.Day.ToString() + "_" + DateTime.Now.Month.ToString() + "_" + DateTime.Now.Year.ToString() + "_" + DateTime.Now.Hour.ToString() + "_" + DateTime.Now.Minute.ToString() + "_.xlsx"; // create a new Excel workbook with the given filename and add a Worksheeet named "Simulation results" Experior.Core.Data.OfficeOpenXml.Excel e = new Core.Data.OfficeOpenXml.Excel(new System.IO.FileInfo(filePath)); Experior.Core.Data.OfficeOpenXml.ExcelWorksheet worksheet = e.Workbook.Worksheets.Add("Simulation results"); // write the data into the cells of the worksheet worksheet.Cells[1, 1].Value = "Total occupation time conveyor system"; worksheet.Cells[1, 2].Value = swTotalOnConv.elapsed.ToString(); worksheet.Cells[2, 1].Value = "Waiting time drivers"; for (int i = 0; i < driverWaitingTime.Count; i++) { worksheet.Cells[3 + i, 1].Value = "Waiting time after pattern " + (i + 1).ToString(); worksheet.Cells[3 + i, 1].Value = driverWaitingTime[i].elapsed.ToString("c"); } // Add another worksheet named "Simulated Pattern" Experior.Core.Data.OfficeOpenXml.ExcelWorksheet worksheetPattern = e.Workbook.Worksheets.Add("Simulated pattern"); r = 1; c = 1; foreach (List<string> rows in SimulatedPatternSheet) { c = 1; foreach (string cell in rows) { worksheetPattern.Cells[r, c].Value = cell; c++; } r++; } //save the Excel workbook file e.Save();

The Experior.Core.Parts.RigidPart class is the base abstract class to encapsulate rigid bodies that are used by the NVIDIA PhysX engine.   Some important classes that derive from RigidPart are RigidSensorPart (used by sensors) and RigidLoadPart (used inside loads).   Methods & Properties related to attaching loads. The methods below are used to attach loads to a rigidpart and keep them at a given relative position and orientation to the RigidPart. For the physics engine the loads are no longer dynamic actors that are moved according to forces and torques that are applied to them, but instead the loads become kinematic objects after attaching them to a RigidPart. You can use these method e.g. to attach a load to a gripper of a robot or keep it on a fast moving shuttle.   Note: There is an important distinction between the different Attach methods related to the collision of the load with a sensor. This distinction is necessary due to a limitation of the PhysX engine. The physics engine does not give a notification if you use the program to change the position of a load that is in contact with a sensor. Therefore, in attach methods that change the position/orientation of the load the load is taken out of the sensors it was colliding with by the programming (generating the Leave event of the sensor to allow reacting upon this change).   Attach(Load load): This method will attach the given load to the current RigidPart.This implies that if the RigidPart moves/rotates that the attached load will move with it, keeping its relative position/orientation as when it was attached. When the load was colliding with a sensor the Leave event of the sensor is not called (see Note above).   Attach(List<Load> loads): This method will attach all loads from the given list to the current RigidPart. When the loads were colliding with a sensor the Leave event of the sensor is not called (see Note above).   Attach(Load load, Vector3 localposition): This method will attach the given load to the current RigidPart at the given relative localposition from the origin of the rigidpart.   Attach(Load load, Vector3 localposition, float localyaw, float localpitch, float localroll): This method will attach the given load to the current RigidPart at the given relative localposition from the origin of the rigidpart and with a relative orientation determined by the given localyaw, localpitch,localroll Euler angles.   Attach(Load load, Vector3 localposition, Matrix localorientation): This method will attach the given load to the current RigidPart at the given relative localposition from the origin of the rigidpart and with a relative orientation determined by the given orientation matrix localorientation.   Attach(List<Load> loads, List<Vector3> positions, List<Matrix> orientations): This method will attach all loads from the given list to the current RigidPart. The given positions list and given orientations list contains the releative position and relative orientation for the load with the same index in the loads list.   UnAttach(Load load): Unattach the given load from the current RigidPart and make it a dynamic actor again for the physics engine.   UnAttach(): Unattach all loads that are attached to the current RigidPart and make them dynamic actors again for the physics engine.   In the example below a load is attached to the sensor upon the Enter event. private void Entering(Core.Parts.Sensors.RigidSensorPart sensor, object trigger) { //already attached if (((Core.Loads.Load)trigger).IsAttached) return; //avoid that the load gets selected ((Core.Loads.Load)trigger).Selectable = false; //attach load at current relative position/orientation to the sensor part sensor.Attach((Core.Loads.Load)trigger); }   Methods & Properties related to PhysX interaction.   Actor Actor: This property sets/returns the instance of the Experior.PhysX.Actor class representing this RigidPart which is used inside the NVIDIA PhysX engine (NxActor class). Actors are the main objects in a physx simulation.   Experior.Core.Parts.Friction Friction: This property sets/returns the friction definition for this RigidPart as used by the physics engine. The Experior.Core.Parts.Friction class defines the static and the dynamic friction and has some predefined Friction configurations for the user’s convenience. These are Friction.Coefficients.Slippy, Friction.Coefficients.Sticky, Friction.Coefficients.Smooth & Friction.Coefficients.None. When you require more control over the static and dynamic friction values used for your RigidPart then you can provide custom values for the Static and Dynamic property of the Friction property when using Friction.Coefficients.Custom. var cube = new Experior.Core.Parts.Cube(System.Drawing.Color.DarkGray, info.length, info.height, info.width); cube.Friction.Coefficient = Friction.Coefficients.Slippy;   bool Kinematic: By setting the Kinematic property to true, the rigidpart is made a kinematic object instead of a dynamic one. This implies that the part will no longer respond to the forces applied to it and the position and orientation of the part is controlled by the user. When kinematic is false then the part is considered a dynamic object for the physics engine.   Methods & Properties related to relative positioning. bool Configured: This getter property returns true when the RigidPart is added to a parent object (e.g. assembly) and positioned using the LocalPosition, LocalYaw, properties.    float LocalYaw: This getter/setter property reflects the rotation angle (in radians) of the RigidPart around the Y-axis of its parent object.    float LocalPitch: This getter/setter property reflects the rotation angle (in radians) of the RigidPart around the X-axis of its parent object.    float LocalRoll: This getter/setter property reflects the rotation angle (in radians) of the RigidPart around the Z-axis of its parent object.    Matrix LocalOrientation: This property returns or sets the relative orientation of the RigidPart with respect to its parent object as defined in the Microsoft.DirectX.Matrix structure   Vector3 LocalPosition: This property returns or sets the relative 3 dimensional coordinates of the center of the RigidPart with respect to its parent object   Methods & Properties related to editing. bool Dragable: Tthis getter/setter property controls whether you can drag the RigidPart, e.g. The start and end fixpoints in the conveyor assemblies are Dragable by default to allow the user to change the length of the conveyor by dragging the fixpoints to another position. bool Locked: This getter/setter property allows to lock/unlock the RigidPart. When the part is locked it will change color to Colors.LOCKEDCOLOR (Yellow by default). bool Selectable: This getter/setter property allows to control whether the RigidPart can be selected (e.g. by clicking on it). IEntity Parent: This getter property returns the parent entity  form the RigidPart. If a RigidPart is added to an Assembly using then the Parent will return this Assembly.   Property related to rendering RenderingMode RenderOption: This getter/setter property is used to get/set how the RigidPart should be rendered. The following values are possible:   Primitive: The part will only be rendered when the Experior.Core.Environment.Scene.PresentationLevel of Experior is Core.Environment.Scene.PresentationLevels.Primitives   PrimitiveAndNormal: The part will only be rendered when the Experior.Core.Environment.Scene.PresentationLevel is Scene.PresentationLevels.Primitives or Scene.PresentationLevels.Normal or Scene.PresentationLevels.Detailed or only its wireframe when Scene.PresentationLevels.Wireframe.   Normal: The part will only be rendered when the Experior.Core.Environment.Scene.PresentationLevel is Scene.PresentationLevels.Normal, Scene.PresentationLevels.Detailed or only its wireframe when Scene.PresentationLevels.Wireframe   Transparent: The part will only be rendered transparently (you can see through it) when the Experior.Core.Environment.Scene.PresentationLevel is Scene.PresentationLevels.Normal, Scene.PresentationLevels.Detailed. Note: Transparency is only visible in Locked mode, in Edit mode the part is rendered nontransparent.   TransparentPrimitiveAndNormal: The part will only be rendered transparently (you can see through it) when the Experior.Core.Environment.Scene.PresentationLevel is Scene.PresentationLevels.Normal, Scene.PresentationLevels.Detailed and Scene.PresentationLevels.Primitives. Note: Transparency is only visible in Locked mode, in Edit mode the part is rendered nontransparent.

The Experior.Core.Data library includes a tool for creating Office Open XML spreadsheets   The sample below shows how to create a work book with a sheet called “Data” FileInfo file = new FileInfo(@"c:\Test.xlsx"); if (file.Exists) { file.Delete(); // ensures we create a new workbook file= new FileInfo(@"c:\Test.xlsx"); } using (Experior.Core.Data.OfficeOpenXml.Excel excel = new Experior.Core.Data.OfficeOpenXml.Excel(newFile)) { Experior.Core.Data.OfficeOpenXml.ExcelWorksheet sheet = excel.Workbook.Worksheets.Add("Date"); sheet.Cells[1, 1].Value = "Data"; sheet.Cells[3, 1].Value = "1"; sheet.Cells[3, 2].Value = "2"; sheet.Cells[4, 1].Value = "3"; sheet.Cells[4, 2].Value = "4"; excel.Save(); }   Result:     Use the sheet:Cells[x,y].Style to set background color, font, border etc.

Experior provides an infrastructure for sending messages between objects.   In the Developer samples catalog an example of how to do this can be found.   The basic steps are; Register an object as a listener. Core.Communication.Internal.AddListener(object listener, RecieveMessage method)   For example. Core.Communication.Internal.AddListener(this, ReceiveMethod);   Where a method like this should be provided. void ReceiveMethod(object sender, object reciever, object message, bool broadcast)   2. Send a message to a known receiver. Core.Communication.Internal.SendMessage(object sender, object reciever, object message)   Broadcast a message to all listeners. Core.Communication.Internal.BroadcastMessage(object sender, object message)   Broadcast a message to all listeners of a specific type. Core.Communication.Internal.BroadcastMessage(object sender, Type recieverType, object message)   Broadcast a message to all listeners of a specific type (FullName). Core.Communication.Internal.BroadcastMessage(object sender, string recieverTypeFullName, object message)   3. When an object should stop listen or is disposed it should be removed. Core.Communication.Internal.RemoveListener(object listener)   Note: The specified delegate of the reciever is executed synchronously.

You can add properties to assemblies at runtime.   To enable the feature the class has to use the attribute Experior.Core.Properties.DynamicObjectConverter.   Example: Adding properties two properties Properties.Add(newDynamicProperty { Name = "Value1", Type = typeof(int), Description = "custom property (integer)",Category = "Testing", Value = 1 }); Properties.Add(newDynamicProperty { Name = "Value2", Type = typeof(float), Description = "custom property (float)", Category = "Testing", Value = 10.0f });   By overriding the DynamicPropertyChanged method the object can handle the changes made to the properties added above public override void DynamicPropertyChanged(DynamicProperty property) { Log.Write(property.Name + " is changed to " + property.Value); }   See the sample DynamicProperties class in the Demo catalog for more information

This example shows how to create a custom statistics class that shows up in the generated report.   To add public values to the Statistics form window in Experior set the Observe value to true.   public class TestStatistics : Core.Reports.Statistics.Statistic { public override string Title { get { return "Test Statistics"; } } private double example; [DisplayName("Example field")] public double Example { get { return example; } set { if (value != example) { example = value; NotifyPropertyChanged("Example field"); } } } }

To safely change properties and call methods in Experior be sure that you are running in the “Engine thread”. If the Property Experior.Core.Environment.InvokeRequried is false, then you are running in the “Engine thread”. Otherwise you need to invoke the method call.   Example code:   private void SomeMethod() { if (Experior.Core.Environment.InvokeRequired) { //Not running in Experior Engine thread Experior.Core.Environment.Invoke(SomeMethod); return; } //Put method code here. //Code is executed in Experior engine thread //and it is safe to call Experior methods. ... }

Please note that if you are creating a custom catalog or plugin for Experior 6 in Visual Studio 2022, you will get an error message when trying to compile the .dll. This is because Visual Studio 2022 will not be able to locate experior.build.dll. The reason it can’t locate the file, is because it is 32 bit and Visual Studio 2022 (or newer) is 64 bit.   You will be able to compile a catalog/plugin with previous versions of Visual Studio, for example 2019 is confirmed working with Experior 6.   Are you experiencing this issue and need help, feel free to contact us on email experior.support@se.com

To provide diagnostic, debug or logging messages Experior provides several mechanisms.   Logging The Experior.Core.Environment.Log class provides the following static methods to write messages to the Log window. public static void Write(Exception exception); public static void Write(string message); public static void Write(Exception se, int id); public static void Write(string message, bool underline); public static void Write(string message, Color color); public static void Write(string message, LogFilter filter); public static void Write(string message, string hightlight); public static void Write(string message, bool underline, LogFilter filter); public static void Write(string message, Color color, LogFilter filter); public static void Write(string message, string hightlight, Color color); public static void Write(string message, string hightlight, LogFilter filter); public static void Write(string message, Color color, bool underline, LogFilter filter); public static void Write(string message, string hightlight, Color color, bool underline); public static void Write(string message, string hightlight, Color color, LogFilter filter); public static void Write(string message, string hightlight, Color color, bool underline, LogFilter filter);   The meaning of the arguments is straightforward; The message is the string that will be logged to the log window (and/or file depending on the properties set by the user in Experior). The highlight is part of the message that will be shown in bold. The color is the color in which the message will be shown. Underline, this boolean indicates whether or not the message will be underlined. The filter corresponds with the chosen filter by the user in the properties of the Log;   To illustrate, the following code Experior.Core.Environment.Log.Write("Created sensorpart assembly", "sensorpart", CadetBlue, true, Communication ); Experior.Core.Environment.Log.Write("Created sensorpart assembly", "sensorpart", Red, false, Action); will be shown as follows (when no filter is applied);     Debug log   Similar to the regular logging there is also the possibility to only log your message in case the debugging option is set in Experior.   In this case the Experior.Core.Environment.Log.Debug class is used with the public static void Write(string message) method.   Example: Experior.Core.Environment.Log.Debug.Write("This is an example debug message");   Diagnostic info   Experior also provides the possibility to print diagnostic messages to other areas than the logging window.   Therefore the class Experior.Core.Environment.Diagnostic contains the following static methods: public static void Message(string message); public static void Message(string message, Color color); public static void Message(string sender, string message); public static void Message(string message, Color color, Environment.DiagnosticAction action); public static void Message(string sender, string message, Color color); public static void Message(string message, Color color, Environment.DiagnosticAction action, Environment.Signs sign); public static void Message(string sender, string message, Color color, Environment.DiagnosticAction action);   By default the messages are shown in the status area underneath the working area.   The arguments are;   Message: The information that will be shown. Sender: This string appended with a : will be shown before the message. It is mainly used to provide the origin of the message e.g. the Assembly name. Environment.DiagnosticAction: This is an enum with the following possible values; ALARM in this case the message will also be shown in the alarm window of experior TEMPORARY in this case the message will only be shown for couple of seconds TEMPORARYANDLOG in this case the message will only be shown for couple of seconds but it will also be printed to the log window (where it will remain) STICKY in this case the message will remain visible in the status area until a new message is requested or until the message is removed or the Clear() method is called of the Diagnostic class REMOVE way to remove a STICKY diagnostic message NONE Environment.Signs: This is an enum to indicate what icon should be attached to the message in the status area.

Experior saves a model by serializing all necessary model entities (actually their corresponding Info objects) into specific xml files and compressing those into an experior file.   Loading a model works vice versa, the experior file is uncompressed and each xml file it contains is deserialized.   The serializing and deserializing can be done using System.Xml.Serialization.XmlSerializer.   However Experior also provides a utility class Experior.Core.Environment.Serialization to make this process simpler.   Example: // Log all serializable types List<Type> serializable = Experior.Core.Environment.SerializableTypes; Experior.Core.Environment.Log.Write("We found " + ser.Count + " serializable types."); foreach (var t in serializable) { Experior.Core.Environment.Log.Write(" : " + t.ToString()); } // create the test.xml file and serialize the Info object of this assembly into it Experior.Core.Environment.Serialization.Serialize("test.xml", this.Info); // load the test.xml file and deserialize into a AssemblyInfo object AssemblyInfo res = (AssemblyInfo)Experior.Core.Environment.Serialization.DeSerialize("test.xml", typeof(AssemblyInfo));

Experior.Core.Environment.Random   Experior.Core.Environment.Random can be used to get a pseudo random sequence of numbers.   Properties int Seed: This property allows to get/set the Seed of the standard pseudo random number generator used by Experior.   Changing the seed allows to get a new sequence of pseudo random numbers.   Experior.Core.Mathematics.Statistics.Generators.Pseudo.StandardGenerator Generator: This property allows to get/set the standard pseudo random number generator used by Experior.   The standard pseudo random number generator has methods to obtain random bytes, integers, doubles, booleans (See example below).   Methods void Reset(): This resets the number generator. After the reset the random number generator will generate the same sequence of numbers for the current seed.   int Random(): Returns a random integer.   int Random(int max): Returns a random integer less than the given max   int Random(int min, int max): Returns a random integer between the given min and less than the given max   Example: Below is an example of the usage of a random number generator of Experior: private void ExampleOfRandom(int seed) { // Example of usage of random number generator // Set the seed of the pseudo random number generator // By using the same seed you'll get the same sequence of pseudo random numbers which fullfills // the reproducablility requirement (e.g. when debugging) // Change the seed for each iteration of experiments Experior.Core.Environment.Random.Seed = seed; // get a pseudo random integer between -20 and less than 21 int randomint = Experior.Core.Environment.Random.Next(-20, +21); Experior.Core.Environment.Log.Debug.Write("Debug message " + attr1); Experior.Core.Environment.Random.Reset(); // randomint will be the same value as before because we have reset the random number generator randomint = Experior.Core.Environment.Random.Next(-20, +21); Experior.Core.Environment.Log.Debug.Write("Debug message after reset seed " + attr1); // reset the scene (this will also reset all assemblies and reset the standard random number generator) Experior.Core.Environment.Scene.Reset(); // randomint will be the same value as before because we have reset the scene randomint = Experior.Core.Environment.Random.Next(-20, +21); Experior.Core.Environment.Log.Debug.Write("Debug message after reset " + attr1); // You can get the standard pseudo random generator through Experior.Core.Environment.Random.Generator // this allows you to get random bytes, radom integers, random doubles, // get random double beteen 0.3 and less then 7.9 double randomnumber = Experior.Core.Environment.Random.Generator.NextDouble(0.3, 7.9); byte[] randombytes = new byte[10]; // fills the given byte array with random values Experior.Core.Environment.Random.Generator.NextBytes(randombytes); // get a random boolean value bool randombool = Experior.Core.Environment.Random.Generator.NextBoolean(); }

Experior.Core.Environment.Properties   Experior.Core.Environment.Properties allows to interact with the properties window in Experior.   Suppose the value of property A of an assembly relies on the value of property B. When  a user changes the value of B, you want to have the new value of property A immediately visible. This can be achieved by using the Experior.Core.Environment.Properties.Refresh() method.   Methods void Refresh(): This will refresh the Property window to show all current property values of the selected entity.   void Clear(): This will clear the Property window of Experior so that is empty and shows no properties.   Example: private int attr1; public int Prop1 { get { return attr1; } set { attr1 = value; // refresh the property window so that // also the new value for CalculatedProp is visible Experior.Core.Environment.Properties.Refresh(); } } public int CalculatedProp { get { return attr1*2; } }

Experior.Core.Environment.Time   Experior.Core.Environment.Time class provides static properties that allow to interact with the time through code similar to the user interacting with below toolbar buttons.   Properties   bool ContinuouslyRunning: This property allows to get/set whether (in discrete mode)  the model will keep running even in case the engine detects no more events. In case this property is false the model will pause in case the simulation engine can find no more events.    double Elapsed: This property returns the elapsed time in seconds. This is the total world time the model has been running.   bool LockScaling: The LockScaling property is used to allow/disallow changing of the Simulation speed. If LockScaling is false the simulation speed can be changed otherwise it is fixed.    float MaxScale: By pressing PageUp in the workarea it is possible to speed up the simulation and run faster than the world time. This property allows to get/set the maximum ratio between simulated time and world time.     float MinScale: By pressing PageDown in the workarea it is possible to decrease the speed of the simulation and run slower than the world time. This property allows to get/set the minimum ratio between simulated time and world time.   float Scale: This property gets/sets the ratio between simulated and world time.     double Simulated: This property returns the simulated time in seconds. This is the total simulated time the model has been running.  

The Experior.Core.Environment.SolutionExplorer class allows the developer to interact with the SolutionExplorer.   A typical usage is to refresh the SolutionExplorer because you know that some code impacts the tree structure.   E.g.: Experior.Core.Environment.SolutionExplorer.Refresh();   Or for a specific entity (assembly, motor…): Experior.Core.Environment.SolutionExplorer.Update(mychangedassembly);

Experior.Core.Environment.Scene   Properties bool Paused: The Paused property returns true when the model is Paused (Simulated time is not progressing), false otherwise. bool Locked: The Locked property returns true if the Environment is in locked mode which implies that the model cannot be edited.   Events event Event Cleared: The Cleared event is triggered when the workspace is cleared. This occurs when a model is closed (either by explicitly closing a model or starting a new model). event Event Loaded: The Loaded event is triggered when a model is opened and completely loaded. event Event Locking: The Locking event is triggered when locking the model. event Event Pausing: The Pausing event is called when the model is being paused. event Event Saved: The Saved event is called when the current model is saved.   Methods Continue(): The Continue method resumes the running of the model. Lock(): The Lock method locks the model. Pause(): The Pause method pauses the running of the model.   Reset(): The Reset method pauses the model and resets the clock to 0. It will also reset all assemblies of the model   UnLock(): The Lock method unlocks the model so that it can be edited.   Example Below is an example of an assembly that illustrates the usage of above described events/methods: public ExampleEnvironment(AssemblyInfo info) : base(info) { Experior.Core.Environment.Scene.Loaded += Scene_Loaded; Experior.Core.Environment.Scene.Pausing += Scene_Pausing; Experior.Core.Environment.Scene.Saved += Scene_Saved; Experior.Core.Environment.Scene.Cleared += Scene_Cleared; Experior.Core.Environment.Scene.Locking += Scene_Locking; } void Scene_Locking() { Experior.Core.Environment.Diagnostic.Message(this.Name, "Diagnostic message : Scene is locked"); } void Scene_Cleared() { Experior.Core.Environment.Diagnostic.Message(this.Name,"Diagnostic message : Scene is cleared"); } void Scene_Saved() { Experior.Core.Environment.Diagnostic.Message(this.Name, "This is a diagnostic message in blue to indicate the model is saved", Blue); } void Scene_Pausing() { Experior.Core.Environment.Diagnostic.Message("This is a diagnostic message to indicate the model is paused"); /// this will clear the Properties window Experior.Core.Environment.Properties.Clear(); } void Scene_Loaded() { // change the presentation level to WireFrame Experior.Core.Environment.Scene.PresentationLevel = Wireframe; // lock the model Experior.Core.Environment.Scene.Lock(); // if custom assemblies contain references to other assemblies those // references can be re-established after the model has been // loaded again in a Scene_Loaded delegate // suppose we have two assemblies A and B both having // property LinkedAssembly that reference the other assembly. // when loading the model this relationship can only be completely // reestablished when the model is completely loaded // and we are sure that both assemblies exist. // (In the constructor of Assembly A we could not do this // yet because it is not garanteed that // Assembly B exists already. Or vice versa) // A.LinkedAssembly = B // B.LinkedAssembly = A Experior.Core.Environment.Diagnostic.Message("This is a sticky diagnostic message in Red", System.Drawing.Color.Red, STICKY); } public override void Reset() { base.Reset(); Experior.Core.Environment.Diagnostic.Message(this.Name, "Diagnostic message : assembly " + this.Name + " is reset"); } public override void Dispose() { base.Dispose(); // unsubscribe to events when disposing Experior.Core.Environment.Scene.Loaded -= Scene_Loaded; Experior.Core.Environment.Scene.Pausing -= Scene_Pausing; Experior.Core.Environment.Scene.Saved -= Scene_Saved; Experior.Core.Environment.Scene.Cleared -= Scene_Cleared; Experior.Core.Environment.Scene.Locking -= Scene_Locking; }