[rules-users] SimpleScoreCalculator
André Fróes
arfmoraes at gmail.com
Wed Feb 20 13:02:28 EST 2013
Not fixed, i threw it on excel and make a comparison with expected results
and there are 2 broken there. This is how it would be (feasible solution):
ID 101 - Engineer Richard
ID 102 - Engineer Andre
ID 103 - Engineer Denny
ID 104 - Engineer Andre
ID 105 - Engineer Andre
ID 106 - Engineer Andre
ID 107 - Engineer Fabio
ID 108 - Engineer Richard
ID 109 - Engineer Fabio
ID 110 - Engineer Fabio
this was the result:
Solved distribution with 10 work orders and 4 engineers:
ID: 104[Skills: ABC 2,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------
Feasible(0)
ID: 103[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] - Denny(8)[Skills: ABC 2,ABC
1,ABC 3,ABC 4,] ------ Feasible(0)
ID: 105[Skills: ABC 2,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------
Broken(1)
ID: 102[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Feasible(0)
ID: 101[Skills: ABC 1,ABC 2,ABC 4,] - Richard(8)[Skills: ABC 1,ABC
2,ABC 4,] ------ Feasible(0)
ID: 107[Skills: ABC 1,ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------
Feasible(0)
ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Feasible(0)
ID: 108[Skills: ABC 1,ABC 4,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Broken(1)
ID: 109[Skills: ABC 3,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Broken(1)
ID: 110[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Feasible(0)
Still working on it, I accept any tips :D
2013/2/20 André Fróes <arfmoraes at gmail.com>
> I think I fixed it, but the broken constraint is still showing, i don't
> know how to remove it. I did this:
>
> verified if the engineer skill list had the same size or bigger than the
> requiredSkillList, iterate to check skills between both counting the
> matches and then, if the match was 100% to other, give the workorder
>
> if (e.getSkillEngineerList().size() >= requiredSkillList.size()) {
> int temp = 0;
> for (SkillEngineer se : e.getSkillEngineerList()) {
> for (Skill s : requiredSkillList) {
> if (se.getSkill().getId() == s.getId()) {
> temp++;
> }
> }
> }
> if (temp == requiredSkillList.size()) {
> hardScore += 1;
> }
> }
>
>
> 2013/2/20 André Fróes <arfmoraes at gmail.com>
>
>> After some workaround I noticed that the workorders are not being 100%
>> corretly distributed to, i've changed the scorecalculator to this:
>>
>> int commonSkillCount = 0;
>> for (Skill s : requiredSkillList){
>> for (SkillEngineer se : e.getSkillEngineerList()){
>> if (se.getSkill().getId() == s.getId()){
>> commonSkillCount++;
>> }
>> }
>> }
>>
>> if ((commonSkillCount - e.getSkillEngineerList().size()) <= 0){
>> hardScore += commonSkillCount;
>> }
>>
>> and I got the result
>>
>> ID: 104[Skills: ABC 2,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------
>> Feasible(0)
>> ID: 103[Skills: ABC 3,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------
>> Feasible(0)
>> ID: 105[Skills: ABC 4,ABC 3,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC
>> 3,ABC 4,] ------ Feasible(0)
>> ID: 102[Skills: ABC 2,ABC 1,ABC 4,] - Qwert(8)[Skills: ABC 2,ABC 4,]
>> ------ Broken(1)
>> ID: 101[Skills: ABC 1,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------
>> Feasible(0)
>> ID: 107[Skills: ABC 4,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------
>> Feasible(0)
>> ID: 106[Skills: ABC 1,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------
>> Broken(1)
>> ID: 108[Skills: ABC 3,ABC 2,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC
>> 3,ABC 4,] ------ Feasible(0)
>>
>> there's a workorder that woud be disconsidered because no engineer have
>> the required skill to complete it
>>
>>
>> 2013/2/19 André Fróes <arfmoraes at gmail.com>
>>
>>> I forgot to post the code:
>>>
>>> public HardAndSoftScore calculateScore(Distributor distributor) {
>>> int hardScore = 0;
>>> int softScore = 0;
>>> for (Engineer e : distributor.getEngineerList()){
>>> long skill = e.getSkillEngineerList().get(0).getSkill().getId();
>>> int requiredWorktime = 0;
>>> List<Skill> requiredSkillList = new ArrayList<Skill>();
>>> for (WorkOrder o : distributor.getWorkOrderList()){
>>> if (e.equals(o.getEngineer())){
>>> requiredWorktime += o.getRequiredWorktime();
>>> for (SkillWorkOrder swo : o.getRequiredSkills()){
>>> requiredSkillList.add(swo.getSkill());
>>> }
>>> }
>>> }
>>> int engineerAvailableTime = e.getWorktime() - requiredWorktime;
>>> if (engineerAvailableTime < 0 ){
>>> hardScore += engineerAvailableTime;
>>> }
>>> int commonSkillCount = 0;
>>> for (SkillEngineer se : e.getSkillEngineerList()){
>>> for (Skill s : requiredSkillList){
>>> if (se.getSkill().getId() == s.getId()){
>>> commonSkillCount++;
>>> }
>>> }
>>> }
>>> if (commonSkillCount != 0){
>>> hardScore += commonSkillCount;
>>> }
>>> }
>>>
>>> return DefaultHardAndSoftScore.valueOf(hardScore, softScore);
>>> }
>>>
>>> ( but i still want to try to create this in dsl rule after this work :D )
>>>
>>>
>>> 2013/2/19 André Fróes <arfmoraes at gmail.com>
>>>
>>>> I managed solving that problem even when there's more than one skill
>>>> involved, but now my hard constraint of worktime breaks if I add more
>>>> worktime than the sum of engineers worktime.
>>>>
>>>> (8) is the worktime, my workorders all have a worktime of 4 hours, so,
>>>> I got 32 available hours and 32 hours of workorders to be assigned right?
>>>> When I stick to this plan, it works:
>>>>
>>>> ----Compilation Result----
>>>> Solved distribution with 8 work orders and 4 engineers:
>>>> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2]
>>>> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3]
>>>> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4]
>>>> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2]
>>>> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1]
>>>> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4]
>>>> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1]
>>>> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3]
>>>> ---------------
>>>>
>>>> So, if I add another worktime with 4 hours, it messes everything, this
>>>> is the outcome:
>>>>
>>>> Solved distribution with 9 work orders and 4 engineers:
>>>> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2]
>>>> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3]
>>>> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4]
>>>> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2]
>>>> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1]
>>>> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4]
>>>> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1]
>>>> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3]
>>>> ID: 109[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3]
>>>>
>>>> ------------
>>>>
>>>> to be precise, i don't know if it is because of worktime or skill
>>>>
>>>>
>>>> 2013/2/19 André Fróes <arfmoraes at gmail.com>
>>>>
>>>>> Just one correction, it is sorting correctly when there's one
>>>>> workorder with a skill, if there's another workorder with same skill, it
>>>>> doesn't sort that workorder to that skill.
>>>>>
>>>>> This is what is happening:
>>>>>
>>>>> Workorder skill ABC1 ------------ Engineer skill ABC1
>>>>> Workorder skill ABC2 ------------ Engineer skill ABC2
>>>>> Workorder skill ABC1 ------------ Engineer skill ABC2
>>>>>
>>>>> but if there's only one workorder with one skill it works:
>>>>>
>>>>> Workorder skill ABC1 ------------ Engineer skill ABC1
>>>>> Workorder skill ABC2 ------------ Engineer skill ABC2
>>>>> Workorder skill ABC3 ------------ Engineer skill ABC3
>>>>>
>>>>> so, from the second workorder on, with a repeated required skill, it
>>>>> doesn't sort properly
>>>>>
>>>>>
>>>>> 2013/2/19 André Fróes <arfmoraes at gmail.com>
>>>>>
>>>>>> Hello, since i'm not moving a step from where I am at dsl rule, I'm
>>>>>> trying to do it with SimpleScoreCalculator, but the same is happening.
>>>>>>
>>>>>> ------------
>>>>>> public HardAndSoftScore calculateScore(Distributor distributor) {
>>>>>> int hardScore = 0;
>>>>>> int softScore = 0;
>>>>>> for (Engineer e : distributor.getEngineerList()){
>>>>>> long skill = e.getSkillEngineerList().get(0).getSkill().getId();
>>>>>> int requiredWorktime = 0;
>>>>>> long requiredSkill = 0l;
>>>>>> for (WorkOrder o : distributor.getWorkOrderList()){
>>>>>> if (e.equals(o.getEngineer())){
>>>>>> requiredWorktime += o.getRequiredWorktime();
>>>>>> requiredSkill = o.getRequiredSkills().get(0).getSkill().getId();
>>>>>> }
>>>>>> }
>>>>>> int engineerAvailableTime = e.getWorktime() - requiredWorktime;
>>>>>> if (engineerAvailableTime < 0 ){
>>>>>> hardScore += engineerAvailableTime;
>>>>>> }
>>>>>> if (requiredSkill == skill){
>>>>>> softScore += requiredSkill;
>>>>>> }
>>>>>> }
>>>>>> return DefaultHardAndSoftScore.valueOf(hardScore, softScore);
>>>>>> }
>>>>>> ------------
>>>>>>
>>>>>> wouldn't that have to fit since i'm comparing the 1st attribute of
>>>>>> each skill list from engineers and workorders? And how can I weight which
>>>>>> engineer would be better to a determined workorder if the workorder have
>>>>>> more skills and so does the engineer?
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.jboss.org/pipermail/rules-users/attachments/20130220/e2a851d2/attachment.html
More information about the rules-users
mailing list