/// <summary>
/// The sub step relative to the mouse position
/// </summary>
/// <returns></returns>
private SubStep SubStepRelatedToMousePosition()
{
SubStep retVal = null;
ModelEvent evt = GetEventUnderMouse();
if (evt != null && evt.Instance != null)
{
retVal = EnclosingFinder <SubStep> .find(evt.Instance as IEnclosed, true);
if (retVal == null)
{
Step step = evt.Instance as Step;
if (step != null && step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
}
if (retVal == null && Steps != null && Steps.Count > 0)
{
Step step = (Step)Steps[Steps.Count - 1];
if (step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
return(retVal);
}
/// <summary>
/// Executes the action
/// </summary>
/// <param name="e"></param>
protected override void OnClick(EventArgs e)
{
Step newStep = (Step)acceptor.getFactory().createStep();
newStep.Enclosing = TimeLineControl.TestCase;
SubStep subStep = (SubStep)acceptor.getFactory().createSubStep();
subStep.Name = "Substep 1";
newStep.appendSubSteps(subStep);
TestCase testCase = GetTestCase();
if (Step != null)
{
newStep.Name = "NewStep";
int index = TimeLineControl.Steps.IndexOf(Step);
testCase.Steps.Insert(index + 1, newStep);
newStep.setFather(testCase);
}
else
{
newStep.Name = "Step " + (TimeLineControl.Steps.Count + 1);
testCase.Steps.Add(newStep);
newStep.setFather(testCase);
}
base.OnClick(e);
}
/// <summary>
/// Adds a step after this one
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void AddSubStepHandler(object sender, EventArgs args)
{
DataDictionary.Tests.SubStep subStep = (DataDictionary.Tests.SubStep)DataDictionary.Generated.acceptor.getFactory().createSubStep();
subStep.Name = "Sub-step" + (Nodes.Count + 1);
subStep.Enclosing = Item;
createSubStep(subStep);
}
/// <summary>
/// Adds a step after this one
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void AddSubStepHandler(object sender, EventArgs args)
{
SubStep subStep = (SubStep)acceptor.getFactory().createSubStep();
subStep.Name = "Sub-step" + Nodes.Count;
subStep.Enclosing = Item;
Item.appendSubSteps(subStep);
}
/// <summary>
/// Creates an expectation in a sub step
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected Expectation CreateExpectation(SubStep enclosing, string name)
{
Expectation retVal = (Expectation)Factory.createExpectation();
enclosing.appendExpectations(retVal);
retVal.ExpressionText = name;
return(retVal);
}
/// <summary>
/// Creates a step in a test case
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected SubStep CreateSubStep(Step enclosing, string name)
{
SubStep retVal = (SubStep)Factory.createSubStep();
enclosing.appendSubSteps(retVal);
retVal.Name = name;
return(retVal);
}
/// <summary>
/// Creates a new sub-step
/// </summary>
/// <param name="testCase"></param>
/// <returns></returns>
public SubStepTreeNode createSubStep(DataDictionary.Tests.SubStep subStep)
{
SubStepTreeNode retVal = new SubStepTreeNode(subStep);
Item.appendSubSteps(subStep);
Nodes.Add(retVal);
return(retVal);
}
/// <summary>
/// Executes the action
/// </summary>
/// <param name="e"></param>
protected override void OnClick(EventArgs e)
{
if (SubStep != null)
{
Expectation expectation = (Expectation)acceptor.getFactory().createExpectation();
expectation.Name = "";
SubStep.appendExpectations(expectation);
}
base.OnClick(e);
}
/// <summary>
/// Executes the action
/// </summary>
/// <param name="e"></param>
protected override void OnClick(EventArgs e)
{
if (SubStep != null)
{
Action action = (Action)acceptor.getFactory().createAction();
action.Name = "";
SubStep.appendActions(action);
}
base.OnClick(e);
}
/// <summary>
/// Positions a substep in the time line
/// </summary>
/// <param name="currentTime"></param>
/// <param name="subStep"></param>
/// <returns></returns>
private void PositionSubStep(double currentTime, SubStep subStep)
{
SubStepActivated subStepActivated = new SubStepActivated(subStep, null)
{
Time = currentTime
};
PositionHandler.RegisterEvent(subStepActivated);
foreach (Action action in subStep.Actions)
{
VariableUpdate variableUpdate = new VariableUpdate(action, action, null);
PositionHandler.RegisterEvent(variableUpdate);
}
foreach (Expectation expectation in subStep.Expectations)
{
Expect expect = new Expect(expectation, null);
PositionHandler.RegisterEvent(expect);
}
}
/// <summary>
/// Splits the selected action to several sub-actions
/// </summary>
public virtual void SplitHandler(object sender, EventArgs args)
{
DataDictionary.Interpreter.Statement.Statement statement = Item.EFSSystem.Parser.Statement(Item, Item.ExpressionText);
DataDictionary.Interpreter.Statement.VariableUpdateStatement variableUpdateStatement = statement as DataDictionary.Interpreter.Statement.VariableUpdateStatement;
if (variableUpdateStatement != null)
{
DataDictionary.Interpreter.Expression expression = variableUpdateStatement.Expression;
DataDictionary.Interpreter.StructExpression structExpression = expression as DataDictionary.Interpreter.StructExpression;
if (structExpression != null)
{
Dictionary <string, DataDictionary.Interpreter.Expression> associations = structExpression.Associations;
foreach (KeyValuePair <string, DataDictionary.Interpreter.Expression> value in associations)
{
DataDictionary.Rules.Action action = (DataDictionary.Rules.Action)DataDictionary.Generated.acceptor.getFactory().createAction();
action.Expression = structExpression.Structure.ToString() + "." + value.Key + " <- " + value.Value.ToString();
string aString = value.Value.ToString();
ActionTreeNode actionTreeNode = new ActionTreeNode(action);
BaseTreeNode parent = Parent as BaseTreeNode;
if ((parent != null) && (parent.Nodes != null))
{
DataDictionary.Rules.RuleCondition ruleCondition = Item.Enclosing as DataDictionary.Rules.RuleCondition;
if (ruleCondition != null)
{
ruleCondition.appendActions(action);
}
else
{
DataDictionary.Tests.SubStep subStep = Item.Enclosing as DataDictionary.Tests.SubStep;
if (subStep != null)
{
subStep.appendActions(action);
}
}
parent.Nodes.Add(actionTreeNode);
}
}
}
}
Delete();
SortSubNodes();
}
/// <summary>
/// Splits the selected action to several sub-actions
/// </summary>
public virtual void SplitHandler(object sender, EventArgs args)
{
Statement statement = new Parser().Statement(Item, Item.ExpressionText);
VariableUpdateStatement variableUpdateStatement = statement as VariableUpdateStatement;
if (variableUpdateStatement != null)
{
Expression expression = variableUpdateStatement.Expression;
StructExpression structExpression = expression as StructExpression;
if (structExpression != null)
{
Dictionary <Designator, Expression> associations = structExpression.Associations;
foreach (KeyValuePair <Designator, Expression> value in associations)
{
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = structExpression.Structure + "." + value.Key + " <- " +
value.Value;
ActionTreeNode actionTreeNode = new ActionTreeNode(action, true);
BaseTreeNode parent = Parent as BaseTreeNode;
if (parent != null)
{
RuleCondition ruleCondition = Item.Enclosing as RuleCondition;
if (ruleCondition != null)
{
ruleCondition.appendActions(action);
}
else
{
SubStep subStep = Item.Enclosing as SubStep;
if (subStep != null)
{
subStep.appendActions(action);
}
}
parent.Nodes.Add(actionTreeNode);
}
}
}
}
Delete();
}
/// <summary>
/// Executes the action
/// </summary>
/// <param name="e"></param>
protected override void OnClick(EventArgs e)
{
SubStep newSubStep = (SubStep)acceptor.getFactory().createSubStep();
if (Step != null)
{
newSubStep.Enclosing = Step;
if (SubStep != null)
{
newSubStep.Name = "NewSubStep";
int index = Step.SubSteps.IndexOf(SubStep);
Step.SubSteps.Insert(index + 1, newSubStep);
}
else
{
newSubStep.Name = "SubStep " + (Step.SubSteps.Count + 1);
Step.SubSteps.Add(newSubStep);
}
}
else if (TimeLineControl.Translation != null)
{
newSubStep.Enclosing = TimeLineControl.Translation;
if (SubStep != null)
{
newSubStep.Name = "NewSubStep";
int index = TimeLineControl.Translation.SubSteps.IndexOf(SubStep);
TimeLineControl.Translation.SubSteps.Insert(index + 1, newSubStep);
}
else
{
newSubStep.Name = "SubStep " + (TimeLineControl.Translation.SubSteps.Count + 1);
TimeLineControl.Translation.SubSteps.Add(newSubStep);
}
}
base.OnClick(e);
}
private void initializeInputForLambda(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Initialize input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a lambda train => no brake models defined in the train data */
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.EBModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.SBModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.NormalServiceBrakeModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.T_brake_emergency <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.T_brake_service <- EMPTY"));
/* Initializing the maximum train speed */
/* This value must be in the range {0km/h; 200km/h}, otherwise the conversion model will not be applicable */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.TrainData.Value.MaximumSpeed <- {0:0.0}",
180.0));
Worksheet aWorksheet = workbook.Sheets[1] as Worksheet;
bool isPassengerTrain;
importCommonTrainDataInformation(aSubStep, aWorksheet, out isPassengerTrain);
/*********************************** TRACK DATA ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Track data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a lambda train => track condition brake inhibition profile is not applicable */
addAction(aSubStep, String.Format("Kernel.TrackDescription.TrackConditions.General.TCProfile <- []"));
aWorksheet = workbook.Sheets[2] as Worksheet;
importCommonTrackDataInformation(aSubStep, aWorksheet);
/*********************************** NATIONAL VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - National values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[3] as Worksheet;
importCommonNationalValuesInformation(aSubStep, aWorksheet);
/*********************************** FIXED VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Fixed values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[4] as Worksheet;
importCommonFixedValuesInformation(aSubStep, aWorksheet);
/****************************** BRAKE PARAMETERS (lambda) ******************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep5 - Brake parameters";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[5] as Worksheet;
Range aRange = aWorksheet.UsedRange;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.BrakePercentage <- {0:0.0#}",
(double)(aRange.Cells[3, 6] as Range).Value2));
/*************************** INTERGRATED CORRECTION FACTORS ***************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep6 - Integrated correction factors";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[8] as Worksheet;
aRange = aWorksheet.UsedRange;
/* Initializing Kr_int */
int index = 0;
double doubleValue = -1;
double temp;
for (int i = 0; i < 9; i++)
{
temp = (double)(aRange.Cells[i + 32, 2] as Range).Value2;
if (doubleValue != temp)
{
double location = (double)(aRange.Cells[i + 32, 1] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKrInt.Val{0} <- Kernel.NationalValues.KrIntValueStruct\n{{\n LengthStep => {1:0.0},\n Value => {2:0.0####}\n}}",
index, location, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKrInt.Val{0} <- Kernel.NationalValues.KrIntValueStruct\n{{\n LengthStep => Default.BaseTypes.Length.Infinity,\n Value => {1:0.0####}\n}}",
index, doubleValue));
/* Case of a passenger train */
if (isPassengerTrain)
{
/* Initializing Kv_int */
double a = -1;
double b = -1;
double tempA, tempB;
index = 0;
for (int i = 0; i <= 9; i++)
{
tempA = (double)(aRange.Cells[i + 5, 5] as Range).Value2;
tempB = (double)(aRange.Cells[i + 31, 5] as Range).Value2;
if (a != tempA || b != tempB)
{
double speed = (double)(aRange.Cells[i + 5, 4] as Range).Value2;
a = tempA;
b = tempB;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.Val{0} <- Kernel.NationalValues.KvIntValue_PassengerTrainStruct\n{{\n SpeedStep => {1:0.0},\n ValueA => {2:0.0#},\n ValueB => {3:0.0#}\n}}",
index, speed, a, b));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.Val{0} <- Kernel.NationalValues.KvIntValue_PassengerTrainStruct\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n ValueA => {1:0.0#},\n ValueB => {2:0.0#}\n}}",
index, a, b));
}
else /* Case of freight trains */
{
/* Initializing Kv_int */
doubleValue = -1;
index = 0;
for (int i = 0; i <= 9; i++)
{
temp = (double)(aRange.Cells[i + 5, 2] as Range).Value2;
if (doubleValue != temp)
{
double speed = (double)(aRange.Cells[i + 5, 1] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_FreightTrain.Val{0} <- Kernel.NationalValues.KvIntValue_FreightTrainStruct\n{{\n SpeedStep => {1:0.0},\n Value => {2:0.0#}\n}}",
index, speed, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_FreightTrain.Val{0} <- Kernel.NationalValues.KvIntValue_FreightTrainStruct\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n Value => {1:0.0#}\n}}",
index, doubleValue));
}
/* Initializing A_NVP12 */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.A_NVP12 <- {0:0.0}",
(double)(aRange.Cells[44, 4] as Range).Value2));
/* Initializing A_NVP23 */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.A_NVP23 <- {0:0.0}",
(double)(aRange.Cells[44, 6] as Range).Value2));
/* Initializing Kt_int */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorForBrakeBuildUpTime <- {0:0.0}",
(double)(aRange.Cells[47, 4] as Range).Value2));
}
/// <summary>
/// Adds a step after this one
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void AddSubStepHandler(object sender, EventArgs args)
{
Item.appendSubSteps(SubStep.CreateDefault(Item.SubSteps));
}
private void importGammaBrakeParameters(SubStep aSubStep, Worksheet aWorksheet,
int brakesCombinationColumnNumber, int dataColumnNumber, bool initializeBrakes)
{
Range aRange = aWorksheet.UsedRange;
string ebBrakesCombination = "";
string sbBrakesCombination = ""; // magnetic shoe brake is not taken in account for SB
object obj = (aRange.Cells[7, brakesCombinationColumnNumber] as Range).Value2;
if (obj != null)
{
if (initializeBrakes)
{
addAction(aSubStep, String.Format("TIU.SpecialBrakeStatus.EddyCurrentBrakeIsActive <- True"));
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.EddyCurrentBrakeInterface <- Kernel.TrainData.BrakingParameters.BrakeInterfaceStatus.Both\n"));
}
ebBrakesCombination += obj == null ? "" : "EddyCurrent";
sbBrakesCombination += obj == null ? "" : "EddyCurrent";
}
obj = (aRange.Cells[8, brakesCombinationColumnNumber] as Range).Value2;
if (obj != null)
{
if (initializeBrakes)
{
addAction(aSubStep, String.Format("TIU.SpecialBrakeStatus.MagneticShoeBrakeIsActive <- True"));
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.MagneticShoeBrakeInterface <- Kernel.TrainData.BrakingParameters.BrakeInterfaceStatus.EB\n"));
}
ebBrakesCombination += ebBrakesCombination == "" ? "Magnetic" : "_Magnetic";
}
obj = (aRange.Cells[6, brakesCombinationColumnNumber] as Range).Value2;
if (obj != null)
{
if (initializeBrakes)
{
addAction(aSubStep, String.Format("TIU.SpecialBrakeStatus.RegenerativeBrakeIsActive <- True"));
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.RegenerativeBrakeInterface <- Kernel.TrainData.BrakingParameters.BrakeInterfaceStatus.Both\n"));
}
ebBrakesCombination += ebBrakesCombination == "" ? "Regenerative" : "_Regenerative";
sbBrakesCombination += sbBrakesCombination == "" ? "Regenerative" : "_Regenerative";
}
ebBrakesCombination = string.IsNullOrEmpty(ebBrakesCombination) ? "No_Special_Brakes" : ebBrakesCombination;
sbBrakesCombination = string.IsNullOrEmpty(sbBrakesCombination) ? "No_Special_Brakes" : sbBrakesCombination;
/* Initializing EB deceleration */
double doubleValue = -1;
double temp;
int index = 0;
for (int i = 0; i < 14; i += 2)
{
temp = (double)(aRange.Cells[i + 7, dataColumnNumber + 2] as Range).Value2;
if (doubleValue != temp)
{
double speed = (double)(aRange.Cells[i + 7, dataColumnNumber] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.EBModels.ModelSet.{0}.Val{1} <- Kernel.TrainData.BrakingParameters.BrakingModelValue\n{{\n SpeedStep => {2:0.0###},\n Acceleration => {3:0.0###}\n}}",
ebBrakesCombination, index, speed, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.EBModels.ModelSet.{0}.Val{1} <- Kernel.TrainData.BrakingParameters.BrakingModelValue\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n Acceleration => {2:0.0###}\n}}",
ebBrakesCombination, index, doubleValue));
/* Initializing EB confidence level */
/// TODO: how can I recover the value of the confidence level? (should be at the line 21....)
/* Initializing Kdry_rst */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.EBModels.Kdry_rstValuesSet.{0}.{1} <- Kernel.TrainData.BrakingParameters.CorrectFactorValue\n{{\n CF0 => {2:0.0###},\n CF1 => {3:0.0###},\n CF2 => {4:0.0###},\n CF3 => {5:0.0###},\n CF4 => {6:0.0###},\n CF5 => {7:0.0###},\n CF6 => {8:0.0###}\n}}",
ebBrakesCombination,
"Cl__99_9999999", // this value should be provided by the previous step
(double)(aRange.Cells[23, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[25, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[27, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[29, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[31, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[33, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[35, dataColumnNumber + 2] as Range).Value2));
/* Initializing Kwet_rst */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.EBModels.Kwet_rstValuesSet.{0} <- Kernel.TrainData.BrakingParameters.CorrectFactorValue\n{{\n CF0 => {1:0.0###},\n CF1 => {2:0.0###},\n CF2 => {3:0.0###},\n CF3 => {4:0.0###},\n CF4 => {5:0.0###},\n CF5 => {6:0.0###},\n CF6 => {7:0.0###}\n}}",
ebBrakesCombination,
(double)(aRange.Cells[38, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[40, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[42, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[44, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[46, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[48, dataColumnNumber + 2] as Range).Value2,
(double)(aRange.Cells[50, dataColumnNumber + 2] as Range).Value2));
/* Initializing T_brake_emergency */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.T_brake_emergency.{0} <- {1:0.0###}",
ebBrakesCombination,
(double)(aRange.Cells[52, dataColumnNumber + 3] as Range).Value2));
/* Initializing SB deceleration */
doubleValue = -1;
index = 0;
for (int i = 0; i < 14; i += 2)
{
temp = (double)(aRange.Cells[i + 54, dataColumnNumber + 2] as Range).Value2;
if (doubleValue != temp)
{
double speed = (double)(aRange.Cells[i + 7, dataColumnNumber] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.SBModels.ModelSet.{0}.Val{1} <- Kernel.TrainData.BrakingParameters.BrakingModelValue\n{{\n SpeedStep => {2:0.0###},\n Acceleration => {3:0.0###}\n}}",
sbBrakesCombination, index, speed, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.SBModels.ModelSet.{0}.Val{1} <- Kernel.TrainData.BrakingParameters.BrakingModelValue\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n Acceleration => {2:0.0###}\n}}",
sbBrakesCombination, index, doubleValue));
/* Initializing T_brake_service */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.T_brake_service.{0} <- {1:0.0###}",
sbBrakesCombination,
(double)(aRange.Cells[68, dataColumnNumber + 3] as Range).Value2));
}
private void initializeInputForGamma(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Initialize input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a gamma train => we have to initialize brake models in the train data */
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.EBModels <- Kernel.TrainData.BrakingParameters.EBModelSet\n{{\n ModelSet => Kernel.TrainData.BrakingParameters.BrakingModelSet{{}},\n Kdry_rstValuesSet => Kernel.TrainData.BrakingParameters.Kdry_rstValuesSet{{}},\n Kwet_rstValuesSet => Kernel.TrainData.BrakingParameters.Kwet_rstValuesSet{{}}\n}}"));
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.SBModels <- Kernel.TrainData.BrakingParameters.SBModelSet{{}}"));
/* Initializing the maximum train speed */
/* I didn't find this value in ERA sheets, but I observed than their P function can exceed 160 km/h => the maximum speed should be greater than 160 km/h */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.TrainData.Value.MaximumSpeed <- {0:0.0}",
180.0));
Worksheet aWorksheet = workbook.Sheets[1] as Worksheet;
bool isPassengerTrain;
importCommonTrainDataInformation(aSubStep, aWorksheet, out isPassengerTrain);
/*********************************** TRACK DATA ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Track data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[2] as Worksheet;
importCommonTrackDataInformation(aSubStep, aWorksheet);
/*********************************** NATIONAL VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - National values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[3] as Worksheet;
importCommonNationalValuesInformation(aSubStep, aWorksheet);
/*********************************** FIXED VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Fixed values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[4] as Worksheet;
importCommonFixedValuesInformation(aSubStep, aWorksheet);
/****************************** BRAKE PARAMETERS (gamma) ******************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep5 - Brake parameters";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[6] as Worksheet;
importGammaBrakeParameters(aSubStep, aWorksheet, 2, 8, true); // first combination
importGammaBrakeParameters(aSubStep, aWorksheet, 3, 20, false); // second combination
/**************************** Initialize time intervals ******************************/
aSubStep = new SubStep();
aSubStep.Name = "Initialize time intervals";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.InitializeTimeIntervals()");
/**************************** CORRECTION FACTOR KDRY_RST ****************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep6 - Correction factor kdry_rst";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[7] as Worksheet;
}
private void importCommonTrackDataInformation(SubStep aSubStep, Worksheet aWorksheet)
{
Range aRange = aWorksheet.UsedRange;
/* Initializing the target type */
/// TODO
/* Initializing the train position location accuracy */
double LocationAccuracy = (double)(aRange.Cells[2, 7] as Range).Value2;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Odometry.Accuracy <- Odometry.OdometerAccuracy{{\n D_ura => {0:0.0},\n D_ora => 0.0,\n V_ura => 0.0,\n V_ora => 0.0\n}}",
LocationAccuracy));
/* Initializing the MA: target speed, release speed, distance origin/target */
TargetSpeed = (double)(aRange.Cells[2, 2] as Range).Value2;
double releaseSpeed = (double)(aRange.Cells[2, 5] as Range).Value2;
double MAdistance = (double)(aRange.Cells[3, 2] as Range).Value2 + 1000.0;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.MA.MA <- Kernel.MA.MAStruct\n{{\n TargetSpeed => {0:0.0},\n Sections => [],\n EndSection => Kernel.MA.EndSectionStruct\n {{\n EndSectionTimeOut => EMPTY,\n Length => {1:0.0},\n DangerPoint => Kernel.MA.DangerPointStruct\n {{\n Distance => 0.0,\n ReleaseSpeed => {2:0.0}\n }},\n Overlap => EMPTY\n }},\n TargetSpeedTimeOut => 0.0\n}}",
TargetSpeed, MAdistance, releaseSpeed));
/* Initializing the Open Cab A of Desk 1 */
addAction(aSubStep, String.Format(CultureInfo.InvariantCulture, "DMI.DMI1.Cab <- DMI.CabEnum.CabA"));
addAction(aSubStep, String.Format(CultureInfo.InvariantCulture, "TIU.CabA.Desk1IsActive <- Boolean.True"));
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "TIU.CabA.IsFittedWithSingleDesk <- Boolean.True"));
/* Initializing the initial speed */
double MAspeedRestriction = (double)(aRange.Cells[4, 2] as Range).Value2;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.MA.SignallingRelatedSpeedRestriction <- Kernel.MA.SignallingRelatedSRStruct{{\n Value => {0:0.0},\n End => {1:0.0}\n}}",
MAspeedRestriction, MAdistance));
/* Initializing the reduced adhesion interval */
/// TODO: need to find how these values are activated and deactivated
double startLocation = (double)(aRange.Cells[9, 2] as Range).Value2;
double endLocation = (double)(aRange.Cells[10, 2] as Range).Value2;
//addAction(aSubStep, String.Format(CultureInfo.InvariantCulture, "INSERT\n Kernel.TrackDescription.TrackConditions.AdhesionFactor\n {{\n Distance => {0:0.0},\n Length => {1:0.0},\n Value => Messages.M_ADHESION.Slippery_rail\n }}\nIN\n Kernel.TrackDescription.TrackConditions.AdhFactors", startLocation, endLocation - startLocation));
/* Initializing the gradient profile */
double gradientValue = (double)(aRange.Cells[14, 3] as Range).Value2;
double gradientDistance = (double)(aRange.Cells[14, 1] as Range).Value2;
;
for (int i = 15; i <= 33; i++)
{
double temp = (double)(aRange.Cells[i, 3] as Range).Value2;
if (temp != gradientValue || i == 33)
{
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"INSERT\n Kernel.TrackDescription.Gradient.GradientStruct\n {{\n Location => {0:0.0},\n Gradient => {1:0.0}\n }}\nIN\n Kernel.TrackDescription.Gradient.Gradients",
gradientDistance, gradientValue));
gradientDistance = (double)(aRange.Cells[i, 1] as Range).Value2;
gradientValue = temp;
}
}
/* Initializing the International Static Speed Profile */
addAction(aSubStep,
"Kernel.TrackDescription.StaticSpeedProfile.SSP <- [Kernel.TrackDescription.StaticSpeedProfile.StaticSpeedRestrictionStruct{\n" +
" Location => 0.0,\n" +
" BasicSpeed => Default.BaseTypes.Speed.MaxSpeed,\n" +
" TrainLengthDelay => Messages.Q_FRONT.No_train_length_delay_on_validity_end_point_of_profile_element,\n" +
" Categories => []\n" +
"}]");
/* Initializing the distance EOA/SvL */
/// TODO: => should be a part of an MA?
//doubleValue = (double)(aRange.Cells[1, 5] as Range).Value2;
/* Initializing the type of the release speed (fixed or calculated on-board) */
/// TODO: verify requirements
/* Initializing the relocation balises */
string readStringValue = (string)(aRange.Cells[15, 4] as Range).Value2;
}
private void verifyInputForLambda(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Verify input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.TrainData.BrakingParameters.ConversionModel.Initialize()");
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.ReleaseSpeedMonitoring.UpdateReleaseSpeed()");
addExpectation(aSubStep,
"Kernel.TrainData.BrakingParameters.ConversionModel.ConversionModelIsUsed() == True");
/********************************* BRAKE PARAMETERS *********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Brake parameters";
aStep.AddModelElement(aSubStep);
Worksheet aWorksheet = workbook.Sheets[5] as Worksheet;
Range aRange = aWorksheet.UsedRange;
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.InitializeTimeIntervals()");
/* Verifying kto */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.kto() == {0:0.0#}",
(double)(aRange.Cells[7, 6] as Range).Value2));
if (TargetSpeed == 0)
/* In this case, the values of T_brake_emergency_cmt and T_brake_service_cmt do not make sense (3.13.3.4.4.1) */
{
/* Verifying T_brake_emergency_cm0 */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_emergency_cm0 == {0:0.0#}",
(double)(aRange.Cells[8, 6] as Range).Value2));
/* Verifying T_brake_service_cm0 */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_service_cm0 == {0:0.0#}",
(double)(aRange.Cells[10, 6] as Range).Value2));
}
else
/* In this case, the values of T_brake_emergency_cm0 and T_brake_service_cm0 do not make sense (3.13.3.4.4.1) */
{
/* Verifying T_brake_emergency_cmt */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_emergency_cmt == {0:0.0#}",
(double)(aRange.Cells[9, 6] as Range).Value2));
/* Verifying T_brake_service_cmt */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_service_cmt == {0:0.0#}",
(double)(aRange.Cells[11, 6] as Range).Value2));
}
/* Verifying T_be */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.BrakingParameters.T_be() == {0:0.0#}",
(double)(aRange.Cells[12, 6] as Range).Value2));
/* Verifying T_bs */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.BrakingParameters.T_bs() == {0:0.0#}",
(double)(aRange.Cells[13, 6] as Range).Value2));
/********************* BRAKE PARAMETERS (A_brake_emergency) *********************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - Brake parameters (A_brake_emergency)";
aStep.AddModelElement(aSubStep);
/* Verifying A_brake_emergency */
double doubleValue = -1;
double temp;
for (int i = 16; i <= 27; i++)
{
temp = (double)(aRange.Cells[i, 10] as Range).Value2;
if (doubleValue != temp)
{
if (doubleValue != -1)
{
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
(double)(aRange.Cells[i, 9] as Range).Value2 - 0.000000001, doubleValue));
}
doubleValue = temp;
double speedValue = (double)(aRange.Cells[i, 9] as Range).Value2;
if (Math.Abs(speedValue - Math.Round(speedValue, 8)) > 0)
{
speedValue += 0.000000001;
}
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
speedValue, doubleValue));
}
}
/* Verifying V_lim EBI */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency.Val1.SpeedStep,\n Val2 => {0:0.0########}\n)",
(double)(aRange.Cells[17, 9] as Range).Value2));
/*********************** BRAKE PARAMETERS (A_brake_service) ***********************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Brake parameters (A_brake_service)";
aStep.AddModelElement(aSubStep);
/* Verifying A_brake_service */
doubleValue = -1;
for (int i = 16; i <= 27; i++)
{
temp = (double)(aRange.Cells[i, 14] as Range).Value2;
if (doubleValue != temp)
{
if (doubleValue != -1)
{
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
(double)(aRange.Cells[i, 13] as Range).Value2 - 0.000000001, doubleValue));
}
doubleValue = temp;
double speedValue = (double)(aRange.Cells[i, 13] as Range).Value2;
if (Math.Abs(speedValue - Math.Round(speedValue, 8)) > 0)
{
speedValue += 0.000000001;
}
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
speedValue, doubleValue));
}
}
/* Verifying V_lim BS */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service.Val1.SpeedStep,\n Val2 => {0:0.0########}\n)",
(double)(aRange.Cells[17, 13] as Range).Value2));
}
private void importCommonFixedValuesInformation(SubStep aSubStep, Worksheet aWorksheet)
{
Range aRange = aWorksheet.UsedRange;
/* Initializing dV_ebi_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_ebi_min <- {0:0.0#}",
(double)(aRange.Cells[1, 2] as Range).Value2));
/* Initializing dV_ebi_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_ebi_max <- {0:0.0#}",
(double)(aRange.Cells[2, 2] as Range).Value2));
/* Initializing V_ebi_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_ebi_min <- {0:0.0#}",
(double)(aRange.Cells[3, 2] as Range).Value2));
/* Initializing V_ebi_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_ebi_max <- {0:0.0#}",
(double)(aRange.Cells[4, 2] as Range).Value2));
/* Initializing dV_sbi_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_sbi_min <- {0:0.0#}",
(double)(aRange.Cells[5, 2] as Range).Value2));
/* Initializing dV_sbi_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_sbi_max <- {0:0.0#}",
(double)(aRange.Cells[6, 2] as Range).Value2));
/* Initializing V_sbi_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_sbi_min <- {0:0.0#}",
(double)(aRange.Cells[7, 2] as Range).Value2));
/* Initializing V_sbi_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_sbi_max <- {0:0.0#}",
(double)(aRange.Cells[8, 2] as Range).Value2));
/* Initializing dV_warning_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_warning_min <- {0:0.0#}",
(double)(aRange.Cells[9, 2] as Range).Value2));
/* Initializing dV_warning_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.dV_warning_max <- {0:0.0#}",
(double)(aRange.Cells[10, 2] as Range).Value2));
/* Initializing V_warning_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_warning_min <- {0:0.0#}",
(double)(aRange.Cells[11, 2] as Range).Value2));
/* Initializing V_warning_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.CeilingSpeedMonitoring.V_warning_max <- {0:0.0#}",
(double)(aRange.Cells[12, 2] as Range).Value2));
/* Initializing T_warning */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.T_warning <- {0:0.0#}",
(double)(aRange.Cells[13, 2] as Range).Value2));
/* Initializing T_driver */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.T_driver <- {0:0.0#}",
(double)(aRange.Cells[14, 2] as Range).Value2));
/* Initializing T_preindication */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.SpeedAndDistanceMonitoring.PreIndicationLocation.T_preindication <- {0:0.0#}",
(double)(aRange.Cells[15, 2] as Range).Value2));
/* Initializing M_rotating_max */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrackDescription.Gradient.M_rotating_max <- {0:0.0#}",
(double)(aRange.Cells[16, 2] as Range).Value2));
/* Initializing M_rotating_min */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrackDescription.Gradient.M_rotating_min <- {0:0.0#}",
(double)(aRange.Cells[17, 2] as Range).Value2));
}
private void importCommonNationalValuesInformation(SubStep aSubStep, Worksheet aWorksheet)
{
/* The national values must be valid */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.DataState <- Default.DataState.Valid"));
Range aRange = aWorksheet.UsedRange;
/* Initializing the usage of service brake in target speed monitoring */
/// TODO: how to extract this value?!
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.UseServiceBrakeInTargetSpeedMonitoring <- Messages.Q_NVSBTSMPERM.Yes"));
/* Initializing the permission to inhibit the compensation of the speed measurement inaccuracy */
/// TODO: how to extract this value?!
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.PermToInhibitTheCompOfTheSpeedMeasurementInaccuracy <- Messages.Q_NVINHSMICPERM.Yes"));
/* Initializing the maximum deceleration value under reduced adhesion conditions(1) */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.MaxDecelValueUnderReducedAdhesionCond1 <- {0:0.0#}",
(double)(aRange.Cells[3, 2] as Range).Value2));
/* Initializing the maximum deceleration value under reduced adhesion conditions(2) */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.MaxDecelValueUnderReducedAdhesionCond2 <- {0:0.0#}",
(double)(aRange.Cells[4, 2] as Range).Value2));
/* Initializing the maximum deceleration value under reduced adhesion conditions(3) */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.MaxDecelValueUnderReducedAdhesionCond3 <- {0:0.0#}",
(double)(aRange.Cells[5, 2] as Range).Value2));
/* Initializing the weighting factor for available wheel/rail adhesion */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.WeightingFactorForAvailableWheelRailAdhesion <- {0:0.0#}",
(double)(aRange.Cells[6, 2] as Range).Value2));
/* Initializing the confidence level for emergency brake safe deceleration on dry rails */
double doubleValue = (double)(aRange.Cells[7, 2] as Range).Value2;
String stringValue = doubleValue.ToString(CultureInfo.InvariantCulture);
string result = "Messages.M_NVEBCL.Confidence_level___99_";
for (int i = 0; i < stringValue.Length - 3; i++)
{
result += "9";
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.ConfLevelForEmergBrakeSafeDecelerationOnDryRails <- {0}",
result));
}
/// <summary>
/// Positions a substep in the time line
/// </summary>
/// <param name="currentTime"></param>
/// <param name="subStep"></param>
/// <returns></returns>
private void PositionSubStep(double currentTime, SubStep subStep)
{
SubStepActivated subStepActivated = new SubStepActivated(subStep, null) {Time = currentTime};
PositionHandler.RegisterEvent(subStepActivated);
foreach (Action action in subStep.Actions)
{
VariableUpdate variableUpdate = new VariableUpdate(action, action, null);
PositionHandler.RegisterEvent(variableUpdate);
}
foreach (Expectation expectation in subStep.Expectations)
{
Expect expect = new Expect(expectation, null);
PositionHandler.RegisterEvent(expect);
}
}
private void intializeEFS(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Setup";
aTestCase.AddModelElement(aStep);
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Setup";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
TestAction powerOn = new TestAction();
powerOn.ExpressionText = "Kernel.PowerOn <- True";
aSubStep.AddModelElement(powerOn);
TestAction modeInitialization = new TestAction();
modeInitialization.ExpressionText = "Kernel.Mode <- Mode.FS";
aSubStep.AddModelElement(modeInitialization);
TestAction levelInitialization = new TestAction();
levelInitialization.ExpressionText =
"Kernel.Level <- Kernel.LevelData\n{\n Value => LevelDataStruct { Value => Level.L1 },\n DataState => DataState.Valid\n}";
aSubStep.AddModelElement(levelInitialization);
TestAction odometryInitialization = new TestAction();
odometryInitialization.ExpressionText = "Odometry.NominalDistance <- 0.0";
aSubStep.AddModelElement(odometryInitialization);
TestAction LRBGInitialization = new TestAction();
LRBGInitialization.ExpressionText = "BTM.LRBG <- BTM.BaliseGroupStruct{\n" +
" NID => 0,\n" +
" Orientation => Default.Orientation.Nominal,\n" +
" Position => BTM.Position{\n" +
" Position => 0.0,\n" +
" UnderReadingAmountOdo => 0.0,\n" +
" OverReadingAmountOdo => 0.0\n" +
" },\n" +
" Timestamp => Default.DateAndTime{\n" +
" Year => 2012,\n" +
" Month => 12,\n" +
" Day => 20,\n" +
" Hour => 20,\n" +
" Minute => 12,\n" +
" Second => 20,\n" +
" TTS => 600\n" +
" }\n" +
"}";
aSubStep.AddModelElement(LRBGInitialization);
}
private void addAction(SubStep aSubStep, string expression)
{
TestAction anAction = new TestAction();
anAction.ExpressionText = expression;
aSubStep.AddModelElement(anAction);
}
/// <summary>
/// Creates an expectation in a sub step
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected Expectation CreateExpectation(SubStep enclosing, string name)
{
Expectation retVal = (Expectation) Factory.createExpectation();
enclosing.appendExpectations(retVal);
retVal.ExpressionText = name;
return retVal;
}
private void importCommonTrainDataInformation(SubStep aSubStep, Worksheet aWorksheet, out bool isPassengerTrain)
{
Range aRange = aWorksheet.UsedRange;
/* Initializing the train position */
string readStringValue = (string)(aRange.Cells[15, 4] as Range).Value2;
string decodedStringValue = "";
isPassengerTrain = false;
if (readStringValue.Equals("Passenger in P"))
{
decodedStringValue = "PassengerTrainInP";
isPassengerTrain = true;
}
else if (readStringValue.Equals("Freight in P"))
{
decodedStringValue = "FreightTrainInP";
}
else if (readStringValue.Equals("Freight in G"))
{
decodedStringValue = "FreightTrainInG";
}
else
{
Log.ErrorFormat("Invalid train position");
}
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.BrakePosition <- Kernel.TrainData.BrakingParameters.BrakePositions.{0}",
decodedStringValue));
/* Initializing the traction model */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.TractionModel <- Kernel.TrainData.TractionModel\n{{\n Coefficient => {0:0.0},\n Constant => {1:0.0}\n}}",
0, (double)(aRange.Cells[16, 4] as Range).Value2));
/* Initializing the service brake interface */
readStringValue = (string)(aRange.Cells[17, 4] as Range).Value2;
decodedStringValue = "";
if (readStringValue.Equals("Yes"))
{
decodedStringValue = "True";
}
else if (readStringValue.Equals("No"))
{
decodedStringValue = "False";
}
else
{
Log.ErrorFormat("Invalid value for service brake interface");
}
addAction(aSubStep,
String.Format("Kernel.TrainData.TrainData.Value.SBCommandIsImplemented <- {0}", decodedStringValue));
/* Initializing the traction cut off interface */
readStringValue = (string)(aRange.Cells[18, 4] as Range).Value2;
decodedStringValue = "";
if (readStringValue.Equals("Yes"))
{
decodedStringValue = "True";
}
else if (readStringValue.Equals("No"))
{
decodedStringValue = "False";
}
else
{
Log.ErrorFormat("Invalid value for traction cut off interface");
}
addAction(aSubStep,
String.Format("Kernel.TrainData.TrainData.Value.TractionCutOffInterfaceIsImplemented <- {0}",
decodedStringValue));
/* Initializing special/additional brake independent form wheel/track adhesion */
/// TODO: where is that value?
addAction(aSubStep,
String.Format("Kernel.TrainData.BrakingParameters.ContributionOfSpecialBrakeIsAllowed <- {0}", "True"));
/* Initializing the speed inaccuracy */
/// TODO: blocked. Why?
/* Initializing the position inaccuracy */
/// TODO
/* addAction(aSubStep, String.Format(CultureInfo.InvariantCulture, "Kernel.NationalValues.ApplicableNationalValues.Value.DefaultLocationAccuracyOfABaliseGroup <- {0:0}", (double)(aRange.Cells[21, 4] as Range).Value2));*/
/* Initializing the train length */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.TrainData.Value.TrainLength <- {0:0.0}",
(double)(aRange.Cells[22, 4] as Range).Value2));
/* Initializing the nominal rotating mass */
readStringValue = (aRange.Cells[23, 4] as Range).Value2.ToString();
if (readStringValue.Equals("Not known"))
{
addAction(aSubStep,
String.Format("Kernel.TrainData.TrainData.Value.M_rotating_nom <- Default.Percentage.NA"));
}
else
{
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.M_rotating_nom <- {0:0.0}",
(double)(aRange.Cells[23, 4] as Range).Value2));
}
/* Initializing the distance antenna - train front */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "BTM.ActiveAntennaPosition <- {0:0.0}",
(double)(aRange.Cells[13, 4] as Range).Value2));
}
private void addExpectation(SubStep aSubStep, string expression)
{
Expectation anExpectation = new Expectation();
anExpectation.ExpressionText = expression;
anExpectation.Blocking = true;
aSubStep.AddModelElement(anExpectation);
}
private void verifyInputForGamma(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Verify input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.ReleaseSpeedMonitoring.UpdateReleaseSpeed()");
addExpectation(aSubStep,
"Kernel.TrainData.BrakingParameters.ConversionModel.ConversionModelIsUsed() == False");
}
private void fillBrakingParametersExpectations(TestCase aTestCase, int stepNumber, string name,
string expression, List<double> distanceValues, List<double> speedValues, List<double> values)
{
Step aStep = new Step();
aStep.Name = String.Format("Step{0} - {1}", stepNumber, name);
aTestCase.AddModelElement(aStep);
SubStep aSubStep = new SubStep();
aSubStep.Name = String.Format("SubStep1 - Verify {0} values", name);
aStep.AddModelElement(aSubStep);
for (int i = 0; i < values.Count; i++)
{
if (values[i] != -1)
{
Expectation expectation = new Expectation();
expectation.ExpressionText = String.Format(CultureInfo.InvariantCulture, expression,
Math.Round(distanceValues[i], 2), Math.Round(speedValues[i], 2), Math.Round(values[i], 4));
aSubStep.AddModelElement(expectation);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
BaseTreeNode sourceNode = e.Data.GetData("WindowsForms10PersistentObject") as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableNode = sourceNode as VariableTreeNode;
if (variableNode != null)
{
SubStep subStep = SubStepRelatedToMousePosition();
if (subStep != null)
{
// Create the default value
IValue value = null;
Expression expression = null;
string defaultValue = variableNode.Item.Default;
if (defaultValue != null)
{
const bool doSemanticalAnalysis = true;
const bool silent = true;
expression = new Parser().Expression(variableNode.Item, defaultValue,
AllMatches.INSTANCE, doSemanticalAnalysis, null, silent);
}
if (expression != null)
{
InterpretationContext context = new InterpretationContext {
UseDefaultValue = false
};
value = expression.GetExpressionValue(context, null);
}
if (value == null || value is EmptyValue)
{
Structure structureType = variableNode.Item.Type as Structure;
if (structureType != null)
{
const bool setDefaultValue = false;
value = new StructureValue(structureType, setDefaultValue);
}
}
// Create the action or the expectation according to the keyboard modifier keys
if (value != null)
{
if ((e.KeyState & Ctrl) != 0)
{
Expectation expectation = (Expectation)acceptor.getFactory().createExpectation();
expectation.ExpressionText = variableNode.Item.FullName + " == " + value.FullName;
subStep.appendExpectations(expectation);
}
else
{
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = variableNode.Item.FullName + " <- " + value.FullName;
subStep.appendActions(action);
}
}
else
{
MessageBox.Show(
Resources
.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_evaluate_variable_default_value,
Resources.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_create_event,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
}
}
}
}
