diff --git a/src/Traffic/GPU/TrafficTimestep.cu b/src/Traffic/GPU/TrafficTimestep.cu
new file mode 100644
index 0000000000000000000000000000000000000000..cbc4b18bbcb2fa23ab1cde1331c4a9f0f63daf17
--- /dev/null
+++ b/src/Traffic/GPU/TrafficTimestep.cu
@@ -0,0 +1,369 @@
+#include "TrafficTimestep.h"
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <curand.h>
+#include <curand_kernel.h>
+
+#include <cmath>
+#include <sstream>
+
+#include <thrust/device_vector.h>
+#include <thrust/reduce.h>
+#include <thrust/device_ptr.h>
+#include <thrust/host_vector.h>
+
+#include <iomanip>
+
+//#include "TrafficMovement.h"
+#include "RoadNetwork/RoadNetworkData.h"
+#include "Junction/Junction.h"
+#include "Sink/Sink.h"
+
+__global__           void trafficTimestepKernel(int* roadCurrent, int* roadNext, int* neighbors, int* oldSpeeds, uint* junctionInCellIndices, bool* junctionCarCanEnter, int* junctionCarsOnJunction, uint* junctionAlreadyMoved, uint* JunctionOldSpeeds, bool* sinkCarCanEnter,
+	uint size_road, uint maxVelocity, uint maxAcceleration, uint safetyDistance, bool useSlowToStart, real slowStartPossibility, real dawdlePossibility, std::mt19937* engine, std::uniform_real_distribution<real> distFloat);
+
+__host__ __device__ inline void trafficTimestepFunction(int* roadCurrent, int* roadNext, int* neighbors, int* oldSpeeds, uint* junctionInCellIndices, bool* junctionCarCanEnter, int* junctionCarsOnJunction, uint* junctionAlreadyMoved, uint* JunctionOldSpeeds, bool* sinkCarCanEnter,
+	uint size_road, uint maxVelocity, uint maxAcceleration, uint safetyDistance, bool useSlowToStart, real slowStartPossibility, real dawdlePossibility, std::mt19937* engine, std::uniform_real_distribution<real> distFloat, uint index);
+__host__ __device__ inline uint getInCellsVectorIndex(uint * junctionInCellIndices, uint size_road, uint cell);
+__host__ __device__ inline void sourceTimestepFunction(int* roadCurrent, int* roadNext, int* neighbors, int* oldSpeeds);
+//__host__ __device__ inline void trafficTimestepFunction( uint index);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+TrafficTimestep::TrafficTimestep(std::shared_ptr<RoadNetworkData> road)
+{
+	//calculate sizes
+	size_roads = road->roadLength;
+	size_junctions = road->junctions.size();
+	size_sources = road->sources.size();
+	size_sinks = road->sinks.size();
+
+	//set attributes
+	maxVelocity = road->maxVelocity;
+	safetyDistance = road->safetyDistance;
+
+	dawdlePossibility = 0.5f;
+	useSlowToStart = false;
+	slowStartPossibility = 0.1f;
+	maxAcceleration = 2;
+
+	//prepare road
+	this->neighbors.resize(size_roads);
+	this->neighbors = road->neighbors;
+	roadCurrent.resize(size_roads);
+	roadNext.resize(size_roads);
+	oldSpeeds.resize(size_roads);
+
+	//prepare junctions
+	combineJunctionInCellIndices(road->junctions);
+	junctionCarCanEnter.resize(junctionInCellIndices.size());
+	junctionCarsOnJunction.resize(junctionInCellIndices.size());
+	junctionAlreadyMoved.resize(junctionInCellIndices.size());
+	JunctionOldSpeeds.resize(junctionInCellIndices.size());
+
+	//prepare sinks
+	sinkCarCanEnter.resize(size_sinks);
+}
+
+void TrafficTimestep::run(std::shared_ptr<RoadNetworkData> road)
+{
+	//copy road to device
+	this->roadCurrent = *road->pcurrent;
+	std::fill(roadNext.begin(), roadNext.end(), -1);
+
+	//reset oldSpeeds
+	std::fill(oldSpeeds.begin(), oldSpeeds.end(), -1);
+
+	//copy junctions an sinks to device
+	combineJunctionCarCanEnter(road->junctions);
+	combineJunctionCarsOnJunction(road->junctions);
+	combineJunctionAlreadyMoved(road->junctions);
+	combineJunctionOldSpeeds(road->junctions);
+	combineSinkCarCanEnterSink(road->sinks);
+
+	//calculate	grid and threads
+	unsigned int numberOfThreads = 128;
+	int Grid = (size_roads / numberOfThreads) + 1;
+	int Grid1, Grid2;
+	if (Grid > 512)
+	{
+		Grid1 = 512;
+		Grid2 = (Grid / Grid1) + 1;
+	}
+	else
+	{
+		Grid1 = 1;
+		Grid2 = Grid;
+	}
+	dim3 grid(Grid1, Grid2);
+	dim3 threads(numberOfThreads, 1, 1);
+
+	//call kernel
+	trafficTimestepKernel << < grid, threads >> > (
+		roadCurrent.data().get(),
+		roadNext.data().get(),
+		neighbors.data().get(),
+		oldSpeeds.data().get(),
+		junctionInCellIndices.data().get(),
+		junctionCarCanEnter.data().get(),
+		junctionCarsOnJunction.data().get(),
+		junctionAlreadyMoved.data().get(),
+		JunctionOldSpeeds.data().get(),
+		sinkCarCanEnter.data().get(),
+		size_roads,
+		maxVelocity,
+		maxAcceleration,
+		safetyDistance,
+		useSlowToStart,
+		slowStartPossibility,
+		dawdlePossibility,
+		&engine,
+		distFloat);
+
+	cudaDeviceSynchronize();
+
+	getLastCudaError("trafficTimestepKernel execution failed");
+
+	thrust::copy(roadNext.begin(), roadNext.end(), (*road->pnext).begin());
+	thrust::copy(roadCurrent.begin(), roadCurrent.end(), (*road->pcurrent).begin());
+	thrust::copy(oldSpeeds.begin(), oldSpeeds.end(), road->oldSpeeds.begin());
+	
+	//combineJunctionCarCanEnter(road->junctions);
+	//combineJunctionCarsOnJunction(road->junctions);
+	//combineJunctionAlreadyMoved(road->junctions);
+	//combineJunctionOldSpeeds(road->junctions);
+
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+__global__ void trafficTimestepKernel(int* roadCurrent, int* roadNext, int* neighbors, int* oldSpeeds, uint* junctionInCellIndices, bool* junctionCarCanEnter, int* junctionCarsOnJunction, uint* junctionAlreadyMoved, uint* JunctionOldSpeeds, bool* sinkCarCanEnter,
+	uint size_road, uint maxVelocity, uint maxAcceleration, uint safetyDistance, bool useSlowToStart, real slowStartPossibility, real dawdlePossibility, std::mt19937* engine, std::uniform_real_distribution<real> distFloat)
+{
+	//////////////////////////////////////////////////////////////////////////
+	const uint x = threadIdx.x;  // Globaler x-Index 
+	const uint y = blockIdx.x;   // Globaler y-Index 
+	const uint z = blockIdx.y;   // Globaler z-Index 
+
+	const uint nx = blockDim.x;
+	const uint ny = gridDim.x;
+
+	const uint index = nx*(ny*z + y) + x;
+	////////////////////////////////////////////////////////////////////////////////
+
+	if (index >= size_road) return;
+
+
+	trafficTimestepFunction(roadCurrent, roadNext, neighbors, oldSpeeds, junctionInCellIndices, junctionCarCanEnter, junctionCarsOnJunction, junctionAlreadyMoved, JunctionOldSpeeds, sinkCarCanEnter,
+		size_road, maxVelocity, maxAcceleration, safetyDistance, useSlowToStart, slowStartPossibility, dawdlePossibility, engine, distFloat, index);
+}
+
+__host__ __device__ void trafficTimestepFunction(int* roadCurrent, int* roadNext, int* neighbors, int* oldSpeeds, uint* junctionInCellIndices, bool* junctionCarCanEnter, int* junctionCarsOnJunction, uint* junctionAlreadyMoved, uint* JunctionOldSpeeds, bool* sinkCarCanEnter,
+	uint size_road, uint maxVelocity, uint maxAcceleration, uint safetyDistance, bool useSlowToStart, real slowStartPossibility, real dawdlePossibility, std::mt19937* engine, std::uniform_real_distribution<real> distFloat, uint index)
+{
+	if (roadCurrent[index] < 0) return;
+
+	uint speed = roadCurrent[index];
+
+
+
+	//// accelerate car ////////////////////////////////////////////////////////////////////
+
+	if (speed <= maxVelocity - maxAcceleration) speed += maxAcceleration;
+
+
+
+	//// brake car /////////////////////////////////////////////////////////////////////////
+
+	//getGapAfterCar
+	uint gap;
+	int neighbor = neighbors[index];
+	uint currentCell = index;
+	for (uint i = 0; i < (speed + safetyDistance); i++) {
+
+		//sink
+		if (neighbor <= -2000) {
+			if (i <= speed && sinkCarCanEnter[(neighbor + 2000)*-1]) gap = speed;
+			else gap = i;
+			break;
+		}
+
+		//junction
+		if (neighbor <= -1000) {
+			if (junctionCarCanEnter[getInCellsVectorIndex(junctionInCellIndices, size_road, currentCell)] && i <= speed) gap = speed;
+			else gap = i;
+			break;
+		}
+
+		//car in Cell
+		if (roadCurrent[neighbor] > -1) {
+			if (i <= safetyDistance) gap = 0;
+			else gap = i - safetyDistance;
+			break;
+		}
+
+		//empty cell -> get next neighbor, update currentCell
+		currentCell = neighbor;
+		neighbor = neighbors[neighbor];
+	}
+	//brake
+	if (speed > gap)
+		speed = gap;
+
+
+
+	//// dawdleCar ///////////////////////////////////////////////////////////////////////////
+	float randomNumber;
+	#if defined(__CUDA_ARCH__)
+		curandState state;
+		curand_init((unsigned long long)clock(), index, 0, &state);
+		randomNumber = curand_uniform_double(&state);
+	#else
+		randomNumber = distFloat(*engine);
+	#endif
+
+
+	//Barlovic / SlowToStart
+	if (useSlowToStart == true && roadCurrent[index] == 0) {
+		if (randomNumber < slowStartPossibility) speed = 0;
+	}
+	else if (randomNumber < dawdlePossibility) //Standard NaSch
+		if (speed >= maxAcceleration)
+			speed -= maxAcceleration;
+		else
+			speed = 0;
+
+
+
+	//// moveCar /////////////////////////////////////////////////////////////////////////////
+	if (speed == 0) {
+		(roadNext)[index] = 0;
+		oldSpeeds[index] = roadCurrent[index];
+		return;
+	}
+
+	neighbor = neighbors[index];
+	currentCell = index;
+
+	// iterateNeighborsInMove
+	uint numberOfCellsMoved = 1;
+	for (uint i = 2; i <= speed; i++) {
+		if (neighbor >= 0) {
+			currentCell = neighbor;
+			neighbor = neighbors[neighbor];
+			++numberOfCellsMoved;
+		}
+		else
+			break;
+	}
+
+
+	if (neighbor <= -1000 && neighbor > -2000) {
+		//registerCar
+		uint index = getInCellsVectorIndex(junctionInCellIndices, size_road, currentCell);
+		junctionCarsOnJunction[index] = speed - 1; //all cars, which enter the junction have to slow down by one increment
+		//getCarsOnJunction[index] = 0; //all cars, which enter the junction have to stop
+		JunctionOldSpeeds[index] = roadCurrent[index];
+		junctionCarCanEnter[index] = false;
+		junctionAlreadyMoved[index] = numberOfCellsMoved;
+		return;
+	}
+
+	if (neighbor >= 0) {
+		roadNext[neighbor] = speed;
+		//writeConcentration(neighbor, (*pcurrent)[carIndex]);
+	}
+}
+
+
+
+
+
+__host__ __device__ uint getInCellsVectorIndex(uint* junctionInCellIndices, uint size_road, uint cell) {
+	for (uint i = 0; i < size_road; i++)
+		if (junctionInCellIndices[i] == cell)
+			return i;
+	// Error: "no matching incoming cell to a junction found in: getInCellsVectorIndex()";
+	return 65000;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//TrafficTimestep::TrafficTimestep(RoadNetworkData* road, TrafficMovement* traffic)
+//{
+//	maxVelocity = road->maxVelocity;
+//	vehicleLength = road->vehicleLength;
+//	safetyDistance = road->safetyDistance;
+//
+//	dawdlePossibility = traffic->getDawdlePossibility();
+//	useSlowToStart = traffic->getUseSlowToStart();
+//	slowStartPossibility = traffic->getSlowToStartPossibility();
+//	maxAcceleration = traffic->getMaxAcceleration();
+//}
+
+
+
+void TrafficTimestep::combineJunctionInCellIndices(std::vector<std::shared_ptr<Junction>> junctions)
+{
+	uint it = 0;
+	for (auto& j : junctions)
+		for (uint i : j->getInCellIndices()) {
+			this->junctionInCellIndices.push_back(i);
+			it++;
+		}
+}
+
+void TrafficTimestep::combineJunctionCarCanEnter(std::vector<std::shared_ptr<Junction>> junctions)
+{
+	uint index = 0;
+	for (auto& j : junctions)
+		for (bool i : j->getCarCanEnter()) {
+			this->junctionCarCanEnter[index] = i;
+			index++;
+		}
+
+}
+
+void TrafficTimestep::combineJunctionCarsOnJunction(std::vector<std::shared_ptr<Junction>> junctions)
+{
+	uint index = 0;
+	for (auto& j : junctions)
+		for (int i : j->getCarsOnJunction()) {
+			this->junctionCarsOnJunction[index] = i;
+			index++;
+		}
+}
+
+
+void TrafficTimestep::combineSinkCarCanEnterSink(std::vector<std::shared_ptr<Sink>> sinks)
+{
+	uint index = 0;
+	for (auto& s : sinks) {
+		this->sinkCarCanEnter.push_back(s->carCanEnter());
+		index++;
+	}
+}
+
+void TrafficTimestep::combineJunctionAlreadyMoved(std::vector<std::shared_ptr<Junction>> junctions)
+{
+	uint index = 0;
+	for (auto& j : junctions)
+		for (int i : j->getCarsOnJunction()) {
+			this->junctionAlreadyMoved[index] = i;
+			index++;
+		}
+}
+
+void TrafficTimestep::combineJunctionOldSpeeds(std::vector<std::shared_ptr<Junction>> junctions)
+{
+	uint index = 0;
+	for (auto& j : junctions)
+		for (int i : j->getCarsOnJunction()) {
+			this->JunctionOldSpeeds[index] = i;
+			index++;
+		}
+}
\ No newline at end of file
diff --git a/src/Traffic/GPU/TrafficTimestep.h b/src/Traffic/GPU/TrafficTimestep.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e90545f3f17fe00a2948369b7f63db88a9479dc
--- /dev/null
+++ b/src/Traffic/GPU/TrafficTimestep.h
@@ -0,0 +1,76 @@
+#ifndef  TrafficTimestep_H
+#define  TrafficTimestep_H
+
+#include <vector>
+//#include <string>
+#include <memory>
+#include <random>
+#include <thrust/device_vector.h>
+
+#include "VirtualFluidsDefinitions.h"
+#include "Utilities/RandomHelper.h"
+#include "Core/PointerDefinitions.h"
+#include "Core/DataTypes.h"
+
+//#include "TrafficMovement.h"
+
+struct RoadNetworkData;
+//class TrafficMovement;
+class Sink;
+class Junction;
+class Source;
+
+class VF_PUBLIC TrafficTimestep
+{
+private:
+
+	//std::vector<real> kineticEnergyTimeSeries;
+	int size_roads;
+	uint maxVelocity;
+	uint safetyDistance;
+
+	real dawdlePossibility;
+	bool useSlowToStart;
+	real slowStartPossibility;
+	uint maxAcceleration;
+
+	int size_junctions;
+	int size_sources;
+	int size_sinks;
+
+	thrust::device_vector<int> neighbors;
+
+	thrust::device_vector<int> roadCurrent;
+	thrust::device_vector<int> roadNext;
+	thrust::device_vector<int> oldSpeeds;
+
+	thrust::device_vector<uint> junctionInCellIndices;
+	thrust::device_vector<bool> junctionCarCanEnter;
+	thrust::device_vector<int> junctionCarsOnJunction;	
+	thrust::device_vector<uint> junctionAlreadyMoved;
+	thrust::device_vector<uint> JunctionOldSpeeds;
+
+	thrust::device_vector<bool> sinkCarCanEnter;
+
+	thrust::device_vector<float> sourcePossibilities;
+
+	std::mt19937 engine = RandomHelper::make_engine();
+	std::uniform_real_distribution<float> distFloat{ 0.0, 1.0 };
+public:
+
+
+	TrafficTimestep(std::shared_ptr<RoadNetworkData> road);
+	//TrafficTimestep(RoadNetworkData* road, TrafficMovement* traffic);
+	void run(std::shared_ptr<RoadNetworkData> road);
+
+	void combineJunctionInCellIndices(std::vector<std::shared_ptr<Junction> > junctions);
+	void combineJunctionCarCanEnter(std::vector<std::shared_ptr<Junction> > junctions);
+	void combineJunctionCarsOnJunction(std::vector<std::shared_ptr<Junction> > junctions);
+	void combineSinkCarCanEnterSink(std::vector<std::shared_ptr<Sink> > sinks);
+	void combineSourcePossibilities(std::vector<std::shared_ptr<Source>> sources);
+	void combineJunctionAlreadyMoved(std::vector<std::shared_ptr<Junction> > junctions);
+	void combineJunctionOldSpeeds(std::vector<std::shared_ptr<Junction> > junctions);
+
+};
+
+#endif
diff --git a/src/Traffic/GPU/package.include b/src/Traffic/GPU/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/Traffic/Junction/Junction.h b/src/Traffic/Junction/Junction.h
index 8af481aefef0f007d463b27d8f1b2190784d2fe4..259bdcb9ee7d7241ad9a03370acc271c4fb4cd6a 100644
--- a/src/Traffic/Junction/Junction.h
+++ b/src/Traffic/Junction/Junction.h
@@ -20,7 +20,9 @@ public:
 	virtual void updateJunction() = 0;
 
 	virtual const std::vector<uint>& getInCellIndices() const  = 0;
+	virtual const std::vector<bool>& getCarCanEnter() const = 0;
+	virtual const std::vector<int>& getCarsOnJunction()const = 0;
 
 	virtual void dispJunction(const uint index, const uint roadLength) const = 0;
-	virtual const uint getNumCarsOnJunction() const = 0;
+	virtual uint getNumCarsOnJunction() const = 0;
 };
\ No newline at end of file
diff --git a/src/Traffic/Junction/JunctionRandom.cpp b/src/Traffic/Junction/JunctionRandom.cpp
index f5c427f8915ceb5f3de31a8e2f7835007c14914c..97b05ba9e6e57cedd27b08ed03a9e8f9f84bf7ff 100644
--- a/src/Traffic/Junction/JunctionRandom.cpp
+++ b/src/Traffic/Junction/JunctionRandom.cpp
@@ -70,9 +70,7 @@ uint JunctionRandom::getInCellsVectorIndex(uint cellIndex)
 		auto it = find(data.inCellIndices.begin(), data.inCellIndices.end(), cellIndex);
 
 		if (it != data.inCellIndices.end())
-		{
 			return static_cast <uint> (distance(data.inCellIndices.begin(), it));
-		}
 
 		throw std::runtime_error("The passed cell is not an incoming cell to this junction.");
 	}
