Esempio n. 1
0
        public IList <int> GetInfeasibleJobIds(IList <Job> jobs, Driver driver, DateTime?planDate)
        {
            var optimizationJobs = new List <Drayage.Optimization.Model.Orders.Job>();

            foreach (var job in jobs)
            {
                var optimizationJob = new Drayage.Optimization.Model.Orders.Job();
                _mapperService.MapDomainToModel(job, optimizationJob, planDate);
                optimizationJobs.Add(optimizationJob);
            }

            var optimizationDriver = new Drayage.Optimization.Model.Orders.Driver();

            _mapperService.MapDomainToModel(driver, optimizationDriver);

            var result = _planGenerator.GetInfeasibleJobIds(optimizationJobs, optimizationDriver);

            return(result);
        }
Esempio n. 2
0
        public PlanGenerationResult GeneratePlan(PlanConfig planConfig)
        {
            if (planConfig == null)
            {
                throw new ArgumentNullException("planConfig");
            }

            PlanGenerationResult result;

            try
            {
                var runNumber = _planService.Select().Count(f => f.PlanConfig.Id == planConfig.Id);

                // select placeholder driver
                var placeholderDriverEntity = _driverService.Select().FirstOrDefault(f => f.IsPlaceholderDriver);

                var placeholderDriver = new Drayage.Optimization.Model.Orders.Driver();
                placeholderDriver.InjectFrom <DomainToModelValueInjection>(placeholderDriverEntity);

                var optimizerSettings = _settingsConfigurationProvider.Settings;

                // Prefetch and stuff
                foreach (var planGeneratorInitializer in _planGeneratorInitializers)
                {
                    planGeneratorInitializer.Initialize(planConfig);
                }

                // Domain Model > Optimization Model
                var planConfigModel = _mapperService.MapDomainToModel(planConfig);

                // set placeholder driver earliest start time
                placeholderDriver.EarliestStartTime = planConfig.JobGroup.ShiftStartTime.HasValue
                    ? planConfig.JobGroup.ShiftStartTime.Value.Ticks
                    : 0;

                // Run Optimization
                var planModel = _planGenerator.GeneratePlan(planConfigModel, placeholderDriver, optimizerSettings);

                var driverIds           = planModel.DriverPlans.Select(p => p.Driver.Id).ToList();
                var driversWithoutPlans = planConfigModel.Drivers.Where(p => !driverIds.Contains(p.Id));
                foreach (var d in driversWithoutPlans)
                {
                    planModel.DriverPlans.Add(new PlanDriver()
                    {
                        Driver   = d,
                        JobPlans = new List <PlanDriverJob>(),
                        RouteSegmentStatistics = new List <RouteSegmentStatistics>()
                    });
                }

                if (planModel.UnassignedJobs.Any())
                {
                    var unassignablePlan = new PlanDriver()
                    {
                        Driver   = placeholderDriver,
                        JobPlans = new List <PlanDriverJob>(),
                        RouteSegmentStatistics = new List <RouteSegmentStatistics>()
                    };

                    foreach (var j in planModel.UnassignedJobs)
                    {
                        unassignablePlan.JobPlans.Add(
                            new PlanDriverJob()
                        {
                            Job        = j,
                            RouteStops = j.RouteStops.ToList()
                        });
                    }

                    planModel.DriverPlans.Add(unassignablePlan);
                }

                // Optimization Model > Domain Model
                var plan  = CreateDomainPlan(planConfig, planModel, runNumber, false);
                var plan2 = CreateDomainPlan(planConfig, planModel, runNumber, true);

                result = new PlanGenerationResult()
                {
                    Success = true,
                    Plan    = plan
                };
            }
            catch (Exception ex)
            {
                result = new PlanGenerationResult()
                {
                    Success = false,
                    Errors  = new string[] { ex.Message }
                };

                throw;
            }

            return(result);
        }