added first implementation of AMALTHEA to Inchron model transformation
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.classpath b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.classpath
new file mode 100644
index 0000000..428337e
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="xtend-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.gitignore b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.gitignore
new file mode 100644
index 0000000..d3fb94c
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.gitignore
@@ -0,0 +1,3 @@
+/bin/
+/target/
+/xtend-gen/
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.project b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.project
new file mode 100644
index 0000000..46d1e82
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.app4mc.transform.to.inchron.m2m</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.settings/org.eclipse.jdt.core.prefs b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..0c68a61
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/META-INF/MANIFEST.MF b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..8d51d5c
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/META-INF/MANIFEST.MF
@@ -0,0 +1,13 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: APP4MC Transformation to Inchron M2M
+Bundle-SymbolicName: org.eclipse.app4mc.transform.to.inchron.m2m;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: Eclipse APP4MC
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: com.google.inject;bundle-version="3.0.0",
+ org.apache.log4j;bundle-version="1.2.15",
+ org.eclipse.emf;bundle-version="2.6.0",
+ org.eclipse.app4mc.transformation.extensions,
+ org.eclipse.app4mc.amalthea.model;visibility:=reexport,
+ com.inchron.realtime.root;bundle-version="2.98.1"
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/build.properties b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/build.properties
new file mode 100644
index 0000000..f39ab1c
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/build.properties
@@ -0,0 +1,16 @@
+###############################################################################
+#  * Copyright (c) 2018 Robert Bosch GmbH.
+#  * All rights reserved. This program and the accompanying materials
+#  * are made available under the terms of the Eclipse Public License v1.0
+#  * which accompanies this distribution, and is available at
+#  * http://www.eclipse.org/legal/epl-v10.html
+#  *
+#  * Contributors:
+#  *    Robert Bosch GmbH - initial API and implementation
+###############################################################################
+source.. = src/,\
+           xtend-gen/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/plugin.xml b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/plugin.xml
new file mode 100644
index 0000000..df6ea1f
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/plugin.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<!--
+     * Copyright (c) 2018 Robert Bosch GmbH.
+     * All rights reserved. This program and the accompanying materials
+     * are made available under the terms of the Eclipse Public License v1.0
+     * which accompanies this distribution, and is available at
+     * http://www.eclipse.org/legal/epl-v10.html
+     *
+     * Contributors:
+     *    Robert Bosch GmbH - initial API and implementation
+ -->
+
+<plugin>
+   <extension
+         point="org.eclipse.app4mc.transformation.configuration">
+    <config
+          enabled="true"
+          id="org.eclipse.app4mc.transform.to.inchron.m2m.config"
+          m2m_class="configuration.M2MTransformation"
+          module_class="module.DefaultM2MInjectorModule">
+    </config>
+   </extension>
+
+</plugin>
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/pom.xml b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/pom.xml
new file mode 100644
index 0000000..73b6dc3
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/pom.xml
@@ -0,0 +1,93 @@
+<!--
+     * Copyright (c) 2018 Robert Bosch GmbH.
+     * All rights reserved. This program and the accompanying materials
+     * are made available under the terms of the Eclipse Public License v1.0
+     * which accompanies this distribution, and is available at
+     * http://www.eclipse.org/legal/epl-v10.html
+     *
+     * Contributors:
+     *    Robert Bosch GmbH - initial API and implementation
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<relativePath>./com.bosch.m2m.simulation.build</relativePath>
+		<groupId>m2m</groupId>
+		<artifactId>com.bosch.m2m.simulation.build</artifactId>
+		<version>1.0.0.qualifier</version>
+	</parent>
+
+	<artifactId>org.eclipse.app4mc.transformation.extensions</artifactId>
+	<packaging>eclipse-plugin</packaging>
+
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+		<resources>
+			<resource>
+				<directory>xtend-gen</directory>
+				<excludes>
+					<exclude>**/*.java</exclude>
+				</excludes>
+			</resource>
+			<resource>
+				<directory>src</directory>
+				<excludes>
+					<exclude>**/*.java</exclude>
+				</excludes>
+			</resource>
+		</resources>
+		<plugins>
+			<plugin>
+				<artifactId>maven-clean-plugin</artifactId>
+				<version>2.4.1</version>
+				<configuration>
+					<filesets>
+						<fileset>
+							<directory>xtend-gen</directory>
+							<includes>
+								<include>**</include>
+							</includes>
+						</fileset>
+					</filesets>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>build-helper-maven-plugin</artifactId>
+				<version>1.7</version>
+				<executions>
+					<execution>
+						<id>add-source</id>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>add-source</goal>
+						</goals>
+						<configuration>
+							<sources>
+								<source>xtend-gen</source>
+							</sources>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+				<version>2.7.3</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+						<configuration>
+							<outputDirectory>xtend-gen</outputDirectory>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+	<groupId>m2m</groupId>
+</project>
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/configuration/M2MTransformation.java b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/configuration/M2MTransformation.java
new file mode 100644
index 0000000..9cadab8
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/configuration/M2MTransformation.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ *  * Copyright (c) 2018 Robert Bosch GmbH.
+ *  * All rights reserved. This program and the accompanying materials
+ *  * are made available under the terms of the Eclipse Public License v1.0
+ *  * which accompanies this distribution, and is available at
+ *  * http://www.eclipse.org/legal/epl-v10.html
+ *  *
+ *  * Contributors:
+ *  *    Robert Bosch GmbH - initial API and implementation
+ *******************************************************************************/
+package configuration;
+
+import java.util.Properties;
+
+import org.apache.log4j.ConsoleAppender;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+import org.apache.log4j.PatternLayout;
+import org.eclipse.app4mc.transformation.extensions.executiontype.IModelToModelConfig;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+
+import com.inchron.realtime.root.RootPackage;
+
+import model.loader.AmaltheaMultiFileLoader;
+
+public class M2MTransformation implements IModelToModelConfig {
+
+	private Properties parameters;
+	
+	private Logger logger=LogManager.getLogger(IModelToModelConfig.class);
+	
+	public M2MTransformation() {
+		logger.addAppender(new ConsoleAppender(new PatternLayout()));
+	}
+
+	@Override
+	public ResourceSet getInputResourceSet() {
+
+		if(parameters !=null){
+			
+			String folderPath = parameters.getProperty("input_models_folder");
+			
+			if(folderPath !=null){
+				
+				logger.info("Loading AMALTHEA model files from folder : "+folderPath);
+				
+				ResourceSet resourceSet = new AmaltheaMultiFileLoader().loadMultipleFiles(folderPath);
+				
+				return resourceSet;
+			}else{
+				logger.error("amalthea_models_folder parameter not set", new NullPointerException("amalthea_models_folder property not set"));
+			}
+			
+		}else{
+			logger.error("Parameters object not set ", new NullPointerException("Parameter object is null"));
+		}
+		return null;
+	}
+
+	@Override
+	public ResourceSet getOuputResourceSet() {
+
+		ResourceSet outputRurceSet=new ResourceSetImpl();
+		
+		outputRurceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put
+		(Resource.Factory.Registry.DEFAULT_EXTENSION, 
+				new XMIResourceFactoryImpl());
+
+		outputRurceSet.getPackageRegistry().put
+		(RootPackage.eNS_URI, 
+				RootPackage.eINSTANCE);
+		
+		return outputRurceSet;
+	}
+
+	@Override
+	public void setProperties(Properties parameters) {
+
+		this.parameters=parameters;
+	}
+
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/model/loader/AmaltheaMultiFileLoader.java b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/model/loader/AmaltheaMultiFileLoader.java
new file mode 100644
index 0000000..b675832
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/model/loader/AmaltheaMultiFileLoader.java
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ *  * Copyright (c) 2018 Robert Bosch GmbH.
+ *  * All rights reserved. This program and the accompanying materials
+ *  * are made available under the terms of the Eclipse Public License v1.0
+ *  * which accompanies this distribution, and is available at
+ *  * http://www.eclipse.org/legal/epl-v10.html
+ *  *
+ *  * Contributors:
+ *  *    Robert Bosch GmbH - initial API and implementation
+ *******************************************************************************/
+package model.loader;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Amalthea;
+import org.eclipse.app4mc.amalthea.model.AmaltheaPackage;
+import org.eclipse.app4mc.amalthea.sphinx.AmaltheaResourceFactory;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.sphinx.emf.resource.ExtendedResourceSet;
+import org.eclipse.sphinx.emf.resource.ExtendedResourceSetImpl;
+
+public class AmaltheaMultiFileLoader  {
+
+	public ResourceSet loadMultipleFiles(String directoryPath){
+
+		File folder = new File(directoryPath);
+
+		if(folder.isDirectory()){
+			File[] listFiles = folder.listFiles( new FilenameFilter() {
+
+				@Override
+				public boolean accept(File file, String name) {
+
+					if(name.endsWith(".amxmi")){
+						return true;
+					}
+
+					return false;
+				}
+			});
+
+			ResourceSet resourceSet = initializeResourceSet();
+
+			loadMultipleFiles(resourceSet, listFiles);
+			
+			return resourceSet;
+		}
+
+		return new ResourceSetImpl();
+
+	}
+
+	private List<Amalthea>   loadMultipleFiles(ResourceSet resourceSet, File[] listFiles) {
+
+		List<Amalthea> models =new ArrayList<Amalthea>();
+
+		for (File amxmiFile : listFiles) {
+
+			final Resource res = resourceSet.createResource(URI.createURI("file:////"+amxmiFile.getAbsolutePath()));
+			try {
+				res.load(null);
+				for (final EObject content : res.getContents()) {
+					if (content instanceof Amalthea) {
+						models.add((Amalthea) content);
+					}
+				}
+			} catch (IOException e) {
+				// ignore
+			}
+		}
+		return models;
+	}
+
+	private static ResourceSet initializeResourceSet() {
+		final ExtendedResourceSet resSet = new ExtendedResourceSetImpl();
+		resSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put("amxmi", new AmaltheaResourceFactory());
+		AmaltheaPackage.eINSTANCE.eClass(); // register the package
+
+		return resSet;
+	}
+
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/module/DefaultM2MInjectorModule.java b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/module/DefaultM2MInjectorModule.java
new file mode 100644
index 0000000..dd3e0fc
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/module/DefaultM2MInjectorModule.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ *  * Copyright (c) 2018 Robert Bosch GmbH.
+ *  * All rights reserved. This program and the accompanying materials
+ *  * are made available under the terms of the Eclipse Public License v1.0
+ *  * which accompanies this distribution, and is available at
+ *  * http://www.eclipse.org/legal/epl-v10.html
+ *  *
+ *  * Contributors:
+ *  *    Robert Bosch GmbH - initial API and implementation
+ *******************************************************************************/
+package module;
+
+import org.eclipse.app4mc.transformation.extensions.AbstractTransformationInjectorModule;
+import org.eclipse.app4mc.transformation.extensions.base.templates.Model2ModelRootTransformer;
+
+import templates.AmaltheaTransformer;
+import templates.CustomHWTransformer;
+import templates.HWTransformer;
+
+public class DefaultM2MInjectorModule extends AbstractTransformationInjectorModule {
+
+	public DefaultM2MInjectorModule() {
+	}
+
+	@Override
+	protected void configure() {
+		
+		initializeBaseConfiguration();
+		
+	}
+	
+	@Override
+	protected void initializeBaseConfiguration() {
+		super.initializeBaseConfiguration();
+		bind(Model2ModelRootTransformer.class).to(AmaltheaTransformer.class);
+		
+	}
+
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AbstractAmaltheaInchronTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AbstractAmaltheaInchronTransformer.xtend
new file mode 100644
index 0000000..1740ae4
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AbstractAmaltheaInchronTransformer.xtend
@@ -0,0 +1,64 @@
+package templates
+
+import com.inchron.realtime.root.RootFactory
+import com.inchron.realtime.root.model.Model
+import com.inchron.realtime.root.model.ModelFactory
+import com.inchron.realtime.root.model.memory.MemoryFactory
+import com.inchron.realtime.root.model.stimulation.StimulationFactory
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.transformation.extensions.base.templates.AbstractTransformer
+import org.eclipse.emf.ecore.EObject
+
+class AbstractAmaltheaInchronTransformer extends AbstractTransformer{
+	
+	public var Model inchronModel;
+	
+	public var Amalthea amaltheaModel
+	
+		/*- Factory initiaization */
+	public val inchronRootFactory = RootFactory.eINSTANCE
+
+	public val inchronModelFactory = ModelFactory.eINSTANCE
+
+	public val inchronmemoryFactory = MemoryFactory.eINSTANCE
+	
+	public val inchronStimulationFactory = StimulationFactory.eINSTANCE
+	
+
+	public val amaltheaFactory = AmaltheaFactory.eINSTANCE
+	
+	public def OSTransformer getOSTransformerInstance(){
+		return customObjsStore.getInstance(OSTransformer)  
+	}
+	
+	public def HWTransformer getHWTransformerInstance(){
+		return customObjsStore.getInstance(HWTransformer) 
+	}
+	
+	public def SWTransformer getSWTransformerInstance(){
+		return customObjsStore.getInstance(SWTransformer) 
+	}
+	
+		
+	public def StimuliTransformer getStimuliTransformerInstance(){
+		return customObjsStore.getInstance(StimuliTransformer) 
+	}
+	
+	public  def static  <T> T getParentContainer(EObject eObject, Class<T> cl)
+	{
+		var EObject result = null;
+		if (eObject != null)
+		{
+			for (var EObject parent = eObject.eContainer(); parent != null; parent = parent.eContainer())
+			{
+
+				if(cl.isAssignableFrom(parent.getClass())){
+					return   parent as T;
+				}
+
+			}
+		}
+		return   result as T;
+	}
+}
\ No newline at end of file
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AmaltheaTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AmaltheaTransformer.xtend
new file mode 100644
index 0000000..79d202d
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/AmaltheaTransformer.xtend
@@ -0,0 +1,141 @@
+package templates
+
+import com.google.inject.Inject
+import com.inchron.realtime.root.RootFactory
+import com.inchron.realtime.root.model.Model
+import com.inchron.realtime.root.model.ModelFactory
+import java.io.File
+import org.apache.log4j.ConsoleAppender
+import org.apache.log4j.PatternLayout
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.transformation.extensions.base.templates.Model2ModelRootTransformer
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.resource.ResourceSet
+import templates.utils.AmltCacheModel
+
+class AmaltheaTransformer extends Model2ModelRootTransformer{
+	
+	/*- Factory initiaization */
+	 val inchronRootFactory = RootFactory.eINSTANCE
+
+	val inchronModelFactory = ModelFactory.eINSTANCE
+
+	/*- Transformer classes initiaization */
+	@Inject extension SWTransformer swTransformer
+
+	@Inject extension HWTransformer hwTransformer
+
+	@Inject extension OSTransformer osTransformer
+	
+	@Inject extension StimuliTransformer stimuliTransformer
+
+	/**
+	 * This method performs the transformation of AMALTHEA model to INCHRON model and saves the transformed model in the output directory.
+	 */
+	override m2mTransformation(ResourceSet inputResourceSet, ResourceSet outputResourceSet) {
+
+		/*- Associating CacheModel to the transformation. 
+		 * Note: This is a cummulative cache of all the elements from various input AMALTHEA model files.
+		 */
+		var AmltCacheModel cacheModel = new AmltCacheModel
+
+		customObjsStore.injectMembers(AmltCacheModel, cacheModel)
+
+		var int fileIndex = 1
+
+		for (resource : inputResourceSet.resources) {
+			for (content : resource.contents) {
+
+				logger.info("Processing file : " + resource.URI)
+
+				/*- Building INCHRON model from AMALTHEA input model */
+				val inchronRoot = transform(content as Amalthea)
+
+				val out_uri = URI.createFileURI(
+					getProperty("m2m_output_folder") + File.separator + fileIndex++ + ".root")
+
+				val out_resource = outputResourceSet.createResource(out_uri)
+
+				/*-Attaching a resource to the INCHRON model element */
+				out_resource.contents.add(inchronRoot)
+
+			}
+		}
+
+		/*- Saving all the root INCHRON model files*/
+		for (resource : outputResourceSet.resources) {
+
+			resource.save(null)
+
+			logger.info("Transformed model file generated at : " + resource.URI)
+		}
+		
+		logger.info("*********************** Completed : Model to Model transformation **************************")
+	}
+
+	
+	/**
+	 * This method is used to transform AMALTHEA model to INCHRON model
+	 */
+	   def create inchronRootFactory.createRoot transform(Amalthea amalthea){
+
+		/*-Step 1: Injecting all the required transformation objects into the CustomObjsStore. Advantage with this approach is, it provides flexibility to access these elements across various transformers */
+		
+	 	customObjsStore.injectMembers(SWTransformer , swTransformer)
+
+	 	customObjsStore.injectMembers(HWTransformer , hwTransformer)
+
+	 	customObjsStore.injectMembers(OSTransformer , osTransformer)
+
+	 	customObjsStore.injectMembers(StimuliTransformer , stimuliTransformer)
+
+		/* Step 2: Building INCHRON model by invoking various transformers */
+	 	model = createInchronModel(amalthea)
+	  
+	 	
+	 	
+	 }
+	 
+	 /**
+	  * This method creates the object of INCHRON Model element, and fills it by invoking various transformations
+	  */
+	   def create inchronModelFactory.createModel createInchronModel(Amalthea amalthea) {
+
+		setRequiredAttributes(amalthea, it)
+		
+		hwTransformer.transfromHWModel(amalthea.hwModel,it)
+
+	}
+	
+	/**
+	 * Each transformation object should be set with the required attributes.
+	 * At present the required attributes are : amaltheaModel and inchronModel elements. In future this list can grow
+	 */
+	protected def EObject setRequiredAttributes(Amalthea amalthea, Model inchronModel) {
+		
+		swTransformer.amaltheaModel=amalthea
+		swTransformer.inchronModel=inchronModel
+		
+		hwTransformer.amaltheaModel=amalthea
+		hwTransformer.inchronModel=inchronModel
+		
+		osTransformer.amaltheaModel=amalthea
+		osTransformer.inchronModel=inchronModel
+		
+		stimuliTransformer.amaltheaModel=amalthea
+		stimuliTransformer.inchronModel=inchronModel
+		
+	}
+	
+ /**
+  * Overriding the logger creation method and attaching "ConsoleAppender" to it.
+  */
+		override protected getLogger() {
+			var logger=super.getLogger()
+			return logger
+			
+		}
+ 
+ 		
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/CustomHWTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/CustomHWTransformer.xtend
new file mode 100644
index 0000000..91683df
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/CustomHWTransformer.xtend
@@ -0,0 +1,40 @@
+package templates
+
+import com.inchron.realtime.root.model.Model
+import org.eclipse.app4mc.amalthea.model.Frequency
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.HwStructure
+import org.eclipse.app4mc.amalthea.model.Memory
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit
+
+public class CustomHWTransformer extends HWTransformer{
+
+protected var Model inchronModel;
+
+	 public override transfromHWModel(HWModel amltHWModel, Model inchronModel){ 
+			super.transfromHWModel(amltHWModel,inchronModel)	 	
+	 }
+	 
+	 
+	 public override create inchronModelFactory.createCpu createCpu(HwStructure amltMicrocontroller){ 
+	 	super.createCpu(amltMicrocontroller)
+	 }
+	 
+	 override create inchronModelFactory.createClock createClock(FrequencyDomain amltQuartz){
+	 	 super.createClock(amltQuartz)
+	 }
+	 
+	  override create inchronModelFactory.createFrequency createFrequency(Frequency amltFrequency){ 
+	  	super.createFrequency(amltFrequency)
+	  }
+
+	 override create inchronModelFactory.createCpuCore createCpuCore(ProcessingUnit core){
+	 	
+		super.createCpuCore(core)	 	
+	 }
+	 
+	  override create inchronmemoryFactory.createMemory createMemory(Memory amltMemory){
+	  	super.createMemory(amltMemory)
+	  }
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/HWTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/HWTransformer.xtend
new file mode 100644
index 0000000..59576da
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/HWTransformer.xtend
@@ -0,0 +1,215 @@
+package templates
+
+import com.inchron.realtime.root.model.FrequencyUnit
+import com.inchron.realtime.root.model.GenericSystem
+import com.inchron.realtime.root.model.Model
+import com.inchron.realtime.root.model.memory.MemoryType
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.app4mc.amalthea.model.Cache
+import org.eclipse.app4mc.amalthea.model.Frequency
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.HwStructure
+import org.eclipse.app4mc.amalthea.model.Memory
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit
+import org.eclipse.app4mc.amalthea.model.StructureType
+import templates.utils.AmltCacheModel
+
+/**
+ * This class is responsible for the transformation of AMALTHEA Hardware Model into corresponding INCHRON mdoel elements and accordingly invoke other transformations 
+ */
+public class HWTransformer extends AbstractAmaltheaInchronTransformer {
+
+	
+
+	public def transfromHWModel(HWModel amltHWModel, Model inchronModel) {
+
+		this.inchronModel=inchronModel
+		
+		val AmltCacheModel cacheModel=customObjsStore.getInstance(AmltCacheModel)
+
+		/*- Transformation of FrequencyDomain elements to Clock elements in Inchron */		
+		
+		amltHWModel?.domains.filter[it instanceof FrequencyDomain].forEach [ amltQuartz |
+			
+			val inchronClock = createClock(amltQuartz as FrequencyDomain)
+			inchronModel.clocks.add(inchronClock)
+		]
+
+		/*- Transformation of each Memory element of SYSTEM to Memory element in Inchron*/
+				
+		amltHWModel?.structures.filter[it.structureType==StructureType.SYSTEM]?.forEach[st|
+			st?.modules.filter[it instanceof Memory].forEach[amltMem|
+				val inchronMemory = createMemory(amltMem as Memory)
+			inchronModel.memories.add(inchronMemory)
+			]
+		]
+		
+		/*- Collecting all Amalthea ECU elements */
+
+		val amltECUs=new ArrayList
+		
+		amltHWModel?.structures.filter[it.structureType==StructureType.SYSTEM]?.forEach[it?.structures.filter[it.structureType==StructureType.ECU].forEach[
+			ecu|
+			amltECUs.add(ecu)
+		]]
+	 
+	 	/*- Conversion of Amalthea ECU and its sub-elements into corresponding Inchron elements */
+	 	
+		for (amaltheaEcu : amltECUs) {
+
+			amaltheaEcu?.modules.forEach [ amltMem |
+				
+			/*- Transformation of each Memory element of ECU to Memory element in Inchron*/
+			
+				if(amltMem instanceof Memory){
+				val inchronMemory = createMemory(amltMem)
+				inchronModel.memories.add(inchronMemory)
+					
+				}
+			]
+
+			val List<GenericSystem> allGenericSystems=new ArrayList<GenericSystem>
+			
+			/*- Transformation of each Structure of type MicroController to correspnding Inchron element*/
+						
+			for (amaltheaMicroController : amaltheaEcu?.structures.filter[it.structureType==StructureType.MICROCONTROLLER]) {
+
+				/*- Each MicroController is created as GenericSystem element in Inchron and corresponding data of sub-elements is transformed accordingly. */
+				
+				val genericSystem = OSTransformerInstance.createGenericSystem(amaltheaMicroController)
+				
+				/*-Building Inchron CPU element */
+				val inchronCpu = createCpu(amaltheaMicroController);
+				
+				/*-Adding Inchron CPU and GenericSystem elements to Inchron Model */
+				
+				inchronModel.cpus.add(inchronCpu)
+				
+				inchronModel.systems.add(genericSystem)
+
+				/*- Transformation of each Memory element of MicroController to Memory element in Inchron*/
+
+				amaltheaMicroController?.modules.filter[it instanceof Memory].forEach [ amltMem |
+					val inchronMemory = createMemory(amltMem as Memory)
+					inchronCpu.memories.add(inchronMemory)
+				]
+
+				/*-Adding Amalthea microController and Inchron GenericSystem into the Cache map. */
+				cacheModel.cacheMappingAmltMicroController_GenericSystem(amaltheaMicroController, genericSystem)
+
+				/*-Collecting all Inchron GenericSystems, so as to process them later */
+				allGenericSystems.add(genericSystem)
+			}
+
+			for (genericSystem : allGenericSystems) {
+
+				/*-======================================Process each Inchron GenericSystem and populate the data ======================================*/
+					
+				OSTransformerInstance.fillGenericSystem(genericSystem, amaltheaModel, inchronModel)
+
+			}
+		}
+		
+		/*-Adding Stimulation scenarios to Inchron Model */
+		inchronModel.stimulationScenarios.add(stimuliTransformerInstance.createstimulationScenario(amaltheaModel))
+	}
+
+/**
+ * Creating a Inchron CPU element from AMALTHEA HwStructure of type MicroController
+ */
+	public def create inchronModelFactory.createCpu createCpu(HwStructure amltMicrocontroller) {
+
+		it.name = amltMicrocontroller.name
+
+		/*Transformation of Amalthea ProcessingUnit to CpuCore element in Inchron */
+		
+		for (amltCore : amltMicrocontroller?.modules.filter[it instanceof ProcessingUnit]) {
+
+			val inchronCpuCore = createCpuCore(amltCore as ProcessingUnit)
+		
+			/*- Transformation of each Memory element of ProcessingUnit to Memory element of type CACHE in Inchron*/
+		
+			(amltCore as ProcessingUnit)?.caches.forEach [ amltMem |
+				val inchronMemory = createMemory_CacheType(amltMem)
+				inchronMemory.type = MemoryType.CACHE
+				it.memories.add(inchronMemory)
+			]
+
+			inchronCpuCore.cpu = it
+
+			it.cores.add(inchronCpuCore)
+
+			/*-Transformation of FrequencyDomain of the ProcessingUnit in Amalthea */
+			val amltQuartz = amltCore?.frequencyDomain
+			
+			if (amltQuartz != null) {
+				val inchronClock = createClock(amltQuartz)
+
+				//TODO:Clarify if this is correct ? as the CpuCore Clock into is set to the CPU level in Inchron 
+				it.clock = (inchronClock)  //TODO: Error : In this case, CPU will only hold the Clock of last CpuCore
+			}
+
+		}
+
+	}
+
+/**
+ * Creating Inchron Clock element for FrequencyDomain element of Amalthea
+ */
+	def create inchronModelFactory.createClock createClock(FrequencyDomain amltQuartz) {
+
+		it.name = amltQuartz.name
+		it.frequency = createFrequency(amltQuartz.defaultValue)
+	}
+
+/**
+ * Creating Inchron Frequency element for the corresponding Frequency element of Amalthea 
+ */
+	def create inchronModelFactory.createFrequency createFrequency(Frequency amltFrequency) {
+
+		it.unit = FrequencyUnit.getByName(amltFrequency?.unit.getName)
+		it.value = amltFrequency?.value.floatValue
+	}
+
+/**
+ * Creating Inchron CpuCore from ProcessingUnit element of Amalthea
+ */
+	def create inchronModelFactory.createCpuCore createCpuCore(ProcessingUnit core) {
+
+		it.name = core.name
+
+	}
+
+/**
+ * Creating Inchron Memory element from Memory element of Amalthea.
+ * In this method, corresponding FrequencyDomain of the Amalthea element is accordingly converted to Inchron Clock element 
+ */
+	def create inchronmemoryFactory.createMemory createMemory(Memory amltMemory) {
+
+		it.name = amltMemory.name
+
+		if (amltMemory.frequencyDomain != null) {
+			it.clock = createClock(amltMemory.frequencyDomain)
+			it.prescaler = amltMemory?.frequencyDomain?.defaultValue?.value
+
+		}
+
+	}
+	
+	/** Creating Inchron Memory element from Memory element of Amalthea.
+	  * In this method, corresponding FrequencyDomain of the Amalthea element is accordingly converted to Inchron Clock element 
+ 	*/
+		def create inchronmemoryFactory.createMemory createMemory_CacheType(Cache amltMemory) {
+
+		it.name = amltMemory.name
+
+		if (amltMemory.frequencyDomain != null) {
+			it.clock = createClock(amltMemory.frequencyDomain)
+			it.prescaler = amltMemory?.frequencyDomain?.defaultValue?.value
+
+		}
+
+	}
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/OSTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/OSTransformer.xtend
new file mode 100644
index 0000000..c184cd7
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/OSTransformer.xtend
@@ -0,0 +1,436 @@
+package templates
+
+import com.inchron.realtime.root.model.GenericSystem
+import com.inchron.realtime.root.model.Model
+import com.inchron.realtime.root.model.SchedulerStrategy
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.FixedPriorityPreemptive
+import org.eclipse.app4mc.amalthea.model.HwStructure
+import org.eclipse.app4mc.amalthea.model.MappingModel
+import org.eclipse.app4mc.amalthea.model.OSEK
+import org.eclipse.app4mc.amalthea.model.SchedulerAssociation
+import org.eclipse.app4mc.amalthea.model.Semaphore
+import org.eclipse.app4mc.amalthea.model.StructureType
+import org.eclipse.app4mc.amalthea.model.TaskScheduler
+import templates.utils.AmltCacheModel
+
+/**
+ * This class is responsible for the transformation of AMALTHEA OS Model into corresponding INCHRON mdoel elements and accordingly invoke other transformations 
+ */
+public class OSTransformer extends AbstractAmaltheaInchronTransformer {
+
+	/**
+	 * Creating Inchron GenericSystem from HwStructure of type MicroController in Amalthea
+	 */
+	def create inchronModelFactory.createGenericSystem createGenericSystem(HwStructure microController) {
+		it.name = "System_" + microController.name
+	}
+
+	/**
+	 * Populating Inchron GenericSystem contents based on the Amalthea model data
+	 */
+	public def void fillGenericSystem(GenericSystem genericSystem, Amalthea amalthea, Model inchronModel) {
+
+		val AmltCacheModel cacheModel=customObjsStore.getInstance(AmltCacheModel)
+		
+		/*-Creating RtosConfig element and associating it to the GenericSystem */
+		
+		var inchronRtosConfig = inchronModelFactory.createRtosConfig
+
+		genericSystem.rtosConfig = inchronRtosConfig
+		
+		/*-Fetching contents of Amalthea OS model */
+		if (amalthea.osModel != null) {
+
+			/*-Fetching all Amalthea Semaphore elements and creating corresponding Inchron elements */
+			
+			for (Semaphore amltSemaphore : amalthea.osModel.semaphores) {
+
+				val inchronSemaphore = createSemaphore(amltSemaphore)
+
+				/*-Caching Inchron Semaphore object */
+				
+				cacheModel.cacheInchronSemaphore(inchronSemaphore)
+			
+				/*- Adding Semaphore to RtosConfig object*/
+				
+				genericSystem.rtosConfig.semaphores.add(inchronSemaphore)
+			}
+		}
+		
+		/*-Fetching Amalthea Tasks objects from SwModel and invoking the StimuliTransformer to build corresponding Inchron objects  */
+		
+		if(amalthea.swModel!=null){
+		
+			stimuliTransformerInstance.createInchronActivationConnections(amalthea.swModel.tasks ,inchronModel  )		
+		
+		}
+		
+
+		// heuristic for Inchron
+		
+		/*-Creating Dummy Inchron Scheduler */
+		
+		val dummyISRScheduler = inchronModelFactory.createScheduler
+
+		/*-Adding Dummy scheduler to RtosConfig element of Inchron */
+		
+		genericSystem.rtosConfig.schedulables.add(dummyISRScheduler)
+
+		val MappingModel amltMappingModel = amalthea.mappingModel
+
+		if (amltMappingModel != null) {
+			
+			/*-Building cache for TaskScheduler <---> and SchedulerAssociation's */
+
+			cacheModel.buildTaskSchedulerAndSchedulerAssociationMap(amltMappingModel)
+
+			/*-Building cache for TaskScheduler <---> and TaskAllocation's */
+			
+			cacheModel.buildTaskSchedulerAndTaskAllocationMap(amltMappingModel)
+
+			/*- Collecting all the root TaskScheduler's  */
+			
+			val rootTaskSchedulers = amltMappingModel?.schedulerAllocation?.map [ amltSchedulerAllocation |
+
+				if (amltSchedulerAllocation.scheduler instanceof TaskScheduler) {
+					return (amltSchedulerAllocation.scheduler as TaskScheduler).rootScheduler
+				}
+
+			].toSet.filter[it != null]
+
+			/*-Case 1: Fetching all the Amalthea SchedulerAllocation objects from Amalthea */
+			
+			amltMappingModel?.schedulerAllocation?.forEach [ amltSchAllocation |
+				
+				/*- Considering only if the associated scheduler is TaskScheduler  */
+				
+				if (amltSchAllocation.scheduler instanceof TaskScheduler) {
+					
+					/*- getting Root scheduler */
+					var rootScheduler = getRootScheduler(amltSchAllocation.scheduler as TaskScheduler)
+
+					/*- gettting the ProcessingUnit from the responsibility of SchedulerAllocation*/
+					
+					if (amltSchAllocation?.responsibility.size > 0) {
+					
+						/*- Based on the Amalthea model, eContainer of ProcessingUnit is HwStructure of type MicroController */
+						
+						var amltMicroController = amltSchAllocation?.responsibility?.get(0)?.eContainer
+
+						if ((amltMicroController != null) && (amltMicroController instanceof HwStructure) &&  (amltMicroController as HwStructure).structureType==StructureType.MICROCONTROLLER ){
+							
+							/*- Based on the extend behaviour, if create method is invoked - with the same parameters again and again -> it does caching and returns back the already created object from cache */
+							
+							var inchronCpu = HWTransformerInstance.createCpu(amltMicroController as HwStructure)
+							
+							if (inchronCpu != null) {
+									
+									if(inchronCpu.eContainer==null){
+										inchronModel.cpus.add(inchronCpu)
+									}
+								
+							}
+
+					/*-Adding the root scheduler to dummy ISR Scheduler */
+					
+					dummyISRScheduler.schedulables.add(OSTransformerInstance.createRootScheduler(rootScheduler))
+						}
+
+					} else {
+						logger.info(amltSchAllocation + " " + amltSchAllocation.scheduler)
+					}
+
+				}
+			]
+
+			/*-Case 2: Fetching all the Amalthea ISRAllocation objects from Amalthea */
+
+			amltMappingModel?.isrAllocation?.forEach [ amltISRAllocation |
+
+				var amltISR = amltISRAllocation.isr
+
+				/*-Fetching InterruptController from ISRAllocation element */
+				
+				var amltInterruptController = amltISRAllocation.controller
+
+				if (amltInterruptController != null) {
+					
+					var AmltCacheModel amltCacheModel = customObjsStore.getInstance(AmltCacheModel)
+					
+					//TODO: Clarify this .. why to get SchedulerAllocation again when ISRAllocation is already present
+					var amltSchedulerAllocation = amltCacheModel.taskScheduler_SchedulerAllocationMap.get(
+						amltInterruptController)
+					
+					if (amltSchedulerAllocation != null) {
+						
+						if (amltSchedulerAllocation.executingPU != null) {
+							
+							/*-get executing Core from SchedulerAllocation */
+							var amltExecutingCore = amltSchedulerAllocation.executingPU
+
+							if(amltExecutingCore!=null){
+								val amltMicroController= amltExecutingCore.eContainer
+								
+								// RootISRScheduler should be unique for each MicroController
+								val inchronRootISRScheduler = OSTransformerInstance.createRootISRScheduler(
+								amltMicroController as HwStructure)
+								
+								/*-creating inchron Cpu element from the MicroController element in Amalthea model*/
+								var inchronCpu = HWTransformerInstance.createCpu(
+								amltExecutingCore.eContainer as HwStructure)
+								
+								/*-Below check is made, if Inchron CPU object is already associated to Inchron model !! If not associating it explicitly */
+								if(inchronCpu.eContainer==null){
+									inchronModel.cpus.add(inchronCpu)
+								}
+								
+								// TODO: clarify if Inchron root ISRScheduler can be added in HyperVisorConfig - vmSchedulers list
+								dummyISRScheduler.schedulables.add(inchronRootISRScheduler)
+	
+								var inchronCpuCore = HWTransformerInstance.createCpuCore(
+									amltExecutingCore)
+									
+								/*-Below check is made, if Inchron CpuCore object is already associated to Inchron Cpu !! If not associating it explicitly */
+								
+									if(inchronCpuCore.eContainer==null){
+										inchronCpu.cores.add(inchronCpuCore)
+									}
+								
+								/*- Creating a Process from ISR */
+								var inchronProcess = SWTransformerInstance.createProcess(amltISR)
+
+								// setting the priority from amlt ISRAllocation
+								inchronProcess.priority = amltISRAllocation.priority
+								
+								/*-Associating CpuCore to Process */
+								inchronProcess.cpuCores.add(inchronCpuCore)
+	
+								// adding all the amlt ISR's as Processes to root ISR scheduler
+								inchronRootISRScheduler.schedulables.add(inchronProcess)
+							}							
+
+						}
+
+					}
+				}
+			]
+
+		}
+		
+	
+
+	}
+
+
+/**
+ * This method is used to create a Inchron Semaphore object from Amalthea Semaphore 
+ */
+	public def create inchronModelFactory.createSemaphore createSemaphore(Semaphore amltSemaphore) {
+		it.initialValue = amltSemaphore.initialValue;
+		it.maxValue = amltSemaphore.maxValue;
+		it.name = amltSemaphore.name;
+	}
+	
+	/**
+	 * This method is used to return the root TaskScheduler object 
+	 */
+	def TaskScheduler getRootScheduler(TaskScheduler sch) {
+
+		if (sch.parentScheduler == null) {
+			return sch
+		}
+		return getRootScheduler(sch.parentScheduler)
+	}
+
+/**
+ * This method is used to create a Root ISR Scheduler object from Amalthea HwStructure (of type MicroController)
+ */
+	public def create inchronModelFactory.createScheduler createRootISRScheduler(HwStructure amltMicroController) {
+		it.name = "Root-ISR" + "_" + amltMicroController.name
+	}
+
+/**
+ * This method is used to create Inchron Root Scheduler object from Amalthea TaskScheduler
+ * <br>
+ * Additional things performed in this method are :
+ * <br>1. creation of child Schedulers for corresponding childAssociations to Amalthea Scheduler
+ * <br>2. Processing through TaskAllocations of a Amalthea scheduler and creating Inchron Process element
+ * <br>3. Processing through SchedulerAssociations of a Amalthea scheduler and creating Inchron CpuCore elements.. and associating them to the the Scheduler object
+ * 
+ */
+
+	public def create inchronModelFactory.createScheduler createRootScheduler(TaskScheduler amltTaskScheduler) {
+
+		it.name = amltTaskScheduler.name
+
+		var amltSchedulingAlgorithm = amltTaskScheduler.schedulingAlgorithm
+
+		if (amltSchedulingAlgorithm instanceof FixedPriorityPreemptive) {
+			it.strategy = SchedulerStrategy.FIXED_PRIORITY
+		}
+		if (amltSchedulingAlgorithm instanceof OSEK) {
+			it.strategy = SchedulerStrategy.OSEK
+		}
+
+		/* ============ building Inchron child Scheduler elements ======================== */
+		
+		amltTaskScheduler.childAssociations.forEach [ amltChildSchedulerAssociation |
+
+			if (amltChildSchedulerAssociation.child instanceof TaskScheduler) {
+				var amltSchedulingParameters = amltChildSchedulerAssociation.schedulingParameters
+
+				var amltSubSchedulerPrio = 0
+
+				if (amltSchedulingParameters != null) {
+					amltSubSchedulerPrio = amltSchedulingParameters.priority
+				}
+				schedulables.add(
+					createScheduler(amltChildSchedulerAssociation.child as TaskScheduler, amltSubSchedulerPrio))
+
+			}
+
+		]
+
+		/* ============ building Inchron Process elements and associating to the Scheduler object ======================== */
+
+		var AmltCacheModel amltCacheModel = customObjsStore.getInstance(AmltCacheModel)
+
+		//fetching all TaskAllocations associated to a specific TaskScheduler		
+		var taskAllocations = amltCacheModel.taskScheduler_TaskAllocationMap.get(amltTaskScheduler)
+
+		if (taskAllocations != null) {
+			taskAllocations.forEach [ amltTaskAllocation |
+
+				var process = SWTransformerInstance.createProcess(amltTaskAllocation.task)
+				// adding a created process inside the schedulables list of inchron scheduler
+				it.schedulables.add(process)
+
+				if (amltTaskAllocation?.schedulingParameters != null) {
+					process.priority = amltTaskAllocation?.schedulingParameters?.priority
+
+				}
+			]
+		}
+		/* ============ building Inchron CpuCore elements and associating to the Scheduler object ======================== */
+
+		var amltSchedulerAllocation = amltCacheModel.getTaskScheduler_SchedulerAllocationMap.get(amltTaskScheduler)
+
+		if (amltSchedulerAllocation != null) {
+
+			amltSchedulerAllocation.responsibility.forEach [ amltcore |
+				// associating CpuCore to HyperVisorSystemSchedulable
+				it.cpuCores.add(HWTransformerInstance.createCpuCore(amltcore))
+			]
+		}
+		
+	}
+
+	@Deprecated
+	public def create inchronModelFactory.createScheduler createSubScheduler(
+		SchedulerAssociation amltSchedulerAssociation) {
+
+		// TODO: create virtual system (use ARSystem instead of OSEK System), create coreMappings, schedulingParameters
+		var amltChildScheduler = amltSchedulerAssociation.child
+
+		// get the appropriate SchedulerAssociation to identify on which Core this scheduler is mapped
+		var AmltCacheModel cacheModel = customObjsStore.getInstance(AmltCacheModel)
+
+		var amltChildSchedulerAllocation = cacheModel.getTaskScheduler_SchedulerAllocationMap.get(amltChildScheduler)
+
+		if (amltChildSchedulerAllocation != null) {
+
+			name = amltChildSchedulerAllocation.scheduler?.name
+
+			amltChildSchedulerAllocation.responsibility.forEach [ amltcore |
+				// associating CpuCore to HyperVisorSystemSchedulable
+				it.cpuCores.add(HWTransformerInstance.createCpuCore(amltcore))
+			]
+		}
+
+	}
+
+/**
+ * This method is used to create Inchron Scheduler object from Amalthea TaskScheduler
+ * <br>
+ * Additional things performed in this method are :
+ * <br>1. creation of child Schedulers for corresponding childAssociations to Amalthea Scheduler
+ * <br>2. Processing through TaskAllocations of a Amalthea scheduler and creating Inchron Process element
+ * <br>3. Processing through SchedulerAssociations of a Amalthea scheduler and creating Inchron CpuCore elements.. and associating them to the the Scheduler object
+ * 
+ */
+	public def create inchronModelFactory.createScheduler createScheduler(TaskScheduler amltTaskScheduler,
+		int priority) {
+		it.name = amltTaskScheduler.name
+		
+		it.priority = priority
+
+		var amltSchedulingAlgorithm = amltTaskScheduler.schedulingAlgorithm
+		
+		//TODO: Mostly the same for the root -- point for harmonization?
+
+		if (amltSchedulingAlgorithm instanceof FixedPriorityPreemptive) {
+			it.strategy = SchedulerStrategy.FIXED_PRIORITY
+		}
+		if (amltSchedulingAlgorithm instanceof OSEK) {
+			it.strategy = SchedulerStrategy.OSEK
+		}
+		
+		/* ============ building Inchron child Scheduler elements ======================== */
+		
+		// TODO: add if conditions for all the sub classes of TaskSchedulingAlgorithm
+		amltTaskScheduler.childAssociations.forEach [ amltChildAssociation |
+
+			if (amltChildAssociation.child instanceof TaskScheduler) {
+				var amltSchedulingParameters = amltChildAssociation.schedulingParameters
+
+				var amltSubSchedulerPrio = 0
+
+				if (amltSchedulingParameters != null) {
+					amltSubSchedulerPrio = amltSchedulingParameters.priority
+				}
+				it.schedulables.add(createScheduler(amltChildAssociation.child as TaskScheduler, amltSubSchedulerPrio))
+
+			}
+
+		]
+
+
+		/* ============ building Inchron Process elements and associating to the Scheduler object ======================== */
+		
+		
+		var AmltCacheModel amltCacheModel = customObjsStore.getInstance(AmltCacheModel)
+
+		// fetching all TaskAllocations associated to a specific TaskScheduler
+		var taskAllocations = amltCacheModel.taskScheduler_TaskAllocationMap.get(amltTaskScheduler)
+
+		if (taskAllocations != null) {
+			taskAllocations.forEach [ amltTaskAllocation |
+
+				var process = SWTransformerInstance.createProcess(amltTaskAllocation.task)
+				// adding a created process inside the schedulables list of inchron scheduler
+				it.schedulables.add(process)
+
+				if (amltTaskAllocation?.schedulingParameters != null) {
+					process.priority = amltTaskAllocation?.schedulingParameters?.priority
+
+				}
+			]
+		}
+		
+		/* ============ building Inchron CpuCore elements and associating to the Scheduler object ======================== */
+
+		var amltChildSchedulerAllocation = amltCacheModel.getTaskScheduler_SchedulerAllocationMap.get(amltTaskScheduler)
+
+		if (amltChildSchedulerAllocation != null) {
+
+			name = amltChildSchedulerAllocation.scheduler?.name
+
+			amltChildSchedulerAllocation.responsibility.forEach [ amltcore |
+				// associating CpuCore to HyperVisorSystemSchedulable
+				it.cpuCores.add(HWTransformerInstance.createCpuCore(amltcore))
+			]
+		}
+	}
+
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/SWTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/SWTransformer.xtend
new file mode 100644
index 0000000..fcaf471
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/SWTransformer.xtend
@@ -0,0 +1,537 @@
+package templates
+
+import com.inchron.realtime.root.model.CallSequenceItem
+import com.inchron.realtime.root.model.GenericSystem
+import com.inchron.realtime.root.model.SemaphoreAccessType
+import com.inchron.realtime.root.model.TimeDistributionType
+import com.inchron.realtime.root.model.TimeUnit
+import java.util.ArrayList
+import java.util.List
+import java.util.Set
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.AsynchronousServerCall
+import org.eclipse.app4mc.amalthea.model.CallGraph
+import org.eclipse.app4mc.amalthea.model.CallSequence
+import org.eclipse.app4mc.amalthea.model.ChannelReceive
+import org.eclipse.app4mc.amalthea.model.ChannelSend
+import org.eclipse.app4mc.amalthea.model.CustomEventTrigger
+import org.eclipse.app4mc.amalthea.model.ExecutionNeed
+import org.eclipse.app4mc.amalthea.model.Group
+import org.eclipse.app4mc.amalthea.model.HwFeature
+import org.eclipse.app4mc.amalthea.model.ISR
+import org.eclipse.app4mc.amalthea.model.InterProcessTrigger
+import org.eclipse.app4mc.amalthea.model.LabelAccess
+import org.eclipse.app4mc.amalthea.model.ModeLabelAccess
+import org.eclipse.app4mc.amalthea.model.ModeSwitch
+import org.eclipse.app4mc.amalthea.model.Need
+import org.eclipse.app4mc.amalthea.model.NeedConstant
+import org.eclipse.app4mc.amalthea.model.NeedDeviation
+import org.eclipse.app4mc.amalthea.model.Preemption
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitch
+import org.eclipse.app4mc.amalthea.model.Process
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit
+import org.eclipse.app4mc.amalthea.model.Runnable
+import org.eclipse.app4mc.amalthea.model.RunnableCall
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch
+import org.eclipse.app4mc.amalthea.model.RunnableProbabilitySwitch
+import org.eclipse.app4mc.amalthea.model.SemaphoreAccess
+import org.eclipse.app4mc.amalthea.model.SemaphoreAccessEnum
+import org.eclipse.app4mc.amalthea.model.SenderReceiverRead
+import org.eclipse.app4mc.amalthea.model.SenderReceiverWrite
+import org.eclipse.app4mc.amalthea.model.SynchronousServerCall
+import org.eclipse.app4mc.amalthea.model.Task
+import org.eclipse.app4mc.amalthea.model.TaskRunnableCall
+import org.eclipse.app4mc.amalthea.model.Time
+import org.eclipse.app4mc.amalthea.model.util.DeploymentUtil
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil.TimeType
+import org.eclipse.emf.common.util.EMap
+import org.eclipse.emf.ecore.util.EcoreUtil
+import templates.utils.AmltCacheModel
+
+/**
+ * This class is responsible to convert Amalthea SW Model eleemnts to corresponding Inchron elements and invoke other transformation classes
+ */
+public class SWTransformer extends AbstractAmaltheaInchronTransformer {
+	
+	/**
+	 * Creating a Inchron Process element from Amalthea ISR element
+	 */
+	def create inchronModelFactory.createProcess createProcess(ISR amltISR){
+		it.isr = true
+		it.name=amltISR.name
+		/*-Building a cache of Stimuli name and the "List of Process" elements to which it is associated to */
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+		amltISR.stimuli.forEach[stimuli |
+			amltCache.cacheAmltStimuliInchronProcessMap(stimuli.getName, it)	
+		]
+		
+	}
+	
+	
+	/**
+	 * Creating a Inchron Process element from Amalthea Task element
+	 */
+	def create inchronModelFactory.createProcess createProcess(Task amltTask){
+		it.isr = false
+		it.name=amltTask.name
+		
+		//TODO: schedule between runnables for co-operative
+		if(amltTask.preemption == Preemption.NON_PREEMPTIVE || amltTask.preemption == Preemption.COOPERATIVE){
+			it.preemptable=false
+		}else{
+			it.preemptable=true
+		} 
+		
+		if(amltTask.callGraph !=null){
+			/*-building a inchron CallGraph element from amalthea CallGraph */
+			it.callGraph=createCallGraph(amltTask.callGraph)
+		}
+		
+		/*-Building a cache of Stimuli name and the "List of Process" elements to which it is associated to */
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+		amltTask.stimuli.forEach[stimuli |
+			amltCache.cacheAmltStimuliInchronProcessMap(stimuli.getName, it)	
+		]
+		
+	}
+	
+	/**
+	 * This method is used to create a Inchron CallGraph element from Amalthea CallGraph element 
+	 */
+	def create inchronModelFactory.createCallGraph createCallGraph(CallGraph amltCallGraph){
+		
+		amltCallGraph.graphEntries.forEach[amltGraphEntry|
+			
+			if(amltGraphEntry instanceof CallSequence){
+				
+				it.graphEntries.add(createCallSequence(amltGraphEntry as CallSequence))
+				
+			}else if(amltGraphEntry instanceof ModeSwitch){
+				it.graphEntries.add(createModeSwitch(amltGraphEntry as ModeSwitch))
+				
+			}else if(amltGraphEntry instanceof ProbabilitySwitch){
+				it.graphEntries.add(createProbabilitySwitch(amltGraphEntry as ProbabilitySwitch))
+				
+			}
+		]
+		
+	}
+	
+	/**
+	 * This method is used to create inchron CallSequence object from Amalthea CallSequence element.
+	 * 
+	 * Below are the CallSequence items are currently supported:
+	 * <br>1.TaskRunnableCall
+	 * <br>2.InterProcessTrigger
+	 *  
+	 */
+	def create inchronModelFactory.createCallSequence createCallSequence(CallSequence amltCallSequence){
+		it.name=amltCallSequence.name
+		amltCallSequence?.calls.forEach[amltCallsequenceItem|
+			
+			//todo: handle other CallSequenceItem's
+			
+			if(amltCallsequenceItem instanceof TaskRunnableCall){
+				
+				it.calls.add(createFunctionCall(amltCallsequenceItem as TaskRunnableCall))
+			}  
+			
+			if (amltCallsequenceItem instanceof InterProcessTrigger) {
+				it.calls.add(createActivationItem(amltCallsequenceItem as InterProcessTrigger))
+			}
+		]
+	}
+	
+	/**
+	 * This method is used to create inchron InterProcessTrigger element from Amalthea ActivationItem element
+	 */
+	def create inchronModelFactory.createActivationItem createActivationItem(InterProcessTrigger trigger) {
+
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+		
+		val tasks = amltCache.interProcessTriggerRelationsMap.get(trigger.stimulus.name);
+		
+		val inchronConnection=amltCache.inchronConnectionElementsMap.get(trigger.stimulus.name)
+		
+		it.connection =inchronConnection
+		
+		if(tasks !=null){
+		for ( task : tasks) {
+			val inchronActivateProcess=createActivateProcess(trigger, task as Task)
+			inchronConnection.activations.add(inchronActivateProcess)
+		}
+			
+		}else{
+			//Note: This is the case where Stimulus is not InterProcessStimulus or there are no Process elements to which this stimulus is triggering
+		}
+
+	}
+	
+	/**
+	 * This method is used to create inchron ActivateProcess element from Amalthea InterProcessTrigger 
+	 */
+	def create inchronModelFactory.createActivateProcess createActivateProcess(InterProcessTrigger trigger, Task amltTask) {
+		
+		it.target = createProcess(amltTask);
+		it.offset = trigger.counter.offset as int
+		it.period = trigger.counter.prescaler as int
+	}
+	
+	
+	def create inchronModelFactory.createModeSwitch createModeSwitch(ModeSwitch amltModeSwitch){
+		//TODO: need to enhance it in near future	
+	}
+	
+	def create inchronModelFactory.createProbabilitySwitch createProbabilitySwitch(ProbabilitySwitch amltProbabilitySwitch){
+				//TODO: need to enhance it in near future
+	}
+	
+	/**
+	 * This method is used to create inchron FunctionCall element from RunnableCall element
+	 */
+	def create inchronModelFactory.createFunctionCall createFunctionCall(RunnableCall amltRunnableCall){
+		
+		var amltProcess=amltRunnableCall.getParentContainer(Process)
+
+		var inchronComponent=createComponent(amltProcess)
+		
+		
+		val inchronGenericSystem=	getInchronGenericSystem(amltProcess)
+		
+		if(inchronGenericSystem !=null){
+			inchronGenericSystem.components.add(inchronComponent)
+			
+		}			
+			
+		var inchronFunction=createFunction(amltProcess, amltRunnableCall.runnable)
+		
+		inchronComponent.functions.add(inchronFunction)
+		
+		it.function=inchronFunction
+	}
+	
+	
+	/**
+	 * This method is used to create inchron FunctionCall element from TaskRunnableCall element
+	 */
+	def create inchronModelFactory.createFunctionCall createFunctionCall(TaskRunnableCall amltTaskRunnableCall){
+		
+		var amltProcess=amltTaskRunnableCall.getParentContainer(Process)
+
+		var inchronComponent=createComponent(amltProcess)
+		
+		val inchronGenericSystem=	getInchronGenericSystem(amltProcess)
+		
+		if(inchronGenericSystem !=null){
+			inchronGenericSystem.components.add(inchronComponent)
+			
+		}		
+				
+		var inchronFunction=createFunction(amltProcess, amltTaskRunnableCall.runnable)
+	
+		it.function=inchronFunction
+		
+		inchronComponent.functions.add(inchronFunction)
+		
+		it.offset=amltTaskRunnableCall?.counter?.offset.intValue
+		
+		it.period=amltTaskRunnableCall?.counter?.prescaler.intValue
+	}
+	
+	/**
+	 * This method is used to fetch the inchron GenericSystem object for a specific Amalthea Process element
+	 */
+	def GenericSystem getInchronGenericSystem(Process amltProcess) {
+		
+		val Set<ProcessingUnit> cores=DeploymentUtil.getAssignedCoreForProcess(amltProcess as Process, EcoreUtil.getRootContainer(amltProcess) as Amalthea)
+
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+
+		//TODO: write validaiton to assure that only 1 core is present
+		
+		//TODO: currently taking 1st core
+		
+		if(cores.size>0){
+			//TODO: clarify if this approach is OK !!
+			val amltCore=cores.get(0)
+			
+			val amltMicroController=amltCore.eContainer
+			
+			val inchronGenericSystem=amltCache.mappingAmltMicroController_GenericSystem.get(amltMicroController)
+			
+			return inchronGenericSystem
+		}
+	}
+	
+	
+	def create inchronModelFactory.createComponent createComponent(Process amltProcess){
+		
+		it.name=amltProcess.name
+	}
+	
+	def create inchronModelFactory.createFunction createFunction(Process amltProcess, Runnable amltRunnable){
+		
+		it.name=amltRunnable.name
+		
+		it.callGraph=inchronModelFactory.createCallGraph
+		
+		val inchronCallSequence=inchronModelFactory.createCallSequence
+		
+		it.callGraph.graphEntries.add(inchronCallSequence)
+		
+		amltRunnable?.runnableItems.forEach[amltRunnableItem|
+			
+			if(amltRunnableItem instanceof AsynchronousServerCall){
+				
+			}
+			else if(amltRunnableItem instanceof ChannelReceive){
+				
+			}
+			else if(amltRunnableItem instanceof ChannelSend){
+				
+			}
+			else if(amltRunnableItem instanceof CustomEventTrigger){
+				
+			}
+			else if(amltRunnableItem instanceof Group){
+				
+			}
+			else if(amltRunnableItem instanceof LabelAccess){
+				
+			}
+			else if(amltRunnableItem instanceof ModeLabelAccess){
+				
+			}
+			else if(amltRunnableItem instanceof RunnableCall){
+				
+				inchronCallSequence.calls.add(createFunctionCall( amltRunnableItem))
+				
+				
+			}else if(amltRunnableItem instanceof ExecutionNeed){//Earlier it was RunnableInstructions
+				
+				inchronCallSequence.calls.add(createResourceConsumption(amltProcess, amltRunnableItem))
+			}
+			else if(amltRunnableItem instanceof RunnableModeSwitch){
+				
+			}
+			else if(amltRunnableItem instanceof RunnableProbabilitySwitch){
+				
+			}
+			else if(amltRunnableItem instanceof SemaphoreAccess){
+				inchronCallSequence.calls.addAll(semaphoreInterruptCreation(amltRunnableItem))
+			}
+		 
+			else if(amltRunnableItem instanceof SenderReceiverRead){
+				
+			}
+			else if(amltRunnableItem instanceof SenderReceiverWrite){
+				
+			}
+			else if(amltRunnableItem instanceof SynchronousServerCall){
+				
+			}
+		]
+	}
+	
+	def create inchronModelFactory.createSemaphoreAccess createSemaphoreAccess(SemaphoreAccess amltAccess) {
+		
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+		
+		val amltSemaphoreName=amltAccess?.semaphore?.name
+		
+		//TODO CREATE THIS THE RIGHT WAY!
+		var inchronSemaphore = amltCache.getInchronSemaphoreCacheElement(amltSemaphoreName)// = createSemaphore(amltSemaphore);
+		//SemaphoreAccessType.;
+		//amltAccess.access;
+		
+		switch (amltAccess.access) {
+			case SemaphoreAccessEnum.RELEASE: {
+				it.type = SemaphoreAccessType.RELEASE
+			} 
+			case SemaphoreAccessEnum.EXCLUSIVE: {
+				it.type = SemaphoreAccessType.EXCLUSIVE				
+			}
+			case SemaphoreAccessEnum.REQUEST : {
+				it.type = SemaphoreAccessType.REQUEST
+			}
+		}
+		it.semaphore = inchronSemaphore;
+		
+
+	}
+	
+	def List<CallSequenceItem> semaphoreInterruptCreation(SemaphoreAccess amltAccess){
+		
+		val List<CallSequenceItem> items=new ArrayList
+		
+			switch (amltAccess.access) {
+				
+			case SemaphoreAccessEnum.RELEASE: {
+		
+			items.add(createSemaphoreAccess(amltAccess))
+			
+			items.add(createResumeAllInterrupts(amltAccess))
+					
+			} 
+			case SemaphoreAccessEnum.EXCLUSIVE: {
+				//TODO:check semantics
+				items.add(createSuspendAllInterrupts(amltAccess))
+				items.add(createSemaphoreAccess(amltAccess))
+				
+			}
+			case SemaphoreAccessEnum.REQUEST : {
+				
+				items.add(createSuspendAllInterrupts(amltAccess))
+				items.add(createSemaphoreAccess(amltAccess))
+				
+
+			}
+		}
+		return items
+	}
+	
+	/*
+	 * LL: SemaphoreAccess object should be mandatorily supplied here, as Xtend caches the elements based on input parameters
+	 */
+	def create inchronModelFactory.createSuspendAllInterrupts createSuspendAllInterrupts(SemaphoreAccess amltAccess) {
+		it.offset=0
+		it.period=0
+	}
+	
+	/*
+	 * LL: SemaphoreAccess object should be mandatorily supplied here, as Xtend caches the elements based on input parameters
+	 */
+	def create inchronModelFactory.createResumeAllInterrupts createResumeAllInterrupts(SemaphoreAccess amltAccess) {
+		it.offset=0
+		it.period=0
+	}
+	
+	
+	def create inchronModelFactory.createResourceConsumption createResourceConsumption(Process amltProcess, ExecutionNeed amltRunnableInstructions){
+		val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+		
+		
+		if(amltProcess instanceof Task){
+		
+			
+			var listOfTaskAllocations=amltCache.tasks_TaskAllocationMap.get(amltProcess as Task)
+			
+			listOfTaskAllocations?.forEach[amltTaskAllocation|
+				var amltScheduler=amltTaskAllocation.scheduler
+				
+			 	var amltSchedulerAllocation=amltCache.taskScheduler_schedulerAllocationMap.get(amltScheduler)
+			 	
+			 	//TODO: What if affinity is not set and core should be derived from SchedulerMapping?
+			 	var List cores1=amltTaskAllocation.affinity
+			 	
+			 	 var List cores2 =(amltSchedulerAllocation.responsibility)
+			 	
+			 	//to obtain only common Core objects across both lists
+			 	cores1.retainAll(cores2)
+			 	
+			 	//TODO: write assumptions about core mapping of tasks (if it is 1 to 1 mapping ?)
+			 	
+			 	if(cores1.size==1){			 	
+			 		var timeDistribution=inchronModelFactory.createTimeDistribution
+			 		//TODO: uniform as a starting point --- more complex distributions need to be simulated 
+			 		timeDistribution.type = TimeDistributionType.UNIFORM
+			 		timeDistribution.bcet = getRuntimeForRunnableInstruction(amltRunnableInstructions, TimeType.BCET, cores1.get(0) as ProcessingUnit); 
+			 		timeDistribution.wcet = getRuntimeForRunnableInstruction(amltRunnableInstructions, TimeType.WCET, cores1.get(0) as ProcessingUnit);
+			 		timeDistribution.mean = getRuntimeForRunnableInstruction(amltRunnableInstructions, TimeType.ACET, cores1.get(0) as ProcessingUnit);
+			 		it.timeDistribution = timeDistribution
+
+			 	}
+			]
+		}
+	}
+	
+	
+	
+	//TODO: Check if some of this methods can be part of AMALTHEA
+	//TODO: set getInstructionCountForInstruction to public in APP4MC UTILS
+	def com.inchron.realtime.root.model.Time getRuntimeForRunnableInstruction(ExecutionNeed amltRunnableInstructions, TimeType timeType, ProcessingUnit core) {
+		//TODO: handle extended instructions
+		var amltInstructions = getInstructionCountForInstruction(amltRunnableInstructions.^default, timeType);
+		val hwFeatureFromExecutionNeed = getHwFeatureFromExecutionNeed(amltRunnableInstructions,core)
+		var amltTime =   RuntimeUtil.getExecutionTimeForExecutionNeedValueCount(amltInstructions, core, hwFeatureFromExecutionNeed,null);
+		return getInchronTimeValue(amltTime);
+		
+	}
+	
+	def HwFeature getHwFeatureFromExecutionNeed(ExecutionNeed executionNeed, ProcessingUnit processingUnit){
+		
+		val EMap<String, Need> defaultMap = executionNeed.^default
+		
+		if(defaultMap.size>0){
+			val processingUnitDefinition = processingUnit.definition
+			if(processingUnitDefinition!=null){
+				for(feature: processingUnitDefinition?.features){ 
+					//TODO:At present supporting only HwFeatureCategory with name "Instructions"
+					if(feature.containingCategory?.name.equals("Instructions")){
+						return feature
+					}
+				}
+			}
+		}
+		
+		return null
+	}
+	
+	def Long getInstructionCountForInstruction(EMap<String, Need> defaultMap, TimeType execTimeType) {
+		
+		
+		for(need: defaultMap.values){
+				if(need instanceof NeedDeviation) {
+			var NeedDeviation instDeviation = need as NeedDeviation ;
+			switch(execTimeType) {
+				case ACET: {
+					return RuntimeUtil.getMean(instDeviation.getDeviation().getDistribution(), instDeviation.getDeviation().getLowerBound().getValue(), instDeviation.getDeviation().getUpperBound().getValue())
+					}
+				case BCET: {
+					return instDeviation.getDeviation().getLowerBound().getValue()
+				}					
+				case WCET: {
+					return instDeviation.getDeviation().getUpperBound().getValue();
+				}	
+				default: 
+					return RuntimeUtil.getMean(instDeviation.getDeviation().getDistribution(), instDeviation.getDeviation().getLowerBound().getValue(), instDeviation.getDeviation().getUpperBound().getValue())
+
+			
+			}
+		} else if(need instanceof NeedConstant) {
+			return (need as NeedConstant).getValue();
+		}
+			
+		}
+		
+		
+		return 0L;
+	}
+	
+	def com.inchron.realtime.root.model.Time getInchronTimeValue(Time amltTime) {
+		var result = inchronModelFactory.createTime
+		
+		result.value = amltTime.value.longValue;
+ 		switch (amltTime.unit.getName) {
+ 			case "s": {
+ 				result.unit = TimeUnit.S
+ 			}
+ 			case "ms": {
+ 				result.unit = TimeUnit.MS
+ 			}
+ 			case "us": {
+ 				result.unit = TimeUnit.US
+ 			}
+ 			case "ns": {
+ 				result.unit = TimeUnit.NS
+ 			}
+ 			case "ps": {
+ 				result.unit = TimeUnit.PS
+ 			}
+		}
+		return result;
+	}
+	
+ 
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/StimuliTransformer.xtend b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/StimuliTransformer.xtend
new file mode 100644
index 0000000..9dc84d7
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/StimuliTransformer.xtend
@@ -0,0 +1,140 @@
+package templates
+
+import com.inchron.realtime.root.model.Model
+import com.inchron.realtime.root.model.ModelFactory
+import com.inchron.realtime.root.model.TimeUnit
+import java.util.List
+import java.util.Map
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.InterProcessStimulus
+import org.eclipse.app4mc.amalthea.model.PeriodicStimulus
+import org.eclipse.app4mc.amalthea.model.Stimulus
+import org.eclipse.app4mc.amalthea.model.Task
+import org.eclipse.app4mc.amalthea.model.Time
+import org.eclipse.emf.common.util.EList
+import templates.utils.AmltCacheModel
+
+public class StimuliTransformer extends AbstractAmaltheaInchronTransformer {
+
+ /**
+  * This method is used to perform following:
+  * 
+  * <br>1.Build a cache of "InterProcess Stimuli name" and "List of Tasks" which are triggered by it
+  * <br>2.Create ActivationConnection for each InterProcessStimulus
+  */
+ public  def void createInchronActivationConnections(EList<Task> amltTasks,Model inchronModel){
+ 	
+ 	val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+ 	
+ 	for (process : amltTasks) {
+ 		 process.stimuli.forEach[stimuli | {
+ 		 	if(stimuli instanceof InterProcessStimulus){
+ 		 		amltCache.cacheInterProcessTriggerRelations(stimuli.name, process)
+ 		 	}
+ 		 	
+ 		 }]
+ 	}
+ 	 
+ 	 /*-For each InterProcessStimulus, create corresponding ActivationConnection in Inchron and store this info in the cache */
+ 	 
+ 	amltCache.interProcessTriggerRelationsMap.keySet.forEach[stimuliName|{
+ 		
+ 		val inchronConnection=ModelFactory.eINSTANCE.createActivationConnection
+ 		
+ 		inchronConnection.name=stimuliName
+ 		
+ 		/*-Adding ActivationConnect object to Inchron Model */ 	
+ 		inchronModel.connections.add(inchronConnection)
+ 		
+ 		/*-Adding ActivationConnect object to Cache */ 	
+ 		amltCache.cacheInchronConnection(stimuliName,inchronConnection)
+ 		
+ 		
+ 	}]
+ 	
+ }
+ /**
+  * This method is used to create SimulationScenario based on Periodic Stimulus objects present in Amalthea model
+  */
+ public def create inchronStimulationFactory.createStimulationScenario createstimulationScenario(Amalthea amaltheaModel) {
+ 	val AmltCacheModel amltCache=customObjsStore.getInstance(AmltCacheModel)
+ 	
+ 	val Map<String, List<com.inchron.realtime.root.model.Process>> stimuliCache = amltCache.amltStimuliInchronProcessElementsMap;
+ 	
+ 	for (Stimulus stimuli : amaltheaModel?.stimuliModel?.stimuli) {
+ 	
+ 	if (stimuli instanceof PeriodicStimulus) {
+ 		
+ 		val inchronProcessList = stimuliCache.get(stimuli.name)
+			
+			if (inchronProcessList  != null) {
+ 				
+ 				for (com.inchron.realtime.root.model.Process inchronProcess : inchronProcessList) {
+ 					
+ 					it.generators.add(createRandomStimuliGenerator(stimuli, inchronProcess))
+ 				}
+ 			
+ 		}
+ 	}
+ 	
+ 	}
+ }
+ 
+ /**
+  * This method is used to create RandomStimuliGenerator object, based on the Amalthea PeriodicStimulus object and Inchron Process object
+  */
+ public def create inchronStimulationFactory.createRandomStimuliGenerator createRandomStimuliGenerator(PeriodicStimulus amltStimuli, com.inchron.realtime.root.model.Process inchronProcess) {
+ 	if (amltStimuli?.minDistance != null)
+ 		it.minInterArrivalTime = getInchronTimeValue(amltStimuli?.minDistance)
+ 	it.period = getInchronTimeValue(amltStimuli.recurrence)
+ 	it.startOffset = getInchronTimeValue(amltStimuli?.offset)
+ 	//it.clock; //need the clock
+ 	it.relative = false; //only for sporadics
+ 	it.iterations = -1 //right?
+ 	//it.startOffsetVariation; //don't know
+ 	it.target = inchronProcess;
+ 	//it.variation
+ 	
+
+	//jitter
+	if (amltStimuli?.jitter != null) {
+		var timeDistribution=inchronModelFactory.createTimeDistribution
+		if (amltStimuli?.jitter?.lowerBound != null) {	
+			timeDistribution.bcet = getInchronTimeValue(amltStimuli?.jitter?.lowerBound)
+		}
+		if (amltStimuli?.jitter?.upperBound != null) {	
+			timeDistribution.wcet = getInchronTimeValue(amltStimuli?.jitter?.upperBound)
+		}
+		
+		//TODO: handle more complex distributions
+		it.variation = timeDistribution
+	}
+
+ 	
+ }
+ 
+ 	def com.inchron.realtime.root.model.Time getInchronTimeValue(Time amltTime) {
+		var result = inchronModelFactory.createTime
+		
+		result.value = amltTime.value.longValue;
+ 		switch (amltTime.unit.getName) {
+ 			case "s": {
+ 				result.unit = TimeUnit.S
+ 			}
+ 			case "ms": {
+ 				result.unit = TimeUnit.MS
+ 			}
+ 			case "us": {
+ 				result.unit = TimeUnit.US
+ 			}
+ 			case "ns": {
+ 				result.unit = TimeUnit.NS
+ 			}
+ 			case "ps": {
+ 				result.unit = TimeUnit.PS
+ 			}
+		}
+		return result;
+	}
+
+}
diff --git a/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java
new file mode 100644
index 0000000..6b41dc7
--- /dev/null
+++ b/eclipse-tools/model-transformation/examples/amalthea-to-inchron-transformation/org.eclipse.app4mc.transform.to.inchron.m2m/src/templates/utils/AmltCacheModel.java
@@ -0,0 +1,215 @@
+/*******************************************************************************
+ *  * Copyright (c) 2018 Robert Bosch GmbH.
+ *  * All rights reserved. This program and the accompanying materials
+ *  * are made available under the terms of the Eclipse Public License v1.0
+ *  * which accompanies this distribution, and is available at
+ *  * http://www.eclipse.org/legal/epl-v10.html
+ *  *
+ *  * Contributors:
+ *  *    Robert Bosch GmbH - initial API and implementation
+ *******************************************************************************/
+package templates.utils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.app4mc.amalthea.model.HwStructure;
+import org.eclipse.app4mc.amalthea.model.InterruptController;
+import org.eclipse.app4mc.amalthea.model.MappingModel;
+import org.eclipse.app4mc.amalthea.model.Process;
+import org.eclipse.app4mc.amalthea.model.Scheduler;
+import org.eclipse.app4mc.amalthea.model.SchedulerAllocation;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.TaskAllocation;
+import org.eclipse.app4mc.amalthea.model.TaskScheduler;
+import org.eclipse.emf.common.util.EList;
+
+import com.inchron.realtime.root.model.ActivationConnection;
+import com.inchron.realtime.root.model.GenericSystem;
+import com.inchron.realtime.root.model.Semaphore;
+
+
+public class AmltCacheModel {
+
+	private  Map<HwStructure, GenericSystem> mappingAmltMicroController_GenericSystem = new HashMap<>();
+			
+	private Map<Scheduler, SchedulerAllocation> taskScheduler_schedulerAllocationMap=new HashMap<Scheduler, SchedulerAllocation>();
+
+	private Map<Task, List<TaskAllocation>> tasks_TaskAllocationMap=new HashMap<Task, List<TaskAllocation>>();
+
+//	private Map<ISR, SchedulerAllocation> isr_schedulerAllocationMap=new HashMap<ISR, SchedulerAllocation>();
+
+	private Map<TaskScheduler, List<TaskAllocation>> taskScheduler_taskAllocationMap=new HashMap<TaskScheduler, List<TaskAllocation>>();
+	
+	private Map<String, Semaphore> inchronSemaphoresMap=new HashMap<>();
+
+	private Map<String, List<org.eclipse.app4mc.amalthea.model.Process>> amltInterProcessStimuli_processActivationsMap=new HashMap<>();
+	
+	private Map<String, ActivationConnection> inchronConnectionElementsMap=new HashMap<>();
+	
+	private Map<String, List<com.inchron.realtime.root.model.Process>> amltStimuliInchronProcessMap=new HashMap<>();
+	
+	public Map<HwStructure, GenericSystem> getMappingAmltMicroController_GenericSystem() {
+		return mappingAmltMicroController_GenericSystem;
+	}
+
+
+	public void cacheMappingAmltMicroController_GenericSystem(HwStructure hwStructure, GenericSystem genericSystem){
+		 mappingAmltMicroController_GenericSystem.put(hwStructure, genericSystem);
+	}
+	
+	public void cacheAmltStimuliInchronProcessMap(String amltStimuliName, com.inchron.realtime.root.model.Process inchronProcess){
+		if(amltStimuliName !=null){
+			List<com.inchron.realtime.root.model.Process> processList = amltStimuliInchronProcessMap.get(amltStimuliName);
+			
+			if(processList==null){
+				processList=new ArrayList<>();
+				amltStimuliInchronProcessMap.put(amltStimuliName, processList);
+			}
+			processList.add(inchronProcess);
+		}
+	}
+	
+	public Map<String, List<com.inchron.realtime.root.model.Process>> getAmltStimuliInchronProcessElementsMap(){
+		
+		return amltStimuliInchronProcessMap;
+	}
+	
+	
+	public void cacheInchronConnection(String name, ActivationConnection connection){
+		if(name !=null){
+			inchronConnectionElementsMap.put(name, connection);
+		}
+	}
+	
+	public Map<String, ActivationConnection> getInchronConnectionElementsMap(){
+		return inchronConnectionElementsMap;
+	}
+	
+	
+	public void cacheInterProcessTriggerRelations(String stimuliName, Process amltProcess){
+		
+		if(stimuliName!=null){
+			List<Process> processList = amltInterProcessStimuli_processActivationsMap.get(stimuliName);
+			
+			if(processList==null){
+				processList=new ArrayList<>();
+				amltInterProcessStimuli_processActivationsMap.put(stimuliName, processList);
+			}
+			processList.add(amltProcess);
+		}
+		
+	}
+	
+	public Map<String, List<Process>> getInterProcessTriggerRelationsMap(){
+		return amltInterProcessStimuli_processActivationsMap;
+	}
+	
+	
+	
+	public void cacheInchronSemaphore(com.inchron.realtime.root.model.Semaphore inchronSemaphore){
+		
+		if(inchronSemaphore.getName()!=null){
+			inchronSemaphoresMap.put(inchronSemaphore.getName(), inchronSemaphore);
+		}
+	}
+	
+	public com.inchron.realtime.root.model.Semaphore getInchronSemaphoreCacheElement(String semaphoreName){
+		return inchronSemaphoresMap.get(semaphoreName);
+	}
+	
+	public Map<Scheduler, SchedulerAllocation> getTaskScheduler_schedulerAllocationMap() {
+		return taskScheduler_schedulerAllocationMap;
+	}
+
+
+	public Map<Task, List<TaskAllocation>> getTasks_TaskAllocationMap() {
+		return tasks_TaskAllocationMap;
+	}
+
+
+	public Map<TaskScheduler, List<TaskAllocation>> getTaskScheduler_taskAllocationMap() {
+		return taskScheduler_taskAllocationMap;
+	}
+
+
+	public void buildProcesses_SchedulerAllocationMap(MappingModel mappingModel){
+		
+		EList<SchedulerAllocation> schedulerAllocations = mappingModel.getSchedulerAllocation();
+		
+		for (SchedulerAllocation schedulerAllocation : schedulerAllocations) {
+			
+			
+			taskScheduler_schedulerAllocationMap.put(schedulerAllocation.getScheduler(), schedulerAllocation);
+		}
+		
+	}
+	
+	
+	public void buildTaskSchedulerAndSchedulerAssociationMap(MappingModel mappingModel){
+		
+		EList<SchedulerAllocation> schedulerAllocations = mappingModel.getSchedulerAllocation();
+		
+		for (SchedulerAllocation schedulerAllocation : schedulerAllocations) {
+			
+			
+			Scheduler scheduler = schedulerAllocation.getScheduler();
+			if(scheduler instanceof TaskScheduler){
+				taskScheduler_schedulerAllocationMap.put(scheduler, schedulerAllocation);
+				
+			}else if(scheduler instanceof InterruptController){
+//				isr_schedulerAllocationMap.put(((InterruptController)scheduler).getISR, schedulerAllocation);
+			}
+		}
+		
+	}
+
+	public Map<Scheduler, SchedulerAllocation> getTaskScheduler_SchedulerAllocationMap() {
+		return taskScheduler_schedulerAllocationMap;
+	}
+
+	public Map<TaskScheduler, List<TaskAllocation>> getTaskScheduler_TaskAllocationMap() {
+		return taskScheduler_taskAllocationMap;
+	}
+	
+	public void buildTaskSchedulerAndTaskAllocationMap(MappingModel mappingModel){
+
+		EList<TaskAllocation> taskAllocations = mappingModel.getTaskAllocation();
+
+		for (TaskAllocation taskAllocation : taskAllocations) {
+
+			List<TaskAllocation> listOfTaskAllocations;
+			
+			if(taskScheduler_taskAllocationMap.containsKey(taskAllocation.getScheduler())){
+				listOfTaskAllocations=taskScheduler_taskAllocationMap.get(taskAllocation.getScheduler());
+			}else{
+				listOfTaskAllocations=new ArrayList<TaskAllocation>();
+				taskScheduler_taskAllocationMap.put(taskAllocation.getScheduler(),listOfTaskAllocations);
+			}
+			
+			listOfTaskAllocations.add(taskAllocation);
+
+			
+			
+			//populating map tasks_TaskAllocationMap
+			
+			List<TaskAllocation> listOftask_TaskAllocations;
+
+			if(tasks_TaskAllocationMap.containsKey(taskAllocation.getTask())){
+				listOftask_TaskAllocations=tasks_TaskAllocationMap.get(taskAllocation.getTask());
+			}else{
+				listOftask_TaskAllocations=new ArrayList<TaskAllocation>();
+				tasks_TaskAllocationMap.put(taskAllocation.getTask(),listOftask_TaskAllocations);
+			}
+
+			listOftask_TaskAllocations.add(taskAllocation);
+			
+			
+		}
+
+	}
+	
+}