[rules-users] SimpleScoreCalculator
André Fróes
arfmoraes at gmail.com
Wed Feb 20 13:13:08 EST 2013
Problem solved (still I think so):
It was simpler (if i'm right):
--------
List<Skill> tempEngSkillList = new ArrayList<Skill>();
for (SkillEngineer se : e.getSkillEngineerList()){
tempEngSkillList.add(se.getSkill());
}
if (tempEngSkillList.containsAll(requiredSkillList)){
hardScore += 1;
}
--------
the result:
Solved distribution with 10 work orders and 4 engineers:
ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
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,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Feasible(0)
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,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------
Feasible(0)
ID: 108[Skills: ABC 1,ABC 4,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,]
------ Feasible(0)
ID: 109[Skills: ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------
Feasible(0)
ID: 110[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------
Feasible(0)
2013/2/20 André Fróes <arfmoraes at gmail.com>
> 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/8424e20c/attachment-0001.html
More information about the rules-users
mailing list