@@ -121,7 +119,7 @@ void JunctionRandom::applyRules(int & carSpeed, int index, TrafficMovement& road
 		}
 	}
 	data.carsOnJunction[index] = 0;				//cars, which can't cross the junctionin one timestep, because they already moved to many cells, loose their speed.
-	//data.carsOnJunction[index] = carSpeed;	//cars, which can't cross the junction in one timestep, because they already moved to many cells, keep their speed.
+	//data.getCarsOnJunction[index] = carSpeed;	//cars, which can't cross the junction in one timestep, because they already moved to many cells, keep their speed.
 }
 
 
@@ -211,6 +209,26 @@ const std::vector<uint>& JunctionRandom::getInCellIndices() const
 	return data.inCellIndices;
 }
 
+const std::vector<bool>& JunctionRandom::getCarCanEnter() const
+{
+	return data.carCanEnter;
+}
+
+const std::vector<int>& JunctionRandom::getCarsOnJunction() const
+{
+	return data.carsOnJunction;
+}
+
+const std::vector<uint>& JunctionRandom::getAlreadyMoved() const
+{
+	return data.alreadyMoved;
+}
+
+const std::vector<uint>& JunctionRandom::getOldSpeeds() const
+{
+	return data.oldSpeeds;
+}
+
 void JunctionRandom::dispJunction(const uint index, const uint roadLength) const
 {
 	if (find(data.inCellIndices.begin(), data.inCellIndices.end(), (roadLength - index - 1)) != data.inCellIndices.end()) {
@@ -224,7 +242,7 @@ void JunctionRandom::dispJunction(const uint index, const uint roadLength) const
 	}
 }
 
