SemanticAdaptationCanonicalGenerator.xtend 55 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534
  1. /*
  2. * generated by Xtext 2.10.0
  3. */
  4. package be.uantwerpen.ansymo.semanticadaptation.generator
  5. import be.uantwerpen.ansymo.semanticadaptation.generator.graph.DirectedGraph
  6. import be.uantwerpen.ansymo.semanticadaptation.generator.graph.FMUGraph
  7. import be.uantwerpen.ansymo.semanticadaptation.generator.graph.TopologicalSort
  8. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Adaptation
  9. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Assignment
  10. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.AtomicUnity
  11. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.BoolLiteral
  12. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.BuiltinFunction
  13. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Close
  14. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.CompositeOutputFunction
  15. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Connection
  16. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.CustomControlRule
  17. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.DataRule
  18. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Declaration
  19. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.DeclaredParameter
  20. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.DivideUnity
  21. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.DoStep
  22. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.DoStepFun
  23. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Expression
  24. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.FMU
  25. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.InnerFMU
  26. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.InnerFMUDeclaration
  27. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.InnerFMUDeclarationFull
  28. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.IntLiteral
  29. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.IsSet
  30. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.MooreOrMealy
  31. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.MultiplyUnity
  32. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Port
  33. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.ReactiveOrDelayed
  34. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.RealLiteral
  35. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SemanticAdaptation
  36. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SemanticAdaptationFactory
  37. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SingleParamDeclaration
  38. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SingleVarDeclaration
  39. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Statement
  40. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.StringLiteral
  41. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Unity
  42. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Variable
  43. import java.io.ByteArrayOutputStream
  44. import java.util.HashMap
  45. import java.util.LinkedList
  46. import java.util.List
  47. import java.util.Map
  48. import org.eclipse.emf.common.util.EList
  49. import org.eclipse.emf.ecore.EObject
  50. import org.eclipse.emf.ecore.resource.Resource
  51. import org.eclipse.xtext.EcoreUtil2
  52. import org.eclipse.xtext.generator.AbstractGenerator
  53. import org.eclipse.xtext.generator.IFileSystemAccess2
  54. import org.eclipse.xtext.generator.IGeneratorContext
  55. import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.CurrentTime
  56. /**
  57. * Generates code from your model files on save.
  58. *
  59. * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation
  60. */
  61. class SemanticAdaptationCanonicalGenerator extends AbstractGenerator {
  62. String CANONICAL_SUFIX = "_canonical"
  63. override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
  64. Log.push("Generating canonical semantic adaptation for file " + resource.URI + "...")
  65. Log.println("Resource URI information:")
  66. Log.println("\t resource.URI.lastSegment = " + resource.URI.lastSegment())
  67. Log.println("\t resource.URI.trimFileExtension = " + resource.URI.trimFileExtension())
  68. // Create in memory representation of canonical SA file
  69. var adaptations = resource.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation);
  70. check(adaptations.size == 1, "Only one semantic adaptation is supported per .sa file")
  71. var adaptation = adaptations.head
  72. Log.println(prettyprint_model(adaptation, "File Read"))
  73. // Create file name for the canonical sa file
  74. var fileNameWithoutExt = resource.URI.trimFileExtension().lastSegment()
  75. Log.println("Checking if file is already a canonical version...")
  76. if (fileNameWithoutExt.indexOf(CANONICAL_SUFIX) == -1){
  77. Log.println("It is not.")
  78. var canonicalFileName = fileNameWithoutExt + CANONICAL_SUFIX + ".sa"
  79. Log.println("canonicalFileName = " + canonicalFileName)
  80. canonicalize(adaptation)
  81. Log.println(prettyprint_model(adaptation, "Generated File"))
  82. fsa.generateFile(canonicalFileName, adaptation.serialize_model)
  83. Log.println("File " + canonicalFileName + " written.")
  84. } else {
  85. Log.println("It is already a canonical version.")
  86. Log.println("Nothing to do.")
  87. }
  88. Log.pop("Generating canonical semantic adaptation for file " + resource.URI + "... DONE.")
  89. }
  90. def prettyprint_model(Adaptation sa, String title){
  91. var outputByteArray = new ByteArrayOutputStream()
  92. sa.eResource.save(outputByteArray,null)
  93. return "______________________________" + title + "______________________________\n" +
  94. sa.serialize_model +
  95. "\n__________________________________________________________________________"
  96. }
  97. def serialize_model(Adaptation sa){
  98. var outputByteArray = new ByteArrayOutputStream()
  99. sa.eResource.save(outputByteArray,null)
  100. return outputByteArray.toString()
  101. }
  102. def inferUnits(Adaptation sa){
  103. // Unit inference
  104. var unitlessElements = genericDeclarationInferenceAlgorithm(sa ,
  105. [// getField
  106. element | {
  107. var DUMMY_UNIT = "Dips"
  108. if (element instanceof SingleParamDeclaration) {
  109. return DUMMY_UNIT
  110. } else if (element instanceof Port){
  111. return element.unity
  112. } else if (element instanceof SingleVarDeclaration){
  113. return DUMMY_UNIT
  114. } else {
  115. throw new Exception("Unexpected element type: " + element)
  116. }
  117. }
  118. ],
  119. [// setField
  120. element, value | {
  121. if (element instanceof SingleParamDeclaration) {
  122. } else if (element instanceof Port){
  123. element.unity = EcoreUtil2.copy(value as Unity)
  124. } else if (element instanceof SingleVarDeclaration){
  125. } else {
  126. throw new Exception("Unexpected element type: " + element)
  127. }
  128. }
  129. ],
  130. [// inferField
  131. element | {
  132. var DUMMY_UNIT = "Dips"
  133. if (element instanceof SingleParamDeclaration) {
  134. return DUMMY_UNIT
  135. } else if (element instanceof Port){
  136. return getPortUnit(element)
  137. } else if (element instanceof SingleVarDeclaration){
  138. return DUMMY_UNIT
  139. } else {
  140. throw new Exception("Unexpected element type: " + element)
  141. }
  142. }
  143. ]
  144. )
  145. if (unitlessElements > 0){
  146. Log.println("Could not infer all element units. There are " + unitlessElements + " unitless elements.")
  147. }
  148. }
  149. def inferTypes(Adaptation sa){
  150. // Type inference
  151. var untypedElements = genericDeclarationInferenceAlgorithm(sa ,
  152. [// getField
  153. element | {
  154. if (element instanceof SingleParamDeclaration) {
  155. return element.type
  156. } else if (element instanceof Port){
  157. return element.type
  158. } else if (element instanceof SingleVarDeclaration){
  159. return element.type
  160. } else {
  161. throw new Exception("Unexpected element type: " + element)
  162. }
  163. }
  164. ],
  165. [// setField
  166. element, value | {
  167. if (element instanceof SingleParamDeclaration) {
  168. element.type = value as String
  169. } else if (element instanceof Port){
  170. element.type = value as String
  171. } else if (element instanceof SingleVarDeclaration){
  172. element.type = value as String
  173. } else {
  174. throw new Exception("Unexpected element type: " + element)
  175. }
  176. }
  177. ],
  178. [// inferField
  179. element | {
  180. if (element instanceof SingleParamDeclaration) {
  181. return extractTypeFromExpression(element.expr, element.name)
  182. } else if (element instanceof Port){
  183. return getPortType(element)
  184. } else if (element instanceof SingleVarDeclaration){
  185. return extractTypeFromExpression(element.expr, element.name)
  186. } else {
  187. throw new Exception("Unexpected element type: " + element)
  188. }
  189. }
  190. ]
  191. )
  192. if (untypedElements > 0){
  193. Log.println("Error: Could not infer all types. There are " + untypedElements + " untyped elements.")
  194. Log.println(prettyprint_model(sa, "Current File"))
  195. throw new Exception("Could not infer all types. There are " + untypedElements + " untyped elements.")
  196. }
  197. }
  198. def canonicalize(Adaptation sa){
  199. Log.push("Canonicalize")
  200. inferUnits(sa)
  201. inferTypes(sa)
  202. addInPorts(sa)
  203. val inputPort2parameterDeclaration = addInParams(sa)
  204. val externalInputPort2InVarDeclaration = addInVars(sa, inputPort2parameterDeclaration)
  205. addInRules_External2Stored_Assignments(sa, externalInputPort2InVarDeclaration)
  206. val internalPort2ExternalPortBindings = findAllExternalPort2InputPort_Bindings(sa)
  207. addInRules_External2Internal_Assignments(sa, internalPort2ExternalPortBindings)
  208. removeBindings(internalPort2ExternalPortBindings, sa)
  209. if (sa.outports.size==0){
  210. addOutPorts(sa)
  211. }
  212. val outputPort2parameterDeclaration = addOutParams(sa)
  213. val internalOutputPort2OutVarDeclaration = addOutVars(sa, outputPort2parameterDeclaration)
  214. val internalOutputPort2ExternalPortBindings = findAllInternalPort2ExternalOutputPort_Bindings(sa)
  215. //val internalOutputPort2OutVarDeclaration = transitiveStep(internalOutputPort2ExternalPortBindings, internalOutputPort2OutVarDeclaration)
  216. addOutRules_Internal2Stored_Assignments(sa, internalOutputPort2OutVarDeclaration)
  217. addOutRules_Internal2External_Assignments(sa, internalOutputPort2ExternalPortBindings)
  218. removeBindings(internalOutputPort2ExternalPortBindings, sa)
  219. if (sa.control === null){
  220. sa.control = SemanticAdaptationFactory.eINSTANCE.createControlRuleBlock()
  221. sa.control.rule = SemanticAdaptationFactory.eINSTANCE.createCustomControlRule()
  222. createCoSimStepInstructions(sa)
  223. }
  224. createInternalBindingAssignments(sa)
  225. Log.push("Replace port refs in input rules")
  226. for (rule : sa.in.rules){
  227. check(rule.outputfunction instanceof CompositeOutputFunction, "Only CompositeOutputFunction are supported in DataRules.")
  228. replacePortRefsByVarDecl((rule.outputfunction as CompositeOutputFunction).statements, externalInputPort2InVarDeclaration)
  229. }
  230. Log.pop("Replace port refs in input rules")
  231. Log.push("Replace port refs in control rule")
  232. if (sa.control.rule instanceof CustomControlRule){
  233. replacePortRefsByVarDecl((sa.control.rule as CustomControlRule).controlRulestatements,internalOutputPort2OutVarDeclaration)
  234. }
  235. Log.pop("Replace port refs in control rule")
  236. Log.push("Replace port refs in output rule")
  237. for (rule : sa.out.rules){
  238. check(rule.outputfunction instanceof CompositeOutputFunction, "Only CompositeOutputFunction are supported in DataRules.")
  239. replacePortRefsByVarDecl((rule.outputfunction as CompositeOutputFunction).statements, internalOutputPort2OutVarDeclaration)
  240. }
  241. Log.pop("Replace port refs in output rule")
  242. Log.pop("Canonicalize")
  243. }
  244. def replacePortRefsByVarDecl(EList<Statement> statements, HashMap<Port, SingleVarDeclaration> port2VarDecl) {
  245. Log.push("replacePortRefsByVarDecl")
  246. for(statement : statements){
  247. val vars = statement.eAllContents.filter[v | v instanceof Variable]
  248. var Variable v
  249. while (vars.hasNext) {
  250. v = vars.next as Variable
  251. if (port2VarDecl.containsKey(v.ref)){
  252. val port = v.ref as Port
  253. v.owner = null
  254. val varDecl = port2VarDecl.get(v.ref)
  255. v.ref = varDecl
  256. Log.println("Replaced ref to " + port.qualifiedName + " by " + varDecl.name)
  257. } else {
  258. Log.println("Var ref not substituted: " + v.ref)
  259. }
  260. }
  261. }
  262. Log.pop("replacePortRefsByVarDecl")
  263. }
  264. def createInternalBindingAssignments(Adaptation sa) {
  265. Log.push("createInternalBindingAssignments")
  266. val scenario = (sa.inner as InnerFMUDeclarationFull)
  267. for (connection : scenario.connection){
  268. val trgFMU = connection.tgt.port.eContainer as InnerFMU
  269. val ctrlRule = sa.control.rule as CustomControlRule
  270. val doStepIndex = findDoStepStatementIndex(ctrlRule, trgFMU)
  271. if (! existsAssignmentToPort_BeforeIndex(connection.tgt.port, doStepIndex, ctrlRule)){
  272. Log.println("Creating assignment to port " + connection.tgt.port.qualifiedName + " at position " + doStepIndex)
  273. addPortAssignment(ctrlRule.controlRulestatements, connection.tgt.port, connection.src.port, doStepIndex, true)
  274. } else {
  275. Log.println("There is already an assignment to port " + connection.tgt.port.qualifiedName + " before position " + doStepIndex)
  276. }
  277. }
  278. Log.pop("createInternalBindingAssignments")
  279. }
  280. def existsAssignmentToPort_BeforeIndex(Port port, int index, CustomControlRule rule) {
  281. val assignmentsToPort = rule.controlRulestatements.indexed
  282. .filter[s | s.value instanceof Assignment &&
  283. (s.value as Assignment).lvalue.ref == port
  284. ]
  285. check(assignmentsToPort.size <= 1, "Multiple assignments to the same port are not supported yet. Use a loop with a single call.")
  286. return assignmentsToPort.size == 1
  287. }
  288. def findDoStepStatementIndex(CustomControlRule rule, InnerFMU fmu) {
  289. Log.push("findDoStepStatementIndex")
  290. var result = -1
  291. val doStepProcedures = rule.controlRulestatements.indexed.filter[s | s.value instanceof DoStep && (s.value as DoStep).fmu == fmu]
  292. check(doStepProcedures.size <= 1, "Multiple calls to the doStep function for the same FMU are not supported yet. Use a loop with a single call.")
  293. if (doStepProcedures.size == 1){
  294. Log.println("Found a doStep procedure for fmu " + fmu.name + " at position " + doStepProcedures.head.key)
  295. result = doStepProcedures.head.key
  296. }
  297. // Warning: this does not support instructions such as:
  298. // var someVar = 10, h = doStep(f), etc...
  299. // Only single declarations are supported, such as:
  300. // var h = doStep(f)
  301. val doStepAssignments = rule.controlRulestatements.indexed
  302. .filter[s | s.value instanceof Declaration &&
  303. (s.value as Declaration).declarations.size == 1 &&
  304. (s.value as Declaration).declarations.head instanceof SingleVarDeclaration &&
  305. ((s.value as Declaration).declarations.head as SingleVarDeclaration).expr instanceof DoStepFun &&
  306. (((s.value as Declaration).declarations.head as SingleVarDeclaration).expr as DoStepFun).fmu == fmu
  307. ]
  308. check(doStepAssignments.size <= 1, "Multiple calls to the doStep function for the same FMU are not supported yet. Use a loop with a single call.")
  309. if (doStepAssignments.size == 1){
  310. check(result==-1, "Multiple calls to the doStep function for the same FMU are not supported yet. Use a loop with a single call.")
  311. Log.println("Found a doStep function for fmu " + fmu.name + " at position " + doStepAssignments.head.key)
  312. result = doStepAssignments.head.key
  313. }
  314. Log.pop("findDoStepStatementIndex")
  315. return result
  316. }
  317. def createCoSimStepInstructions(Adaptation sa) {
  318. check((sa.inner as InnerFMUDeclarationFull).fmus.size > 0, "At least one internal FMU is expected...")
  319. if (onlyOneInternalFMU(sa)){
  320. createCosimStepForOneFMU(sa)
  321. } else {
  322. createCosimStepForMultipleFMUs(sa)
  323. }
  324. }
  325. def createCosimStepForOneFMU(Adaptation sa) {
  326. Log.push("createCosimStepForOneFMU")
  327. val fmu = (sa.inner as InnerFMUDeclarationFull).fmus.head
  328. val controlRule = sa.control.rule as CustomControlRule
  329. val returnedStepVar = controlRule.appendDoStep(fmu)
  330. val stepVarSingleton = new LinkedList()
  331. stepVarSingleton.add(returnedStepVar)
  332. controlRule.appendReturnCosimStep(stepVarSingleton)
  333. Log.pop("createCosimStepForOneFMU")
  334. }
  335. def appendReturnCosimStep(CustomControlRule rule, LinkedList<SingleVarDeclaration> stepVariables) {
  336. Log.push("appendReturnCosimStep")
  337. if (stepVariables.size == 0){
  338. throw new Exception("Does not make sense. At least one inner FMU is expected.")
  339. }
  340. val minExpression = SemanticAdaptationFactory.eINSTANCE.createMin()
  341. Log.println("Creating min(...) expression with the following arguments:")
  342. for(varDecl : stepVariables){
  343. val varRef = SemanticAdaptationFactory.eINSTANCE.createVariable()
  344. varRef.ref = varDecl
  345. minExpression.args.add(varRef)
  346. Log.println(varDecl.name)
  347. }
  348. rule.returnstatement = SemanticAdaptationFactory.eINSTANCE.createReturnStatement()
  349. rule.returnstatement.expr = minExpression
  350. Log.pop("appendReturnCosimStep")
  351. }
  352. def appendDoStep(CustomControlRule rule, InnerFMU fmu) {
  353. Log.push("appendDoStep")
  354. val t = SemanticAdaptationFactory.eINSTANCE.createCurrentTime()
  355. val H = SemanticAdaptationFactory.eINSTANCE.createStepSize()
  356. val doStep = SemanticAdaptationFactory.eINSTANCE.createDoStepFun()
  357. doStep.t = t
  358. doStep.h = H
  359. doStep.fmu = fmu
  360. val step_var = SemanticAdaptationFactory.eINSTANCE.createSingleVarDeclaration()
  361. step_var.name = "H_" + fmu.name
  362. step_var.expr = doStep
  363. val step_decl = SemanticAdaptationFactory.eINSTANCE.createDeclaration()
  364. step_decl.declarations.add(step_var)
  365. rule.controlRulestatements.add(step_decl)
  366. Log.println("Added var " + step_var.name + " := doStep(t, H, " + fmu.name + ")")
  367. Log.pop("appendDoStep")
  368. return step_var
  369. }
  370. def createCosimStepForMultipleFMUs(Adaptation sa) {
  371. Log.push("createCosimStepForMultipleFMUs")
  372. val innerDeclaration = (sa.inner as InnerFMUDeclarationFull)
  373. val controlRule = sa.control.rule as CustomControlRule
  374. val stepVarSingleton = new LinkedList()
  375. for (fmu : innerDeclaration.topologicalSort()){
  376. val returnedStepVar = controlRule.appendDoStep(fmu)
  377. stepVarSingleton.add(returnedStepVar)
  378. }
  379. controlRule.appendReturnCosimStep(stepVarSingleton)
  380. Log.pop("createCosimStepForMultipleFMUs")
  381. }
  382. def topologicalSort(InnerFMUDeclarationFull scenario){
  383. Log.push("topologicalSort")
  384. val DirectedGraph<InnerFMU> inner_fmu_graph = createFMUGraph(scenario)
  385. val result = TopologicalSort.sort(inner_fmu_graph)
  386. Log.println("Sorting: " + result)
  387. Log.pop("topologicalSort")
  388. return result
  389. }
  390. def createFMUGraph(InnerFMUDeclarationFull scenario) {
  391. Log.push("createFMUGraph")
  392. val graph = new FMUGraph()
  393. for (fmu : scenario.fmus){
  394. graph.addNode(fmu)
  395. }
  396. for (connection : scenario.connection){
  397. check(connection.src.port.eContainer instanceof InnerFMU &&
  398. connection.tgt.port.eContainer instanceof InnerFMU, "Weird connection found: " + connection)
  399. if (reactiveMealyFMU(connection.tgt.port.eContainer as InnerFMU)){
  400. graph.addEdge(connection.src.port.eContainer as InnerFMU, connection.tgt.port.eContainer as InnerFMU)
  401. } else {
  402. Log.println("FMU " + (connection.tgt.port.eContainer as InnerFMU).name + " is not reactive mealy, so it has no algebraic dependencies.")
  403. }
  404. }
  405. Log.println(graph.toString())
  406. Log.pop("createFMUGraph")
  407. return graph
  408. }
  409. def reactiveMealyFMU(InnerFMU fmu) {
  410. return fmu.reactiveness == ReactiveOrDelayed.REACTIVE && fmu.machine == MooreOrMealy.MEALY
  411. }
  412. def check(Boolean condition, String msg){
  413. if (! condition){
  414. throw new Exception("Assertion error: " + msg)
  415. }
  416. }
  417. def onlyOneInternalFMU(Adaptation sa) {
  418. if(sa.inner instanceof InnerFMUDeclarationFull){
  419. return (sa.inner as InnerFMUDeclarationFull).fmus.size == 1
  420. } else {
  421. throw new Exception('This kind of internal scenario is not supported yet.')
  422. }
  423. }
  424. def transitiveStep(HashMap<Port, Port> internalOutputPort2ExternalPortBindings, HashMap<Port, SingleVarDeclaration> externalOutputPort2OutVarDeclaration) {
  425. Log.push("transitiveStep")
  426. val internalOutputPort2OutVarDeclaration = new HashMap<Port, SingleVarDeclaration>()
  427. for(internalOutputPort : internalOutputPort2ExternalPortBindings.keySet){
  428. val externalOutputPort = internalOutputPort2ExternalPortBindings.get(internalOutputPort)
  429. if (externalOutputPort2OutVarDeclaration.containsKey(externalOutputPort)){
  430. val outVar = externalOutputPort2OutVarDeclaration.get(externalOutputPort)
  431. Log.println("Found binding: " + internalOutputPort.qualifiedName + "->" + externalOutputPort.qualifiedName + " to be stored in " + outVar.name)
  432. internalOutputPort2OutVarDeclaration.put(internalOutputPort, outVar)
  433. }
  434. }
  435. Log.pop("transitiveStep")
  436. return internalOutputPort2OutVarDeclaration
  437. }
  438. def String qualifiedName(Port port){
  439. if (port.eContainer instanceof FMU){
  440. return (port.eContainer as FMU).name + "." + port.name
  441. }
  442. return port.name
  443. }
  444. def removeBindings(HashMap<Port, Port> internalPort2ExternalPortBindings, Adaptation sa) {
  445. Log.push("removeBindings")
  446. for (internalPort : internalPort2ExternalPortBindings.keySet){
  447. val externalPort = internalPort2ExternalPortBindings.get(internalPort)
  448. Log.println("Removing binding " + externalPort.qualifiedName + "->" + internalPort.qualifiedName)
  449. externalPort.targetdependency = null
  450. Log.println("Removing binding " + externalPort.qualifiedName + "<-" + internalPort.qualifiedName)
  451. externalPort.sourcedependency = null
  452. }
  453. Log.pop("removeBindings")
  454. }
  455. def findAllExternalPort2InputPort_Bindings(Adaptation sa) {
  456. Log.push("findAllExternalPort2InputPort_Bindings")
  457. val internalPort2ExternalPortBindings = new HashMap<Port, Port>()
  458. for (port : getAllInnerFMUInputPortDeclarations(sa)){
  459. var parentFMU = port.eContainer as InnerFMU
  460. Log.println("Checking if port " + port.qualifiedName + " is bound to an external port.")
  461. val externalPort = findExternalPortByTargetDependency(sa.inports, port)
  462. if (externalPort !== null){
  463. Log.println("Port " + port.qualifiedName + " is bound to an external port: " + externalPort.qualifiedName)
  464. internalPort2ExternalPortBindings.put(port, externalPort)
  465. } else {
  466. Log.println("Port " + port.qualifiedName + " is not bound to an external port.")
  467. }
  468. }
  469. Log.pop("findAllExternalPort2InputPort_Bindings")
  470. return internalPort2ExternalPortBindings
  471. }
  472. def findAllInternalPort2ExternalOutputPort_Bindings(Adaptation sa) {
  473. Log.push("findAllInternalPort2ExternalOutputPort_Bindings")
  474. val internalPort2ExternalPortBindings = new HashMap<Port, Port>()
  475. for (port : getAllInnerFMUOutputPortDeclarations(sa)){
  476. Log.println("Checking if port " + port.qualifiedName + " is bound to an external port.")
  477. val externalPort = findExternalPortBySourceDependency(sa.outports, port)
  478. if (externalPort !== null){
  479. Log.println("Port " + externalPort.qualifiedName + " is bound to an internal port: " + port.qualifiedName
  480. )
  481. internalPort2ExternalPortBindings.put(port, externalPort)
  482. } else {
  483. Log.println("Port " + port.qualifiedName + " is not bound to an external port.")
  484. }
  485. }
  486. Log.pop("findAllInternalPort2ExternalOutputPort_Bindings")
  487. return internalPort2ExternalPortBindings
  488. }
  489. def createExternalPortNameFromInternalPort(String parentFMUName, String internalPortName) {
  490. //return parentFMUName + "__" + internalPortName // Violates transparency
  491. return internalPortName
  492. }
  493. def addInRules_External2Internal_Assignments(Adaptation sa, HashMap<Port, Port> internalPort2ExternalPort) {
  494. Log.push("addInRules_External2Internal_Assignments")
  495. val dataRule = getOrPrependTrueRule(sa.in.rules)
  496. for(internalPort : internalPort2ExternalPort.keySet){
  497. val externalPort = internalPort2ExternalPort.get(internalPort)
  498. check((dataRule.outputfunction instanceof CompositeOutputFunction), "Only CompositeOutputFunction is supported for now.")
  499. val outFunction = dataRule.outputfunction as CompositeOutputFunction
  500. addPortAssignment(outFunction.statements, internalPort, externalPort, 0, true)
  501. }
  502. Log.pop("addInRules_External2Internal_Assignments")
  503. }
  504. def addOutRules_Internal2External_Assignments(Adaptation sa, HashMap<Port, Port> internalPort2ExternalPort){
  505. Log.push("addOutRules_Internal2External_Assignments")
  506. val dataRule = getOrPrependTrueRule(sa.out.rules)
  507. for(internalPort : internalPort2ExternalPort.keySet){
  508. val externalPort = internalPort2ExternalPort.get(internalPort)
  509. check((dataRule.outputfunction instanceof CompositeOutputFunction), "Only CompositeOutputFunction is supported for now.")
  510. val outFunction = dataRule.outputfunction as CompositeOutputFunction
  511. addPortAssignment(outFunction.statements, externalPort, internalPort, 0, true)
  512. }
  513. Log.pop("addOutRules_Internal2External_Assignments")
  514. }
  515. def addPortAssignment(List<Statement> statements, Port toPort, Port fromPort, int position, boolean convertUnits) {
  516. Log.push("addPortAssignment")
  517. val assignment = SemanticAdaptationFactory.eINSTANCE.createAssignment()
  518. assignment.lvalue = SemanticAdaptationFactory.eINSTANCE.createVariable()
  519. (assignment.lvalue as Variable).owner = toPort.eContainer as FMU
  520. (assignment.lvalue as Variable).ref = toPort
  521. val varRef = SemanticAdaptationFactory.eINSTANCE.createVariable()
  522. varRef.owner = fromPort.eContainer as FMU
  523. varRef.ref = fromPort
  524. if (convertUnits && compatibleUnits(toPort.unity, fromPort.unity) && !unitsEqual(toPort.unity, fromPort.unity)){
  525. Log.println("Converting units " + fromPort.unity + " to " + toPort.unity)
  526. assignment.expr = getConversionExpression(toPort.unity, fromPort.unity, varRef)
  527. } else {
  528. assignment.expr = varRef
  529. Log.println("Assignment " + toPort.qualifiedName + " := " + fromPort.qualifiedName + " created.")
  530. }
  531. statements.add(position, assignment)
  532. Log.pop("addPortAssignment")
  533. }
  534. def getConversionExpression(Unity toUnits, Unity fromUnit, Variable varFrom) {
  535. check(toUnits instanceof AtomicUnity && fromUnit instanceof AtomicUnity, "Conversion between units is only supported for AtomicUnits.")
  536. var toAtomic = toUnits as AtomicUnity
  537. var fromAtomic = fromUnit as AtomicUnity
  538. check(fromAtomic.name == "cm" && toAtomic.name == "m", "Conversion only possible between cm and m... Not very usefull :)")
  539. var division = SemanticAdaptationFactory.eINSTANCE.createDiv()
  540. division.left = varFrom
  541. var hundred = SemanticAdaptationFactory.eINSTANCE.createRealLiteral()
  542. hundred.value=100f
  543. division.right = hundred
  544. return division
  545. }
  546. def dispatch boolean unitsEqual(DivideUnity u1, DivideUnity u2) {
  547. return unitsEqual(u1.left, u2.left) && unitsEqual(u1.right, u2.right)
  548. }
  549. def dispatch boolean unitsEqual(Void u1, Void u2) {
  550. return true
  551. }
  552. def dispatch boolean unitsEqual(MultiplyUnity u1, MultiplyUnity u2) {
  553. return unitsEqual(u1.left, u2.left) && unitsEqual(u1.right, u2.right)
  554. }
  555. def dispatch boolean unitsEqual(AtomicUnity u1, AtomicUnity u2) {
  556. return u1.name == u2.name && u1.power == u2.power
  557. }
  558. def compatibleUnits(Unity u1, Unity u2) {
  559. if ((u1 === null && u2===null) ||
  560. (u1 !== null && u2!==null)
  561. ){
  562. // TODO What makes two units compatible?
  563. return true
  564. } else {
  565. return false
  566. }
  567. }
  568. def addInRules_External2Stored_Assignments(Adaptation sa, HashMap<Port, SingleVarDeclaration> inputPort2InVarDeclaration) {
  569. Log.push("addInRules_External2Stored_Assignments")
  570. if (sa.in === null){
  571. sa.in = SemanticAdaptationFactory.eINSTANCE.createInRulesBlock()
  572. }
  573. addRules_Port2Stored_Assignments(sa.in.rules, inputPort2InVarDeclaration)
  574. Log.pop("addInRules_External2Stored_Assignments")
  575. }
  576. def addOutRules_Internal2Stored_Assignments(Adaptation sa, HashMap<Port, SingleVarDeclaration> internalOutputPort2OutVarDeclaration) {
  577. Log.push("addOutRules_Internal2Stored_Assignments")
  578. if (sa.out === null){
  579. sa.out = SemanticAdaptationFactory.eINSTANCE.createOutRulesBlock()
  580. }
  581. addRules_Port2Stored_Assignments(sa.out.rules, internalOutputPort2OutVarDeclaration)
  582. Log.pop("addOutRules_Internal2Stored_Assignments")
  583. }
  584. def addRules_Port2Stored_Assignments(List<DataRule> rules, HashMap<Port, SingleVarDeclaration> port2VarDeclaration) {
  585. Log.push("addRules_External2Stored_Assignments")
  586. val dataRule = getOrPrependTrueRule(rules)
  587. if (dataRule.statetransitionfunction.expression !== null){
  588. throw new Exception("Expressions in rules are not supported yet.")
  589. // This and the one below are asily solved with a syntactic sugar substitution.
  590. }
  591. if (dataRule.statetransitionfunction.assignment !== null){
  592. throw new Exception("Assignment in rules are not supported yet.")
  593. }
  594. for(port : port2VarDeclaration.keySet){
  595. val storedVarDecl = port2VarDeclaration.get(port)
  596. addAssignmentToStoredVar(dataRule.statetransitionfunction.statements, port, storedVarDecl)
  597. }
  598. Log.pop("addRules_External2Stored_Assignments")
  599. }
  600. def addAssignmentToStoredVar(List<Statement> statements, Port internalPort, SingleVarDeclaration storedVarDecl) {
  601. Log.push("addAssignmentToStoredVar")
  602. val assignment = SemanticAdaptationFactory.eINSTANCE.createAssignment()
  603. assignment.lvalue = SemanticAdaptationFactory.eINSTANCE.createVariable()
  604. assignment.lvalue.ref = storedVarDecl
  605. assignment.expr = SemanticAdaptationFactory.eINSTANCE.createVariable()
  606. (assignment.expr as Variable).owner = internalPort.eContainer as FMU
  607. (assignment.expr as Variable).ref = internalPort
  608. statements.add(0, assignment)
  609. Log.println("Assignment " + storedVarDecl.name + " := " + internalPort.qualifiedName + " created.")
  610. Log.pop("addAssignmentToStoredVar")
  611. }
  612. def getOrPrependTrueRule(List<DataRule> rules) {
  613. var DataRule rule = null
  614. if (rules.size == 0 || !isTrueRule(rules.head)){
  615. Log.println("No existing rule found with true condition. Creating one.")
  616. val trueRule = SemanticAdaptationFactory.eINSTANCE.createDataRule()
  617. trueRule.condition = SemanticAdaptationFactory.eINSTANCE.createRuleCondition()
  618. val trueExpr = SemanticAdaptationFactory.eINSTANCE.createBoolLiteral()
  619. trueExpr.value = "true"
  620. trueRule.condition.condition = trueExpr
  621. trueRule.statetransitionfunction = SemanticAdaptationFactory.eINSTANCE.createStateTransitionFunction()
  622. trueRule.outputfunction = SemanticAdaptationFactory.eINSTANCE.createCompositeOutputFunction()
  623. rules.add(0, trueRule)
  624. rule = trueRule
  625. } else {
  626. Log.println("Existing rule with true condition found.")
  627. rule = rules.head
  628. }
  629. return rule
  630. }
  631. def isTrueRule(DataRule rule){
  632. if (rule.condition.condition instanceof BoolLiteral){
  633. return (rule.condition.condition as BoolLiteral).value == "true"
  634. }
  635. return false
  636. }
  637. def addInVars(Adaptation sa, Map<Port, SingleParamDeclaration> inputPort2parameterDeclaration){
  638. Log.push("addInVars")
  639. if (sa.in === null){
  640. sa.in = SemanticAdaptationFactory.eINSTANCE.createInRulesBlock()
  641. }
  642. val inputPort2InVarDeclaration = addStorageVars(sa.in.globalInVars, inputPort2parameterDeclaration)
  643. Log.pop("addInVars")
  644. return inputPort2InVarDeclaration
  645. }
  646. def addOutVars(Adaptation sa, Map<Port, SingleParamDeclaration> outputPort2parameterDeclaration){
  647. Log.push("addOutVars")
  648. if (sa.out === null){
  649. sa.out = SemanticAdaptationFactory.eINSTANCE.createOutRulesBlock()
  650. }
  651. val outputPort2InVarDeclaration = addStorageVars(sa.out.globalOutVars, outputPort2parameterDeclaration)
  652. Log.pop("addOutVars")
  653. return outputPort2InVarDeclaration
  654. }
  655. def addStorageVars(List<Declaration> varDeclarations, Map<Port, SingleParamDeclaration> port2parameterDeclaration){
  656. Log.push("addStorageVars")
  657. var port2VarDeclaration = new HashMap<Port, SingleVarDeclaration>()
  658. for(port : port2parameterDeclaration.keySet){
  659. Log.println("Processing port " + port.qualifiedName)
  660. val paramDecl = port2parameterDeclaration.get(port)
  661. val varDeclarationName = getStorageVarDeclarationName(port)
  662. if (!varDeclarationExists(varDeclarationName, varDeclarations) ){
  663. Log.println("Creating new variable declaration " + varDeclarationName)
  664. val varDeclaration = addNewVarDeclaration(port, paramDecl, varDeclarations)
  665. port2VarDeclaration.put(port, varDeclaration)
  666. } else {
  667. Log.println("Input variable declaration " + varDeclarationName + " already exists.")
  668. }
  669. }
  670. Log.pop("addStorageVars")
  671. return port2VarDeclaration
  672. }
  673. def addNewVarDeclaration(Port externalInputPort, SingleParamDeclaration paramDecl, List<Declaration> varDeclarations) {
  674. /*
  675. if (sa.in === null){
  676. sa.in = SemanticAdaptationFactory.eINSTANCE.createInRulesBlock()
  677. }
  678. */
  679. if (varDeclarations.size == 0){
  680. varDeclarations.add(SemanticAdaptationFactory.eINSTANCE.createDeclaration())
  681. }
  682. val newSingleVarDecl = SemanticAdaptationFactory.eINSTANCE.createSingleVarDeclaration()
  683. newSingleVarDecl.name = getStorageVarDeclarationName(externalInputPort)
  684. newSingleVarDecl.type = externalInputPort.type
  685. val initValue = SemanticAdaptationFactory.eINSTANCE.createVariable()
  686. initValue.ref = paramDecl
  687. newSingleVarDecl.expr = initValue
  688. varDeclarations.head.declarations.add(newSingleVarDecl)
  689. Log.println("New variable declaration created: " + newSingleVarDecl.name + " := " + paramDecl.name)
  690. return newSingleVarDecl
  691. }
  692. def varDeclarationExists(String invarName, List<Declaration> varDeclarations) {
  693. for (declarations : varDeclarations){ // sa.in.globalInVars
  694. for (decl : declarations.declarations){
  695. if (decl.name == invarName){
  696. return true
  697. }
  698. }
  699. }
  700. return false
  701. }
  702. def getStorageVarDeclarationName(Port externalInputPort) {
  703. return "stored__" + externalInputPort.name;
  704. }
  705. def genericDeclarationInferenceAlgorithm(Adaptation sa,
  706. (EObject)=>Object getField,
  707. (EObject, Object)=>void setField,
  708. (EObject)=>Object inferField
  709. ){
  710. Log.push("Running generic inference algorithm...")
  711. /*
  712. * Dumbest (and simplest) algorithm for this is a fixed point computation:
  713. * 1. Look for every var/port declaration
  714. * 2. If that var has a XXX already, nothing else to be done.
  715. * 3. If that var has no XXX declared, then
  716. * 3.1 If var/port has an initial value or connection, then
  717. * 3.1.1 If the initial_value/connection has a XXX declared, then var gets that XXX.
  718. * 3.1.2 Otherwise, nothing else to be done.
  719. * 3.2 If var/port has no initial value or connection then this either is a missing feature, or an error.
  720. * 3.3 If something has changed, go to 1. Otherwise, end.
  721. *
  722. * An extra set of instructions is there to push the element field information using connections and bindings.
  723. */
  724. var fixedPoint = false
  725. var unfieldedElementsCounter = 0
  726. while (! fixedPoint){
  727. fixedPoint = true
  728. unfieldedElementsCounter = 0
  729. Log.println("Inferring parameter fields...")
  730. for (paramDeclarations : sa.params) {
  731. for (paramDeclaration : paramDeclarations.declarations) {
  732. Log.println("Computing field for param " + paramDeclaration.name)
  733. if(getField.apply(paramDeclaration) !== null){
  734. Log.println("Already has been inferred: " + getField.apply(paramDeclaration))
  735. } else {
  736. Log.println("Has not been inferred yet.")
  737. if (tryInferAndAssignField(paramDeclaration, getField, setField, inferField)){
  738. fixedPoint = false
  739. } else {
  740. unfieldedElementsCounter++
  741. }
  742. }
  743. }
  744. }
  745. if(sa.inner !== null){
  746. if(sa.inner instanceof InnerFMUDeclarationFull){
  747. var innerFMUFull = sa.inner as InnerFMUDeclarationFull
  748. for(fmu : innerFMUFull.fmus){
  749. Log.println("Inferring port fields of FMU " + fmu.name)
  750. for (port : EcoreUtil2.getAllContentsOfType(fmu, Port)) {
  751. if(getField.apply(port) !== null){
  752. Log.println("Already has a field: " + getField.apply(port))
  753. } else {
  754. if (tryInferAndAssignField(port, getField, setField, inferField)){
  755. fixedPoint = false
  756. } else {
  757. unfieldedElementsCounter++
  758. }
  759. }
  760. }
  761. }
  762. if (innerFMUFull.connection.size > 0){
  763. Log.println("Inferring port fields using internal scenario bindings.")
  764. for (binding : innerFMUFull.connection){
  765. if (getField.apply(binding.src.port) !== null && getField.apply(binding.tgt.port) !== null){
  766. Log.println("Both ports have fields already.")
  767. } else {
  768. var inferredFieldAttempt = inferPortFieldViaConnection(binding, getField, setField, inferField)
  769. if (inferredFieldAttempt !== null){
  770. if (getField.apply(binding.src.port) === null){
  771. setField.apply(binding.src.port, inferredFieldAttempt)
  772. } else if (getField.apply(binding.tgt.port) === null){
  773. setField.apply(binding.tgt.port, inferredFieldAttempt)
  774. }
  775. fixedPoint = false
  776. unfieldedElementsCounter--
  777. Log.println("Got new field: " + inferredFieldAttempt)
  778. } else {
  779. Log.println("Cannot infer field from binding now.")
  780. }
  781. }
  782. }
  783. }
  784. } else {
  785. throw new Exception("Field inference only supported for InnerFMUDeclarationFull.")
  786. }
  787. }
  788. Log.println("Inferring external port fields...")
  789. var externalPorts = new LinkedList(sa.inports)
  790. externalPorts.addAll(sa.outports)
  791. for (port : externalPorts) {
  792. if (getField.apply(port) !== null){
  793. Log.println("Already has a field: " + getField.apply(port))
  794. if (pushPortField(port, getField, setField, inferField)){
  795. fixedPoint = false
  796. unfieldedElementsCounter--
  797. }
  798. } else {
  799. if (tryInferAndAssignField(port, getField, setField, inferField)){
  800. fixedPoint = false
  801. } else {
  802. unfieldedElementsCounter++
  803. }
  804. }
  805. }
  806. Log.println("Inferring all other declaration fields...")
  807. for (varDeclaration : EcoreUtil2.getAllContentsOfType(sa, SingleVarDeclaration)) {
  808. Log.println("Computing field for declaration " + varDeclaration.name)
  809. if(getField.apply(varDeclaration) !== null){
  810. Log.println("Already has a field: " + getField.apply(varDeclaration))
  811. } else {
  812. if (tryInferAndAssignField(varDeclaration, getField, setField, inferField)){
  813. fixedPoint = false
  814. } else {
  815. unfieldedElementsCounter++
  816. }
  817. }
  818. }
  819. Log.println("Ended iteration with unfielded elements remaining: " + unfieldedElementsCounter)
  820. } // while (! fixedPoint)
  821. Log.pop("Running generic inference algorithm... DONE")
  822. return unfieldedElementsCounter
  823. }
  824. def tryInferAndAssignField(EObject element,
  825. (EObject)=>Object getField,
  826. (EObject, Object)=>void setField,
  827. (EObject)=>Object inferField) {
  828. var inferredFieldAttempt = inferField.apply(element)
  829. if (inferredFieldAttempt !== null){
  830. setField.apply(element, inferredFieldAttempt)
  831. Log.println("Got new field: " + inferredFieldAttempt)
  832. return true
  833. } else {
  834. Log.println("Cannot infer field now.")
  835. return false
  836. }
  837. }
  838. def extractTypeFromExpression(Expression expression, String declarationName){
  839. if (expression instanceof IntLiteral){
  840. return "Integer"
  841. } else if (expression instanceof RealLiteral){
  842. return "Real"
  843. } else if (expression instanceof BoolLiteral){
  844. return "Bool"
  845. } else if (expression instanceof StringLiteral){
  846. return "String"
  847. } else if (expression instanceof Variable){
  848. var varRef = expression as Variable
  849. if (varRef.ref instanceof Port){
  850. var decl = varRef.ref as Port
  851. if (decl.type !== null){
  852. return decl.type
  853. }
  854. } else if(varRef.ref instanceof SingleParamDeclaration){
  855. var decl = varRef.ref as SingleParamDeclaration
  856. if (decl.type !== null){
  857. return decl.type
  858. }
  859. } else if(varRef.ref instanceof SingleVarDeclaration){
  860. var decl = varRef.ref as SingleVarDeclaration
  861. if (decl.type !== null){
  862. return decl.type
  863. }
  864. } else if(varRef.ref instanceof DeclaredParameter){
  865. throw new Exception("Type cannot be inferred for references to DeclaredParameter (for now). Please specify the explicit type of declaration " + declarationName)
  866. } else {
  867. throw new Exception("Unexpected kind of Variable expression found.")
  868. }
  869. } else if(expression instanceof BuiltinFunction){
  870. if (expression instanceof IsSet || expression instanceof Close){
  871. return "Bool"
  872. } else {
  873. return "Real"
  874. }
  875. } else if (expression instanceof CurrentTime) {
  876. return "Real"
  877. }
  878. else {
  879. throw new Exception("Initial value for declaration " + declarationName + " must be literal or var ref for now. Got instead " + expression + ". If you want complex expressions, give it an explicit type.")
  880. }
  881. return null
  882. }
  883. def inferPortFieldViaConnection(Connection binding,
  884. (EObject)=>Object getField,
  885. (EObject, Object)=>void setField,
  886. (EObject)=>Object inferField
  887. ){
  888. var Object resultField = null
  889. if (getField.apply(binding.src.port) !== null && getField.apply(binding.tgt.port) !== null){
  890. throw new Exception("Wrong way of using this function. It assumes type is not inferred yet.")
  891. } else if (getField.apply(binding.src.port) !== null){
  892. resultField = getField.apply(binding.src.port)
  893. Log.println("Target port "+ binding.tgt.port.qualifiedName +" got new type: " + resultField)
  894. } else if (getField.apply(binding.tgt.port) !== null){
  895. resultField = getField.apply(binding.tgt.port)
  896. Log.println("Target port "+ binding.src.port.qualifiedName +" got new type: " + resultField)
  897. }
  898. return resultField
  899. }
  900. def pushPortField(Port port,
  901. (EObject)=>Object getField,
  902. (EObject, Object)=>void setField,
  903. (EObject)=>Object inferField){
  904. var fieldInferred = false
  905. Log.println("Pushing field of port " + port.qualifiedName + " to its bindings.")
  906. if(getField.apply(port) === null){
  907. Log.println("Has no field to be pushed.")
  908. throw new Exception("Wrong way of using this function. It assumes field is already inferred.")
  909. } else {
  910. Log.println("Pushing field: " + getField.apply(port))
  911. if(port.sourcedependency !== null){
  912. Log.println("Has a source dependency: " + port.sourcedependency.port.qualifiedName)
  913. if(getField.apply(port.sourcedependency.port) === null){
  914. setField.apply(port.sourcedependency.port, getField.apply(port))
  915. Log.println("Port " + port.sourcedependency.port.qualifiedName + " got new type: " + getField.apply(port.sourcedependency.port))
  916. fieldInferred = true
  917. } else {
  918. Log.println("Source port already has field.")
  919. }
  920. } else {
  921. Log.println("Has no source dependency.")
  922. }
  923. if (port.targetdependency !== null) {
  924. Log.println("Has a target dependency: " + port.targetdependency.port.qualifiedName)
  925. if(getField.apply(port.targetdependency.port) === null){
  926. Log.println("Dependency has no field yet.")
  927. setField.apply(port.targetdependency.port, getField.apply(port))
  928. Log.println("Port " + port.targetdependency.port.qualifiedName + " got new type: " + getField.apply(port.targetdependency.port))
  929. fieldInferred = true
  930. } else {
  931. Log.println("Target port already has field.")
  932. }
  933. } else {
  934. Log.println("Has no target dependency.")
  935. }
  936. }
  937. return fieldInferred
  938. }
  939. def getPortUnit(Port port){
  940. var unitInferred = false
  941. Log.println("Computing unit for port " + port.qualifiedName)
  942. var Unity returnUnit = null
  943. if(port.unity !== null){
  944. throw new Exception("Wrong way of using this function. It assumes unit is not inferred yet.")
  945. } else {
  946. Log.println("Has no unit.")
  947. Log.println("Attempting to infer unit from bindings.")
  948. if(port.sourcedependency !== null){
  949. Log.println("Has a source dependency: " + port.sourcedependency.port.qualifiedName)
  950. if(port.sourcedependency.port.unity === null){
  951. Log.println("Dependency has no unit yet.")
  952. } else {
  953. returnUnit = port.sourcedependency.port.unity
  954. Log.println("Got new unit: " + returnUnit)
  955. unitInferred = true
  956. }
  957. } else {
  958. Log.println("Has no source dependency.")
  959. }
  960. if (port.targetdependency !== null && !unitInferred) {
  961. Log.println("Has a target dependency: " + port.targetdependency.port.qualifiedName)
  962. if(port.targetdependency.port.unity === null){
  963. Log.println("Dependency has no unit yet.")
  964. } else {
  965. returnUnit = port.targetdependency.port.unity
  966. Log.println("Got new unit: " + returnUnit)
  967. unitInferred = true
  968. }
  969. } else {
  970. Log.println("Has no target dependency, or unit has already been inferred from source dependency.")
  971. }
  972. }
  973. return returnUnit
  974. }
  975. def getPortType(Port port){
  976. var typeInferred = false
  977. Log.println("Computing type for port " + port.qualifiedName)
  978. var String returnType = null
  979. if(port.type !== null){
  980. throw new Exception("Wrong way of using this function. It assumes type is not inferred yet.")
  981. } else {
  982. Log.println("Has no type.")
  983. Log.println("Attempting to infer type from units.")
  984. if (port.unity !== null){
  985. returnType = "Real"
  986. Log.println("Got new type: " + returnType)
  987. typeInferred = true
  988. } else {
  989. Log.println("Attempting to infer type from bindings.")
  990. if(port.sourcedependency !== null){
  991. Log.println("Has a source dependency: " + port.sourcedependency.port.qualifiedName)
  992. if(port.sourcedependency.port.type === null){
  993. Log.println("Dependency has no type yet.")
  994. } else {
  995. returnType = port.sourcedependency.port.type
  996. Log.println("Got new type: " + returnType)
  997. typeInferred = true
  998. }
  999. } else {
  1000. Log.println("Has no source dependency.")
  1001. }
  1002. if (port.targetdependency !== null && !typeInferred) {
  1003. Log.println("Has a target dependency: " + port.targetdependency.port.qualifiedName)
  1004. if(port.targetdependency.port.type === null){
  1005. //println("Port object: " + port.targetdependency.port)
  1006. Log.println("Dependency has no type yet.")
  1007. } else {
  1008. returnType = port.targetdependency.port.type
  1009. Log.println("Got new type: " + returnType)
  1010. typeInferred = true
  1011. }
  1012. } else {
  1013. Log.println("Has no target dependency, or type has already been inferred from source dependency.")
  1014. }
  1015. }
  1016. }
  1017. return returnType
  1018. }
  1019. def addInPorts(Adaptation sa) {
  1020. Log.push("Adding input ports...")
  1021. for (port : getAllInnerFMUInputPortDeclarations(sa)){
  1022. var parentFMU = port.eContainer as InnerFMU
  1023. Log.println("Checking if port " + port.qualifiedName + " has incoming connections"
  1024. )
  1025. if (! hasConnection(port, sa, true)){
  1026. Log.println("Port " + port.qualifiedName + " has no incoming connections.")
  1027. val externalPortName = createExternalPortNameFromInternalPort(parentFMU.name, port.name)
  1028. if (findExternalPortByName(sa, externalPortName) === null){
  1029. var newExternalPort = createExternalInputPortDeclarationFromInnerPort(port, parentFMU, sa)
  1030. Log.println("External port " + newExternalPort.qualifiedName + " created.")
  1031. newExternalPort.bindExternalInputPortTo(parentFMU, port)
  1032. Log.println("External port " + newExternalPort.qualifiedName + " bound to port " + port.qualifiedName)
  1033. } else {
  1034. Log.println("Error: External port " + externalPortName + " already declared.")
  1035. throw new Exception("Error: External port " + externalPortName + " already declared. Please rename it to avoid clashes.")
  1036. }
  1037. } else {
  1038. Log.println("Port " + port.qualifiedName + " has an incoming connection.")
  1039. }
  1040. }
  1041. Log.pop("Adding input ports... DONE")
  1042. }
  1043. def bindExternalInputPortTo(Port externalInputPort, InnerFMU internalPortParent, Port internalPort) {
  1044. externalInputPort.targetdependency = SemanticAdaptationFactory.eINSTANCE.createSpecifiedPort()
  1045. externalInputPort.targetdependency.owner = internalPortParent
  1046. externalInputPort.targetdependency.port = internalPort
  1047. }
  1048. def bindExternalOutputPortTo(Port externalOutputPort, InnerFMU internalPortParent, Port internalPort) {
  1049. externalOutputPort.sourcedependency = SemanticAdaptationFactory.eINSTANCE.createSpecifiedPort()
  1050. externalOutputPort.sourcedependency.owner = internalPortParent
  1051. externalOutputPort.sourcedependency.port = internalPort
  1052. }
  1053. def createExternalInputPortDeclarationFromInnerPort(Port port, FMU parent, Adaptation sa) {
  1054. var externalInputPort = createExternalPortDeclarationFromInnerPort(port, parent)
  1055. sa.inports.add(externalInputPort)
  1056. return externalInputPort
  1057. }
  1058. def createExternalOutputPortDeclarationFromInnerPort(Port port, FMU parent, Adaptation sa) {
  1059. var externalOutputPort = createExternalPortDeclarationFromInnerPort(port, parent)
  1060. sa.outports.add(externalOutputPort)
  1061. return externalOutputPort
  1062. }
  1063. def createExternalPortDeclarationFromInnerPort(Port port, FMU parent) {
  1064. var externalInputPort = SemanticAdaptationFactory.eINSTANCE.createPort()
  1065. externalInputPort.name = createExternalPortNameFromInternalPort(parent.name, port.name)
  1066. externalInputPort.type = port.type
  1067. externalInputPort.unity = EcoreUtil2.copy(port.unity)
  1068. return externalInputPort
  1069. }
  1070. def findExternalPortByName(Adaptation adaptation, String name) {
  1071. for (externalInputPort : adaptation.inports){
  1072. if (externalInputPort.name == name){
  1073. return externalInputPort
  1074. }
  1075. }
  1076. return null
  1077. }
  1078. def findExternalPortByTargetDependency(List<Port> ports, Port targetDependency) {
  1079. for (externalInputPort : ports){
  1080. if (externalInputPort.targetdependency !== null && externalInputPort.targetdependency.port == targetDependency){
  1081. return externalInputPort
  1082. }
  1083. }
  1084. return null
  1085. }
  1086. def findExternalPortBySourceDependency(List<Port> ports, Port sourceDependency) {
  1087. for (externalInputPort : ports){
  1088. if (externalInputPort.sourcedependency !== null && externalInputPort.sourcedependency.port == sourceDependency){
  1089. return externalInputPort
  1090. }
  1091. }
  1092. return null
  1093. }
  1094. def hasConnection(Port port, Adaptation adaptation, Boolean checkForIncomming) {
  1095. var result = false
  1096. if ( (checkForIncomming && port.sourcedependency !== null) ||
  1097. (! checkForIncomming && port.targetdependency !== null)
  1098. ){
  1099. result = true
  1100. } else {
  1101. if (port.eContainer instanceof InnerFMU){
  1102. var innerScenarioDeclaration = EcoreUtil2.getContainerOfType(port, InnerFMUDeclaration)
  1103. if (innerScenarioDeclaration instanceof InnerFMUDeclarationFull){
  1104. var innerScenarioWithCoupling = innerScenarioDeclaration as InnerFMUDeclarationFull
  1105. if (innerScenarioWithCoupling.connection.size > 0){
  1106. for (connection : innerScenarioWithCoupling.connection ){
  1107. if ( (checkForIncomming && connection.tgt.port == port)){
  1108. Log.println("Port " + port.qualifiedName + " has an incoming connection from internal port " + connection.src.port.qualifiedName)
  1109. result = true
  1110. } else if (!checkForIncomming && connection.src.port == port) {
  1111. Log.println("Port " + port.qualifiedName + " has an outgoing connection to internal port " + connection.tgt.port.qualifiedName)
  1112. result = true
  1113. }
  1114. }
  1115. }
  1116. }
  1117. for (externalInputPort : adaptation.inports.filter[p | (checkForIncomming && p.targetdependency !== null) || (!checkForIncomming && p.sourcedependency !== null) ]){
  1118. if (checkForIncomming && externalInputPort.targetdependency.port == port){
  1119. Log.println("Port " + port.qualifiedName + " has an incoming connection from external port " + externalInputPort.qualifiedName)
  1120. result = true
  1121. } else if ( !checkForIncomming && externalInputPort.sourcedependency.port == port){
  1122. Log.println("Port " + port.qualifiedName + " has an outgoing connection to external port " + externalInputPort.qualifiedName)
  1123. result = true
  1124. }
  1125. }
  1126. }
  1127. }
  1128. return result
  1129. }
  1130. def getAllInnerFMUInputPortDeclarations(Adaptation sa){
  1131. return mapAllInnerFMUs(sa, [fmu | fmu.inports]);
  1132. }
  1133. def getAllInnerFMUOutputPortDeclarations(Adaptation sa){
  1134. return mapAllInnerFMUs(sa, [fmu | fmu.outports]);
  1135. }
  1136. def <T> List<T> mapAllInnerFMUs(Adaptation sa, (InnerFMU)=>List<T> map){
  1137. var result = new LinkedList()
  1138. if(sa.inner !== null){
  1139. if(sa.inner instanceof InnerFMUDeclarationFull){
  1140. var innerFMUFull = sa.inner as InnerFMUDeclarationFull
  1141. for(fmu : innerFMUFull.fmus){
  1142. result.addAll(map.apply(fmu))
  1143. }
  1144. } else {
  1145. throw new Exception("Only support for InnerFMUDeclarationFull.")
  1146. }
  1147. }
  1148. return result;
  1149. }
  1150. def addInParams(Adaptation sa) {
  1151. Log.push("Adding input parameters...")
  1152. val result = addParamForPortDeclarations(sa, sa.inports)
  1153. Log.pop("Adding input parameters... DONE")
  1154. return result
  1155. }
  1156. def addOutParams(Adaptation sa) {
  1157. Log.push("Adding output parameters...")
  1158. val result = addParamForPortDeclarations(sa, getAllInnerFMUOutputPortDeclarations(sa))
  1159. Log.pop("Adding output parameters... DONE")
  1160. return result
  1161. }
  1162. def addParamForPortDeclarations(Adaptation sa, List<Port> ports){
  1163. Log.push("addParamForPortDeclarations")
  1164. val PARAM_PREFIX = "INIT_"
  1165. var port2parameterDeclaration = new HashMap<Port, SingleParamDeclaration>(ports.size)
  1166. for (externalPortDecl : ports) {
  1167. Log.println("Generating parameter for port " + externalPortDecl.qualifiedName)
  1168. var paramname = PARAM_PREFIX + externalPortDecl.name.toUpperCase()
  1169. if (paramAlreadyDeclared(paramname, sa)){
  1170. Log.println("Parameter " + paramname + " already declared for port " + externalPortDecl.qualifiedName)
  1171. } else {
  1172. Log.println("Declaring new parameter " + paramname + " for port " + externalPortDecl.qualifiedName)
  1173. var paramDeclaration = addNewParamDeclaration(paramname, externalPortDecl, sa)
  1174. port2parameterDeclaration.put(externalPortDecl, paramDeclaration)
  1175. }
  1176. }
  1177. Log.pop("addParamForPortDeclarations")
  1178. return port2parameterDeclaration
  1179. }
  1180. def addNewParamDeclaration(String name, Port fromPort, Adaptation sa) {
  1181. var factory = SemanticAdaptationFactory.eINSTANCE
  1182. var paramDeclaration = factory.createSingleParamDeclaration()
  1183. paramDeclaration.name = name
  1184. paramDeclaration.type = fromPort.type
  1185. paramDeclaration.expr = getDefaultTypeExpression(paramDeclaration.type)
  1186. if (sa.params.size == 0){
  1187. sa.params.add(factory.createParamDeclarations())
  1188. }
  1189. sa.params.head.declarations.add(paramDeclaration)
  1190. return paramDeclaration
  1191. }
  1192. def getDefaultTypeExpression(String type) {
  1193. switch (type) {
  1194. case "Integer": {
  1195. val result = SemanticAdaptationFactory.eINSTANCE.createIntLiteral
  1196. result.value = 0
  1197. return result
  1198. }
  1199. case "Real": {
  1200. val result = SemanticAdaptationFactory.eINSTANCE.createRealLiteral
  1201. result.value = 0.0f
  1202. return result
  1203. }
  1204. case "Bool": {
  1205. val result = SemanticAdaptationFactory.eINSTANCE.createBoolLiteral
  1206. result.value = "false"
  1207. return result
  1208. }
  1209. case "String": {
  1210. val result = SemanticAdaptationFactory.eINSTANCE.createStringLiteral
  1211. result.value = " "
  1212. return result
  1213. }
  1214. default: {
  1215. throw new Exception("Unexpected type.")
  1216. }
  1217. }
  1218. }
  1219. def paramAlreadyDeclared(String name, Adaptation sa) {
  1220. for(paramDeclarations : sa.params){
  1221. for(paramDeclaration : paramDeclarations.declarations){
  1222. if(paramDeclaration.name == name){
  1223. return true
  1224. }
  1225. }
  1226. }
  1227. return false
  1228. }
  1229. def addOutPorts(Adaptation sa) {
  1230. Log.push("Adding output ports...")
  1231. for (port : getAllInnerFMUOutputPortDeclarations(sa)){
  1232. var parentFMU = port.eContainer as InnerFMU
  1233. Log.println("Checking if port " + port.qualifiedName + " has outgoing connections")
  1234. if (! hasConnection(port, sa, false)){
  1235. Log.println("Port " + port.qualifiedName + " has no outgoing connections.")
  1236. val externalPortName = createExternalPortNameFromInternalPort(parentFMU.name, port.name)
  1237. if (findExternalPortByName(sa, externalPortName) === null){
  1238. var newExternalPort = createExternalOutputPortDeclarationFromInnerPort(port, parentFMU, sa)
  1239. Log.println("External port " + newExternalPort.qualifiedName + " created.")
  1240. newExternalPort.bindExternalOutputPortTo(parentFMU, port)
  1241. Log.println("External port " + newExternalPort.qualifiedName + " bound to port " + port.qualifiedName)
  1242. } else {
  1243. Log.println("Error: External port " + externalPortName + " already declared.")
  1244. throw new Exception("Error: External port " + externalPortName + " already declared. Please rename it to avoid clashes.")
  1245. }
  1246. } else {
  1247. Log.println("Port " + port.qualifiedName + " has an incoming connection.")
  1248. }
  1249. }
  1250. Log.pop("Adding output ports... DONE")
  1251. }
  1252. }