Blocs activités-ressources


o ActivitiesResourcesBlock
nom C++ symbole de classe nom de classe classe des éléments classes des composants
ActivitiesResourcesBlock ACTIVITIES_RESOURCES_BLOCK activitiesResourcesBlock ACTIVITY RESOURCE_POOL_CONJUNCTION

Les deux composants sont :

Note importante : On a vu ou on verra qu'une stratégie est un ensemble de "blocs activités-ressources". Les ensembles de ressources associés à ces blocs doivent être disjoints. En d'autres termes, ils constituent une partition de l'ensemble des ressources qui servent l'un ou l'autre des plans de la stratégie. Si, après avoir identifié deux plans, il s'avère qu'une ressource est au service des deux, alors il faut réunir les deux plans. Par exemple, le schéma ci-dessous n'est pas gérable par le moteur de simulation :

strategie : {bloc_1, bloc_2)
bloc 1 : {plan_1, pool_1}
bloc 2 : {plan_2, pool_2}
pool_1 : (r1, r2, r3)
pool_2 : (r1, r4, r5)

Il doit être remplacé par celui-ci :

strategie : {bloc_1b)
bloc 1b : {plan_1b, pool_1b}
plan_1b : and(plan_1, plan_2)
pool_1b : (r1, r2, r3, r4, r5)

Descripteurs :

type classe, symbole, nom v. par défaut
C Entity* AttachedEntity ATTACHED_ENTITY attachedEntity NULL l'entité naturellement associée au bloc

Un bloc activités-ressources contient des spécifications d'activités, lesquelles mettent en oeuvre des opérations, lesquelles agissent sur des entités, éléments ou composants du système piloté. On a fréquemment besoin, notamment dans le codage de cet effet des opérations, de pointer sur l'entité touchée. Il est commode de rendre ce pointage relatif à une autre, choisie comme référence pour le plus de pointages possible, et telle que la distance entre cette référence et les objets à pointer soit courte, donc aisée à écrire. Une fois choisie cette entité-référence, on l'affecte comme valeur du descripteur AttachedEntity.

Typiquement, cette entité 'attachée' est le système piloté lui-même (la valeur du descripteur AttachedEntity de l'unique instance de ControlledSystem). Dans le cas d'une partition du système controlé en sous-systèmes pilotés indépendamment (plans différents servis par des pools de ressources disjoints), les entités attachées aux différents 'blocs activités-ressources' ainsi identifiés seront plus naturellement les sous-systèmes.

Voici un exemple de gestion de cette information :

{
  ...
  Entity* pPlan = ...;                   // le plan d'activités
  Entity* pARB = new ActivitiesResourcesBlock();
  Entity* pPlot = ...;                   // un objet dans le système piloté
  pARB->SetEntityConstValue(ATTACHED_ENTITY, pPlot);
  pPlot->SetIntVarValue(IS_OPERATED, FALSE); // une variable d'état
  pARB->AddComponent(pPlan);
  Entity* pARBSet = pStrategy->GetComponent(ACTIVITIES_RESOURCES_BLOCK_SET);
  pARBSet->AddElement(pARB);
  ...
}
{
  ...
  pInst = ...; // une activité primitive
  Operation* pOt = (Operation*)pInst->GetEntityVarValue(ALLOCATED_OPERATION);
  ActivitiesResourcesBlock* pARB = pOt->GetActivitiesResourcesBlock();
  Entity* pPlot = pARB->GetEntityConstValue(ATTACHED_ENTITY);
  pPlot->SetIntVarValue(IS_OPERATED, TRUE); // var. d'état modifiée par opération
  ...
}

Méthodes :

type classe, symbole, nom corps par défaut classes des arguments
Entity* LocalBestActivitySetSelector LOCAL_BEST_ACTIVITY_SET_SELECTOR localBestActivitySetSelector ActivitySetsArgument
Entity* LocalCandidateActivitySetSortMethod LOCAL_CANDIDATE_ACTIVITY_SET_SORT_METHOD localCandidateActivitySetSortMethod ActivitySetArgument

Arguments des méthodes :

type classe, symbole, nom v. par défaut domaine
Entity* ActivitiesResourcesBlockArgument ACTIVITIES_RESOURCES_BLOCK_ARGUMENT activitiesResourcesBlockArgument NULL instance de ActivitiesResourcesBlock
Entity* ActivitySetsArgument ACTIVITY_SETS_ARGUMENT activitySetsArgument NULL instance de InstructionSetConjunction

Ces méthodes portent une connaissances qui peut aussi être localisée sur le gestionnaire du système (classe Manager) si elle est reconnue applicable de la même manière sur tous les blocs activités-ressources (et notamment quand il n'y en a qu'un seul). Si une telle connaissance est localisée sur le bloc, elle est exploitée prioritairement (et exclusivement) à celle éventuellement localisée sur le gestionnaire.

Définition de la procédure de sélection du meilleur jeu d'activités :

BasicEntity* My_BestActivitySetSelector_Body (EntityMethod* pM) {
  Entity* pARB = pM->DescribedEntity();
  Entity* pSetDisjunction = pM->GetEntityArgValue(ACTIVITY_SETS_ARGUMENT);
  int nbSets = pSetDisjunction->GetNumberOfElements();
  BasicEntity* result = NULL;

  for(int i=nbSets-1;i>=0;i--) {
	Entity* pSet_i = pSetDisjunction->GetElement(i);
	Boolean toRemove = FALSE;
    // ...
	}
	if(toRemove) {
	  pSetDisjunction->RemoveElement(i);
	}
  }
  // ...
  if(pSetDisjunction->GetNumberOfElements() > 0) { 
	result = pSetDisjunction->GetElement(0);
  }
  return result;
}

Assignation de ce corps à la méthode de sélection du meilleur jeu :

{
  ...
  pInst = ...; // une activité primitive
  Activity* pPlan = pInst->RootActivity();  // le plan d'activités
  ActivitiesResourcesBlock* 
     pARB = (ActivitiesResourcesBlock*)(pPlan->GetSuperEntity());
  pARB->AssignBody(LOCAL_BEST_ACTIVITY_SET_SELECTOR,
				   My_BestActivitySetSelector_Body);
  ...
}

This page was generated with the help of DOC++.