This thread is a bit long, could you summarize the open problems?
Op 20-02-13 19:22, André Fróes schreef:
I added another variable to check if it would still show the broken
constraint and break the planner, and it still happens, I added this:
WorkOrder wo33 = new WorkOrder(103l, 8, Priority.P1, Nature.CORRECTIVE);
SkillWorkOrder swo333 = new SkillWorkOrder(20333l, wo33, ABC1);
SkillWorkOrder swo3332 = new SkillWorkOrder(203332l, wo33, ABC2);
SkillWorkOrder swo3333 = new SkillWorkOrder(203333l, wo33, ABC3);
SkillWorkOrder swo3334 = new SkillWorkOrder(203334l, wo33, ABC4);
List<SkillWorkOrder> lswo33 = new ArrayList<SkillWorkOrder>();
lswo33.add(swo333);
lswo33.add(swo3332);
lswo33.add(swo3333);
lswo33.add(swo3334);
wo33.setRequiredSkills(lswo33);
it breaks in worktime and required skill, and even so, it shows there
in the result breaking everything T.T
2013/2/20 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>>
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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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(a)gmail.com
<mailto:arfmoraes@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?
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users