diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/CallGraphTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/CallGraphTransformer.xtend
new file mode 100644
index 0000000..f1eaa80
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/CallGraphTransformer.xtend
@@ -0,0 +1,31 @@
+package templates.m2m.sw
+
+import com.google.inject.Inject
+import java.util.Map
+import org.eclipse.app4mc.amalthea.model.CallGraph
+import org.eclipse.app4mc.amalthea.model.Process
+import templates.AbstractAmaltheaInchronTransformer
+
+class CallGraphTransformer extends AbstractAmaltheaInchronTransformer{
+	
+	@Inject GraphEntryBaseTransformer graphEntryBaseTransformer
+	
+		def void transformCallGraph(CallGraph amltGraph, Process amltTask,
+		Map<Process,  com.inchron.realtime.root.model.Process> amltProcess_inchronProcessMap) {
+		
+		val com.inchron.realtime.root.model.Process inchronProcess = amltProcess_inchronProcessMap.get(amltTask)
+
+
+		val inchronCallGraph = inchronModelFactory.createCallGraph
+		inchronProcess.callGraph = inchronCallGraph
+		
+		amltGraph?.graphEntries?.forEach[amltGraphEntry|
+				
+				var inchronGraphEntryBase=	graphEntryBaseTransformer.transformGraphEntryBase(amltGraphEntry, amltTask,
+					amltProcess_inchronProcessMap)
+					inchronCallGraph.graphEntries.add(inchronGraphEntryBase)
+		]
+
+		
+		}
+}
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/GraphEntryBaseTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/GraphEntryBaseTransformer.xtend
index bf8af8a..932cab3 100644
--- a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/GraphEntryBaseTransformer.xtend
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/GraphEntryBaseTransformer.xtend
@@ -16,6 +16,7 @@
 package templates.m2m.sw;
 
 import com.google.inject.Inject
+import com.inchron.realtime.root.model.CallGraph
 import com.inchron.realtime.root.model.Process
 import java.util.Map
 import org.eclipse.app4mc.amalthea.model.CallSequence
@@ -35,106 +36,94 @@
 
 	@Inject RunnableTransformer runnableTransformer
 
+	@Inject ModeSwitchTransformer modeSwitchTransformer
+
 	def create inchronModelFactory.createFunction createFunction(java.lang.Process amltProcess, Runnable amltRunnable) {
 
 		cacheModel = customObjsStore.getInstance(AmltCacheModel)
 
 	}
 
