LogisticsServiceProvider.gaml

model LogisticsServiceProvider

import "Provider.gaml"
import "SupplyChain.gaml"
import "TransferredStocks.gaml"
import "Strategies.gaml"

species LogisticsServiceProvider {
	int timeShifting <- rnd(23);
	int adoptedStrategy;
	SupplyChain supplyChain <- nil;
	list<int> timeToDeliver <- [];
	list<Warehouse> lvl1Warehouses <- []; // close warehouse
	list<Warehouse> lvl2Warehouses <- []; // large warehouse
	list<FinalDestinationManager> customers <- [];
	Provider provider;
	float cumulateCosts <- 0;
	float averageCosts <- 0;
	float threshold <- 0.3;
	float probaAnt <- 0.5;
	string costsPathStrategy <- one_of(['financial_costs','travel_time']);//'financial_costs';//
	
	init {
		adoptedStrategy <- one_of(possibleStrategies);
		provider <- one_of(Provider);
		ask provider {
			do addCustomer(myself);
		}

		timeToDeliver <- [];
		if(use_gs){
			// Add a new node event for corresponding sender
			if(use_r1){
				gs_add_node gs_sender_id:"actor" gs_node_id:name;
			}
			if(use_r2){
				gs_add_node gs_sender_id:"neighborhood_all" gs_node_id:name;
				gs_add_node_attribute gs_sender_id:"neighborhood_all" gs_node_id:name gs_attribute_name:"type" gs_attribute_value:"logistic_provider";
			}
			if(use_r5){
				gs_add_node gs_sender_id:"neighborhood_logistic_provider" gs_node_id:name;
			}
			if(use_r7){
				gs_add_node gs_sender_id:"neighborhood_logistic_final" gs_node_id:name;
			}
		}
	}

	reflex testRestockNeeded when: supplyChain != nil and (((time/3600.0) + timeShifting) mod nbStepsbetweenTRN) = 0.0 and (time/3600.0) > 0 {
		ask supplyChain.leafs { 
			do recursiveTests([] as list<Order>);
		}
	}

	action updateSupplyChainProvider {
		// Select (or not) a new provider
		Provider LHP <- nil;
		Provider AntP <- nil;
		ask Provider {
			if(self.port = "LE HAVRE"){
				LHP <- self;
			}
			else{
				AntP <- self;
			}
		}
		bool update <- false;
		if(flip(probaAnt)){
			if(AntP != provider){
				ask provider {
					do lostCustomer(myself);
				}
				provider <- AntP;
				update <- true;
				ask provider {
					do addCustomer(myself);
				}
			}
		}
		else {
			if(LHP != provider){
				ask provider {
					do lostCustomer(myself);
				}
				provider <- LHP;
				update <- true;
				ask provider {
					do addCustomer(myself);
				}
			}
		}
		// Do I need to update ?
		if(update and supplyChain != nil){
			// Update the supply chain according to this new provider
			create SupplyChainElement number:1 returns:rt {
				supplyChain <- myself.supplyChain;
				building <- myself.provider;
				sons <- [];
				position <- 0;
			}
			SupplyChainElement newRoot <- rt[0];
			int j <- 0;
			loop while: j<length(supplyChain.root.sons) {
				int i <- 0;
				loop while: i < length(supplyChain.root.sons[j].fathers) {
					if(supplyChain.root.sons[j].fathers[i].building = supplyChain.root.building){
						supplyChain.root.sons[j].fathers[i] <- newRoot;
						newRoot.sons <- newRoot.sons + supplyChain.root.sons[j];
					}
					i <- i + 1;
				}
				j <- j + 1;
			}
			supplyChain.root <- newRoot;
		}
	}

	/*
	 * This method looks for the warehouse of his supply chain which need to be restocked
	 */
	action manageLostStock(AwaitingStock aws) {
		list<Warehouse> lw;
		if(aws.position = 1){
			lw <- lvl2Warehouses;
		}
		else {
			lw <- lvl1Warehouses;
		}
		int i <- 0;
		bool notfound <- true;
		loop while: i < length(lw) and notfound {
			Warehouse w <- lw[i];
			int j <- 0;
			loop while: j < length(w.stocks) and notfound {
				if(aws.stock.product = w.stocks[j].product and w.stocks[j].lp = self and aws.stock.fdm = w.stocks[j].fdm){	
					create Commodity number:1 returns:returnedAgent;
					Commodity commodity <- returnedAgent[0];
					commodity.stock <- aws.stock;
					commodity.volume <- aws.stock.quantity;
					commodity.finalDestination <- w;
					commodity.stepOrderMade <- aws.stepOrderMade;
					aws.building.leavingCommodities <- aws.building.leavingCommodities + commodity;
					ask forwardingAgent {
						commodity.paths <- compute_shortest_path(aws.building, w, myself.costsPathStrategy, commodity);//'financial_costs'//travel_time
					}
					notfound <- false;
				}
				j <- j + 1;
			}
			i <- i + 1;
		}
	}



	/*
	 * These methods are used to remove a customer and disconnect him of the supply chain
	 */

	/**
	 * When a logistic provider loose a customer (a FinalDestinationManager) he must update the stock on its warehouses
	 */
	TransferredStocks lostCustomer(FinalDestinationManager fdm){
		int k <- 0;
		bool notfound <- true;
		loop while: k < length(customers) and notfound {
			if(fdm = customers[k]){
				remove index: k from: customers;
				notfound <- false;
			}
			else{
				k <- k + 1;
			}
		}
		/*
		 * Browse the warehouses to get the stocks to remove and the list of warehouses which could be deleted from the supply chain
		 */
		int i <- 0;
		list<Warehouse> uselessWarehouses <- [];
		TransferredStocks stocksRemoved;
		create TransferredStocks number: 1 returns: rts;
		stocksRemoved <- rts[0];
		loop while: i < length(lvl1Warehouses) {
			int j <- 0;
			list<Stock> temp_stocks <- (lvl1Warehouses[i] as Warehouse).stocks;
			bool useless <- true;
			loop while: j < length(temp_stocks) {
				if(temp_stocks[j].fdm = fdm and temp_stocks[j].lp = self){
					(lvl1Warehouses[i] as Warehouse).occupiedSurface <- (lvl1Warehouses[i] as Warehouse).occupiedSurface - temp_stocks[j].maxQuantity;
					stocksRemoved.stocksLvl1 <- stocksRemoved.stocksLvl1 + temp_stocks[j];
					remove index: j from: (lvl1Warehouses[i] as Warehouse).stocks;
				}
				else {
					// if the current stock is managed by the current LP, but does not belong to the FDM, then it means that this warehouse is useful
					if(temp_stocks[j].lp = self){
						useless <- false;
					}
					j <- j + 1;
				}
			}
			if(useless){
				uselessWarehouses <- uselessWarehouses + lvl1Warehouses[i];
				remove index: i from: lvl1Warehouses;
			}
			else {
				i <- i + 1;
			}
		}

		// I wanted to make a mathod in order to not duplicate the following code, unfortunately, I can't return both the list of useless warehouse and of stocks...
		// It is ugly... I know and I feel ashamed!
		i <- 0;
		loop while: i < length(lvl2Warehouses) {
			int j <- 0;
			list<Stock> temp_stocks <- (lvl2Warehouses[i] as Warehouse).stocks;
			bool useless <- true;
			loop while: j < length(temp_stocks) {
				if(temp_stocks[j].fdm = fdm and temp_stocks[j].lp = self){
					(lvl2Warehouses[i] as Warehouse).occupiedSurface <- (lvl2Warehouses[i] as Warehouse).occupiedSurface - temp_stocks[j].maxQuantity;
					stocksRemoved.stocksLvl2 <- stocksRemoved.stocksLvl2 + temp_stocks[j];
					remove index: j from: (lvl2Warehouses[i] as Warehouse).stocks;
				}
				else {
					// if the current stock is managed by the current LP, but does not belong to the FDM, then it means that this warehouse is useful
					if(temp_stocks[j].lp = self){
						useless <- false;
					}
					j <- j + 1;
				}
			}
			if(useless){
				uselessWarehouses <- uselessWarehouses + lvl2Warehouses[i];
				remove index: i from: lvl2Warehouses;
			}
			else {
				i <- i + 1;
			}
		}

		/*
		 * Delete the useless SupplyChainElement and the supply chain itself if there is no more customer
		 */
		list<SupplyChainElement> uselessSCE <- deleteUselessSCE(supplyChain.root, fdm, uselessWarehouses);
		loop while: 0 < length(uselessSCE) {
			ask uselessSCE[0] {
				if(building != myself.provider and building != fdm.building){
					(building as RestockingBuilding).maxProcessOrdersCapacity <- (building as RestockingBuilding).maxProcessOrdersCapacity - 5;
				}
				do die;
			}
			remove index: 0 from: uselessSCE;
		}
		if(length(supplyChain.root.sons) = 0){
			ask supplyChain.root {
				do die;
			}
			ask supplyChain {
				do die;
			}
			supplyChain <- nil;
		}

		return stocksRemoved;
	}

	/*
	 * A recursive method which browse the supply chain and delete the useless supply chain elements from the leafs to the root
	 */
	list<SupplyChainElement> deleteUselessSCE(SupplyChainElement sce, FinalDestinationManager fdm, list<Warehouse> uselessWarehouses){
		int i <- 0;
		list<SupplyChainElement> uselessSCE <- [];
		loop while: i < length(sce.sons) {
			uselessSCE <- uselessSCE + deleteUselessSCE(sce.sons[i], fdm, uselessWarehouses);
			if(uselessSCE contains sce.sons[i]){
				remove index: i from: sce.sons;
			}
			else {
				i <- i + 1;
			}
		}
		if(sce.building = fdm.building){
			remove sce from: sce.supplyChain.leafs;
		}
		if(uselessWarehouses contains sce.building or sce.building = fdm.building){
			return uselessSCE + sce;
		}
		return uselessSCE;
	}



	/*
	 * These methods are used to connect a new customer to the supply chain
	 */

	action connectRoot {
		// Build the root of this almost-tree
		create SupplyChainElement number:1 returns:rt {
			building <- myself.provider;
			(building as RestockingBuilding).maxProcessOrdersCapacity <- (building as RestockingBuilding).maxProcessOrdersCapacity + 5;
			sons <- [];
			position <- 0;
		}
		// and build the supply chain with this root
		create SupplyChain number:1 returns:sc {
			logisticsServiceProvider <- myself;
			root <- rt[0];
		}
		supplyChain <- first(sc);
		first(rt).supplyChain <- supplyChain;

		if(use_gs){
			if(use_r9){
				gs_add_node_attribute gs_sender_id:"supply_chain" gs_node_id:provider.name gs_attribute_name:"type" gs_attribute_value:"provider";
			}
		}
	}

	SupplyChainElement connectCustomer(FinalDestinationManager fdm) {
		create SupplyChainElement number:1 returns:fdmLeaf {
			self.building <- fdm.building;
			self.sons <- [];
			self.supplyChain <- myself.supplyChain;
			position <- 3;
		}
		supplyChain.leafs <- supplyChain.leafs + fdmLeaf[0];
		if(use_gs){
			if(use_r9){
				gs_add_node_attribute gs_sender_id:"supply_chain" gs_node_id:fdm.name gs_attribute_name:"type" gs_attribute_value:"final_dest";
			}
		}
		return fdmLeaf[0];
	}

	SupplyChainElement connectLvl1Warehouse(FinalDestinationManager fdm, SupplyChainElement fdmLeaf, list<Stock> stocksLvl1) {
		// First we find an appropriate local warehouse
		Warehouse closeWarehouse <- findWarehouseLvl1(fdm, sizeOfStockLocalWarehouse);
		do initStock(closeWarehouse, fdm, stocksLvl1, sizeOfStockLocalWarehouse);
		SupplyChainElement sceCloseWarehouse <- nil;

		if(!(lvl1Warehouses contains closeWarehouse)){
			lvl1Warehouses <- lvl1Warehouses + closeWarehouse;
			// We must create a SCE corresponding to this warehouse
			create SupplyChainElement number:1 returns:sceBuild {
				self.supplyChain <- myself.supplyChain;
				position <- 2;
				building <- closeWarehouse;
				sons <- [] + fdmLeaf;
				fathers <- [];
			}
			sceCloseWarehouse <- sceBuild[0];

			if(use_gs){
				if(use_r9){
					gs_add_node_attribute gs_sender_id:"supply_chain" gs_node_id:sceCloseWarehouse.building.name gs_attribute_name:"type" gs_attribute_value:"close_warehouse";
				}
			}
		}
		else{
			// The selected warehouse exists already in the supply chain. We must find it
			bool found <- false;
			int i <- 0;
			loop while: i<length( (supplyChain.root as SupplyChainElement).sons) and sceCloseWarehouse = nil {
				int j <- 0;
				loop while: j<length( (supplyChain.root.sons[i] as SupplyChainElement).sons) and sceCloseWarehouse = nil {
					if(closeWarehouse = ((supplyChain.root.sons[i] as SupplyChainElement).sons[j] as SupplyChainElement).building){
						sceCloseWarehouse <- (supplyChain.root.sons[i] as SupplyChainElement).sons[j];
					}
					j <- j + 1;
				}
				i <- i + 1;
			}

			// We must update the fathers of the leaf and the sons of the close warehouse
			sceCloseWarehouse.sons <- sceCloseWarehouse.sons + fdmLeaf;

		}

		fdmLeaf.fathers <- [] + sceCloseWarehouse;

		ask sceCloseWarehouse {
			(building as RestockingBuilding).maxProcessOrdersCapacity <- (building as RestockingBuilding).maxProcessOrdersCapacity + 5;
		}

		if(use_gs){
			if(use_r9){
				gs_add_edge gs_sender_id:"supply_chain" gs_edge_id:(fdm.name + sceCloseWarehouse.building.name) gs_node_id_from:fdm.name gs_node_id_to:sceCloseWarehouse.building.name gs_is_directed:false;
				float p <- 0.0;
					using topology(road_network){
	                       p <-  (fdm.building.location distance_to sceCloseWarehouse.building.location);
	                }
					gs_add_edge_attribute gs_sender_id:"supply_chain" gs_edge_id:(fdm.building.name + sceCloseWarehouse.building.name) gs_attribute_name:"length" gs_attribute_value:p;
			}
		}

		return sceCloseWarehouse;
	}

	action connectLvl2Warehouse(FinalDestinationManager fdm, SupplyChainElement sceCloseWarehouse, list<Stock> stocksLvl2){
		// We try to find a father who has an appropriate surface
		SupplyChainElement sceLarge <- nil;
		bool found <- false;
		int i <- 0;
		loop while: i<length(supplyChain.root.sons) and !found {
			sceLarge <- supplyChain.root.sons[i];
			if( ((sceLarge.building as Building).totalSurface - (sceLarge.building as Building).occupiedSurface ) >= ((fdm.building as Building).occupiedSurface * sizeOfStockLargeWarehouse) ){
				found <- true;
				do initStock( (sceLarge.building as Warehouse), fdm, stocksLvl2, sizeOfStockLargeWarehouse);
			}
			i <- i + 1;
		}

		// If we have not found it in the large warehouses
		if(!found){
			// we must create one SCE
			// we find an appropriate large warehouse
			Warehouse largeWarehouse <- findWarehouseLvl2(fdm, sizeOfStockLargeWarehouse);
			if(! (lvl2Warehouses contains largeWarehouse)){// Should always be true, isn't it? otherwise, we would have found a SCE...
				lvl2Warehouses <- lvl2Warehouses + largeWarehouse;
			}
			do initStock(largeWarehouse, fdm, stocksLvl2, sizeOfStockLargeWarehouse);
			// and create a SCE
			create SupplyChainElement number:1 returns:sceBuild {
				self.supplyChain <- myself.supplyChain;
				self.position <- 1;
				self.building <- largeWarehouse;
				self.sons <- [];
				self.fathers <- [] + myself.supplyChain.root;
			}
			sceLarge <- sceBuild[0];
			supplyChain.root.sons <- supplyChain.root.sons + sceLarge;

			if(use_gs){
				if(use_r9){
					gs_add_node_attribute gs_sender_id:"supply_chain" gs_node_id:sceLarge.building.name gs_attribute_name:"type" gs_attribute_value:"large_warehouse";
					gs_add_edge gs_sender_id:"supply_chain" gs_edge_id:(sceLarge.building.name + provider.name) gs_node_id_from:sceLarge.building.name gs_node_id_to:provider.name gs_is_directed:false;
					float p <- 0.0;
					using topology(road_network){
	                       p <-  (sceLarge.building.location distance_to provider.location);
	                }
					gs_add_edge_attribute gs_sender_id:"supply_chain" gs_edge_id:(sceLarge.building.name + provider.name) gs_attribute_name:"length" gs_attribute_value:p;
				}
			}
		}

		// and then this father become the real father of this close warehouse
		found <- false;
		i <- 0;
		loop while: i<length(sceCloseWarehouse.fathers) and !found {
			if(sceCloseWarehouse.fathers[i] = sceLarge){
				found <- true;
			}
			i <- i + 1;
		}
		if(!found){
			sceCloseWarehouse.fathers <- sceCloseWarehouse.fathers + sceLarge;
		}

		found <- false;
		i <- 0;
		loop while: i<length(sceLarge.sons) and !found {
			if(sceLarge.sons[i] = sceCloseWarehouse){
				found <- true;
			}
			i <- i + 1;
		}
		if(!found){
			sceLarge.sons <- sceLarge.sons + sceCloseWarehouse;
		}

		ask sceLarge {
			(building as RestockingBuilding).maxProcessOrdersCapacity <- (building as RestockingBuilding).maxProcessOrdersCapacity + 5;
		}

		if(use_gs){
			if(use_r9){
				gs_add_edge gs_sender_id:"supply_chain" gs_edge_id:(sceCloseWarehouse.building.name + sceLarge.building.name) gs_node_id_from:sceCloseWarehouse.building.name gs_node_id_to:sceLarge.building.name gs_is_directed:false;
				float p <- 0.0;
				using topology(road_network){
                       p <-  (sceCloseWarehouse.building.location distance_to sceLarge.building.location);
                }
				gs_add_edge_attribute gs_sender_id:"supply_chain" gs_edge_id:(sceCloseWarehouse.building.name + sceLarge.building.name) gs_attribute_name:"length" gs_attribute_value:p;
			}
		}
	}

	/**
	 * When a logistic provider has a new customer, he needs to find a new supply chain. This method build it.
	 */
	action getNewCustomer(FinalDestinationManager fdm, list<Stock> stocksLvl1, list<Stock> stocksLvl2){

		/*
		 * Initiate the supply chain with just the provider as root
		 */
		if(supplyChain = nil){
			do connectRoot;
		}

		/*
		 * The new customer become a new leaf of the "almost-tree" supply chain.
		 */
		SupplyChainElement fdmLeaf <- connectCustomer(fdm);

		/*
		 * connect this leaf to a close warehouse
		 */
		SupplyChainElement sceCloseWarehouse <- connectLvl1Warehouse(fdm, fdmLeaf, stocksLvl1);

		/*
		 * Connect the close warehouse to the large warehouse
		 */
		do connectLvl2Warehouse(fdm, sceCloseWarehouse, stocksLvl2);
		customers <- customers + fdm;
	}
	
	/**
	 * We assume that the warehouse have already a stock when we initialize a new supply chain
	 */
	action initStock(Warehouse warehouse, FinalDestinationManager f, list<Stock> stocks, int sizeOfStock){
		if(stocks = nil or length(stocks) = 0){
			loop stockFdm over: (f.building as Building).stocks {
				// We create the stock agent
				create Stock number:1 returns:s {
					self.product <- stockFdm.product;
					self.quantity <- rnd(stockFdm.maxQuantity * sizeOfStock);
					self.maxQuantity <- stockFdm.maxQuantity * sizeOfStock;
					self.status <- 0;
					self.fdm <- f;
					self.lp <- myself;
					self.building <- warehouse;
				}

				// and add it to the list of stocks in the warehouse
				warehouse.stocks <- warehouse.stocks + s[0];

				// Finally we update the occupied surface
				warehouse.occupiedSurface <- warehouse.occupiedSurface + (s[0] as Stock).maxQuantity;
			}
		}
		else {
			loop stock over: stocks {
				warehouse.occupiedSurface <- warehouse.occupiedSurface + stock.maxQuantity;
				stock.fdm <- f;
				stock.lp <- self;
				stock.building <- warehouse;
				stock.status <- 0;
			}
			warehouse.stocks <- warehouse.stocks + stocks;
		}
	}
	
	/**
	 * Return a warehouse of first level in the supply chain
	 */
	Warehouse findWarehouseLvl1(FinalDestinationManager fdm, int sizeOfStock){
		Warehouse w <- nil;
		if(adoptedStrategy = 1){
			w <- world.findWarehouseLvl1Strat1(fdm, sizeOfStock, lvl2Warehouses);
		}
		else if(adoptedStrategy = 2){
			w <- world.findWarehouseLvl1Strat2(fdm, sizeOfStock, lvl1Warehouses, lvl2Warehouses);
		}
		else if(adoptedStrategy = 3){
			w <- world.findWarehouseLvl1Strat3(fdm, sizeOfStock, lvl2Warehouses);
		}
		else if(adoptedStrategy = 4){
			w <- world.findWarehouseLvl1Strat4(fdm, sizeOfStock, lvl2Warehouses);
		}
		return w;
	}

	/**
	 * Return a warehouse of third level in the supply chain
	 */
	Warehouse findWarehouseLvl2(FinalDestinationManager fdm, int sizeOfStock){
		Warehouse w <- nil;
		if(adoptedStrategy = 1){
			w <- world.findWarehouseLvl2Strat1(fdm, sizeOfStock, lvl1Warehouses);
		}
		else if(adoptedStrategy = 2){
			w <- world.findWarehouseLvl2Strat2(fdm, sizeOfStock, lvl1Warehouses, lvl2Warehouses);
		}
		else if(adoptedStrategy = 3){
			w <- world.findWarehouseLvl2Strat3(fdm, sizeOfStock, lvl1Warehouses);
		}
		else if(adoptedStrategy = 4){
			w <- world.findWarehouseLvl2Strat4(fdm, sizeOfStock, lvl1Warehouses);
		}
		return w;
	}
	
	aspect base { 
		Provider LHP <- nil;
		Provider AntP <- nil;
		ask Provider {
			if(self.port = "LE HAVRE"){
				LHP <- self;
			}
			else{
				AntP <- self;
			}
		}
		if(AntP = provider){
			draw shape+3°px  color: rgb(14, 234, 2) ; //vert
		}
		else {
			draw shape+3°px color: rgb(12, 0, 236) ; // bleu
		}

	}
	
	aspect simple_base { 
		draw shape+3°px  color: rgb(66, 219, 108) ; //vert
	}
}