-const uint JunctionRandom::getNumCarsOnJunction() const
+uint JunctionRandom::getNumCarsOnJunction() const
 {
 	uint num = 0;
 	for (auto car : data.carsOnJunction) {
diff --git a/src/Traffic/Junction/JunctionRandom.h b/src/Traffic/Junction/JunctionRandom.h
index 531eb210f93112eac60660efb5527a7eaf12844a..cb6cd29314302a87ec1b60e2de4a5d66c5793c78 100644
--- a/src/Traffic/Junction/JunctionRandom.h
+++ b/src/Traffic/Junction/JunctionRandom.h
@@ -28,9 +28,13 @@ public:
 	virtual void updateJunction();
 
 	virtual const std::vector<uint>& getInCellIndices() const;
+	virtual const std::vector<bool>& getCarCanEnter() const;
+	virtual const std::vector<int>& getCarsOnJunction()const;
+	virtual const std::vector<uint>& getAlreadyMoved()const;
+	virtual const std::vector<uint>& getOldSpeeds()const;
 	
 	virtual void dispJunction(const uint index, const uint roadLength) const;
-	virtual const uint getNumCarsOnJunction() const; 
+	virtual uint getNumCarsOnJunction() const; 
 
 	virtual void checkOutCellIndices(const uint roadLength) const; 
 
diff --git a/src/Traffic/Output/ConcBySpeedAndAcceleration.cpp b/src/Traffic/Output/ConcBySpeedAndAcceleration.cpp
index cf9760ee27f720c3262a84544c14b385dc69398c..03fdaf8c3246b01d5f39f029a4459f745f7fcda9 100644
--- a/src/Traffic/Output/ConcBySpeedAndAcceleration.cpp
+++ b/src/Traffic/Output/ConcBySpeedAndAcceleration.cpp
@@ -2,17 +2,18 @@
 
 #include <iostream>
 
-ConcBySpeedAndAcceleration::ConcBySpeedAndAcceleration(uint roadlength, real * concArrayStart, uint maxSpeed)
+ConcBySpeedAndAcceleration::ConcBySpeedAndAcceleration(uint roadLength, real * concArrayStart, uint maxSpeed)
 {
 	if (concArrayStart == nullptr) {
-		std::cout << "using ConcBySpeedAndAcceleration::concentration for concentrations" << std::endl;
-		concentration.resize(roadlength);
+		std::cout << "using ConcBySpeedAndAcceleration::concentration-vector for concentrations" << std::endl;
+		concentration.resize(roadLength);
+		this->roadLength = roadLength;
 		this->maxSpeed = static_cast<real>(maxSpeed);
 	}
 	else {
 		std::cout << "using passed array for concentrations" << std::endl;
 		useLBMConcArray = true;
-		this->roadLength = roadlength;
+		this->roadLength = roadLength;
 		this->concArrayStart = concArrayStart;
 		this->maxSpeed = static_cast<real>(maxSpeed);
 	}
@@ -25,6 +26,14 @@ void ConcBySpeedAndAcceleration::calculateConcForSingleCar(uint index, uint oldS
 }
 
 
+void ConcBySpeedAndAcceleration::calculateConcForAllCars(const std::vector<int> oldSpeeds, const std::vector<int> newSpeeds)
+{
+	for (uint i = 0; i < roadLength; i++) {
+		if (newSpeeds[i] > -1)
+			putConcIntoArrayOrVector(i, chooseConc(oldSpeeds[i], newSpeeds[i]));
+	}
+}
+
 void ConcBySpeedAndAcceleration::calculateConcForJunctionCar(uint index, uint oldSpeed, uint speed)
 {
 	addConcToArrayOrVector(index, chooseConc(oldSpeed, speed));
diff --git a/src/Traffic/Output/ConcBySpeedAndAcceleration.h b/src/Traffic/Output/ConcBySpeedAndAcceleration.h
index 71ef332e092d6b248b3337c1402f983677b9392c..3bb36e927e80c21fcee464350cb7560d96b06f8b 100644
--- a/src/Traffic/Output/ConcBySpeedAndAcceleration.h
+++ b/src/Traffic/Output/ConcBySpeedAndAcceleration.h
@@ -11,6 +11,7 @@ public:
 
 	virtual void calculateConcForSingleCar(uint index, uint oldSpeed, uint speed);
 	virtual void calculateConcForJunctionCar(uint index, uint oldSpeed, uint speed);
+	virtual void calculateConcForAllCars(const std::vector<int> oldSpeeds, const std::vector<int> newSpeeds);
 
 
 private:
diff --git a/src/Traffic/Output/ConcentrationByPosition.cpp b/src/Traffic/Output/ConcentrationByPosition.cpp
index cc28bcad23baa6083c41b56495591956b3553acd..bdfc46e13b319e542805b50c5a76cb89f7aeacec 100644
--- a/src/Traffic/Output/ConcentrationByPosition.cpp
+++ b/src/Traffic/Output/ConcentrationByPosition.cpp
@@ -2,11 +2,12 @@
 
 #include <iostream>
 
-ConcentrationByPosition::ConcentrationByPosition(uint roadlength, real * concArrayStart, uint maxSpeed)
+ConcentrationByPosition::ConcentrationByPosition(uint roadLength, real * concArrayStart, uint maxSpeed)
 {
 	if (concArrayStart == nullptr) {
-		std::cout << "using ConcentrationByPosition::concentration for concentrations" << std::endl;
-		concentration.resize(roadlength);
+		std::cout << "using ConcentrationByPosition::concentration-vector for concentrations" << std::endl;
+		concentration.resize(roadLength);
+		this->roadLength = roadLength;
 	}
 	else {
 		std::cout << "using passed array for concentrations" << std::endl;
@@ -40,4 +41,11 @@ void ConcentrationByPosition::calculateConcForJunctionCar(uint index, uint oldSp
 	addConcToArrayOrVector(index, 1.0);
 }
 
+void ConcentrationByPosition::calculateConcForAllCars(const std::vector<int> oldSpeeds, const std::vector<int> newSpeeds)
+{
+	for (uint i = 0; i < roadLength; i++) 
+		if (newSpeeds[i] >= 0)
+			putConcIntoArrayOrVector(i, 1.0);
+}
+
 
diff --git a/src/Traffic/Output/ConcentrationByPosition.h b/src/Traffic/Output/ConcentrationByPosition.h
index 7bcf89d0801b1c9770a9bea73e489f8f92f8142a..48c93878e9f607ec1a3029fd61f8524c2816a6d9 100644
--- a/src/Traffic/Output/ConcentrationByPosition.h
+++ b/src/Traffic/Output/ConcentrationByPosition.h
@@ -11,5 +11,6 @@ public:
 
 	virtual void calculateConcForSingleCar(uint index, uint oldSpeed = 0, uint speed = 0);
 	virtual void calculateConcForJunctionCar(uint index, uint oldSpeed = 0, uint speed = 0);
+	virtual void calculateConcForAllCars(const std::vector<int> oldSpeeds, const std::vector<int> newSpeeds) = 0;
 };
 
diff --git a/src/Traffic/Output/ConcentrationOutwriter.h b/src/Traffic/Output/ConcentrationOutwriter.h
index 8908b508ced02f270952a4819bbccac9c7063108..0c6082912d65c6f8865cee953d5125a0f15f1f77 100644
--- a/src/Traffic/Output/ConcentrationOutwriter.h
+++ b/src/Traffic/Output/ConcentrationOutwriter.h
@@ -11,7 +11,7 @@ public:
 	virtual void resetConcentrations();
 	virtual void calculateConcForSingleCar(uint index, uint oldSpeed = 0, uint speed = 0) = 0;
 	virtual void calculateConcForJunctionCar(uint index, uint oldSpeed = 0, uint speed = 0) = 0;
-
+	virtual void calculateConcForAllCars(const std::vector<int> oldSpeeds, const std::vector<int> newSpeeds)=0;
 	void dispConcentrations();
 
 protected:
diff --git a/src/Traffic/RoadNetwork/RoadNetworkData.h b/src/Traffic/RoadNetwork/RoadNetworkData.h
index 1a19822bf4d1d303a262abdbc77809d46880011a..904b89230faf039299740d68fb466f72924bd9f8 100644
--- a/src/Traffic/RoadNetwork/RoadNetworkData.h
+++ b/src/Traffic/RoadNetwork/RoadNetworkData.h
@@ -12,7 +12,7 @@
 
 struct VF_PUBLIC RoadNetworkData
 {
-protected:
+public:
 	friend class TrafficMovement;
 
 	uint roadLength;
@@ -28,5 +28,11 @@ protected:
 	std::vector<std::shared_ptr<Sink> > sinks; 
 	std::vector<std::shared_ptr<Junction> > junctions;
 	std::vector<std::shared_ptr<Source> > sources;
+
+	std::vector<int> *pcurrent;
+	std::vector<int> *pnext;
+	std::vector<int> *pdummy;
+
+	std::vector<int> oldSpeeds;
 };
 
diff --git a/src/Traffic/TrafficMovement.cpp b/src/Traffic/TrafficMovement.cpp
index b4ff8b0569c990bf9c929868e69f34a1b5a75773..0e90e2653d49b66922f40aafc9f7509e11fbbaed 100644
--- a/src/Traffic/TrafficMovement.cpp
+++ b/src/Traffic/TrafficMovement.cpp
@@ -9,12 +9,14 @@
 #include "Output/ConcentrationOutwriter.h"
 #include "Output/CarDisplay.h"
 
-TrafficMovement::TrafficMovement(std::unique_ptr<RoadNetworkData> road, const real dawdlePossibility)
+#include "GPU/TrafficTimestep.h"
+
+TrafficMovement::TrafficMovement(std::shared_ptr<RoadNetworkData> road, const real dawdlePossibility)
 {
 	this->road = std::move(road);
 
-	pcurrent = &this->road->current;
-	pnext = &(this->road->next);
+	this->road->pcurrent = &this->road->current;
+	this->road->pnext = &(this->road->next);
 
 	checkCurrentForSafetyDistance();
 
@@ -24,9 +26,9 @@ TrafficMovement::TrafficMovement(std::unique_ptr<RoadNetworkData> road, const re
 
 TrafficMovement::~TrafficMovement()
 {
-	pcurrent = NULL;
-	pnext = NULL;
-	pdummy = NULL;
+	road->pcurrent = NULL;
+	road->pnext = NULL;
+	road->pdummy = NULL;
 }
 
 
@@ -68,6 +70,14 @@ void TrafficMovement::setSlowToStart(const real slowStartPossibility)
 	}
 }
 
+void TrafficMovement::setUseGPU()
+{
+	useGPU = true;
+	this->road->oldSpeeds.resize(this->road->roadLength);
+	VectorHelper::fillVector(this->road->oldSpeeds, -1);
+	gpuCalculation = std::make_unique<TrafficTimestep>(TrafficTimestep(this->road));
+}
+
 void TrafficMovement::setMaxAcceleration(uint maxAcceleration)
 {
 	this->maxAcceleration = maxAcceleration;
@@ -81,43 +91,65 @@ void TrafficMovement::setConcentrationOutwriter(std::unique_ptr<ConcentrationOut
 
 void TrafficMovement::setSaveResultsTrue(uint timeSteps)
 {
-	this->display = std::make_unique<CarDisplay>(&pcurrent, road->safetyDistance);
+	this->display = std::make_unique<CarDisplay>(&road->pcurrent, road->safetyDistance);
 	if (display != nullptr) display->initResults(timeSteps);
 }
 
 
-const uint TrafficMovement::getNumberOfCars() const
+uint TrafficMovement::getNumberOfCars() const
 {
 	uint num = 0;
 	for (auto& junc : road->junctions) {
 		num += junc->getNumCarsOnJunction();
 	}
 
-	for (auto cell : *pcurrent) {
+	for (auto cell : *road->pcurrent) {
 		if (cell >= 0) ++num;
 	}
 	return num;
 }
 
 
-const int TrafficMovement::getSpeedAtPosition(uint pos) const
+int TrafficMovement::getSpeedAtPosition(uint pos) const
 {
-	return (*pcurrent)[pos];
+	return (*road->pcurrent)[pos];
 }
 
 
-const uint TrafficMovement::getRoadLength() const
+uint TrafficMovement::getRoadLength() const
 {
 	return road->roadLength;
 }
 
 
-const uint TrafficMovement::getMaxVelocity() const
+uint TrafficMovement::getMaxVelocity() const
 {
 	return road->maxVelocity;
 }
 
 
+real TrafficMovement::getDawdlePossibility()
+{
+	return dawdlePossibility;
+}
+
+bool TrafficMovement::getUseSlowToStart()
+{
+	return useSlowToStart;
+}
+
+real TrafficMovement::getSlowToStartPossibility()
+{
+	return slowStartPossibility;
+}
+
+uint TrafficMovement::getMaxAcceleration()
+{
+	return maxAcceleration;
+}
+
+
+
 void TrafficMovement::loopTroughTimesteps(uint timeSteps)
 {
 	for (uint step = 1; step < timeSteps + 1; step++) {
@@ -132,15 +164,19 @@ void TrafficMovement::calculateTimestep(uint step)
 	//if (display != nullptr)	display->dispCurrentRoad();
 	//if (concWriter != nullptr) concWriter->dispConcentrations();
 
-	VectorHelper::fillVector(*pnext, -1);
+	VectorHelper::fillVector(*(road->pnext), -1);
 	if (concWriter != nullptr) concWriter->resetConcentrations();
 
-	//apply rules on all cars  
-	for (uint i = 0; i < road->roadLength; i++) {
-		if ((*pcurrent)[i] > -1) {
-			applyRules(i);
-		}
+	//apply rules on all cars
+	if (useGPU) {
+		this->gpuCalculation->run(road);
+		if (concWriter != nullptr) concWriter->calculateConcForAllCars(road->oldSpeeds, *(road->pcurrent));
 	}
+	else 
+		for (uint i = 0; i < road->roadLength; i++) 
+			if ((*road->pcurrent)[i] > -1) 
+				applyRules(i);
+	
 
 	calculateJunctionStep();
 
@@ -163,7 +199,7 @@ void TrafficMovement::calculateSourceStep()
 		gap = getGapAfterOutCell(sourceIndex, road->maxVelocity);
 		if (gap > 0) {
 			uint speed = source->getSourceCar();
-			(*pnext)[sourceIndex] = speed;
+			(*road->pnext)[sourceIndex] = speed;
 			writeConcentration(sourceIndex, speed);
 		}
 	}
@@ -179,14 +215,14 @@ void TrafficMovement::calculateJunctionStep()
 
 void TrafficMovement::switchCurrentNext()
 {
-	pdummy = pcurrent;
-	pcurrent = pnext;
-	pnext = pdummy;
+	road->pdummy = road->pcurrent;
+	road->pcurrent = road->pnext;
+	road->pnext = road->pdummy;
 }
 
 void TrafficMovement::applyRules(uint carIndex)
 {
-	uint speed = (*pcurrent)[carIndex];
+	uint speed = (*road->pcurrent)[carIndex];
 	accelerateCar(speed);
 	brakeCar(carIndex, speed);
 	dawdleCar(carIndex, speed);
@@ -195,18 +231,16 @@ void TrafficMovement::applyRules(uint carIndex)
 
 void TrafficMovement::accelerateCar(uint & speed)
 {
-	if (speed <= road->maxVelocity - maxAcceleration) {
+	if (speed <= road->maxVelocity - maxAcceleration)
 		speed += maxAcceleration;
-	}
 }
 
 void TrafficMovement::brakeCar(uint carIndex, uint &speed)
 {
 	int neighbor = road->neighbors[carIndex];
 	gap = getGapAfterCar(carIndex, speed, neighbor);
-	if (speed > gap) {
+	if (speed > gap)
 		speed = gap;
-	}
 }
 
 void TrafficMovement::dawdleCar(uint carIndex, uint & speed)
@@ -214,7 +248,7 @@ void TrafficMovement::dawdleCar(uint carIndex, uint & speed)
 	randomNumber = distFloat(engine);
 
 	//Barlovic / SlowToStart
-	if (useSlowToStart == true && (*pcurrent)[carIndex] == 0) {
+	if (useSlowToStart == true && (*road->pcurrent)[carIndex] == 0) {
 		if (randomNumber < slowStartPossibility) {
 			speed = 0;
 		}
@@ -233,8 +267,8 @@ void TrafficMovement::dawdleCar(uint carIndex, uint & speed)
 void TrafficMovement::moveCar(const uint carIndex, uint speed)
 {
 	if (speed == 0) {
-		(*pnext)[carIndex] = 0;
-		writeConcentration(carIndex, (*pcurrent)[carIndex]);
+		(*road->pnext)[carIndex] = 0;
+		writeConcentration(carIndex, (*road->pcurrent)[carIndex]);
 		return;
 	}
 
@@ -244,13 +278,13 @@ void TrafficMovement::moveCar(const uint carIndex, uint speed)
 	uint numberOfCellsMoved = iterateNeighborsInMove(currentCell, speed, neighbor);
 
 	if (neighbor <= -1000 && neighbor > -2000) {
-		getJunctionFromNeighbor(neighbor)->registerCar(currentCell, numberOfCellsMoved, speed, (*pcurrent)[carIndex]);
+		getJunctionFromNeighbor(neighbor)->registerCar(currentCell, numberOfCellsMoved, speed, (*road->pcurrent)[carIndex]);
 		return;
 	}
 
 	if (neighbor >= 0) {
-		(*pnext)[neighbor] = speed;
-		writeConcentration(neighbor, (*pcurrent)[carIndex]);
+		(*road->pnext)[neighbor] = speed;
+		writeConcentration(neighbor, (*road->pcurrent)[carIndex]);
 	}
 }
 
@@ -258,7 +292,7 @@ void TrafficMovement::moveCar(const uint carIndex, uint speed)
 void TrafficMovement::moveJunctionCar(uint outCellIndex, uint remainingDistance, uint speed, uint oldSpeed)
 {
 	if (remainingDistance == 1) {
-		(*pnext)[outCellIndex] = speed;
+		(*road->pnext)[outCellIndex] = speed;
 		writeConcentration(outCellIndex, oldSpeed);
 		return;
 	}
@@ -267,10 +301,10 @@ void TrafficMovement::moveJunctionCar(uint outCellIndex, uint remainingDistance,
 
 	uint numberOfCellsMoved = iterateNeighborsInMove(outCellIndex, remainingDistance, neighbor);
 
-	try{
-	if (neighbor <= -1000 && neighbor > -2000) {
-		throw std::runtime_error("car entered two junctions in one timestep");
-	}
+	try {
+		if (neighbor <= -1000 && neighbor > -2000) {
+			throw std::runtime_error("car entered two junctions in one timestep");
+		}
 	}
 	catch (const std::exception& e) {
 		std::cerr << e.what() << std::endl;
@@ -279,7 +313,7 @@ void TrafficMovement::moveJunctionCar(uint outCellIndex, uint remainingDistance,
 	}
 
 	if (neighbor >= 0) {
-		(*pnext)[neighbor] = speed;
+		(*road->pnext)[neighbor] = speed;
 		writeConcentration(neighbor, oldSpeed);
 	}
 }
@@ -327,7 +361,7 @@ uint TrafficMovement::getGapAfterCar(uint carIndex, uint speed, int neighbor)
 			return getGapToJunction(neighbor, i, speed, carIndex);
 
 		//car in Cell
-		if ((*pcurrent)[neighbor] > -1)
+		if ((*road->pcurrent)[neighbor] > -1)
 			return adjustGapToSafetyDist(i);
 
 		//empty cell -> get next neighbor, update currentCell
@@ -340,9 +374,9 @@ uint TrafficMovement::getGapAfterCar(uint carIndex, uint speed, int neighbor)
 
 uint TrafficMovement::getGapAfterOutCell(uint outCellIndex, uint speed)
 {
-	if ((*pcurrent)[outCellIndex] > -1)
+	if ((*road->pcurrent)[outCellIndex] > -1)
 		return 0;
-	 
+
 	int neighbor = outCellIndex;
 
 	for (uint i = 0; i < (speed + road->safetyDistance); i++) {
@@ -353,7 +387,7 @@ uint TrafficMovement::getGapAfterOutCell(uint outCellIndex, uint speed)
 			return i;
 
 		//car in Cell
-		if ((*pcurrent)[neighbor] > -1)
+		if ((*road->pcurrent)[neighbor] > -1)
 			return adjustGapToSafetyDist(i);
 
 		//empty cell -> get next neighbor
@@ -390,7 +424,7 @@ uint TrafficMovement::adjustGapToSafetyDist(uint gap)
 void TrafficMovement::writeConcentration(uint index, uint oldSpeed)
 {
 	if (concWriter != nullptr) {
-		concWriter->calculateConcForSingleCar(index, oldSpeed, (*pnext)[index]);
+		concWriter->calculateConcForSingleCar(index, oldSpeed, (*road->pnext)[index]);
 	}
 }
 
@@ -416,13 +450,13 @@ void TrafficMovement::checkCurrentForSafetyDistance()
 	if (road->safetyDistance > 0) {
 		uint neighbor;
 		for (uint i = 0; i < road->roadLength; i++) {
-			if ((*pcurrent)[i] > -1) {
+			if ((*road->pcurrent)[i] > -1) {
 				neighbor = road->neighbors[i];
 
 				for (uint j = 1; j <= road->safetyDistance; j++) {
 					if (neighbor <= -1000)
 						break;
-					if ((*pcurrent)[neighbor] > -1) {
+					if ((*road->pcurrent)[neighbor] > -1) {
 						std::cerr << "timestep 0: safetyDistance was violated: carIndex: " << i << std::endl;
 						break;
 					}
@@ -442,24 +476,24 @@ const std::vector<int> & TrafficMovement::getVehiclesForVTK()
 
 void TrafficMovement::visualizeVehicleLengthForVTK()
 {
-	road->currentWithLongVehicles = *pcurrent;
+	road->currentWithLongVehicles = *road->pcurrent;
 
 	if (road->safetyDistance != 0) {
 		for (uint i = 0; i < road->roadLength; i++) {
-			if ((*pcurrent)[i] > -1) {
-				checkSpeed((*pcurrent)[i]);
+			if ((*road->pcurrent)[i] > -1) {
+				checkSpeed((*road->pcurrent)[i]);
 				int neighbor = road->neighbors[i];
 
 				for (uint j = 1; j <= road->safetyDistance; j++) {
 
 					if (neighbor <= -1000)
 						break;
-					if ((*pcurrent)[neighbor] > -1) {
+					if ((*road->pcurrent)[neighbor] > -1) {
 						std::cerr << "safetyDistance was violated: timestep: " << currentStep << "\t carIndex: " << i << std::endl;
 						break;
 					}
 					else
-						(road->currentWithLongVehicles)[neighbor] = (*pcurrent)[i];
+						(road->currentWithLongVehicles)[neighbor] = (*road->pcurrent)[i];
 					neighbor = road->neighbors[neighbor];
 				}
 			}
diff --git a/src/Traffic/TrafficMovement.h b/src/Traffic/TrafficMovement.h
index ccd7c8c74ca3e92100c9ae1b14d866d685545789..a86dfa799b7e3bd4ca09be64426afa902a033bf9 100644
--- a/src/Traffic/TrafficMovement.h
+++ b/src/Traffic/TrafficMovement.h
@@ -8,14 +8,16 @@
 #include "Core/DataTypes.h"
 
 #include "RoadNetwork/RoadNetworkData.h"
+#include "Utilities/RandomHelper.h"
 
 class ConcentrationOutwriter;
 class CarDisplay;
+class TrafficTimestep;
 
 class VF_PUBLIC TrafficMovement
 {
 public:
-	TrafficMovement(std::unique_ptr<RoadNetworkData> road, const real dawdlePossibility);
+	TrafficMovement(std::shared_ptr<RoadNetworkData> road, const real dawdlePossibility);
 	//TrafficMovement() {};
 	TrafficMovement(const TrafficMovement&) = delete;
 	~TrafficMovement();
@@ -25,16 +27,22 @@ public:
 	void setMaxAcceleration(uint maxAcceleration);
 	void setConcentrationOutwriter(std::unique_ptr<ConcentrationOutwriter> writer);
 	void setSaveResultsTrue(uint timeSteps);
+	void setUseGPU();
 
 	//timpestep
 	void loopTroughTimesteps(uint numberOfTimesteps);
 	void calculateTimestep(uint step);
 
 	//get
-	const uint getRoadLength() const;
-	const uint getMaxVelocity() const;
-	const uint getNumberOfCars() const;			//only use for testing
-	const int getSpeedAtPosition(uint pos) const;       //only use for testing
+	uint getRoadLength() const;
+	uint getMaxVelocity() const;
+	uint getNumberOfCars() const;			//only use for testing
+	int getSpeedAtPosition(uint pos) const;       //only use for testing
+	real getDawdlePossibility();
+	bool getUseSlowToStart();
+	real getSlowToStartPossibility();
+	uint getMaxAcceleration();
+
 
 	//methods used by junctions and sources
 	uint getGapAfterOutCell(uint outCellIndex, uint speed);
@@ -83,13 +91,12 @@ private:
 	void writeConcentration(uint index, uint oldSpeed);
 
 private:
-	std::unique_ptr<RoadNetworkData> road;
+	std::shared_ptr<RoadNetworkData> road;
 	std::unique_ptr<ConcentrationOutwriter> concWriter = nullptr;
 	std::unique_ptr<CarDisplay> display = nullptr;
 
-	std::vector<int> *pcurrent;
-	std::vector<int> *pnext;
-	std::vector<int> *pdummy;
+	bool useGPU = false;
+	std::unique_ptr<TrafficTimestep> gpuCalculation;
 
 	real dawdlePossibility;
 
@@ -106,6 +113,6 @@ private:
 private:
 	//temporary variables for calculation
 	uint gap;
-	double randomNumber;
+	float randomNumber;
 };
 
diff --git a/src/Traffic/TrafficMovementFactoryImpl.cpp b/src/Traffic/TrafficMovementFactoryImpl.cpp
index a01625ef00cfa25ab7f53f39f90a6decaf81ad3e..ec1eb8cce8b877cdfaf49f8795980167cfc1e8bf 100644
--- a/src/Traffic/TrafficMovementFactoryImpl.cpp
+++ b/src/Traffic/TrafficMovementFactoryImpl.cpp
@@ -90,7 +90,7 @@ void TrafficMovementFactoryImpl::initTrafficMovement(real * pconcArrayStart)
 	this->simulator = std::make_shared<TrafficMovement>(move(roadNetwork), dawdlePossibility);
 	simulator->setSlowToStart(slowToStartPossibility);
 	simulator->setMaxAcceleration(2);
-
+	simulator->setUseGPU();
 
 	//init ConcentrationOutwriter
 	std::unique_ptr<ConcentrationOutwriter> writer = std::make_unique<ConcBySpeedAndAcceleration>(ConcBySpeedAndAcceleration(simulator->getRoadLength(), pconcArrayStart));
diff --git a/src/Traffic/TrafficMovementFactoryTest.cpp b/src/Traffic/TrafficMovementFactoryTest.cpp
index b8ab1051e6a3e48ce6c7b647043f05c8e80631b8..358a335eb5a0af24e30cbb7d830d4b5fdc7b02d3 100644
--- a/src/Traffic/TrafficMovementFactoryTest.cpp
+++ b/src/Traffic/TrafficMovementFactoryTest.cpp
@@ -1,68 +1,68 @@
-#include "TrafficMovementFactoryTest.h"
-
-#include <iostream>
-
-#include "GridGenerator/StreetPointFinder/JunctionReader.h"
-#include "GridGenerator/StreetPointFinder/SourceReader.h"
-#include "GridGenerator/StreetPointFinder/SinkReader.h"
-
-#include "RoadNetwork/RoadMaker.h"
-#include "TrafficMovement.h"
-#include "Source/SourceRandom.h"
-#include "Junction/JunctionRandom.h"
-#include "Sink/SinkRandom.h"
-#include "Output/ConcentrationByPosition.h"
-#include "Output/ConcBySpeedAndAcceleration.h"
-#include "Utilities/safe_casting.h"
-
-
-void TrafficMovementFactoryTest::initTrafficMovement(real * pconcArrayStart)
-{
-	//Variables
-
-	real vehicleDensity = 0.1f;
-
-	const uint maxVelocity = 14;
-	real dawdlePossibility = (real) 0.2; //typical value: 0.2
-	real slowToStartPossibility = (real) 0.4;
-
-	uint vehicleLength = 7;
-
-	uint roadLength = 10;
-
-
-	//make RoadNetwork
-	auto roadNetwork = std::make_unique<RoadMaker>(roadLength, maxVelocity, vehicleLength, vehicleDensity);
-
-
-	//Sources
-	std::unique_ptr<Source> source = std::make_unique <SourceRandom>(SourceRandom(0, 0.7f, maxVelocity));
-	roadNetwork->addSource(source);
-
-
-	//Sinks
-	std::unique_ptr<Sink> s = std::make_unique <SinkRandom>(SinkRandom(9, 0.5f));
-	roadNetwork->addSink(move(s));
-
-
-	//init TrafficMovement
-	this->simulator = std::make_shared<TrafficMovement>(move(roadNetwork), dawdlePossibility);
-	simulator->setSlowToStart(slowToStartPossibility);
-	simulator->setMaxAcceleration(2);
-
-
-	////init ConcentrationOutwriter
-	//std::unique_ptr<ConcentrationOutwriter> writer = std::make_unique<ConcBySpeedAndAcceleration>(ConcBySpeedAndAcceleration(simulator->getRoadLength(), pconcArrayStart));
-	//simulator->setConcentrationOutwriter(move(writer));
-}
-
-void TrafficMovementFactoryTest::calculateTimestep(uint step, uint stepForVTK)
-{
-	simulator->calculateTimestep(step);
-}
-
-void TrafficMovementFactoryTest::loopThroughTimesteps(uint timeSteps)
-{
-	simulator->setSaveResultsTrue(timeSteps);
-	simulator->loopTroughTimesteps(timeSteps);
-}
+//#include "TrafficMovementFactoryTest.h"
+//
+//#include <iostream>
+//
+//#include "GridGenerator/StreetPointFinder/JunctionReader.h"
+//#include "GridGenerator/StreetPointFinder/SourceReader.h"
+//#include "GridGenerator/StreetPointFinder/SinkReader.h"
+//
+//#include "RoadNetwork/RoadMaker.h"
+//#include "TrafficMovement.h"
+//#include "Source/SourceRandom.h"
+//#include "Junction/JunctionRandom.h"
+//#include "Sink/SinkRandom.h"
+//#include "Output/ConcentrationByPosition.h"
+//#include "Output/ConcBySpeedAndAcceleration.h"
+//#include "Utilities/safe_casting.h"
+//
+//
+//void TrafficMovementFactoryTest::initTrafficMovement(real * pconcArrayStart)
+//{
+//	//Variables
+//
+//	real vehicleDensity = 0.1f;
+//
+//	const uint maxVelocity = 14;
+//	real dawdlePossibility = (real) 0.2; //typical value: 0.2
+//	real slowToStartPossibility = (real) 0.4;
+//
+//	uint vehicleLength = 7;
+//
+//	uint roadLength = 10;
+//
+//
+//	//make RoadNetwork
+//	auto roadNetwork = std::make_unique<RoadMaker>(roadLength, maxVelocity, vehicleLength, vehicleDensity);
+//
+//
+//	//Sources
+//	std::unique_ptr<Source> source = std::make_unique <SourceRandom>(SourceRandom(0, 0.7f, maxVelocity));
+//	roadNetwork->addSource(source);
+//
+//
+//	//Sinks
+//	std::unique_ptr<Sink> s = std::make_unique <SinkRandom>(SinkRandom(9, 0.5f));
+//	roadNetwork->addSink(move(s));
+//
+//
+//	//init TrafficMovement
+//	this->simulator = std::make_shared<TrafficMovement>(move(roadNetwork), dawdlePossibility);
+//	simulator->setSlowToStart(slowToStartPossibility);
+//	simulator->setMaxAcceleration(2);
+//
+//
+//	////init ConcentrationOutwriter
+//	//std::unique_ptr<ConcentrationOutwriter> writer = std::make_unique<ConcBySpeedAndAcceleration>(ConcBySpeedAndAcceleration(simulator->getRoadLength(), pconcArrayStart));
+//	//simulator->setConcentrationOutwriter(move(writer));
+//}
+//
+//void TrafficMovementFactoryTest::calculateTimestep(uint step, uint stepForVTK)
+//{
+//	simulator->calculateTimestep(step);
+//}
+//
+//void TrafficMovementFactoryTest::loopThroughTimesteps(uint timeSteps)
+//{
+//	simulator->setSaveResultsTrue(timeSteps);
+//	simulator->loopTroughTimesteps(timeSteps);
+//}
diff --git a/src/Traffic/TrafficMovementFactoryTest.h b/src/Traffic/TrafficMovementFactoryTest.h
index 77df69e166e86fb4899f36bcb73eb072352acf0a..846702949d2890d2e1a0868563e631c15554f75e 100644
--- a/src/Traffic/TrafficMovementFactoryTest.h
+++ b/src/Traffic/TrafficMovementFactoryTest.h
@@ -1,21 +1,21 @@
-# pragma once
-
-//#include <VirtualFluidsDefinitions.h>
-#include "TrafficMovementFactoryImpl.h"
-
-#include <vector>
-#include <memory>
-
-#include "Core/DataTypes.h"
-#include "GridGenerator/StreetPointFinder/StreetPointFinder.h"
-
-
-class VF_PUBLIC TrafficMovementFactoryTest:
-public TrafficMovementFactoryImpl{
-public:
-	TrafficMovementFactoryTest() {};
-	~TrafficMovementFactoryTest() {};
-	virtual void initTrafficMovement(real * pconcArrayStart = nullptr);
-	virtual void calculateTimestep(uint step, uint stepForVTK);
-	void loopThroughTimesteps(uint timeSteps);
-};
\ No newline at end of file
+//# pragma once
+//
+////#include <VirtualFluidsDefinitions.h>
+//#include "TrafficMovementFactoryImpl.h"
+//
+//#include <vector>
+//#include <memory>
+//
+//#include "Core/DataTypes.h"
+//#include "GridGenerator/StreetPointFinder/StreetPointFinder.h"
+//
+//
+//class VF_PUBLIC TrafficMovementFactoryTest:
+//public TrafficMovementFactoryImpl{
+//public:
+//	TrafficMovementFactoryTest() {};
+//	~TrafficMovementFactoryTest() {};
+//	virtual void initTrafficMovement(real * pconcArrayStart = nullptr);
+//	virtual void calculateTimestep(uint step, uint stepForVTK);
+//	void loopThroughTimesteps(uint timeSteps);
+//};
\ No newline at end of file
diff --git a/targets/apps/LBM/TrafficTest/TrafficTest.cpp b/targets/apps/LBM/TrafficTest/TrafficTest.cpp
index f6dbc40b7f03c2a2d5cbae5b7c9115386727b9a2..681cd350cfa04c1a205d27fe36b111d109e2aad4 100644
--- a/targets/apps/LBM/TrafficTest/TrafficTest.cpp
+++ b/targets/apps/LBM/TrafficTest/TrafficTest.cpp
@@ -7,44 +7,60 @@
 
 
 #include "Traffic/TrafficMovementFactoryImpl.h"
-#include "TrafficMovementFactoryTest.h"
+//#include "Traffic/TrafficMovementFactoryTest.h"
 
 
 
 int main()
 {
-	//{uint numberOfTimesteps = 30;
+	{uint numberOfTimesteps = 2;
+
+	//Logger
+	logging::Logger::addStream(&std::cout);
+	logging::Logger::setDebugLevel(logging::Logger::Level::INFO_LOW);
+	logging::Logger::timeStamp(logging::Logger::ENABLE);
+	logging::Logger::enablePrintedRankNumbers(logging::Logger::ENABLE);
+
+
+	TrafficMovementFactory * factory = new TrafficMovementFactoryImpl();
+	factory->initTrafficMovement();
+
+	for (uint step = 1; step <= numberOfTimesteps; step++) {
+		factory->calculateTimestep(step, step);
+	}
+
+	std::cout << std::endl << std::endl; }
+
 
 
-		////Logger
-		//logging::Logger::addStream(&std::cout);
-		//logging::Logger::setDebugLevel(logging::Logger::Level::INFO_LOW);
-		//logging::Logger::timeStamp(logging::Logger::ENABLE);
-		//logging::Logger::enablePrintedRankNumbers(logging::Logger::ENABLE);
 
 
-		//TrafficMovementFactory * factory = new TrafficMovementFactoryImpl();
-		//factory->initTrafficMovement();
 
-		//for (uint step = 1; step <= numberOfTimesteps; step++) {
-		//	factory->calculateTimestep(step,step);
-		//}
 
-		//std::cout << std::endl << std::endl;}
 
 	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-		{uint numberOfTimesteps = 20;
+	//{uint numberOfTimesteps = 20;
 
 
-		TrafficMovementFactoryTest * factory = new TrafficMovementFactoryTest();
-		factory->initTrafficMovement();
-		factory->loopThroughTimesteps(numberOfTimesteps);
+	//TrafficMovementFactoryTest * factory = new TrafficMovementFactoryTest();
+	//factory->initTrafficMovement();
+	//factory->loopThroughTimesteps(numberOfTimesteps);
 
-		std::cout << std::endl << std::endl; }
+	//std::cout << std::endl << std::endl; }
 
 	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
+
+
+
+
+
+
+
+
+
+
 	//std::vector<int> oneCar = { -1,1,-1,-1,-1,-1 };
 	//std::vector<int> fiveCars = { 1, -1,-1, 1, -1, -1, -1, -1, 1, -1,-1,-1,-1,0,-1,-1,1,-1,-1,-1 };
 	//int roadLength = 20;
diff --git a/targets/libs/Traffic/3rdPartyLinking.cmake b/targets/libs/Traffic/3rdPartyLinking.cmake
index 0c6183ae8eb8c985730d90c5ffd560c216be68e7..e7057893ad86d745967cf13ab7dd3f6501d0ecb9 100644
--- a/targets/libs/Traffic/3rdPartyLinking.cmake
+++ b/targets/libs/Traffic/3rdPartyLinking.cmake
@@ -1,5 +1,5 @@
-#include (${CMAKE_SOURCE_DIR}/${cmakeMacroPath}/Cuda/Link.cmake)
-#linkCuda(${targetName})
+include (${CMAKE_SOURCE_DIR}/${cmakeMacroPath}/Cuda/Link.cmake)
+linkCuda(${targetName})
 #include (${CMAKE_SOURCE_DIR}/${cmakeMacroPath}/MPI/Link.cmake)
 #linkMPI(${targetName})
 #include (${CMAKE_SOURCE_DIR}/${cmakeMacroPath}/Boost/Link.cmake)