public void Initialize()
{
_bits = new TaskKnowledgeBits
{
KnowledgeId = _knowledgeId
};
_bits.SetRequired(new byte[] { 1, 2 });
_bits.SetMandatory(new byte[] { 1, 2 });
_knowledgeBits.Add(_bits);
}
/// <summary>
/// As the worker will work on specific TaskKnowledgeBits, they can't be forget
/// ForgettingExpertiseOfTheDay is updated
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="taskBits"></param>
public void UpdateForgettingProcess(IAgentId knowledgeId, TaskKnowledgeBits taskBits)
{
if (taskBits is null)
{
throw new ArgumentNullException(nameof(taskBits));
}
// Check if forgetting process is On
if (!_isAgentOnToday)
{
return;
}
UpdateForgettingProcess(knowledgeId, taskBits.GetMandatory());
UpdateForgettingProcess(knowledgeId, taskBits.GetRequired());
}
/// <summary>
/// Check Knowledge required by a task against the worker expertise
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="taskBitIndexes">KnowledgeBits indexes of the task that must be checked against worker Knowledge</param>
/// <param name="knowledgeModel"></param>
/// <param name="mandatoryCheck"></param>
/// <param name="requiredCheck"></param>
/// <param name="mandatoryIndex"></param>
/// <param name="requiredIndex"></param>
/// <param name="step"></param>
public void CheckKnowledge(IAgentId knowledgeId, TaskKnowledgeBits taskBitIndexes,
KnowledgeModel knowledgeModel,
ref bool mandatoryCheck,
ref bool requiredCheck, ref byte mandatoryIndex, ref byte requiredIndex, ushort step)
{
if (taskBitIndexes is null)
{
throw new ArgumentNullException(nameof(taskBitIndexes));
}
if (knowledgeModel == null)
{
throw new ArgumentNullException(nameof(knowledgeModel));
}
// model is off
if (!IsAgentOn())
{
mandatoryCheck = true;
requiredCheck = true;
return;
}
// agent may don't have the knowledge at all
var actorKnowledge = knowledgeModel.GetActorKnowledge(knowledgeId);
if (actorKnowledge == null)
{
return;
}
mandatoryCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetMandatory(), out mandatoryIndex,
ThresholdForReacting, step);
requiredCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetRequired(), out requiredIndex,
ThresholdForReacting, step);
}
public static void CheckRiskAversion(Belief belief, TaskKnowledgeBits taskBitIndexes, ActorBelief actorBelief,
ref float mandatoryCheck, ref byte mandatoryIndex, float threshold)
{
if (taskBitIndexes is null)
{
throw new ArgumentNullException(nameof(taskBitIndexes));
}
if (belief is null)
{
throw new NullReferenceException(nameof(belief));
}
// agent may don't have the belief at all
//var agentBelief = actorBeliefs?.GetActorBelief<ActorBelief>(belief.EntityId);
if (actorBelief == null)
{
mandatoryCheck = 0;
return;
}
mandatoryCheck = actorBelief.Check(taskBitIndexes.GetMandatory(), out mandatoryIndex, belief,
threshold, false);
}
/// <summary>
/// Check belief required by a task against the worker expertise
/// </summary>
/// <param name="belief"></param>
/// <param name="taskBitIndexes">KnowledgeBit indexes of the task that must be checked against agent's beliefs</param>
/// <param name="actorBelief"></param>
/// <param name="mandatoryCheck">
/// The normalized score of the agent belief [-1; 1] at the first mandatoryIndex that is above
/// beliefThreshHoldForReacting
/// </param>
/// <param name="requiredCheck"></param>
/// <param name="mandatoryIndex"></param>
/// <param name="requiredIndex"></param>
/// <returns>0 if agent has no beliefs</returns>
public void CheckBelief(Belief belief, TaskKnowledgeBits taskBitIndexes, ActorBelief actorBelief,
ref float mandatoryCheck,
ref float requiredCheck, ref byte mandatoryIndex, ref byte requiredIndex)
{
if (taskBitIndexes is null)
{
throw new ArgumentNullException(nameof(taskBitIndexes));
}
if (belief is null)
{
throw new ArgumentNullException(nameof(belief));
}
// model is off
if (!IsAgentOn())
{
mandatoryCheck = 0;
requiredCheck = 0;
return;
}
// agent may don't have the belief at all
//var actorBelief = actorBeliefs?.GetActorBelief<ActorBelief>(belief.EntityId);
if (actorBelief == null)
{
mandatoryCheck = 0;
requiredCheck = 0;
return;
}
mandatoryCheck = actorBelief.Check(taskBitIndexes.GetMandatory(), out mandatoryIndex, belief,
ThresholdForReacting, true);
requiredCheck = actorBelief.Check(taskBitIndexes.GetRequired(), out requiredIndex, belief,
ThresholdForReacting, true);
}
