Une ressource atomique à capacité (classe SingleCapacitatedResource) est caractérisée par un vecteur de valeurs exprimant une capacité multidimensionnelle. Son degré de disponibilité est, à un instant donné, le vecteur des valeurs courantes sur ces dimensions.
L'état de disponibilité de la ressource dépend de son degré de disponibilité et des contraintes de disponibilité liées à cette capacité (instances de CapacityAvailabilityConstraint) attachées à la ressource.
Pour exemple, soit une instance de la classe MultiStock dans le domaine d'application, contenant 10 entités de classe P1 et 5 entités de classe P2. Ceci peut-être modélisé par deux descripteurs :
- P1Content dont la valeur est 10
- P2Content dont la valeur est 5
Si on a fait hériter cette classe de SingleCapacitatedResource, elle possède le descripteur ResourceCapacitySupply, qui a pour valeur une instance de MultipleResourceCapacity. Cette dernière possède deux éléments de classe IntegerResourceCapacity, qui ont été ajoutés par le développeur de l'application par le service InstallIntegerCapacity, de la manière suivante :
{ //... SingleCapacitatedResource* pMS = new MultiStock(); int nb_P1 = pMS->GetIntVarValue(P1_CONTENT); pMS->InstallFloatCapacity(pMS->GetDescriptor(P1_CONTENT), nb_P1); int nb_P2 = pMS->GetIntVarValue(P2_CONTENT); pMS->InstallFloatCapacity(pMS->GetDescriptor(P2_CONTENT), nb_P2); //... }On ne le fait pas dans le code ci-dessus, mais on peut déclarer que la capacité offerte est inférieure au contenu.
Selon que MultiStock est une instance de SingleCapacitatedReusableResource ou de SingleCapacitatedConsumableResource, cette capacité pourra être utilisée ou consommée. Pour poursuivre l'illustration, on envisage ici une consommation. On distingue deux situations de développement :
- la consommation est réalisée par une opération de transfert dans le cadre d'une activité de transfert (TransferActivity) ;
- la consommation est réalisée dans un processus ou dans la "procédure de transition d'état" d'une opération banale.
Dans le second cas, on exploite le service ConsumeCapacity, argumenté par la grandeur consommée et la quantité qui ne sera plus consommable :
{ //... pMS->ConsumeCapacity(P1_CONTENT, 3); //... }ConsumeCapacity assure que la capacité restant disponible n'est pas inférieure au niveau minimal (valeur de IntLowerLevel de la IntegerResourceCapacity) si la ressource est un SingleStock, et pas inférieure à 0 sinon.
Dans le premier cas (opération de transfert), la consommation est une procédure déjà codée dans le moteur de simulation. Cette procédure est alimentée par des informations attachées par l'utilisateur à son instance de TransferActivity :
- Une TransferActivity est dotée d'un descripteur dont la valeur est une instance de TransferInformation, et de deux descripteurs qui pointent sur l'objet opéré "source" et sur l'objet opéré "destination" du transfert.
- La TransferInformation est dotée d'un descripteur TransferQuantityId (ce qui sera transféré) et d'un descripteur TransferQuantityIntValue (en quelle quantité).
Dans le cas d'un transfert, la procédure d'allocation des ressources, crée deux instances de MultipleResourceCapacity, une pour exprimer la demande (au profit de la destination) et une autre pour exprimer l'offre (par la source). Puis elle teste la ou les contraintes de disponibilité (liées à la capacité) attachées aux ressources en jeu. Il se trouve que, par construction, toute instance de SingleCapacitatedResource est dotée d'une contrainte prédéfinie (StandardCapacityAvailabilityConstraint) qui stipule, dans sa méthode CapacityOfferDemandComparison, que la demande ne doit pas dépasser l'offre en capacité. Cette méthode compare les deux instances de MultipleResourceCapacity évoquées ci-dessus. La contrainte est satisfaite si la méthode renvoie vrai et dans ce cas, le transfert est autorisé.
Poursuivant l'illustration, le transfert ne sera pas autorisé si l'information sur le transfert est la suivante, dans le fichier de déclaration externalisée :
+ I multiStock pSrcStock p1Content = 10; p1Content = 3; // l'offre ; + I multiStock pDestStock ; + I transferInformation pTrInfo1, transferQuantityId = P1_CONTENT; transferQuantityIntValue = 5; // demande > offre ! ; + I myTransferActivity pTrAct operatedObjectSpecAttribute = + I operatedObjectSpecification laSource, //... preExpandedList << <I><, pSrcStock>; ; ; destinationSpecAttribute = + I operatedObjectSpecification laDestination, //... preExpandedList << <I><, pDestStock>; ; ; transferInformationAttribute = <I><, pTrInfo1>; ;Noter que la contrainte StandardCapacityAvailabilityConstraint est attachée à la ressource comme élément de la liste valeur du descripteur CapacityAvailabilityAttribute. Bien que naturelle, on peut l'enlever, et la remplacer ou la compléter par d'autres spécifiques au domaine d'application. De la manière suivante, dans un code internalisé :
bool myCapacityOfferDemandComparison_Body(EntityMethod* pM) { // une critere de satisfaction spécifique à l'application bool result = true; Entity* pConstraint = pM->DescribedEntity(); Entity* pCapRsc = pConstraint->GetEntityConstValue(DESCRIBED_RESOURCE); Entity* pMultipleCapDemand = pCapRsc->GetEntityConstValue(RESOURCE_CAPACITY_DEMAND); Entity* pMultipleCapSupply = pCapRsc->GetEntityConstValue(RESOURCE_CAPACITY_SUPPLY); // ... établissement de result à faux dans une situation // où la contrainte doit être perçue comme non satisfaite return result; } { // ... MultipleResourceCapacity* pMultRscCap = pSrcStock->GetEntityConstValue(CAPACITY_AVAILABILITY_ATTRIBUTE); int nbCtr = pMultRscCap->GetNumberOfElements(); for(int k=nbCtr-1;k>=0;k--) { BasicEntity* pCtr_k = pMultRscCap->GetElement(k); if(pCtr_k->IsInstanceOf(STANDARD_CAPACITY_AVAILABILITY_CONSTRAINT)) { pMultRscCap->RemoveElement(k); break; } } Entity* pNewCtr = new CapacityAvailabilityConstraint(); pNewCtr->AssignBody(CAPACITY_OFFER_DEMAND_COMPARISON, myCapacityOfferDemandComparison_Body); pNewCtr->SetEntityConstValue(DESCRIBED_RESOURCE, pSrcStock); pMultRscCap->AddElement(pNewCtr); // ... }Descripteurs :
type classe, symbole, nom v. par défaut C pEntity* ResourceCapacitySupply RESOURCE_CAPACITY_SUPPLY, resourceCapacitySupply NULL une instance de MultipleResourceCapacity C pEntity* ResourceCapacityDemand RESOURCE_CAPACITY_DEMAND, resourceCapacityDemand NULL une instance de MultipleResourceCapacity C pEntityTab* CapacityAvailabilityAttribute CAPACITY_AVAILABILITY_ATTRIBUTE capacityAvailabilityAttribute un tableau vide une liste d'instances de CapacityAvailabilityConstraint