-	def void transformGraphEntryBase(GraphEntryBase amltGraphEntry, org.eclipse.app4mc.amalthea.model.Process amltTask,
+	def com.inchron.realtime.root.model.GraphEntryBase transformGraphEntryBase(GraphEntryBase amltGraphEntry, org.eclipse.app4mc.amalthea.model.Process amltTask,
 		Map<org.eclipse.app4mc.amalthea.model.Process, Process> amltProcess_inchronProcessMap) {
 
 		val Process inchronProcess = amltProcess_inchronProcessMap.get(amltTask)
 		cacheModel = customObjsStore.getInstance(AmltCacheModel)
 
-		val inchronCallGraph = inchronModelFactory.createCallGraph
-
-		inchronProcess.callGraph = inchronCallGraph
+	 
 
 		if (amltGraphEntry instanceof CallSequence) {
 
-			val inchronCallSequence = inchronModelFactory.createCallSequence
-
-			inchronCallSequence.name = "CS"
-
-			inchronCallGraph.graphEntries.add(inchronCallSequence)
-
-			amltGraphEntry.calls.forEach [ amltCallSequenceItem |
-
-				if (amltCallSequenceItem instanceof TaskRunnableCall) {
-
-					var amltRunnable = amltCallSequenceItem.runnable
-
-					var inchronComponent = cacheModel.getInchronComponent(amltTask)
-
-					var inchronFunction = runnableTransformer.createFunction(inchronComponent, amltTask, amltRunnable)
-
-					var inchronFunctionCall = inchronModelFactory.createFunctionCall
-					inchronFunctionCall.function = inchronFunction
-					inchronFunctionCall.name = "call_" + inchronFunction.name
-					inchronCallSequence.calls.add(inchronFunctionCall)
-
-				} else if (amltCallSequenceItem instanceof InterProcessTrigger) {
-
-					var inchronActivationItem = inchronModelFactory.createActivationItem
-
-					inchronActivationItem.name = "ActivationItem"
-					inchronCallSequence.calls.add(inchronActivationItem)
-
-					val inchronActivationConnection = createActivationConnection()
-
-					inchronActivationConnection.name = inchronProcess.name + "_" + amltCallSequenceItem.stimulus.name +
-						"_Connection"
-					inchronActivationItem.connection = inchronActivationConnection
-
-					cacheModel.inchronModel.connections.add(inchronActivationConnection)
-
-					(amltCallSequenceItem.stimulus as InterProcessStimulus).affectedProcesses.forEach [ amltRefProcess |
-						{
-
-							var inchronActivateProcess = inchronModelFactory.createActivateProcess
-
-							inchronActivateProcess.target = amltProcess_inchronProcessMap.get(amltRefProcess)
-
-							inchronActivationConnection.activations.add(inchronActivateProcess)
-
-						}
-					]
-
-				// in the call sequence of the process, create ActivateProcess
-				// create ActivationItem -> ActivationConnection -> ActivationAction (ActivateProcess)
-				// In Amalthea -> It is handled with InterProcessStimulus being refered by InterProcessTrigger -> Stimulus is referred inside a Task 
-				} else if (amltCallSequenceItem instanceof SchedulePoint) {
-				}
-
-			]
-		} else if (amltGraphEntry instanceof ModeSwitch) {
-
-			var amltDefaultEntry = amltGraphEntry.defaultEntry
-
-			if (amltDefaultEntry !== null) {
-				amltDefaultEntry?.items.forEach [ amltEntryItem |
-					transformGraphEntryBase(amltEntryItem as GraphEntryBase, amltTask, amltProcess_inchronProcessMap)
-				]
-			}
-
-			amltGraphEntry.entries.forEach [ amltEntry |
-				{
-
-					amltEntry.items.forEach [ amltEntryItem |
-						{
-							transformGraphEntryBase(amltEntryItem as GraphEntryBase, amltTask,
-								amltProcess_inchronProcessMap)
-
-						}
-					]
-
-				}
-			]
-
+			var inchronCallSequence=createCallSequence( amltGraphEntry, amltTask, inchronProcess, amltProcess_inchronProcessMap)
+			
+			return (inchronCallSequence)
+			
+		} else if (amltGraphEntry instanceof ModeSwitch) { 
+			
+			var inchronModeSwitch=modeSwitchTransformer.createModeSwitch(amltGraphEntry,amltTask, amltProcess_inchronProcessMap)
+			
+			return (inchronModeSwitch)
+			
 		} else if (amltGraphEntry instanceof ProbabilitySwitch) {
-			// TODO: handle it later
+			return inchronModelFactory.createProbabilitySwitch
 		}
+		return null
+	}
+	
+	protected def create inchronModelFactory.createCallSequence   createCallSequence(  CallSequence amltGraphEntry, org.eclipse.app4mc.amalthea.model.Process amltTask, Process inchronProcess, Map<org.eclipse.app4mc.amalthea.model.Process, Process> amltProcess_inchronProcessMap) {
+		
+		it.name = "CS"
+		
+		
+		amltGraphEntry.calls.forEach [ amltCallSequenceItem |
+		
+			if (amltCallSequenceItem instanceof TaskRunnableCall) {
+		
+				var amltRunnable = amltCallSequenceItem.runnable
+		
+				var inchronComponent = cacheModel.getInchronComponent(amltTask)
+		
+				var inchronFunction = runnableTransformer.createFunction(inchronComponent, amltTask, amltRunnable)
+		
+				var inchronFunctionCall = inchronModelFactory.createFunctionCall
+				inchronFunctionCall.function = inchronFunction
+				inchronFunctionCall.name = "call_" + inchronFunction.name
+				it.calls.add(inchronFunctionCall)
+		
+			} else if (amltCallSequenceItem instanceof InterProcessTrigger) {
+		
+				var inchronActivationItem = inchronModelFactory.createActivationItem
+		
+				inchronActivationItem.name = "ActivationItem"
+				it.calls.add(inchronActivationItem)
+		
+				val inchronActivationConnection = createActivationConnection()
+		
+				inchronActivationConnection.name = inchronProcess.name + "_" + amltCallSequenceItem.stimulus.name +
+					"_Connection"
+				inchronActivationItem.connection = inchronActivationConnection
+		
+				cacheModel.inchronModel.connections.add(inchronActivationConnection)
+		
+				(amltCallSequenceItem.stimulus as InterProcessStimulus).affectedProcesses.forEach [ amltRefProcess |
+					{
+		
+						var inchronActivateProcess = inchronModelFactory.createActivateProcess
+		
+						inchronActivateProcess.target = amltProcess_inchronProcessMap.get(amltRefProcess)
+		
+						inchronActivationConnection.activations.add(inchronActivateProcess)
+		
+					}
+				]
+		
+			// in the call sequence of the process, create ActivateProcess
+			// create ActivationItem -> ActivationConnection -> ActivationAction (ActivateProcess)
+			// In Amalthea -> It is handled with InterProcessStimulus being refered by InterProcessTrigger -> Stimulus is referred inside a Task 
+			} else if (amltCallSequenceItem instanceof SchedulePoint) {
+			}
+		
+		]
 	}
 
 	def create inchronModelFactory.createActivationConnection createActivationConnection() {
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeSwitchTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeSwitchTransformer.xtend
new file mode 100644
index 0000000..5aaae60
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeSwitchTransformer.xtend
@@ -0,0 +1,99 @@
+/**
+ * *******************************************************************************
+ * Copyright (c) 2019 Robert Bosch GmbH and others.
+ * 
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Robert Bosch GmbH - initial API and implementation
+ * *******************************************************************************
+ */
+package templates.m2m.sw
+
+import com.google.inject.Inject
+import com.inchron.realtime.root.model.Component
+import java.util.Map
+import org.eclipse.app4mc.amalthea.model.GraphEntryBase
+import org.eclipse.app4mc.amalthea.model.ModeSwitch
+import org.eclipse.app4mc.amalthea.model.Process
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch
+import templates.utils.AmltCacheModel
+
+class ModeSwitchTransformer extends GraphEntryBaseTransformer { 
+	
+	@Inject RunnableItemTransformer runnableItemTransformer
+	@Inject ModeValueDisjunctionTransformer modeValueDisjunctionTransformer
+		
+	var AmltCacheModel cacheModel
+	
+	public def create inchronModelFactory.createModeSwitch createModeSwitch(Component inchronComponent, Process amltTask,
+		 RunnableModeSwitch amltRunnableModeSwitch){
+		
+		cacheModel = customObjsStore.getInstance(AmltCacheModel)
+		
+	 val inchronCallSequence=inchronModelFactory.createCallSequence
+	 
+		amltRunnableModeSwitch?.defaultEntry?.items?.forEach[amltRunnableModeSwitchRunnableItem|
+			
+			inchronCallSequence.calls.addAll(runnableItemTransformer.transformRunnableItem(inchronComponent,amltTask,amltRunnableModeSwitchRunnableItem))
+		]
+		
+	}
+	
+	public def create inchronModelFactory.createModeSwitch createModeSwitch(ModeSwitch amltGraphEntry,Process amltTask,
+		Map<Process, com.inchron.realtime.root.model.Process> amltProcess_inchronProcessMap){
+		
+		cacheModel = customObjsStore.getInstance(AmltCacheModel)
+		
+			var amltDefaultEntry = amltGraphEntry.defaultEntry
+			
+			if (amltDefaultEntry !== null) {
+					it.defaultEntry=inchronModelFactory.createModeSwitchDefault
+					
+				amltDefaultEntry?.items.forEach [ amltEntryItem |
+					var inchronGraphEntryBase=transformGraphEntryBase(amltEntryItem as GraphEntryBase, amltTask, amltProcess_inchronProcessMap)
+					it.defaultEntry.graphEntries.add(inchronGraphEntryBase)
+				]
+			}
+
+			amltGraphEntry?.entries?.forEach [ amltEntry |
+				{
+					val inchronModeSwitchEntry=inchronModelFactory.createModeSwitchEntry
+					
+					it.entries.add(inchronModeSwitchEntry)
+
+					amltEntry?.items?.forEach [ amltEntryItem |
+						{
+							var inchronGraphEntryBase=transformGraphEntryBase(amltEntryItem as GraphEntryBase, amltTask,
+								amltProcess_inchronProcessMap)
+								
+								inchronModeSwitchEntry.graphEntries.add(inchronGraphEntryBase)
+
+						}
+						
+					]
+					
+					var amltCondition=amltEntry.condition
+					if(amltCondition!==null){
+						var inchronConditon=modeValueDisjunctionTransformer.createModeCondition(amltCondition,amltTask,amltProcess_inchronProcessMap)
+						
+						inchronModeSwitchEntry.condition = inchronConditon
+						
+						if(inchronConditon.eContainer===null){
+							//Adding ModeCondition to the Inchron Model
+							cacheModel.inchronModel.globalModeConditions.add(inchronConditon)
+						}
+					}
+
+				}
+			]
+
+		
+	}
+	
+ 
+}
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeTransformer.xtend
new file mode 100644
index 0000000..2129222
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeTransformer.xtend
@@ -0,0 +1,14 @@
+package templates.m2m.sw
+
+import templates.AbstractAmaltheaInchronTransformer
+import org.eclipse.app4mc.amalthea.model.Mode
+
+class ModeTransformer  extends AbstractAmaltheaInchronTransformer {
+	
+		public def create inchronModelFactory.createModeGroup createModeGroup(Mode amltMode){
+			
+			it.name=amltMode.name
+			
+			
+		}
+}
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeValueDisjunctionTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeValueDisjunctionTransformer.xtend
new file mode 100644
index 0000000..087f87f
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/ModeValueDisjunctionTransformer.xtend
@@ -0,0 +1,58 @@
+package templates.m2m.sw;
+
+import java.util.Map
+import org.eclipse.app4mc.amalthea.model.ModeLabel
+import org.eclipse.app4mc.amalthea.model.ModeLiteral
+import org.eclipse.app4mc.amalthea.model.ModeValue
+import org.eclipse.app4mc.amalthea.model.ModeValueConjunction
+import org.eclipse.app4mc.amalthea.model.ModeValueDisjunction
+import org.eclipse.app4mc.amalthea.model.Process
+import templates.AbstractAmaltheaInchronTransformer
+import templates.utils.AmltCacheModel
+
+public class ModeValueDisjunctionTransformer extends AbstractAmaltheaInchronTransformer {
+
+var AmltCacheModel cacheModel
+
+public def create inchronModelFactory.createModeCondition createModeCondition(ModeValueDisjunction amltModeValueDisjunction,Process amltTask,
+		Map<Process, com.inchron.realtime.root.model.Process> amltProcess_inchronProcessMap){
+			
+				cacheModel = customObjsStore.getInstance(AmltCacheModel)
+				
+			amltModeValueDisjunction?.entries?.forEach[amltModeValueDisjunctionEntry|{
+				
+				val inchronModeConjunction=inchronModelFactory.createModeConjunction
+				//Adding ModeConjunction
+				it.conjunctions.add(inchronModeConjunction)
+				
+				
+				if(amltModeValueDisjunctionEntry instanceof ModeValue){
+					
+				}else if(amltModeValueDisjunctionEntry instanceof ModeValueConjunction){
+					
+					amltModeValueDisjunctionEntry?.entries?.forEach[amltModeValueEntry|{
+						
+						var amltModeLiteral=amltModeValueEntry.value
+						var amltModeValueProvider=amltModeValueEntry.valueProvider
+							//Adding Mode
+						inchronModeConjunction.modes.add(createMode(amltModeLiteral,amltModeValueProvider))
+						
+					}]
+				}
+			}]
+		}
+		
+		
+		
+		public def create inchronModelFactory.createMode  createMode(ModeLiteral amltModeLiteral, ModeLabel amltModeLabel){
+			
+			it.name=amltModeLiteral.name
+			
+			var inchronModeGroup=cacheModel.getInchronModeGroup(amltModeLiteral?.containingMode?.name)
+			
+			if(inchronModeGroup!==null){
+				inchronModeGroup.modes.add(it)
+			}
+			
+		}
+}
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableItemTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableItemTransformer.xtend
new file mode 100644
index 0000000..07bd6a3
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableItemTransformer.xtend
@@ -0,0 +1,49 @@
+package templates.m2m.sw
+
+import com.google.inject.Inject
+import com.inchron.realtime.root.model.Component
+import org.eclipse.app4mc.amalthea.model.RunnableCall
+import org.eclipse.app4mc.amalthea.model.Ticks
+import templates.AbstractAmaltheaInchronTransformer
+import templates.m2m.sw.runnableItem.RunnableCallTransformer
+import templates.m2m.sw.runnableItem.TicksTransformer
+import org.eclipse.app4mc.amalthea.model.RunnableItem
+import com.inchron.realtime.root.model.CallSequenceItem
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch
+import java.util.List
+
+class RunnableItemTransformer extends AbstractAmaltheaInchronTransformer{
+	
+	@Inject RunnableCallTransformer runnableCallTransformer
+
+	@Inject TicksTransformer ticksTransformer
+	
+	@Inject ModeSwitchTransformer modeSwitchTransformer
+	
+	def List<CallSequenceItem>  transformRunnableItem(Component inchronComponent, org.eclipse.app4mc.amalthea.model.Process amltTask,
+		RunnableItem amltRunnableItem) {
+			
+			val List<CallSequenceItem> list=newArrayList
+		
+			if (amltRunnableItem instanceof RunnableCall) {
+
+				var inchronFunctionCall = runnableCallTransformer.createFunctionCall(inchronComponent, amltTask,
+					amltRunnableItem)
+
+				  list.add(inchronFunctionCall)
+			 
+	
+			} else if (amltRunnableItem instanceof Ticks) {
+				var inchronResourceConsumption = ticksTransformer.createResourceConsumption(amltTask, amltRunnableItem)
+				 list.add(inchronResourceConsumption)
+
+			}else if(amltRunnableItem instanceof RunnableModeSwitch){
+				
+				var inchronModeSwitch =  modeSwitchTransformer.createModeSwitch(inchronComponent, amltTask,amltRunnableItem)
+				 
+//				 list.add(inchronModeSwitch)
+			} 
+			
+			return list
+	}
+}
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableTransformer.xtend
index 1e8cf3a..d212533 100644
--- a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableTransformer.xtend
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/RunnableTransformer.xtend
@@ -30,9 +30,7 @@
 
 	var AmltCacheModel cacheModel
 
-	@Inject RunnableCallTransformer runnableCallTransformer
-
-	@Inject TicksTransformer ticksTransformer
+	@Inject RunnableItemTransformer runnableItemTransformer
 
 	def create inchronModelFactory.createFunction createFunction(Component inchronComponent, Process amltTask,
 		Runnable amltRunnable) {
@@ -54,18 +52,9 @@
 		inchronCallGraph.graphEntries.add(inchronCallSequence)
 
 		amltRunnable?.runnableItems?.forEach [ amltRunnableItem |
-			if (amltRunnableItem instanceof RunnableCall) {
-
-				var inchronFunctionCall = runnableCallTransformer.createFunctionCall(inchronComponent, amltTask,
-					amltRunnableItem)
-
-				inchronCallSequence.calls.add(inchronFunctionCall)
-
-			} else if (amltRunnableItem instanceof Ticks) {
-				var inchronResourceConsumption = ticksTransformer.createResourceConsumption(amltTask, amltRunnableItem)
-				inchronCallSequence.calls.add(inchronResourceConsumption)
-
-			}
+			
+			inchronCallSequence.calls.addAll(runnableItemTransformer.transformRunnableItem(inchronComponent, amltTask,	amltRunnableItem))
+	 
 		]
 	}
 }
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/SWTransformer.xtend b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/SWTransformer.xtend
index 66c8b55..c68119f 100644
--- a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/SWTransformer.xtend
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/m2m/sw/SWTransformer.xtend
@@ -35,7 +35,10 @@
 	@Inject ISRTransformer isrTransformer
 	@Inject GraphEntryBaseTransformer graphEntryBaseTransformer
 	@Inject RunnableTransformer runnableTransformer
+	@Inject CallGraphTransformer callGraphTransformer
+	@Inject ModeTransformer modeTransformer
 
+	
 	val Map<Process, com.inchron.realtime.root.model.Process> amltProcess_inchronProcessMap = new HashMap
 
 	def transformSWModel(SWModel amltSwModel, Model inchronModel) {
@@ -43,6 +46,10 @@
 		this.inchronModel = inchronModel
 
 		cacheModel = customObjsStore.getInstance(AmltCacheModel)
+		
+		amltSwModel?.modes?.forEach[amltMode|{
+			inchronModel.globalModeGroups.add(modeTransformer.createModeGroup(amltMode))
+		}]
 
 		val inchronScheduler_amltSchedulerMap = cacheModel.getInchronScheduler_amltSchedulerMap()
 
@@ -89,10 +96,17 @@
 
 		amltProcess_inchronProcessMap.forEach [ amltProcess, inchronProcess |
 
-			amltProcess?.callGraph?.graphEntries?.forEach [ amltGraphEntry |
-				graphEntryBaseTransformer.transformGraphEntryBase(amltGraphEntry, amltProcess,
-					amltProcess_inchronProcessMap)
-			]
+
+ 
+			if(amltProcess.callGraph!==null)
+			{
+				callGraphTransformer.transformCallGraph(amltProcess.callGraph,amltProcess,amltProcess_inchronProcessMap)
+				
+			}
+			
+			
+			
+		 
 
 			amltProcess?.stimuli?.forEach [ amltStimuli |
 				val inchronActivationConnection = cacheModel.amltStimuli_inchronActivationConnectionMap.get(
diff --git a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java
index a1760ec..b597f52 100644
--- a/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java
+++ b/eclipse-tools/model-transformation/examples/amlt2inchron/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java
@@ -37,6 +37,7 @@
 import com.inchron.realtime.root.model.Component;
 import com.inchron.realtime.root.model.CpuCore;
 import com.inchron.realtime.root.model.GenericSystem;
+import com.inchron.realtime.root.model.ModeGroup;
 import com.inchron.realtime.root.model.Model;
 import com.inchron.realtime.root.model.RtosConfig;
 import com.inchron.realtime.root.model.Semaphore;
@@ -54,6 +55,8 @@
 
 	private Map<String, Component> inchronComponentsMap = new HashMap<>();
 
+	private Map<String, ModeGroup> inchronModeGroupsMap = new HashMap<>();
+
 	private Map<Process, Component> amltProcess_InchronComponentMap = new HashMap<>();
 
 	private Model inchronModel;
@@ -303,6 +306,20 @@
 	public Component getInchronComponent(String name) {
 		return inchronComponentsMap.get(name);
 	}
+	
+	
+	
+	public void addInchronModeGroup(ModeGroup modeGroup) {
+		inchronModeGroupsMap.put(modeGroup.getName(), modeGroup);
+	}
+	
+	public ModeGroup getInchronModeGroup(String name) {
+		return inchronModeGroupsMap.get(name);
+	}
+	
+	public Map<String, ModeGroup> getInchronModeGroupMap( ) {
+		return inchronModeGroupsMap ;
+	}
 
 	public void addAmltProcess_InchronComponent(Process amltProcess, Component inchronComponent) {
 		amltProcess_InchronComponentMap.put(amltProcess, inchronComponent);