/// <summary>
/// Load the project file and return a SimioProject
/// </summary>
/// <param name="projectFullPath"></param>
private static ISimioProject LoadProject(string projectFullPath, out string explanation)
{
explanation = "";
string marker = "Begin.";
string[] warnings;
try
{
// If File Not Exist, Throw Exeption
if (File.Exists(projectFullPath) == false)
{
explanation = $"Project File={projectFullPath} not found.";
return(null);
}
// Open project file.
marker = "Loading Model";
LogIt($"Info: {marker}");
ISimioProject simioProject = SimioProjectFactory.LoadProject(projectFullPath, out warnings);
foreach (string warning in warnings)
{
LogIt($"Warning: {warning}");
}
return(simioProject);
}
catch (Exception ex)
{
throw new ApplicationException($"Cannot load={projectFullPath} Err={ex}");
}
}
public void crearModeloCarnet()
{
pintarCarnet();
dibujarPath();
// Crea el modelo final
SimioProjectFactory.SaveProject(apiCarnet, rutaFinal, out warnings);
}
/// <summary>
/// Initialize, which means setting the ExtensionsPath and loading the project.
/// If there are warnings, they are placed in LoadWarningsList.
/// </summary>
/// <param name="extensionsPath"></param>
/// <param name="projectFullPath"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public bool Initialize(string extensionsPath, out string explanation)
{
explanation = "";
string marker = "Checking extension and project paths.";
try
{
if (Directory.Exists(extensionsPath) == false)
{
explanation = $"ExtensionsPath={extensionsPath} not found.";
return(false);
}
ExtensionsPath = extensionsPath;
marker = $"Setting extensions path={extensionsPath}";
SimioProjectFactory.SetExtensionsPath(extensionsPath);
return(true);
}
catch (Exception ex)
{
explanation = $"Failed to initialize HeadlessContext. ExtensionsPath={extensionsPath} Err={ex.Message}";
return(false);
}
}
public Form1()
{
proyectoApi = SimioProjectFactory.LoadProject(rutabase, out warnings);
modelo = proyectoApi.Models[1];
intelligentObjects = modelo.Facility.IntelligentObjects;
InitializeComponent();
}
public Form1()
{
APIProject = SimioProjectFactory.LoadProject(rutabase, out warnings);
modelo = APIProject.Models[1];
InteligentObject = modelo.Facility.IntelligentObjects;
InitializeComponent();
}
public void crearModelo()
{
crearRegiones();
//modelo.Facility.IntelligentObjects["Source1"].Properties["InterarrivalTime"].Value = "Random.Exponential(5)";
SimioProjectFactory.SaveProject(proyectoApi, rutafinal, out warnings);
}
public Modelo(string nombreMdlBase, string nombreMdlFinal)
{
this.nombrePryctBase = nombreMdlBase;
this.nombrePryctNuevo = nombreMdlFinal;
modSimioNuevo = SimioProjectFactory.LoadProject(nombrePryctBase, out warnings);
Base.model = modSimioNuevo.Models[(int)Tipo.Model];
}
public ApiSimio(String rbase, String rfinal)
{
rutabase = rbase;
rutafinal = rfinal;
proyectoApi = SimioProjectFactory.LoadProject(rutabase, out warnings);
model = proyectoApi.Models[1];
intelligentObjects = model.Facility.IntelligentObjects;
}
public Objetos()
{
//creamos el constructor de la clase en el cual se creara el proyecto y
// vamos a utilizar el modelo base para poder crear los elementos necesarios
// para la consturccion de los datos correspondientes.
proyectoApi = SimioProjectFactory.LoadProject(rutabase, out warnings);
model = proyectoApi.Models[1];
intelligentObjects = model.Facility.IntelligentObjects;
}
public SimioFile()
{
if (File.Exists(this.outputFile))
{
File.Delete(this.outputFile);
}
SimioProject = SimioProjectFactory.LoadProject(inputFiele, out warnings);
this.model = SimioProject.Models[1];
}
public void CrearCarnets()
{
String carnet1 = "201612097";
String carnet2 = "201612276";
CrearModelo(carnet1, 10, 10);
CrearModelo(carnet2, 10, 40);
SimioProjectFactory.SaveProject(proyectoApi, rutafinal, out warnings);
}
private static void CrearNombreYApellido()
{
try
{
proyectoApi = SimioProjectFactory.LoadProject(BASE, out warnings);
intelligentObjects = proyectoApi.Models[1].Facility.IntelligentObjects;
CrearNombre();
CrearApellido();
SimioProjectFactory.SaveProject(proyectoApi, FINAL_NOMBRE, out warnings);
} catch
{
}
}
/// <summary>
/// Run an experiment. The experiment is Reset prior to run.
/// A loaded project is passed in that must contain the named Model and Experiment.
/// If the saveProjectPath is present and exists, then the project will be
/// saved to that location. If there are Save warnings, then true is still
/// returned, but the warnings are in explanation.
/// </summary>
/// <param name="projectPathAndFile"></param>
/// <param name="experimentName"></param>
/// <param name="saveModelAfterRun"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public static bool RunModelExperiment(ISimioProject project, string saveProjectPath,
string modelName, string experimentName,
out string explanation)
{
explanation = "";
string marker = "Begin";
try
{
marker = $"Loading Model named={modelName}";
IModel model = LoadModel(project, modelName, out explanation);
if (model == null)
{
return(false);
}
marker = $"Loading Experiment named={experimentName}";
if (!RunModelExperiment(model, experimentName, out explanation))
{
throw new ApplicationException($"Cannot Run Experiment={experimentName}. Err={explanation}");
}
// Successful run. Save the project?
if (File.Exists(saveProjectPath))
{
marker = $"Save Project After Experiment Run to={saveProjectPath}";
LogIt($"Info: {marker}");
SimioProjectFactory.SaveProject(project, saveProjectPath, out string[] warnings);
explanation = "";
if (warnings.Any())
{
LogIt($"Warning: 'SaveProject' had {warnings.Length} Warnings:");
int nn = 0;
foreach (string warning in warnings)
{
explanation += $" Warning[{++nn}]:{warning}";
LogIt($" Warning: {warning}");
}
}
}
return(true);
}
catch (Exception ex)
{
throw new ApplicationException($"Marker={marker} Err={ex.Message}");
}
}
public void GenerarMapa()
{
GenerarRegiones();
Generar_Puntos_Cardinales();
Generar_Aeropuertos();
Generar_SalidaAeropuerto();
Generar_Movimientos();
Unir_Entrada_Aeropuertos();
Generar_Turistas_Nacionales();
Generar_Salida_Hacia_Aeropuertos();
Generar_Quedarse_En_Misma_Region();
GenerarContornosGuatemala();
SimioProjectFactory.SaveProject(proyectoApi, rutafinal, out warnings);
}
private void Form1_Load(object sender, EventArgs e)
{
if (File.Exists(_rutaSalida))
{
File.Delete(_rutaSalida);
}
_simioproyecto = SimioProjectFactory.LoadProject(_rutaBase, out warnings);
_modelo = _simioproyecto.Models[1];
//crear();
//guardarModeloSalida();
}
public void crearModelo()
{
//this.principal();
this.crearEntradaSalida();
this.Mesas();
this.Barras();
this.Atencion();
this.nodos();
this.tiemposAtencion();
this.rutas();
//CREACION MODELO
SimioProjectFactory.SaveProject(proyectoApi, rutafinal, out warnings);
MessageBox.Show("El proyecto Simio ha sido generado");
Console.WriteLine("Modelo Creado");
}
public void SetProject(string project, string model, string experiment)
{
// Set extension folder path
//SimioProjectFactory.SetExtensionsPath(Directory.GetCurrentDirectory().ToString());
// Open project
string[] warnings;
currentProject = SimioProjectFactory.LoadProject(project, out warnings);
if (model != null || model != "")
{
SetModel(model);
SetExperiment(experiment);
//return currentProject;
}
//return null;
}
/// <summary>
/// Save the given project to the 'savePath'.
/// </summary>
/// <param name="project"></param>
/// <param name="savePath"></param>
public static bool SaveProject(HeadlessContext context, string savePath, out string explanation)
{
explanation = "";
string marker = "Begin.";
string[] warnings;
// If project not loaded, return error
if (context == null || context.CurrentProject == null)
{
explanation = $"Context or Project is null.";
return(false);
}
string folderPath = Path.GetDirectoryName(savePath);
if (Directory.Exists(folderPath) == false)
{
explanation = $"FolderPath={folderPath} not found.";
return(false);
}
try
{
// Open project file.
marker = $"Saving Project={context.CurrentProject.Name} to {savePath}.";
LogIt($"Info: {marker}");
if (!SimioProjectFactory.SaveProject(context.CurrentProject, savePath, out warnings))
{
LogIt($"SaveProject failed.");
}
marker = $"Saved Project={savePath} with {warnings.Count()} warnings.";
int ii = 1;
foreach (string warning in warnings)
{
LogIt($"Warning: {ii++}{warning}");
}
return(true);
}
catch (Exception ex)
{
explanation = $"Cannot Save Simio Project={context.CurrentProject.Name} to {savePath} Err={ex.Message}";
return(false);
}
}
/// <summary>
/// Save the given project to the 'savePath'.
/// </summary>
/// <param name="project"></param>
/// <param name="savePath"></param>
public bool SaveProject(string savePath, out string explanation)
{
explanation = "";
string marker = "Begin.";
string[] warnings;
// If project not loaded, return error
if (CurrentProject == null)
{
explanation = $"No project is loaded (Project is null).";
return(false);
}
string folderPath = Path.GetDirectoryName(savePath);
if (Directory.Exists(folderPath) == false)
{
explanation = $"FolderPath={folderPath} not found.";
return(false);
}
try
{
// Save project file.
marker = $"Saving Project={CurrentProject.Name} to {savePath}.";
if (!SimioProjectFactory.SaveProject(CurrentProject, savePath, out warnings))
{
explanation = $"SaveProject failed.";
}
marker = $"Saved Project={savePath} with {warnings.Count()} warnings.";
ProjectSaveErrorList = new List <string>();
int ii = 1;
foreach (string warning in warnings)
{
ProjectSaveErrorList.Add($"Warning: {ii++}{warning}");
}
return(true);
}
catch (Exception ex)
{
explanation = $"Cannot Save Simio Project={CurrentProject.Name} to {savePath} Err={ex.Message}";
return(false);
}
}
/// <summary>
/// Initialize, which means setting the ExtensionsPath and loading the project.
/// If there are warnings, they are placed in LoadWarningsList.
/// </summary>
/// <param name="projectFullPath"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public bool LoadProject(string projectFullPath, out string explanation)
{
explanation = "";
string marker = "Checking extension and project paths.";
if (ExtensionsPath == null)
{
explanation = $"Cannot LoadProject with null ExtensionsPath";
return(false);
}
try
{
// If File Not Exist, Throw Exception
if (File.Exists(projectFullPath) == false)
{
explanation = $"Project File={projectFullPath} not found.";
return(false);
}
ProjectPath = projectFullPath;
marker = $"Setting extensions path={ExtensionsPath}";
SimioProjectFactory.SetExtensionsPath(ExtensionsPath); // No harm in doing it again.
// Open project file.
marker = $"Loading Project={projectFullPath}.";
CurrentProject = SimioProjectFactory.LoadProject(projectFullPath, out string[] warnings);
ProjectLoadErrorList = null;
if (warnings.Length > 0)
{
ProjectLoadErrorList = new List <string>();
foreach (string warning in warnings)
{
ProjectLoadErrorList.Add(warning);
}
}
return(true);
}
catch (Exception ex)
{
explanation = $"Failed to LoadProject={projectFullPath} Err={ex.Message}";
return(false);
}
}
/// <summary>
/// Set the extensions path and then Load the project file and return a SimioProject.
/// </summary>
/// <param name="projectFullPath"></param>
public static ISimioProject LoadProject(string extensionsPath, string projectFullPath, out string explanation)
{
explanation = "";
string marker = "Begin.";
string[] warnings;
try
{
// If File Not Exist, Throw Exeption
if (File.Exists(projectFullPath) == false)
{
explanation = $"Project File={projectFullPath} not found.";
return(null);
}
if (Directory.Exists(extensionsPath) == false)
{
explanation = $"ExtensionsPath={extensionsPath} not found.";
return(null);
}
marker = $"Setting extensions path={extensionsPath}";
LogIt($"Info: {marker}");
SimioProjectFactory.SetExtensionsPath(extensionsPath);
// Open project file.
marker = $"Loading Project={projectFullPath}.";
LogIt($"Info: {marker}");
ISimioProject simioProject = SimioProjectFactory.LoadProject(projectFullPath, out warnings);
marker = $"Loaded Project={projectFullPath} with {warnings.Count()} warnings.";
int ii = 1;
foreach (string warning in warnings)
{
LogIt($"Warning: {ii++}{warning}");
}
return(simioProject);
}
catch (Exception ex)
{
throw new ApplicationException($"Cannot load={projectFullPath} Err={ex.Message}");
}
}
public void CreateCards()
{
try
{
System.IO.File.WriteAllBytes(BASE_MODEL_PATH, FileStore.Resource.BaseModel);
ISimioProject project = SimioProjectFactory.LoadProject(BASE_MODEL_PATH, out string[] warnings);
IModel model = project.Models[1];
IIntelligentObjects intelligentObjects = model.Facility.IntelligentObjects;
CreateCarnet201503918(intelligentObjects);
CreateCard201504420(intelligentObjects);
SimioProjectFactory.SaveProject(project, CARD_MODEL_PATH, out warnings);
System.IO.File.WriteAllLines(WARNINGS_FILE_PATH, warnings);
}
catch (Exception e)
{
System.IO.File.WriteAllText(WARNINGS_FILE_PATH, e.Message);
}
}
public void CreateModel(string finalModelPath)
{
try
{
System.IO.File.WriteAllBytes(BASE_MODEL_PATH, FileStore.Resource.BaseModel);
ISimioProject project = SimioProjectFactory.LoadProject(BASE_MODEL_PATH, out string[] warnings);
IModel model = project.Models[1];
IIntelligentObjects intelligentObjects = model.Facility.IntelligentObjects;
CreateMap(intelligentObjects);
CreateShips(intelligentObjects);
CreatePointCardinal(intelligentObjects);
CreateAirports(intelligentObjects);
SimioProjectFactory.SaveProject(project, finalModelPath, out warnings);
System.IO.File.WriteAllLines(WARNINGS_FILE_PATH, warnings);
} catch (Exception e)
{
System.IO.File.WriteAllText(WARNINGS_FILE_PATH, e.Message);
}
}
/// <summary>
/// Run an experiment. The experiment is Reset prior to run.
/// </summary>
/// <param name="extensionsPath"></param>
/// <param name="sourceProjectPath"></param>
/// <param name="saveProjectPath"></param>
/// <param name="experimentName"></param>
/// <param name="modelName"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public static bool RunModelExperiment(string extensionsPath, string sourceProjectPath, string saveProjectPath,
string modelName, string experimentName,
out string explanation)
{
string contextInfo = $"ExtensionsPath={extensionsPath}, ProjectPath={sourceProjectPath}:";
string marker = "Begin.";
try
{
// Set an extensions path to where we can locate User Extensions, etc.
if (string.IsNullOrEmpty(extensionsPath))
{
extensionsPath = System.AppDomain.CurrentDomain.BaseDirectory;
}
marker = $"{contextInfo}. Setting Extensions Path...";
LogIt($"Info: {marker}");
SimioProjectFactory.SetExtensionsPath(extensionsPath);
marker = $"{contextInfo}. Loading Project...";
ISimioProject project = LoadProject(extensionsPath, sourceProjectPath, out explanation);
if (project == null)
{
return(false);
}
marker = $"{contextInfo}. Running Experiment...";
if (RunModelExperiment(project, saveProjectPath, modelName, experimentName, out explanation))
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
explanation = $"Marker={marker} Err={ex.Message}";
return(false);
}
}
private static void CrearCarnet()
{
try
{
proyectoApi = SimioProjectFactory.LoadProject(BASE, out warnings);
intelligentObjects = proyectoApi.Models[1].Facility.IntelligentObjects;
CrearDos(10, 50);
CrearCero(50, 50);
CrearUno(90, 50);
CrearCinco(120, 50);
CrearCero(160, 50);
CrearCuatro(200, 50);
CrearCuatro(240, 50);
CrearDos(280, 50);
CrearCero(320, 50);
SimioProjectFactory.SaveProject(proyectoApi, FINAL_CARNET, out warnings);
}
catch
{
}
}
/// <summary>
/// Run an experiment
/// </summary>
/// <param name="projectPathAndFile"></param>
/// <param name="experimentName"></param>
/// <param name="saveModelAfterRun"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public static bool RunExperiment(string projectFullPath, string modelName, string experimentName, bool saveModelAfterRun, out string explanation)
{
explanation = "";
string marker = "Begin";
try
{
// Set an extensions path to where we can locate User Extensions, etc.
string extensionsPath = System.AppDomain.CurrentDomain.BaseDirectory;
marker = $"Setting Extensions Path to={extensionsPath}";
LogIt($"Info: {marker}");
SimioProjectFactory.SetExtensionsPath(extensionsPath);
marker = $"Loading Project from={projectFullPath}";
ISimioProject project = LoadProject(projectFullPath, out explanation);
if (project == null)
{
return(false);
}
marker = $"Loading Model named={modelName}";
IModel model = LoadModel(project, modelName, out explanation);
if (model == null)
{
return(false);
}
marker = $"Loading Experiment named={experimentName}";
IExperiment experiment = LoadExperiment(model, experimentName, out explanation);
if (experiment == null)
{
return(false);
}
// Create some methods to handle experiment events
experiment.ReplicationEnded += (s, e) =>
{
LogIt($"Info: Event=> Ended Replication={e.ReplicationNumber} of Scenario={e.Scenario.Name}.");
};
experiment.ScenarioEnded += (s, e) =>
{
LogIt($"Info: Event=> Scenario={e.Scenario.Name} Ended.");
};
experiment.RunCompleted += (s, e) =>
{
LogIt($"Info: Event=> Experiment={experiment.Name} Run Complete. ");
};
// Now do the run.
experiment.Reset();
experiment.Run();
//experiment.RunAsync(); // Another option
if (saveModelAfterRun)
{
marker = $"Save Project After Experiment Run to= (SimioProjectFactory.SaveProject)";
LogIt($"Info: {marker}");
string[] warnings;
SimioProjectFactory.SaveProject(project, projectFullPath, out warnings);
foreach (string warning in warnings)
{
LogIt($"Warning: {warning}");
}
}
return(true);
}
catch (Exception ex)
{
throw new ApplicationException($"Marker={marker} Err={ex}");
}
}
/// <summary>
/// Run a model plan
/// </summary>
/// <param name="projectPathAndFile"></param>
/// <param name="modelName"></param>
/// <param name="runRiskAnalysis"></param>
/// <param name="saveModelAfterRun"></param>
/// <param name="publishPlanAfterRun"></param>
/// <param name="explanation"></param>
/// <returns></returns>
public static bool RunModel(string projectFullPath, string modelName, bool runRiskAnalysis, bool saveModelAfterRun, bool publishPlanAfterRun, out string explanation)
{
explanation = "";
string marker = "Begin";
string[] warnings;
try
{
// Set an extensions path to where we can locate User Extensions, etc.
string extensionsPath = System.AppDomain.CurrentDomain.BaseDirectory;
marker = $"Setting Extensions Path to={extensionsPath}";
LogIt($"Info: {marker}");
ISimioProject project = null;
try
{
Cursor.Current = Cursors.WaitCursor;
SimioProjectFactory.SetExtensionsPath(extensionsPath);
project = LoadProject(projectFullPath, out explanation);
if (project == null)
{
return(false);
}
}
catch (Exception ex)
{
explanation = $"Cannot load from {projectFullPath}. Err={ex}";
return(false);
}
finally
{
Cursor.Current = Cursors.Default;
}
IModel model = LoadModel(project, modelName, out explanation);
if (model == null)
{
return(false);
}
// Check for Plan
if (model.Plan == null)
{
explanation = $"Model={model.Name} has no Plan.";
return(false);
}
// Start Plan
marker = "Starting Plan (model.Plan.RunPlan)";
LogIt($"Info: {marker}");
model.Plan.RunPlan();
if (runRiskAnalysis)
{
marker = "Plan Finished...Starting Analyze Risk (model.Plan.RunRiskAnalysis)";
LogIt($"Info: {marker}");
model.Plan.RunRiskAnalysis();
}
if (saveModelAfterRun)
{
marker = "Save Project After Schedule Run (SimioProjectFactory.SaveProject)";
LogIt($"Info: {marker}");
SimioProjectFactory.SaveProject(project, projectFullPath, out warnings);
}
if (publishPlanAfterRun)
{
marker = "PublishPlan";
LogIt($"Info: {marker}");
// ADD PUBLISH PLAN CODE HERE
}
marker = "End";
return(true);
}
catch (Exception ex)
{
explanation = $"Project={projectFullPath} Model={modelName} Marker={marker} Err={ex.Message}";
Alert(explanation);
return(false);
}
} // RunModel
public void saveFile()
{
SimioProjectFactory.SaveProject(SimioProject, this.outputFile, out warnings);
}
public void crearModelo()
{
pintarBasicNode();
pintarServer();
actualizarObjetos();
dibujarRuta();
modificarRegiones();
//Source de la Fuerza Armada
crearSource("Source", "FuerzaArmada", -8.75, -81);
cambioNombre("Source1", "FuerzaArmada");
crearModelEntyty("ModelEntity", "avion", -4.356, -78.731);
cambioNombre("ModelEntity1", "avion");
modificarPropiedades("FuerzaArmada", "InterarrivalTime", "15");
modificarPropiedades("FuerzaArmada", "MaximumArrivals", "15");
modificarPropiedades("FuerzaArmada", "EntityType", "avion");
crearSource("Source", "IN_AERO_La_Aurora", 0, 10);
cambioNombre("Source1", "IN_AERO_La_Aurora");
crearModelEntyty("ModelEntity", "turista", 0, 15);
cambioNombre("ModelEntity1", "turista");
modificarPropiedades("IN_AERO_La_Aurora", "InterarrivalTime", "Random.Exponential(35)");
modificarPropiedades("IN_AERO_La_Aurora", "EntitiesPerArrival", "70");
modificarPropiedades("IN_AERO_La_Aurora", "EntityType", "turista");
crearSource("Source", "InMetropolitana", 0, 5);
cambioNombre("Source1", "InMetropolitana");
modificarPropiedades("InMetropolitana", "InterarrivalTime", "Random.Poisson(2)");
modificarPropiedades("InMetropolitana", "EntityType", "turista");
crearBasicNode("BasicNode", "BM", 0, 8);
cambioNombre("BasicNode1", "BM");
crearSink("Sink", "OutMetropolitana", -3, 8);
cambioNombre("Sink1", "OutMetropolitana");
crearSource("Source", "IN_AERO_Mundo_Maya", 10, -60);
cambioNombre("Source1", "IN_AERO_Mundo_Maya");
modificarPropiedades("IN_AERO_Mundo_Maya", "InterarrivalTime", "Random.Exponential(35)");
modificarPropiedades("IN_AERO_Mundo_Maya", "EntitiesPerArrival", "40");
modificarPropiedades("IN_AERO_Mundo_Maya", "EntityType", "turista");
crearSource("Source", "InPeten", 10, -55);
cambioNombre("Source1", "InPeten");
modificarPropiedades("InPeten", "InterarrivalTime", "Random.Poisson(4)");
modificarPropiedades("InPeten", "EntityType", "turista");
crearSource("Source", "IN_AERO_Quetzal", -40, 20);
cambioNombre("Source1", "IN_AERO_Quetzal");
modificarPropiedades("IN_AERO_Quetzal", "InterarrivalTime", "Random.Exponential(35)");
modificarPropiedades("IN_AERO_Quetzal", "EntitiesPerArrival", "30");
modificarPropiedades("IN_AERO_Quetzal", "EntityType", "turista");
crearSource("Source", "InSurOccidente", -40, 15);
cambioNombre("Source1", "InSurOccidente");
modificarPropiedades("InSurOccidente", "InterarrivalTime", "Random.Poisson(4)");
modificarPropiedades("InSurOccidente", "EntityType", "turista");
crearSource("Source", "InSurOriente", 15, 25);
cambioNombre("Source1", "InSurOriente");
modificarPropiedades("InSurOriente", "InterarrivalTime", "Random.Poisson(10)");
modificarPropiedades("InSurOriente", "EntityType", "turista");
crearSource("Source", "InNorOriente", 30, -5);
cambioNombre("Source1", "InNorOriente");
modificarPropiedades("InNorOriente", "InterarrivalTime", "Random.Poisson(6)");
modificarPropiedades("InNorOriente", "EntityType", "turista");
crearSource("Source", "InNorte", 5, -15);
cambioNombre("Source1", "InNorte");
modificarPropiedades("InNorte", "InterarrivalTime", "Random.Poisson(8)");
modificarPropiedades("InNorte", "EntityType", "turista");
crearSource("Source", "InCentral", -15, 25);
cambioNombre("Source1", "InCentral");
modificarPropiedades("InCentral", "InterarrivalTime", "Random.Poisson(3)");
modificarPropiedades("InCentral", "EntityType", "turista");
crearSource("Source", "InNorOccidente", -50, -20);
cambioNombre("Source1", "InNorOccidente");
modificarPropiedades("InNorOccidente", "InterarrivalTime", "Random.Poisson(12)");
modificarPropiedades("InNorOccidente", "EntityType", "turista");
crearLink("Conveyor", getNodoServer("FuerzaArmada", 0), getNodo("Pto6", 1));
crearLink("Path", getNodoServer("IN_AERO_La_Aurora", 0), getNodo("BM", 1));
cambioNombre("Path1", "InAurora");
crearLink("Path", getNodo("BM", 1), getNodoServer("Metropolitana", 0));
modificarPropiedades("Path1", "SelectionWeight", "0.5");
noPath++;
rutasRegiones();
// Crea el modelo final
llenarCarnet.crearModeloCarnet();
SimioProjectFactory.SaveProject(practica4, rutaFinal, out warnings);
}
public llenarCarnet()
{
apiCarnet = SimioProjectFactory.LoadProject(ruta, out warnings);
model = apiCarnet.Models[1];
intelligentObjects = model.Facility.IntelligentObjects;
}
