def addTriggerCount(self, value=None, validFor=None, result_request=None):
if result_request is None:
if self.checkApplicability("TriggerCount"):
super().addTriggerCount(value, validFor)
else:
raise ValueError(
'ERROR: TriggerCount can be assigned only to startEvent element'
)
else:
utility.checkResultRequest(result_request)
if result_request not in REQUEST['triggerCount']:
raise ValueError(
"ERROR: for TriggerCount result_request must be " +
str(REQUEST['triggerCount']))
attributes = {'value': value, 'validFor': validFor}
utility.filterNoneAttributes(attributes)
if len(attributes) == 0 and self.checkResultRequestApplicability(
'triggerCount'):
super().addInterTriggerCountResultRequest(result_request)
elif len(attributes) > 0:
raise ValueError(
"ERROR: for ResultRequest insert only result_request parameter"
)
else:
raise ValueError(
"ERROR: result_request can be insert only to " +
str(REQUEST_APPLICABILITY['triggerCount']) + " element")
def addValidationTime(self,
value=None,
timeUnit=None,
validFor=None,
nameDistribution=None,
shape=None,
scale=None,
probability=None,
trials=None,
mean=None,
k=None,
standardDeviation=None,
mode=None,
min=None,
max=None,
discrete=None,
points=None,
enum_list=None,
expression=None,
result_request=None):
if result_request is None:
if self.checkApplicability("Time"):
super().addValidationTime(value, timeUnit, validFor,
nameDistribution, shape, scale,
probability, trials, mean, k,
standardDeviation, mode, min, max,
discrete, points, enum_list,
expression)
else:
raise ValueError(
'ERROR: Validation time can be assigned only to task element'
)
else:
utility.checkResultRequest(result_request)
if result_request not in REQUEST['Time']:
raise ValueError(
"ERROR: for ValidationTime result_request must be " +
str(REQUEST["Time"]))
attributes = {
'value': value,
'timeUnit': timeUnit,
'validFor': validFor,
'enum_list': enum_list
}
utility.filterNoneAttributes(attributes)
if len(attributes) == 0 and self.checkResultRequestApplicability(
'Time'):
super().addValidationTimeResultRequest(result_request)
elif len(attributes) > 0:
raise ValueError(
"ERROR: for ResultRequest insert only result_request parameter"
)
else:
raise ValueError(
"ERROR: result_request can be insert only to " +
str(REQUEST_APPLICABILITY['Time']) + " element")
def addTriggerCount(self, value=None, validFor=None):
self.checkControlParametersTag()
if type(value) == int:
self.typeValueTC = "NumericParameter"
self.triggerCountAttrib = {
"value": str(value),
"validFor": validFor
}
self.triggerCountAttrib = utility.filterNoneAttributes(
self.triggerCountAttrib)
if self.triggerCountPointer is None:
self.triggerCountPointer = etree.SubElement(
self.controlPointer, utility.BPSIM + "TriggerCount")
new_parameter = etree.SubElement(self.triggerCountPointer,
utility.BPSIM + self.typeValueTC,
attrib=self.triggerCountAttrib)
utility.write_on_file(self.write, self.tree)
utility.checkCalendar(self.scenario.getCalendars(), validFor,
self.verbosity)
if self.verbosity == 0:
print("INFO: TriggerCount added " + self.typeValueTC + " ",
self.triggerCountAttrib)
else:
raise ValueError(
"ERROR: Type of TriggerCount is not correct, must be NumericParameter"
)
def filterParameterAttributes(self, value, timeUnit, validFor):
if timeUnit is not None:
utility.checkTimeUnit(timeUnit)
utility.checkCalendar(self.scenario.getCalendars(), validFor,
self.verbosity)
value = str(value)
attributes = attributes = {
"value": value,
"timeUnit": timeUnit,
"validFor": validFor
}
return utility.filterNoneAttributes(attributes)
def addProbability(self, value):
self.checkControlParametersTag()
self.typeValuePr = self.checkProbability(value)
attrib = {"value": str(value)}
attrib = utility.filterNoneAttributes(attrib)
if self.probabilityPointer is None:
self.probabilityPointer = etree.SubElement(
self.controlPointer, utility.BPSIM + "Probability")
new_parameter = etree.SubElement(self.probabilityPointer,
utility.BPSIM + self.typeValuePr,
attrib=attrib)
utility.write_on_file(self.write, self.tree)
if self.verbosity == 0:
print("INFO: Probability added" + self.typeValuePr, attrib)
def filterDistributionAttributes(self, timeUnit, nameDistribution, shape,
scale, probability, trials, mean, k,
standardDeviation, mode, min, max,
discrete, points, validFor):
self.checkNameDistribution(nameDistribution)
utility.checkCalendar(self.scenario.getCalendars(), validFor,
self.verbosity)
if nameDistribution == 'UserDistribution':
attributes = {'discrete': discrete, 'points': points}
attributes = utility.filterNoneAttributes(attributes)
self.checkDistributionAttributes('UserDistribution', attributes)
self.checkBooleanType(discrete, 'discrete')
else:
attributes = {
'shape': shape,
'scale': scale,
'probability': probability,
'trials': trials,
'mean': mean,
'k': k,
'standardDeviation': standardDeviation,
'mode': mode,
'min': min,
'max': max
}
attributes = utility.filterNoneAttributes(attributes)
self.checkDistributionAttributes(nameDistribution, attributes)
self.checkNumericDistributionAttributes(attributes)
for key in list(attributes.keys()):
attributes[key] = str(attributes[key])
if timeUnit is not None:
utility.checkTimeUnit(timeUnit)
attributes['timeUnit'] = timeUnit
if validFor is not None:
attributes['validFor'] = validFor
return attributes
def addAvailability(self,value,validFor):
self.checkResourceParametersTag()
if super().checkBooleanParameter(value):
typeValue = "BooleanParameter"
utility.checkCalendar(self.scenario.getCalendars(), validFor, self.verbosity)
self.availabilityAttrib = {"value": str(value), "validFor": validFor}
self.availabilityAttrib = utility.filterNoneAttributes(self.availabilityAttrib)
if self.availabilityPointer is None:
self.availabilityPointer=etree.SubElement(self.resourcePointer, utility.BPSIM + "Availability")
new_parameter= etree.SubElement(self.availabilityPointer, utility.BPSIM + typeValue, attrib=self.availabilityAttrib)
utility.write_on_file(self.write, self.tree)
if self.verbosity==0:
print("INFO: Availability added " + typeValue, self.availabilityAttrib)
else:
raise ValueError("ERROR: Type of Availability is not correct, must be BooleanParameter")
def filterScenarioAttributes(self):
if self.created is not None:
self.created = utility.getDateTimeType(self.created)
if self.modified is not None:
self.modified = utility.getDateTimeType(self.modified)
attributes = {
"id": self.id,
"name": self.name,
"author": self.author,
"description": self.description,
"created": self.created,
"modified": self.modified,
"version": self.version,
"vendor": self.vendor,
"inherits": self.inherits
}
self.attributes = utility.filterNoneAttributes(attributes)
return self.attributes
def filterScenarioParametersAttributes(self):
attributes = {
"replication": self.replication,
"seed": self.seed,
"baseTimeUnit": self.baseTimeUnit,
"baseCurrencyUnit": self.baseCurrencyUnit,
"showResultRequestColumn": self.showResultRequestColumn,
"expressionLanguage": self.expressionLanguage,
"baseResultFrequency": self.baseResultFrequency,
"baseResultFrequencyCumul": self.baseResultFrequencyCumul,
"traceOutput": self.traceOutput,
"traceFormat": self.traceFormat
}
attributes = utility.filterNoneAttributes(attributes)
if self.replication is not None:
attributes["replication"] = str(self.replication)
if self.baseResultFrequency is not None:
self.baseResultFrequency = utility.getDurationType(
self.baseResultFrequency)
attributes["baseResultFrequency"] = self.baseResultFrequency
if self.baseTimeUnit is not None:
utility.checkTimeUnit(self.baseTimeUnit)
return attributes
def setTriggerCount(self, value=None, validFor=None, result_request=None):
if self.triggerCountPointer is None:
raise ValueError("ERROR: TriggerCount not exist")
if value is None and result_request is None:
raise ValueError("ERROR: insert value or result_request")
newTriggerCount = self.triggerCountPointer.findall("./" +
utility.BPSIM +
self.typeValueTC)
if len(newTriggerCount) > 0:
self.triggerCountPointer.remove(newTriggerCount[-1])
if value is not None and result_request is None:
if not super().checkNumericParameter(value):
raise ValueError(
"ERROR: Type of TriggerCount is not correct, must be NumericParameter"
)
self.typeValueTC = "NumericParameter"
newTriggerCount = etree.SubElement(self.triggerCountPointer,
utility.BPSIM +
"NumericParameter",
attrib={'value': str(value)})
if validFor is not None:
utility.checkCalendar(self.scenario.getCalendars(), validFor,
self.verbosity)
newTriggerCount.set('validFor', validFor)
elif value is None and result_request is not None:
attributes = {'value': value, 'validFor': validFor}
attributes = utility.filterNoneAttributes(attributes)
if len(attributes) == 0:
self.typeValueTC = "ResultRequest"
request = etree.SubElement(self.triggerCountPointer,
utility.BPSIM + "ResultRequest")
request.text = result_request
else:
raise ValueError("ERROR: insert only result_request parameter")
utility.write_on_file(self.write, self.tree)
if self.verbosity == 0:
print("INFO: TriggerCount updated")
def addCostParameter(self, value, validFor, resultRequest, pointer, name):
attributes = None
if value is None and validFor is None and resultRequest is not None:
typeValue = "ResultRequest"
new_parameter = etree.SubElement(pointer,
utility.BPSIM + typeValue)
new_parameter.text = resultRequest
elif value is not None and resultRequest is None:
typeValue = super().checkParameterType(value)
if not super().checkNumericParameter(
value) and not super().checkFloatingParameter(value):
raise ValueError(
'ERROR: type of ' + name +
' must be NumericParameter or FloatingParameter')
utility.checkCalendar(self.scenario.getCalendars(), validFor,
self.verbosity)
attributes = {"value": str(value), "validFor": validFor}
attributes = utility.filterNoneAttributes(attributes)
new_parameter = etree.SubElement(pointer,
utility.BPSIM + typeValue,
attrib=attributes)
else:
raise ValueError('ERROR: insert only value or resultRequest')
return typeValue, pointer, attributes
def addInterTriggerTimer(self,
value=None,
timeUnit=None,
validFor=None,
nameDistribution=None,
shape=None,
scale=None,
probability=None,
trials=None,
mean=None,
k=None,
standardDeviation=None,
mode=None,
min=None,
max=None,
discrete=None,
points=None,
enum_list=None,
result_request=None):
if result_request is None:
if self.checkApplicability("InterTriggerTimer"):
super().addInterTriggerTimer(value, timeUnit, validFor,
nameDistribution, shape, scale,
probability, trials, mean, k,
standardDeviation, mode, min, max,
discrete, points, enum_list)
else:
raise ValueError(
'ERROR: InterTriggerTimer can be assigned only to startEvent element'
)
else:
if result_request not in REQUEST['interTriggerTimer']:
raise ValueError(
"ERROR: for InterTriggerTimer result_request must be " +
str(REQUEST["interTriggerTimer"]))
attributes = {
'value': value,
'timeUnit': timeUnit,
'validFor': validFor,
'nameDistribution': nameDistribution,
'shape': shape,
'scale': scale,
'probability': probability,
'trials': trials,
'mean': mean,
'k': k,
'standardDeviation': standardDeviation,
'mode': mode,
'min': min,
'max': max,
'discrete': discrete,
'points': points,
'enum_list': enum_list
}
utility.filterNoneAttributes(attributes)
if len(attributes) == 0 and self.checkApplicability(
"InterTriggerTimer"):
super().addInterTriggerTimerResultRequest(result_request)
elif len(attributes) > 0:
raise ValueError(
"ERROR: for ResultRequest insert only result_request parameter"
)
else:
raise ValueError(
"ERROR: result_request can be insert only to " +
str(APPLICABILITY["InterTriggerTimer"]) + " element")
def setInterTriggerTimer(self,
value=None,
enum_list=None,
timeUnit=None,
validFor=None,
nameDistribution=None,
shape=None,
scale=None,
probability=None,
trials=None,
mean=None,
k=None,
standardDeviation=None,
mode=None,
min=None,
max=None,
discrete=None,
points=None,
result_request=None):
if self.triggerTimePointer is None:
raise ValueError("ERROR: TriggerTimer not exist")
if value is None and nameDistribution is None and enum_list is None and result_request is None:
raise ValueError(
'ERROR: To set InterTriggerTimer insert value or nameDistribution or enum_list or result_request'
)
if nameDistribution is None and result_request is None:
if self.typeValueTT == self.nameDistribution:
self.triggerTimerAttrib = {}
super().setParameterWithEnumList(self.typeValueTT,
self.triggerTimePointer,
self.triggerTimerAttrib, value,
enum_list, timeUnit, validFor)
newTriggerTimer = self.triggerTimePointer.findall("./" +
utility.BPSIM +
self.typeValueTT)
if len(newTriggerTimer) > 0:
self.triggerTimePointer.remove(newTriggerTimer[-1])
if value is None and nameDistribution is not None and enum_list is None and result_request is None:
super().checkNameDistribution(nameDistribution)
newTriggerTimerAttrib = super().filterDistributionAttributes(
timeUnit, nameDistribution, shape, scale, probability, trials,
mean, k, standardDeviation, mode, min, max, discrete, points,
validFor)
if nameDistribution == 'UserDistribution':
super().createUserDistributionDataPoint(
points, self.triggerTimePointer, discrete, timeUnit)
else:
new_parameter = etree.SubElement(self.triggerTimePointer,
utility.BPSIM +
nameDistribution,
attrib=newTriggerTimerAttrib)
elif result_request is not None:
utility.checkResultRequest(result_request)
if result_request == 'count':
raise ValueError(
"ERROR: result_request must be min, max, mean or sum")
attributes = {
'value': value,
'timeUnit': timeUnit,
'validFor': validFor,
'nameDistribution': nameDistribution,
'shape': shape,
'scale': scale,
'probability': probability,
'trials': trials,
'mean': mean,
'k': k,
'standardDeviation': standardDeviation,
'mode': mode,
'min': min,
'max': max,
'discrete': discrete,
'points': points,
'enum_list': enum_list
}
utility.filterNoneAttributes(attributes)
if len(attributes) == 0:
self.addInterTriggerTimerResultRequest(result_request)
else:
raise ValueError("ERROR: insert only result_request parameter")
else:
raise ValueError(
'ERROR: if InterTriggerTimer is NumericParameter, FloatingParameter, DurationParameter add value, add nameDistribution otherwise'
)
utility.write_on_file(self.write, self.tree)
if self.verbosity == 0:
print("INFO: InterTriggerTimer updated")
