public SimulationResults CreateResultsFrom(DataRepository dataRepository)
{
if (dataRepository.IsNull())
{
return(new NullSimulationResults());
}
var results = new SimulationResults();
var baseGrid = dataRepository.BaseGrid;
results.Time = valuesFrom(baseGrid);
foreach (var columnsForIndividual in dataRepository.AllButBaseGrid().GroupBy(selectIndividualIndex))
{
var individualResults = new IndividualResults {
IndividualId = columnsForIndividual.Key, Time = results.Time
};
foreach (var dataColumn in columnsForIndividual)
{
individualResults.Add(valuesFrom(dataColumn, pathWithoutIndividualIndex(dataColumn, columnsForIndividual.Key)));
}
individualResults.UpdateQuantityTimeReference();
results.Add(individualResults);
}
return(results);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <ISimulation>();
_runResults = A.Fake <SimulationResults>();
var outputSelections = new OutputSelections();
outputSelections.AddOutput(new QuantitySelection("Liver|Cell|Drug|Concentration", QuantityType.Drug));
A.CallTo(() => _simulation.OutputSelections).Returns(outputSelections);
var pKCalculationOptions = new PKCalculationOptions();
A.CallTo(_pkCalculationOptionsFactory).WithReturnType <PKCalculationOptions>().Returns(pKCalculationOptions);
_p1 = new PKParameter().WithName("AUC");
_p1.Mode = PKParameterMode.Single;
_p2 = new PKParameter().WithName("AUC" + Constants.PKParameters.NormSuffix);
_p2.Mode = PKParameterMode.Single;
A.CallTo(() => _pkParameterRepository.All()).Returns(new[] { _p1, _p2 });
var individualResults = A.Fake <IndividualResults>();
A.CallTo(() => _runResults.AllIndividualResults).Returns(new HashSet <IndividualResults>(new [] { individualResults }));
var pKValues = new PKValues();
pKValues.AddValue(_p1.Name, 10f);
pKValues.AddValue(_p2.Name, 20f);
A.CallTo(_pkValuesCalculator).WithReturnType <PKValues>().Returns(pKValues);
}
protected override void Context()
{
base.Context();
_newName = "TOTO";
_f1 = new ExplicitFormula("A+B");
_f2 = new ExplicitFormula("A+B");
_f3 = new ExplicitFormula("A+B");
_f1.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell"));
_f1.AddObjectPath(new FormulaUsablePath("Drug", "LogP"));
_f2.AddObjectPath(new FormulaUsablePath("SU", "Liver", "Cell"));
_f2.AddObjectPath(new FormulaUsablePath("Drug", "LogP"));
_f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell"));
_f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "LogP"));
var p1 = new PKSimParameter().WithName("P1").WithFormula(_f1);
var p2 = new PKSimParameter().WithName("P2").WithFormula(_f2);
var p3 = new PKSimParameter().WithName("P3").WithFormula(_f3);
var c1 = new Container().WithName("C1");
c1.Add(p3);
_root.Add(p1);
_root.Add(p2);
_root.Add(c1);
var results = new SimulationResults {
Time = new QuantityValues {
ColumnId = "0", QuantityPath = "baseGrid"
}
};
_individualResults = new IndividualResults {
IndividualId = 1
};
results.Add(_individualResults);
var quantityCache = new PathCacheForSpecs <IQuantity>
{
{ "Liver|Cell|Drug", new MoleculeAmount {
QuantityType = QuantityType.Drug
} },
{ "Liver|Cell|Meta", new MoleculeAmount {
QuantityType = QuantityType.Metabolite
} },
};
_individualResults.Add(new QuantityValues {
PathList = new[] { "Liver", "Cell", "Drug" }.ToList()
});
_individualResults.Add(new QuantityValues {
PathList = new[] { "Liver", "Cell", "Meta" }.ToList()
});
_individualSimulation.Results = results;
_individualSimulation.DataRepository = new DataRepository();
_individualSimulation.Reactions = new ReactionBuildingBlock();
_individualSimulation.SimulationSettings = new SimulationSettings();
A.CallTo(_containerTask).WithReturnType <PathCache <IQuantity> >().Returns(quantityCache);
A.CallTo(() => _curveNamer.RenameCurvesWithOriginalNames(_individualSimulation, A <Action> ._, true)).Invokes(x => x.Arguments[1].DowncastTo <Action>()());
}
private SimulationResults createResultsFrom(DataRepository dataRepository, ISimModelBatch simModel, string[] parameters)
{
if (dataRepository.IsNull() || dataRepository.BaseGrid == null)
{
return(new NullSimulationResults());
}
var results = new SimulationResults {
Time = valuesFrom(dataRepository.BaseGrid, null, new string[] { })
};
foreach (var columnsForIndividual in dataRepository.AllButBaseGrid().GroupBy(selectIndividualIndex))
{
var individualResults = new IndividualResults {
IndividualId = columnsForIndividual.Key, Time = results.Time
};
foreach (var dataColumn in columnsForIndividual)
{
individualResults.Add(valuesFrom(dataColumn, pathWithoutIndividualIndex(dataColumn, columnsForIndividual.Key), simModel, parameters));
}
individualResults.UpdateQuantityTimeReference();
results.Add(individualResults);
}
return(results);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <ISimulation>();
_runResults = A.Fake <SimulationResults>();
var outputSelections = new OutputSelections();
outputSelections.AddOutput(new QuantitySelection("Liver|Cell|Drug|Concentration", QuantityType.Drug));
A.CallTo(() => _simulation.OutputSelections).Returns(outputSelections);
var pKCalculationOptions = new PKCalculationOptions();
A.CallTo(_pkCalculationOptionsFactory).WithReturnType <PKCalculationOptions>().Returns(pKCalculationOptions);
_p1 = new PKParameter {
Name = "AUC", Mode = PKParameterMode.Single
};
_userDefinedParameter1 = new UserDefinedPKParameter {
Name = "Dynamic1", Mode = PKParameterMode.Single
};
A.CallTo(() => _pkParameterRepository.All()).Returns(new[] { _p1, _userDefinedParameter1 });
var individualResults = A.Fake <IndividualResults>();
A.CallTo(() => _runResults.AllIndividualResults).Returns(new HashSet <IndividualResults>(new[] { individualResults }));
var pKValues = new PKValues();
pKValues.AddValue(_p1.Name, 10f);
pKValues.AddValue(_userDefinedParameter1.Name, 30f);
A.CallTo(_pkValuesCalculator).WithReturnType <PKValues>().Returns(pKValues);
}
protected override void Context()
{
_dataFactory = A.Fake <IDataFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new DataRepositoryFromResultsCreator(_dimensionRepository, new ObjectPathFactoryForSpecs(), _dataFactory);
_simulation = new IndividualSimulation().WithName("S");
_simulation.Model = new OSPSuite.Core.Domain.Model();
var root = new Container().WithContainerType(ContainerType.Simulation).WithName(_simulation.Name);
_simulation.Model.Root = root;
var liver = new Container().WithName("LIVER");
liver.Add(new Observer().WithName("C"));
var kidney = new Container().WithName("KIDNEY");
kidney.Add(new Observer().WithName("C"));
root.Add(liver);
root.Add(kidney);
_simulationResults = new SimulationResults();
_simulation.Results = _simulationResults;
_timeValues = new QuantityValues {
QuantityPath = "Time", Values = new[] { 1f, 2f, 3f }
};
_simulationResults.Time = _timeValues;
_individualResults = new IndividualResults();
_individualResults.Add(new QuantityValues {
QuantityPath = "LIVER|C", Time = _timeValues, Values = new[] { 10f, 20f, 30f }
});
_individualResults.Add(new QuantityValues {
QuantityPath = "KIDNEY|C", Time = _timeValues, Values = new[] { 11f, 22f, 33f }
});
}
public SetPopulationSimulationResultsCommand(PopulationSimulation populationSimulation, SimulationResults simulationResults)
{
_populationSimulation = populationSimulation;
_simulationResults = simulationResults;
ObjectType = PKSimConstants.ObjectTypes.Simulation;
CommandType = PKSimConstants.Command.CommandTypeEdit;
Description = PKSimConstants.Command.SetPopulationSimulationResultsCommandDescription(populationSimulation.Name);
}
protected override void Context()
{
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_pkValuesCalculator = A.Fake <IPKValuesCalculator>();
_pkParameterRepository = A.Fake <IPKParameterRepository>();
_pkCalculationOptionsFactory = A.Fake <IPKCalculationOptionsFactory>();
_entityPathResolver = A.Fake <IEntityPathResolver>();
_pkMapper = A.Fake <IPKValuesToPKAnalysisMapper>();
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new PKAnalysesTask(_lazyLoadTask, _pkValuesCalculator, _pkParameterRepository, _pkCalculationOptionsFactory, _entityPathResolver, _pkMapper, _dimensionRepository);
_populationSimulation = A.Fake <PopulationSimulation>();
_outputSelections = new OutputSelections();
A.CallTo(() => _populationSimulation.OutputSelections).Returns(_outputSelections);
_allBodyWeights = new List <double>();
_bodyWeight = A.Fake <IParameter>();
var bodyWeightPath = "PATH";
A.CallTo(() => _populationSimulation.BodyWeight).Returns(_bodyWeight);
A.CallTo(() => _entityPathResolver.PathFor(_bodyWeight)).Returns(bodyWeightPath);
A.CallTo(() => _populationSimulation.AllValuesFor(bodyWeightPath)).Returns(_allBodyWeights);
A.CallTo(() => _populationSimulation.NumberOfItems).Returns(2);
_individualResult0 = new IndividualResults {
IndividualId = 0, Time = new QuantityValues {
Values = new[] { 1f, 2f }
}
};
_individualResult0.Add(new QuantityValues {
QuantityPath = _quantityPath1, Values = new[] { 10f, 20f }
});
_individualResult0.Add(new QuantityValues {
QuantityPath = _quantityPath2, Values = new[] { 11f, 21f }
});
_individualResult1 = new IndividualResults {
IndividualId = 1, Time = new QuantityValues {
Values = new[] { 3f, 4f }
}
};
_individualResult1.Add(new QuantityValues {
QuantityPath = _quantityPath1, Values = new[] { 30f, 40f }
});
_individualResult1.Add(new QuantityValues {
QuantityPath = _quantityPath2, Values = new[] { 31f, 41f }
});
_simulationResults = new SimulationResults {
_individualResult0, _individualResult1
};
_populationSimulation.Results = _simulationResults;
_pkParameter1 = new PKParameter {
Mode = PKParameterMode.Always, Name = "Cmax"
};
_pkParameter2 = new PKParameter {
Mode = PKParameterMode.Always, Name = "tMax"
};
A.CallTo(() => _pkParameterRepository.All()).Returns(new[] { _pkParameter1, _pkParameter2 });
}
private void updateFromImportedResults(SimulationResultsImport importResults)
{
_simulationResults = importResults.SimulationResults;
_importSimulationResultsDTO.Clear();
importResults.SimulationResultsFiles.Each(f => _importSimulationResultsDTO.AddFile(SimulationResultsFileSelectionDTO.From(f)));
_importSimulationResultsDTO.Status = importResults.Status;
_importSimulationResultsDTO.Messages = importResults.Log;
rebind();
}
public override void Process()
{
foreach (var simulation in List)
{
simulation.SetEnvironment(Environment);
simulation.Process();
SimulationResults.AddRange(simulation.SimulationResults);
}
}
public override void InitializeIteration()
{
foreach (var simulation in List)
{
simulation.InitializeIteration();
}
SimulationResults.Clear();
}
//------------------------------------------------------
public void BuildAnnualParameterStream(WaterSimManagerClass WSIM, SimulationResults SimRes, string fldname, string fieldlabel, bool start)
{
if (start)
{
StreamW(@"Outputs\\"); StreamW1(@"Outputs\\"); StreamW2(@"Outputs\\"); StreamW3(@"Outputs\\");
}
//if (fldname == "POP_P") { StreamW(@"Outputs\\"); StreamW1(@"Outputs\\"); StreamW2(@"Outputs\\"); StreamW3(@"Outputs\\"); }
BuildAnnualParameterStream(WSIM, SimRes, fldname, fieldlabel, null);
}
public override void ViewChanged()
{
if (IsLatched)
{
return;
}
_simulationResults = new NullSimulationResults();
updateButtonState();
base.ViewChanged();
}
protected override void Context()
{
base.Context();
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation
});
_userDefinedPKParameter =
_pkParameterTask.CreateUserDefinedPKParameter("MyCmax", StandardPKParameter.C_max, displayName: null, displayUnit: "mg/l");
_pkParameterTask.AddUserDefinedPKParameter(_userDefinedPKParameter);
}
protected override void Because()
{
var simulationBatchRunValues = new SimulationBatchRunValues
{
InitialValue = 10.0,
ParameterValue = 3.0
};
_results = sut.Run(simulationBatchRunValues);
}
protected override void Context()
{
base.Context();
var simulationRunner = Api.GetSimulationRunner();
_results = simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation
});
_csvFile = FileHelper.GenerateTemporaryFileName();
}
private BaseGrid timeColumnFrom(SimulationResults simulationResults)
{
var time = simulationResults.Time;
return(new BaseGrid(dataColumnIdFrom(time), Constants.TIME, _dimensionRepository.Time)
{
QuantityInfo = new QuantityInfo(new[] { Constants.TIME }, QuantityType.Time),
Values = time.Values
});
}
protected override void Context()
{
base.Context();
_newName = "TOTO";
_f1 = new ExplicitFormula("A+B");
_f2 = new ExplicitFormula("A+B");
_f3 = new ExplicitFormula("A+B");
_f1.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell"));
_f1.AddObjectPath(new FormulaUsablePath("Drug", "LogP"));
_f2.AddObjectPath(new FormulaUsablePath("SU", "Liver", "Cell"));
_f2.AddObjectPath(new FormulaUsablePath("Drug", "LogP"));
_f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell"));
_f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "LogP"));
var p1 = new PKSimParameter().WithName("P1").WithFormula(_f1);
var p2 = new PKSimParameter().WithName("P2").WithFormula(_f2);
var p3 = new PKSimParameter().WithName("P3").WithFormula(_f3);
var c1 = new Container().WithName("C1");
c1.Add(p3);
_root.Add(p1);
_root.Add(p2);
_root.Add(c1);
var results = new SimulationResults {
Time = new QuantityValues {
ColumnId = "0", QuantityPath = "baseGrid"
}
};
_individualResults = new IndividualResults {
IndividualId = 1
};
results.Add(_individualResults);
var quantityCache = new PathCacheForSpecs <IQuantity>
{
{ "Liver|Cell|Drug", new MoleculeAmount {
QuantityType = QuantityType.Drug
} },
{ "Liver|Cell|Meta", new MoleculeAmount {
QuantityType = QuantityType.Metabolite
} },
};
_individualResults.Add(new QuantityValues {
PathList = new[] { "Liver", "Cell", "Drug" }.ToList()
});
_individualResults.Add(new QuantityValues {
PathList = new[] { "Liver", "Cell", "Meta" }.ToList()
});
_individualSimulation.Results = results;
A.CallTo(_containerTask).WithReturnType <PathCache <IQuantity> >().Returns(quantityCache);
}
public override void GlobalContext()
{
base.GlobalContext();
var populationFile = HelperForSpecs.DataFile("pop_5_sparse_id.csv");
var populationTask = Api.GetPopulationTask();
_population = populationTask.ImportPopulation(populationFile);
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation, Population = _population
});
}
protected override void Context()
{
base.Context();
_populationSimulation = A.Fake <PopulationSimulation>();
_simulationResults = new SimulationResults();
_importSimulationResultsPresenter = A.Fake <IImportSimulationResultsPresenter>();
A.CallTo(() => _applicationController.Start <IImportSimulationResultsPresenter>()).Returns(_importSimulationResultsPresenter);
A.CallTo(() => _importSimulationResultsPresenter.ImportResultsFor(_populationSimulation)).Returns(_simulationResults);
A.CallTo(() => _buildingBlockTask.AddCommandToHistory(A <IPKSimCommand> ._))
.Invokes(x => _command = x.GetArgument <IPKSimCommand>(0));
}
protected override void Context()
{
base.Context();
var simulationFile = HelperForSpecs.DataFile("multiple_dosing.pkml");
var simulationPersister = Api.GetSimulationPersister();
_simulation = simulationPersister.LoadSimulation(simulationFile);
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation
});
}
/// <summary>
/// Remove an agent with all the relations
/// </summary>
/// <param name="agent"></param>
public void RemoveAgent(DeepRLAgentParameters agent)
{
ClearAgent(agent);
Experiences.RemoveRange(Experiences.Where(e => e.AgentId == agent.Id));
SimulationResults.RemoveRange(SimulationResults.Where(e => e.AgentId == agent.Id));
Entry(agent).Reference(a => a.StockExchange).Load();
StockExchangeParameters.Remove(agent.StockExchange);
DeepRLAgentParameters.Remove(agent);
}
public void TestExecuteModel()
{
ModelInfo modelInfo = compartments.Program.LoadModel("resources\\testmodel.emodl");
const int runs = 10;
const int samples = 250;
SimulationResults results = compartments.Program.ExecuteModel(modelInfo, "SSA", 1825.0f, runs, samples);
Assert.AreEqual(runs * 2, results.Labels.Length);
Assert.AreEqual("Susceptible{0}", results.Labels[0]);
Assert.AreEqual(runs * 2, results.Data.Length);
Assert.AreEqual(samples, results.Data[0].Length);
}
///-------------------------------------------------------------------------------------------------
/// <summary> Initializes the data. </summary>
/// <param name="Years"> The years. </param>
/// <param name="StartYear"> the AnnualSimulationResults . </param>
/// <param name="SimResults"> The simulation results. </param>
/// <param name="IncludeAggregates"> true to include, false to exclude the aggregates. </param>
///-------------------------------------------------------------------------------------------------
internal void initializeData(int Years, int StartYear, ref SimulationResults SimResults, bool IncludeAggregates)
{
if ((SimResults != null) && (Years == (SimResults.LastYear - SimResults.StartYear) + 1))
// if not new then zero it out from last use Added 5 22 12
{
// Only supporting Aggregates in Output right now
ProviderIntArray OutBlank = new ProviderIntArray(0, IncludeAggregates);
ProviderIntArray InBlank = new ProviderIntArray(0, false);
for (int yr = 0; yr < Years; yr++)
{
AnnualSimulationResults TheASR = SimResults[yr];
int cnt = 0;
cnt = ParamManager.NumberOfParameters(modelParamtype.mptOutputBase);
for (int parmi = 0; parmi < cnt; parmi++)
{
TheASR.Outputs.BaseOutput[parmi] = 0;
TheASR.Outputs.BaseOutputModelParam[parmi] = -1;
}
cnt = 0;
cnt = ParamManager.NumberOfParameters(modelParamtype.mptOutputProvider);
for (int parmi = 0; parmi < cnt; parmi++)
{
TheASR.Outputs.ProviderOutput[parmi] = OutBlank;
TheASR.Outputs.ProviderOutputModelParam[parmi] = -1;
}
cnt = 0;
cnt = ParamManager.NumberOfParameters(modelParamtype.mptInputBase);
for (int parmi = 0; parmi < cnt; parmi++)
{
TheASR.Inputs.BaseInput[parmi] = 0;
TheASR.Inputs.BaseInputModelParam[parmi] = -1;
}
cnt = 0;
cnt = ParamManager.NumberOfParameters(modelParamtype.mptInputProvider);
for (int parmi = 0; parmi < cnt; parmi++)
{
TheASR.Inputs.ProviderInput[parmi] = InBlank;
TheASR.Inputs.ProviderInputModelParam[parmi] = -1;
}
}
}
else
{
SimResults = new SimulationResults(Years, StartYear,
ParamManager.NumberOfParameters(modelParamtype.mptOutputBase),
ParamManager.NumberOfParameters(modelParamtype.mptOutputProvider),
ParamManager.NumberOfParameters(modelParamtype.mptInputBase),
ParamManager.NumberOfParameters(modelParamtype.mptInputProvider),
IncludeAggregates);
}
}
protected override void UpdateLocalContext(SirContext localContext)
{
var todayCensus = (SirDailyRecord)SimulationResults.Result(Day);
localContext.SusceptibleTotal = todayCensus.S;
localContext.ExposedTotal = todayCensus.E;
localContext.InfectiousTotal = todayCensus.I;
localContext.ResistantTotal = todayCensus.R;
localContext.N = todayCensus.N;
localContext.ProbabilityOfInfection = localContext.BetaParam * localContext.InfectiousTotal / localContext.N;
}
public void ExportResultsToCSV(SimulationResults simulationResults, IModelCoreSimulation simulation, string csvFile)
{
if (simulationResults.IsNull() || simulationResults.Count == 0)
{
_logger.AddWarning(Error.NoResultsAvailableForExportToCSV);
return;
}
var dataTable = _simulationResultsToDataTableConverter.ResultsToDataTable(simulationResults, simulation);
dataTable.ExportToCSV(csvFile);
}
protected override void Context()
{
_pkAnalysisTask = A.Fake <ISensitivityAnalysisPKAnalysesTask>();
sut = new SensitivityAnalysisRunResultCalculator(_pkAnalysisTask);
_pkAnalyses = new PopulationSimulationPKAnalyses();
_sensitivityAnalysis = new SensitivityAnalysis();
_variationData = new VariationData();
_simulationResults = new SimulationResults();
A.CallTo(_pkAnalysisTask).WithReturnType <PopulationSimulationPKAnalyses>().Returns(_pkAnalyses);
}
int[] grabBaseDataByYear(SimulationResults SR, ModelParameterClass MP)
{
int ArrayLength = SR.Length;
int[] TheData = new int[ArrayLength];
int DataIndex = SR[0].GetParmIndex(MP);
for (int i = 0; i < ArrayLength; i++)
{
TheData[i] = grabParmBaseData(SR[i], MP.ParamType, DataIndex);
}
return(TheData);
}
public override void GlobalContext()
{
base.GlobalContext();
var populationFile = HelperForSpecs.DataFile("pop_5.csv");
var populationTask = Api.GetPopulationTask();
_population = populationTask.ImportPopulation(populationFile);
//negative volumes ensures that we have one simulation crashing
_population.SetValues("Organism|Liver|Volume", new[] { 2.3, 2.3, 2.3, 2.3, -10 });
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation, Population = _population
});
}
public ActionResult Simulate(String motor)
{
SimulationResults results = new SimulationResults();
List <List <Double> > speed = graphs.InputSpeedTrace;
List <List <Double> > torque = graphs.InputTorqueTrace;
double sample1 = speed[0][1] - speed[0][0];
double sample2 = torque[0][1] - torque[0][0];
if (sample1 != sample2)
{
return(Json(new { zoh = false, sm = false }, JsonRequestBehavior.AllowGet));
}
else
{
int speed_size = speed[0].Count;
int torque_size = torque[0].Count;
bool zohused = false;
if (speed_size > torque_size)
{
double zoh = torque[1][torque_size - 1];
for (int i = torque_size; i < speed_size; i++)
{
torque[0].Add(speed[0][i]);
torque[1].Add(zoh);
}
zohused = true;
}
if (torque_size > speed_size)
{
double zoh = speed[1][speed_size - 1];
for (int i = speed_size; i < torque_size; i++)
{
speed[0].Add(torque[0][i]);
speed[1].Add(zoh);
}
zohused = true;
}
List <List <List <double> > > output = results.startSimulation(motor, speed, torque, speed_size);
graphs.OutputCurrentTrace = output[0];
graphs.OutputSpeedTrace = output[1];
graphs.OutputRefSpeedTrace = output[2];
graphs.OutputTorqueTrace = output[3];
graphs.OutputRefTorqueTrace = output[4];
graphs.OutputVoltageTrace = output[5];
return(Json(new { zoh = zohused, sm = true }, JsonRequestBehavior.AllowGet));
}
}
