SemanticAdaptationCanonicalGenerator.xtend 54 KB

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