//===================== § AIV_E2.1 ===================== void lectureCroissanceHerbe_initializeProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'initialisation // du processus continu de lecture d'un fichier sequentiel. //--------------------------------------------- { ReadSequentialDataFileProcess* pCP = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess()); UserFileId fileClassId = pCP->FileClassId(); SequentialDataFile* pF = (SequentialDataFile*)App_NewSerialDataFileFromId(fileClassId); if(! pF) UnknownFileClassSymbol("SequentialDataFile", fileClassId); pCP->SetFile(pF); //------------------------------------------- // recuperation des specifications du fichier //------------------------------------------- pCP->SetNamesFromFile(pF); //pCP->DisplayNames(); //------------------------------------------- // etablissement du chemin complet du fichier // a partir des specifications du fichier et du processus //------------------------------------------- pCP->AssignFullNameToFile(pF); //--------------------- // ouverture du fichier //--------------------- pF->Open(); //--------------------- // saut des premieres lignes : // - la ligne d'entete // - les lignes avant la date de début de la simulation //--------------------- tm* tm_debutSim = pCurrentSim->CurrentTmDate(); int jourJulien = tm_debutSim->tm_yday; // 0 pour 1 JAN delete tm_debutSim; int nbLinesToSkip = pF->GetNbTopCommentLines() + jourJulien; //printf("\n%s jourJulien = %d nbLinesToSkip = %d", pF->GetFullName(), jourJulien, nbLinesToSkip); pF->Skip(nbLinesToSkip); }; //===================== § AIV_E2.1 ===================== //===================== § AIV_E2.2 ===================== void lectureCroissanceHerbe_postReadProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'exploitation des valeurs // lues sur un enregistrement. //--------------------------------------------- { ReadSequentialDataFileProcess* pCP = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess()); Entity* pHerbe = pCP->ProcessedEntity(); // // recuperation de la valeur des champs // SequentialDataFile* pF = pCP->GetFile(); //int nDayFromOrig = pF->GetIntFieldValue(NDAY_FROM_ORIG); // unused float netGrowth = pF->GetFloatFieldValue(NET_GROWTH); // // exploitation de la croissance nette // pHerbe->SetFloatVarValue(CROISSANCE_NETTE, netGrowth); //int now = pCurrentSim->Clock(); //printf("\n");TraceDateFromClock(now, DATE_DMY);printf(" croissance nette de %s : %f", pHerbe->InstanceName(), netGrowth); }; //===================== § AIV_E2.2 ===================== //===================== § AV_E2.1 ===================== void lectureUnitesDeveloppementBle_initializeProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'initialisation // du processus continu de lecture d'un fichier sequentiel. //--------------------------------------------- { ReadSequentialDataFileProcess* pCP = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess()); UserFileId fileClassId = pCP->FileClassId(); SequentialDataFile* pF = (SequentialDataFile*)App_NewSerialDataFileFromId(fileClassId); if(! pF) UnknownFileClassSymbol("SequentialDataFile", fileClassId); pCP->SetFile(pF); //------------------------------------------- // recuperation des specifications du fichier //------------------------------------------- pCP->SetNamesFromFile(pF); //pCP->DisplayNames(); //------------------------------------------- // etablissement du chemin complet du fichier // a partir des specifications du fichier et du processus //------------------------------------------- pCP->AssignFullNameToFile(pF); //--------------------- // ouverture du fichier //--------------------- pF->Open(); //--------------------- // saut des premieres lignes : // - la ligne d'entete // - les lignes avant la date de début de la simulation //--------------------- tm* tm_debutSim = pCurrentSim->CurrentTmDate(); int jourJulien = tm_debutSim->tm_yday; // 0 pour 1 JAN delete tm_debutSim; int nbLinesToSkip = pF->GetNbTopCommentLines() + jourJulien; //printf("\n%s jourJulien = %d nbLinesToSkip = %d", pF->GetFullName(), jourJulien, nbLinesToSkip); pF->Skip(nbLinesToSkip); }; //===================== § AV_E2.1 ===================== //===================== § AV_E2.2 ===================== void lectureUnitesDeveloppementBle_postReadProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'exploitation des valeurs // lues sur un enregistrement. //--------------------------------------------- { ReadSequentialDataFileProcess* pCP = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess()); Entity* pBle = pCP->ProcessedEntity(); // // recuperation de la valeur des champs // SequentialDataFile* pF = pCP->GetFile(); //int nDayFromOrig = pF->GetIntFieldValue(NDAY_FROM_ORIG2); // unused float uDev = pF->GetFloatFieldValue(DEV_UNITS); // // exploitation du nb d'UDev // pBle->SetFloatVarValue(QUANTITE_UNITES_DEV, uDev); //int now = pCurrentSim->Clock(); //printf("\n");TraceDateFromClock(now, DATE_DMY);printf(" unites de developpement de %s : %f", pBle->InstanceName(), uDev); }; //===================== § AV_E2.2 ===================== //===================== § AVI_E2.4 ===================== AgeBle::AgeBle() { // ========================================================= // Une classe de Entity : 'AgeBle' // Ne pas modifier les lignes au-dessus du code spécifique. // (*) la parente est declaree dans App_InstallMetaClasses() // ========================================================= SetMetaClass(AGE_BLE); //SetParentClassId(AGE_CULTURE); // pour memoire (*) AddInstanceToClass(); // *** DEBUT DU CODE SPECIFIQUE. NE RIEN MODIFIER CI-DESSUS *** pEntityTab* pStadeTab = GetEntityTabConstValue(TABLEAU_STADES); StadePhenoBle* pStade; //-------------------------------------------------- pStade = new StadeAvantSemis(); pStade->SetEntityConstValue(ATTRIBUT_AGE, this); pStadeTab->push_back(pStade); //-------------------------------------------------- pStade = new StadeApresSemis(); pStade->SetEntityConstValue(ATTRIBUT_AGE, this); pStadeTab->push_back(pStade); //-------------------------------------------------- pStade = new StadeEpi1cm(); pStade->SetEntityConstValue(ATTRIBUT_AGE, this); pStadeTab->push_back(pStade); //-------------------------------------------------- pStade = new StadeGonflement(); pStade->SetEntityConstValue(ATTRIBUT_AGE, this); pStadeTab->push_back(pStade); //-------------------------------------------------- pStade = new StadeFloraison(); pStade->SetEntityConstValue(ATTRIBUT_AGE, this); pStadeTab->push_back(pStade); //-------------------------------------------------- }; //===================== § AVI_E2.4 ===================== //===================== § AVI_E2.5.2 ===================== bool stadeApresSemis_checkStageAchievement_Body(EntityMethod* pM) { //----------------------------------------------------------- // check whether the addressed stage has reached full achievement //----------------------------------------------------------- Entity* pE = pM->DescribedEntity(); bool result = TRUE; // Le stade a l'initialisation est AVANT_SEMIS. // Le processus d'avancee regerde le stade suivant, cad celui-ci. // Ce stade APRES_SEMIS doit etre atteint tout de suite, parce que c'est // l'operation de semis qui lance de le processus de parcours des stades // Donc ce prédicat doit renvoyer 'vrai'. return result; }; //===================== § AVI_E2.5.2 ===================== //===================== § AVI_E2.5.3 ===================== bool stadeEpi1cm_checkStageAchievement_Body(EntityMethod* pM) { //------------------------------------------------------------- // check whether the addressed stage has reached full achievement //------------------------------------------------------------- Entity* pAddressedStage = pM->DescribedEntity(); Entity* pPlantAge = pAddressedStage->GetEntityConstValue(ATTRIBUT_AGE); int result = FALSE; // // Critere d'atteinte : un seuil d'UDev // = la valeur accumulee par le ble au semis + ecart[semis epi1cm] // pEntityTab* stageTab = pPlantAge->GetEntityTabConstValue(TABLEAU_STADES); int stageIndex = GetPosition(*stageTab, pAddressedStage); Entity* pPreviousStage = (Entity*) stageTab->get_element(stageIndex-1); float UDev_debutStade = pPreviousStage->GetFloatVarValue(UNIT_DEV_REEL_AU_STADE); float UDev_dureeStade = pAddressedStage->GetFloatConstValue(DUREE_STADE_EN_UNIT_DEV); float seuilUDev = UDev_debutStade+ UDev_dureeStade; // // Indicateur d'atteinte : la valeur accumulee jusqu'a cet instant // Entity* pBle = (Entity*)pPlantAge->GetEntityConstValue(ATTRIBUT_CULTURE); float accumulatedUDev = pBle->GetFloatVarValue(QUANTITE_UNITES_DEV); // // Test : le seuil specifie est atteint // if(accumulatedUDev >= seuilUDev) { result = TRUE; } return result; }; //===================== § AVI_E2.5.3 ===================== //===================== § AVI_E2.5.4 ===================== bool stadeGonflement_checkStageAchievement_Body(EntityMethod* pM) { //----------------------------------------------------------------- // check whether the addressed stage has reached full achievement //----------------------------------------------------------------- Entity* pAddressedStage = pM->DescribedEntity(); Entity* pPlantAge = pAddressedStage->GetEntityConstValue(ATTRIBUT_AGE); int result = FALSE; // // Critere d'atteinte : un seuil d'UDev // ------------------ // = la valeur accumulee par le ble a epi1cm + ecart[epi1cm gonflement] // pEntityTab* stageTab = pPlantAge->GetEntityTabConstValue(TABLEAU_STADES); int stageIndex = GetPosition(*stageTab, pAddressedStage); Entity* pPreviousStage = (Entity*) stageTab->get_element(stageIndex-1); float UDev_debutStade = pPreviousStage->GetFloatVarValue(UNIT_DEV_REEL_AU_STADE); float UDev_dureeStade = pAddressedStage->GetFloatConstValue(DUREE_STADE_EN_UNIT_DEV); float seuilUDev = UDev_debutStade+ UDev_dureeStade; // // Indicateur d'atteinte : la valeur accumulee jusqu'a cet instant // --------------------- Entity* pBle = (Entity*)pPlantAge->GetEntityConstValue(ATTRIBUT_CULTURE); float accumulatedUDev = pBle->GetFloatVarValue(QUANTITE_UNITES_DEV); // // Test : le seuil specifie est atteint // ---- if(accumulatedUDev >= seuilUDev) { result = TRUE; } return result; }; //===================== § AVI_E2.5.4 ===================== //===================== § AVI_E2.5.5 ===================== bool stadeEpi1cm_checkStageAchievement_Body(EntityMethod* pM) { //------------------------------------------------------------- // check whether the addressed stage has reached full achievement //------------------------------------------------------------- Entity* pAddressedStage = pM->DescribedEntity(); Entity* pPlantAge = pAddressedStage->GetEntityConstValue(ATTRIBUT_AGE); int result = FALSE; // // Critere d'atteinte : un seuil d'UDev // = la valeur accumulee par le ble au semis + ecart[semis epi1cm] // pEntityTab* stageTab = pPlantAge->GetEntityTabConstValue(TABLEAU_STADES); int stageIndex = GetPosition(*stageTab, pAddressedStage); Entity* pPreviousStage = (Entity*) stageTab->get_element(stageIndex-1); float UDev_debutStade = pPreviousStage->GetFloatVarValue(UNIT_DEV_REEL_AU_STADE); float UDev_dureeStade = pAddressedStage->GetFloatConstValue(DUREE_STADE_EN_UNIT_DEV); float seuilUDev = UDev_debutStade+ UDev_dureeStade; // // Indicateur d'atteinte : la valeur accumulee jusqu'a cet instant // Entity* pBle = (Entity*)pPlantAge->GetEntityConstValue(ATTRIBUT_CULTURE); float accumulatedUDev = pBle->GetFloatVarValue(QUANTITE_UNITES_DEV); // // Test : le seuil specifie est atteint // if(accumulatedUDev >= seuilUDev) { result = TRUE; } return result; }; //===================== § AVI_E2.5.5 ===================== //===================== § AVI_E2.6.1 ===================== float seuilAtteinte = GetRealParameterValue("stadesBle", "seuilUnitDevPourEpi1cm"); SetFloatConstValue(SEUIL_UNIT_DEV_POUR_ATTEINTE, seuilAtteinte); seuilAtteinte = GetRealParameterValue("stadesBle", "dureeSemisEpi1cm"); SetFloatConstValue(DUREE_STADE_EN_UNIT_DEV, seuilAtteinte); //===================== § AVI_E2.6.1 ===================== //===================== § AVI_E2.6.2 ===================== float seuilAtteinte = GetRealParameterValue("stadesBle", "seuilUnitDevPourGonflement"); SetFloatConstValue(SEUIL_UNIT_DEV_POUR_ATTEINTE, seuilAtteinte); seuilAtteinte = GetRealParameterValue("stadesBle", "dureeEpi1cmGonflement"); SetFloatConstValue(DUREE_STADE_EN_UNIT_DEV, seuilAtteinte); //===================== § AVI_E2.6.2 ===================== //===================== § AVI_E2.6.3 ===================== float seuilAtteinte = GetRealParameterValue("stadesBle", "seuilUnitDevPourFloraison"); SetFloatConstValue(SEUIL_UNIT_DEV_POUR_ATTEINTE, seuilAtteinte); seuilAtteinte = GetRealParameterValue("stadesBle", "dureeGonflementFloraison"); SetFloatConstValue(DUREE_STADE_EN_UNIT_DEV, seuilAtteinte); //===================== § AVI_E2.6.3 ===================== //===================== § AVI_E2.7 ===================== AgeBle* pAge = new AgeBle(); SetEntityConstValue(ATTRIBUT_AGE, pAge); pAge->SetEntityConstValue(ATTRIBUT_CULTURE, this); //===================== § AVI_E2.7 ===================== //===================== § AVI_E3.1 ===================== void processusDeveloppementBle_initializeProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'initialisation du processus continu. //--------------------------------------------- { ContinuousProcess* pCP = pM->DescribedContinuousProcess(); Entity* pBle = pCP->ProcessedEntity(); // // Recuperation AgeBle (instancie dans constructeur Ble) // Entity* pAgeBle = pBle->GetEntityValue(ATTRIBUT_AGE); // // on se place par convention en AVANT_SEMIS // pAgeBle->SetIntVarValue(CURRENT_ELEMENT_INDEX, AVANT_SEMIS); }; //===================== § AVI_E3.1 ===================== //===================== § AVI_E3.2 ===================== void processusDeveloppementBle_goOneStepForwardProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'avancee du processus continu. //--------------------------------------------- { ContinuousProcess* pCP = pM->DescribedContinuousProcess(); Entity* pBle = pCP->ProcessedEntity(); AgeBle* pAgeBle = (AgeBle*) pBle->GetEntityValue(ATTRIBUT_AGE); int currentStageIndex = pAgeBle->GetIntVarValue(CURRENT_ELEMENT_INDEX); // ----------------------------------------------- // Reperage d'un eventuel changement de stade // ----------------------------------------------- Entity* pNextStage = NULL; bool toUpdate = FALSE; pEntityTab* stageTab = pAgeBle->GetEntityTabConstValue(TABLEAU_STADES); int stageNumber = stageTab->size(); if(currentStageIndex < stageNumber-1) { pNextStage = (Entity*) stageTab->get_element(currentStageIndex+1); toUpdate = pNextStage->ExecPredicate(CHECK_STAGE_ACHIEVEMENT); } if(toUpdate) { // // pointage sur le stade suivant // ----------------------------- currentStageIndex++; pAgeBle->SetIntVarValue(CURRENT_ELEMENT_INDEX, currentStageIndex); // // valuation des unites de dev. accumulees a ce stade // -------------------------------------------------- float accumulatedUDev = pBle->GetFloatVarValue(QUANTITE_UNITES_DEV); pNextStage->SetFloatVarValue(UNIT_DEV_REEL_AU_STADE, accumulatedUDev); if(currentStageIndex > APRES_SEMIS) { // // captage date d'atteinte // (pour calcul stage suivant par duree a partir du precedent) // ----------------------- int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int jj = pTm->tm_yday; delete pTm; pNextStage->SetIntConstValue(JOUR_JULIEN_QUAND_STADE_ATTEINT, jj); } // // Affichage du changement de stade // -------------------------------- if(gTraceStadesBle) { //pNextStage->ExecVoidMethod(DISPLAY_STAGE); int now = pCurrentSim->Clock(); printf("\n");TraceDateFromClock(now, DATE_DMY);printf(" %s a atteint le stade %s", pBle->InstanceName(), App_EnumToChar(currentStageIndex)); } } }; //===================== § AVI_E3.2 ===================== //===================== § AVI_E3.3 ===================== void App_ParseMainArguments (int argc, char* argv[]) //--------------------------------------------- // Description : interpretation of main function arguments // Precondition : // Retour : //--------------------------------------------- { Boolean arg_ok = C_ParseMainArguments(argc, argv); if ((argc < 6) || !strcmp(argv[1], "-h")) { printf("\n\t[-sb] : trace du developpement du ble"); printf("\n\t[-o] : trace des operations culturales"); printf("\n"); exit(0); }; if(arg_ok) { for (int i=6;iDescribedEntitySpec(); pEntityTab* result = pES->GetExpansion(); result->erase(); int size = pM->GetIntArgValue(LISTSIZE_ARGUMENT); pEntityTab* allAgentsTab = GetEntityList(AGENT); pEntityDTab* splittedTab = SplitToSubsets(2, allAgentsTab); int nbTeams = splittedTab->size(); //printf("\n");TraceDateFromClock(pCurrentSim->Clock(), DATE_DMY);printf(" specificationUnitesPersonnelRecolte_ELI -> {"); for(int k=0;kget_nth(k); Entity* pUPR_k = new UnitePersonnelRecolte(); // la puissance collective est 1 par construction (contre 2 par defaut) // pour n'engager qu'une seule unite materielle de recolte (MB+RT) pUPR_k->AddElement(team_k->get_nth(0)); pUPR_k->AddElement(team_k->get_nth(1)); //printf("(%s %s) ", team_k->get_nth(0)->InstanceName(), team_k->get_nth(1)->InstanceName()); result->push_back(pUPR_k); } depth_delete(*splittedTab); //printf("}\n"); return result; }; //===================== § AVII_E3.3.1 ===================== //===================== § AVIII_E2.1 ===================== float operationTraceeDegreProgression_whenSetFloat_Body(MonitorMethod* pM) //--------------------------------------------- // Definition de la fonction qui sera declenchee lors de // chaque modification de la variable surveillee. //--------------------------------------------- { Descriptor* pVD = pM->GetDescriptorArgValue(MONITOREDDESCRIPTOR_ARGUMENT); float oldValue = pM->GetFloatArgValue(CURRENTFLOATVALUE_ARGUMENT); //float newValue = pM->GetFloatArgValue(CANDIDATEFLOATVALUE_ARGUMENT); Operation* pOt = (Operation*)pVD->DescribedEntity(); // -------------------------------------------------------- // tache 0) invocation moniteur sur classe de base // -------------------------------------------------------- float newValue = operationPercentAchieved_whenSetFloat_Body(pM); // on ne reagit pas s'il s'agit de l'initialisation du degre de progression // -------------------------------------------------------- if(newValue < gFloatingPointEqualityTolerance) return newValue; // -------------------------------------------------------- // tache 1) trace des progressions journalieres d'execution // -------------------------------------------------------- int now = pCurrentSim->Clock(); tm* pTm_now = ClockValueToTm(now); Entity* pInst = pOt->GetEntityVarValue(INSTRUCTION_CONTAINER); Entity* pV_alloc = pInst->GetEntityConstValue(ALLOCATION_ATTRIBUTE); // l'objet opéré pEntityTab* ooList = ((InstructionAllocation*)pV_alloc)->ExtractOOSet(); Entity* pOO = (Entity*)ooList->get_element(0); // la main d'oeuvre pEntityTab* perfList = ((InstructionAllocation*)pV_alloc)->ExtractPerfSet(); if(gTraceOperations) { printf("\n%s ", ShortWeekDayNameToCharTab[pTm_now->tm_wday]);TraceDateFromClock(now, DATE_DMY);printf(" '%s' sur '%s' -> %4.3f\t", pOt->InstanceName(), pOO->InstanceName(), newValue);// if(((PrimitiveActivity*)pInst)->IsOptional()) printf(" [optionnelle]"); perfList->display_names(); } delete pTm_now; delete ooList; delete perfList; return newValue; }; //===================== § AVIII_E2.1 ===================== //===================== § AVIII_E4 ===================== bool semerBle_stateTransitionProcedure_Body(EntityMethod* pM) { //------------------------------------------------------------- // Definit l'impact de l'operation sur l'entite operee. // L'entite operee est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une operation de transfert, consulter la documentation generale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE; int now = pCurrentSim->Clock(); // S D F T R char* newValue = "S_*_*_*_*"; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); pCulture->SetStringVarValue(ETAPE_I_T_BLE, newValue); if(gTraceOperations) { printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" historique IT sur %s : %s", pCulture->InstanceName(), newValue); } // // Lancement du processus de developpement ... // ---------------------------------------- ContinuousProcess* pCP = new ProcessusDeveloppementBle(); // // ... attache a la Cereale precedemment instanciee // pCP->ProcessedEntity(pCulture); // // ... et lance immediatement // result = pCP->PostInitAndProceedEvent(now, 10); return result; }; //===================== § AVIII_E4 ===================== //===================== § AVIII_E4.4 ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "semerBle"); SetFloatConstValue(TIME_SPEED, speed); //===================== § AVIII_E4.4 ===================== //===================== § AVIII_E5.2.4 ===================== // // le performer par défaut est spécifie ci-dessus (ANYONE par construction) // on installe ici eventuellement la variante MAX // pBE = GetEntityVarValue(PERFORMER_SPEC_ATTRIBUTE); Entity* pManager = (Entity*)GetEntityList(MANAGER)->get_nth(0); //printf("\nconstructeur ActiviteBle pManager : %s", pManager->InstanceName()); int option = pManager->GetIntConstValue(MODALITE_DEUX_AGENTS); if((option == MAX)) ((Entity*)pBE)->SetIntConstValue(SELECTOR_FCT_ID, option); // l'operation est specifiee dans les sous-classes // specification incomplete de l'objet opere, completee lors de la // valuation de UniteDeGestion de l'itineraire dans le fichier externe // Entity* pOOSpec = new OperatedObjectSpecification(); SetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE, pOOSpec); //===================== § AVIII_E5.2.4 ===================== < //===================== § AIX_E2 ===================== Activity* pInst, * pAct; pInst = new SemisBle(); AddElement(pInst); // element 1 /* pInst = new DesherbageAutomne(); AddElement(pInst); // element 2 pAct = new ActivityConjunction(); Activity* pIterate = new IterationApportsAzote(); pAct->AddElement(pIterate); Activity* pBefore = new SequenceTraitementsFongicides(); pAct->AddElement(pBefore); AddElement(pAct); // element 3 pInst = new MoissonBle(); AddElement(pInst); // element 4 */ //===================== § AIX_E2 ===================== //===================== § AIX_E6 ===================== int revisionMatinaleDuPlan_defineNextEventClockTime_Body(EventMethod* pM) //--------------------------------------------- // Fonction de generation d'un nouvel evenement. // Methode : 'SetDefineNextEventClockTime' // . pNextEvent a ete instancie par la methode standard // . sa date candidate tient deja compte de la specification // des delais min et max a ajouter a la precedente occurrence. //--------------------------------------------- { //printf("\nrevisionMatinaleDuPlan_defineNextEventClockTime en t = %d", pCurrentSim->Clock()); int nextEventClockTime; Event* pNextEvent = pM->DescribedEvent(); Event* pPreviousEvent = pM->GetEventArgValue(PREVIOUS_EVENT_ARGUMENT); int previousEventClockTime = pPreviousEvent->OccurrenceClockTime(); // // horloge = 1 HOUR ou 24 HOUR : // on change seulement le jour -> heure conservée lors des chgt d'heures // puis on calcule l'instant d'horloge correspondant // tm* pNextEventTm = ClockValueToTm(previousEventClockTime); pNextEventTm->tm_mday += 1; mktime(pNextEventTm); // gere les chgts d'heure nextEventClockTime = StructTmToClockValue(pNextEventTm); delete pNextEventTm; //printf(" --> nextEventClockTime : %d", nextEventClockTime); return nextEventClockTime; }; //===================== § AIX_E6 ===================== //===================== § AIX_E8 ===================== BasicEntity* uniteDeGestion_whenSetEntity_Body(MonitorMethod* pM) //--------------------------------------------- // Definition de la fonction qui sera declenchee lors de // chaque modification de la variable surveillee. //--------------------------------------------- { Descriptor* pVD = pM->GetDescriptorArgValue(MONITOREDDESCRIPTOR_ARGUMENT); BasicEntity* oldValue = pM->GetEntityArgValue(CURRENTENTITYVALUE_ARGUMENT); // l'entite de l'exploitation objet de l'activite agregee BasicEntity* newValue = pM->GetEntityArgValue(CANDIDATEENTITYVALUE_ARGUMENT); Activity* pAct = (Activity*)pVD->DescribedEntity(); // les activites primitives elements a une profondeur quelconque pEntityTab* pInstList = pAct->PrimitiveList(); int nbInst = pInstList->size(); for(int k=0;kget_nth(k); Entity* pOOSpec_k = pInst_k->GetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE); // l'objet de l'act. agregee devient l'objet explicite de la primitive //printf("\nuniteDeGestion_whenSet dans pAct : '%s' newValue : '%s' --> pInst : '%s'", pAct->InstanceName(), newValue->InstanceName(), pInst_k->InstanceName()); pOOSpec_k->AddEntityValueElement(PRE_EXPANDED_LIST, newValue); } free(pInstList); return newValue; }; //===================== § AIX_E8 ===================== //===================== § AX_E1.1.1a ===================== bool desherberBle_stateTransitionProcedure_Body(EntityMethod* pM) { //----------------------------------------------------------------- // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //----------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE;; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); char* str = pCulture->GetStringVarValue(ETAPE_I_T_BLE); char* chaineS = strtok(str,"_"); char* chaineD = strtok(NULL,"_"); if(! strcmp(chaineD, "*")) chaineD = "\0"; char* chaineF = strtok(NULL,"_"); char* chaineT = strtok(NULL,"_"); char* chaineR = strtok(NULL,"_"); char newValue[20]; sprintf(newValue, "%s_%s%s_%s_%s_%s", chaineS, chaineD, "D", chaineF, chaineT, chaineR); pCulture->SetStringVarValue(ETAPE_I_T_BLE, newValue); if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" historique IT sur %s : %s", pCulture->InstanceName(), newValue); } return result; }; //===================== § AX_E1.1.1b ===================== //===================== § AX_E1.1.1b ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "desherberBle"); SetFloatConstValue(TIME_SPEED, speed); //===================== § AX_E1.1.1b ===================== //===================== § AX_E1.1.2a ===================== bool fertiliserBle_stateTransitionProcedure_Body(EntityMethod* pM) { //------------------------------------------------------------------ // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //------------------------------------------------------------------ Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); char* str = pCulture->GetStringVarValue(ETAPE_I_T_BLE); char* chaineS = strtok(str,"_"); char* chaineD = strtok(NULL,"_"); char* chaineF = strtok(NULL,"_"); if(! strcmp(chaineF, "*")) chaineF = "\0"; char* chaineT = strtok(NULL,"_"); char* chaineR = strtok(NULL,"_"); char newValue[20]; sprintf(newValue, "%s_%s_%s%s_%s_%s", chaineS, chaineD, chaineF, "F", chaineT, chaineR); pCulture->SetStringVarValue(ETAPE_I_T_BLE, newValue); if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" historique IT sur %s : %s", pCulture->InstanceName(), newValue); } return result; }; //===================== § AX_E1.1.2a ===================== //===================== § AX_E1.1.2b ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "fertiliserBle"); SetFloatConstValue(TIME_SPEED, speed); // // interruptibilite // char* flag = GetStringParameterValue("interruptionAutorisee", "fertiliserBle"); if(! strcmp(flag, "non")) SetFloatConstValue(SUSPENSION_THRESHOLD, (float)0.); //===================== § AX_E1.1.2b ===================== //===================== § AX_E1.1.3a ===================== bool traiterBle_stateTransitionProcedure_Body(EntityMethod* pM) { //--------------------------------------------------------------- // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //--------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); char* str = pCulture->GetStringVarValue(ETAPE_I_T_BLE); char* chaineS = strtok(str,"_"); char* chaineD = strtok(NULL,"_"); char* chaineF = strtok(NULL,"_"); char* chaineT = strtok(NULL,"_"); if(! strcmp(chaineT, "*")) chaineT = "\0"; char* chaineR = strtok(NULL,"_"); char newValue[20]; sprintf(newValue, "%s_%s_%s_%s%s_%s", chaineS, chaineD, chaineF, chaineT, "T", chaineR); pCulture->SetStringVarValue(ETAPE_I_T_BLE, newValue); if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" historique IT sur %s : %s", pCulture->InstanceName(), newValue); } return result; }; //===================== § AX_E1.1.3a ===================== //===================== § AX_E1.1.3b ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "traiterBle"); SetFloatConstValue(TIME_SPEED, speed); // // interruptibilite // char* flag = GetStringParameterValue("interruptionAutorisee", "traiterBle"); if(! strcmp(flag, "non")) SetFloatConstValue(SUSPENSION_THRESHOLD, (float)0.); //===================== § AX_E1.1.3b ===================== //===================== § AX_E1.1.4a ===================== bool recolterBle_stateTransitionProcedure_Body(EntityMethod* pM) { //---------------------------------------------------------------- // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //---------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE;; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); char* str = pCulture->GetStringVarValue(ETAPE_I_T_BLE); char* chaineS = strtok(str,"_"); char* chaineD = strtok(NULL,"_"); char* chaineF = strtok(NULL,"_"); char* chaineT = strtok(NULL,"_"); char newValue[20]; sprintf(newValue, "%s_%s_%s_%s_%s", chaineS, chaineD, chaineF, chaineT, "R"); pCulture->SetStringVarValue(ETAPE_I_T_BLE, newValue); if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" historique IT sur %s : %s", pCulture->InstanceName(), newValue); } return result; }; //===================== § AX_E1.1.4a ===================== //===================== § AX_E1.1.4b ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "recolterBle"); SetFloatConstValue(TIME_SPEED, speed); //===================== § AX_E1.1.4b ===================== //===================== § AX_E1.2a ===================== bool couperLuzerne_stateTransitionProcedure_Body(EntityMethod* pM) { //----------------------------------------------------------------- // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //----------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pParcelle = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE; Entity* pCulture = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" coupe %s sur %s", pCulture->InstanceName(), pParcelle->InstanceName()); } return result; }; //===================== § AX_E1.2a ===================== //===================== § AX_E1.2b ===================== // // vitesse // float speed= GetRealParameterValue("vitesseOperation", "atelierLuzerne"); SetFloatConstValue(TIME_SPEED, speed); // // priorite // int priority = GetIntParameterValue("prioriteOperation", "atelierLuzerne"); SetIntConstValue(PRIORITY_DEGREE, priority); //===================== § AX_E1.2b ===================== //===================== § AX_E1.3a ===================== bool apporterFourrage_stateTransitionProcedure_Body(EntityMethod* pM) { //--------------------------------------------------------------------- // D�finit l'impact de l'op�ration sur l'entit� op�r�e. // L'entit� op�r�e est la valeur de l'argument OPERATION_TARGET. // S'il s'agit d'une op�ration de transfert, consulter la documentation g�n�rale // pour la liste et le sens de la valeur des arguments (source, destination, ...). //--------------------------------------------------------------------- Operation* pOt = (Operation*)(pM->DescribedEntity()); Entity* pTroupeau = pM->GetEntityArgValue(OPERATION_TARGET); bool result = TRUE; // // calcul apport pour 3 jours // -------------------------- int effectif = pTroupeau->GetIntVarValue(NOMBRE_ANIMAUX); float consoJour_1Animal = GetRealParameterValue("unAnimal", "consoQuotidienneHerbe"); float consoJour_troupeau = consoJour_1Animal * effectif; float apport = consoJour_troupeau * (float) 3.0; // // calcul nouvelle disponibilite // ----------------------------- float oldDispo = pTroupeau->GetFloatVarValue(HERBE_DISPONIBLE); float newDispo = oldDispo + apport; pTroupeau->SetFloatVarValue(HERBE_DISPONIBLE, newDispo); /* if(gTraceOperations) { int now = pCurrentSim->Clock(); printf("\n"); TraceDateFromClock(now, DATE_DMY);printf(" apport fourrage pour %s herbe dispo %f -> %f", pTroupeau->InstanceName(), oldDispo, newDispo); } */ return result; }; //===================== § AX_E1.3a ===================== //===================== § AX_E1.3b ===================== // // vitesse // float speed = GetRealParameterValue("vitesseOperation", "atelierVaches"); SetFloatConstValue(TIME_SPEED, speed); // // priorite // int priority = GetIntParameterValue("prioriteOperation", "atelierVaches"); SetIntConstValue(PRIORITY_DEGREE, priority); //===================== § AX_E1.3b ===================== //===================== § AX_E2.3 ===================== int priority = GetIntParameterValue("prioriteOperation", "atelierBle"); SetIntConstValue(PRIORITY_DEGREE, priority); //===================== § AX_E2.3 ===================== //===================== § AXI_E1 ===================== bool mobilisationAgent_generateNextEvent_Body(EventMethod* pM) //--------------------------------------------- // Fonction de generation d'un nouvel evenement. // par 'GenerateNextEvent' //--------------------------------------------- { // // l'evenement de mobilisation et la ressource en jeu // Event* pCurrentEvent = pM->DescribedEvent(); Process* pDP = pCurrentEvent->FirstProcess(); Entity* pRsc = pDP->ProcessedEntity(); // // la date de la presente mobilisation // int dateMobilisation = pCurrentSim->Clock(); //printf("\nmobilisationAgent_GNE dateMobilisation = %d", dateMobilisation); tm* pTm = ClockValueToTm(dateMobilisation); int numJourSemaine = pTm->tm_wday; delete pTm; //printf("\nmobilisationAgent_GNE numJourSemaine = %d", numJourSemaine); // // l'evenement d'immobilisation a generer (sur la meme ressouce) // Event* pNextEvent = new ImmobilisationAgent(); Process* pNextDP = pNextEvent->FirstProcess(); pNextDP->ProcessedEntity(pRsc); pCurrentEvent->SetNextEvent(pNextEvent); // // recuperation duree de la journee de travail // int dureeJourTravail = GetIntParameterValue("agent", "dureeJourTravailSemaine"); // // la date de l'immobilisation generee // int dateImmobilisation = dateMobilisation + dureeJourTravail; //printf("\nmobilisationAgent_GNE dateImmobilisation = %d", dateImmobilisation); pNextEvent->SetOccurrenceClockTime(dateImmobilisation); return true; }; //===================== § AXI_E1 ===================== //===================== § AXI_E2 ===================== bool immobilisationAgent_generateNextEvent_Body(EventMethod* pM) //--------------------------------------------- // Fonction de generation d'un nouvel evenement. // par 'GenerateNextEvent' //--------------------------------------------- { // // l'evenement d'immobilisation et la ressource en jeu // Event* pCurrentEvent = pM->DescribedEvent(); Process* pDP = pCurrentEvent->FirstProcess(); Entity* pRsc = pDP->ProcessedEntity(); // // la date de la presente immobilisation // int dateImmobilisation = pCurrentSim->Clock(); //printf("\nimmobilisationAgent_GNE dateImmobilisation = %d", dateImmobilisation); tm* pTm = ClockValueToTm(dateImmobilisation); int numJourSemaine = pTm->tm_wday; //printf("\nimmobilisationAgent_GNE numJourSemaine = %d", numJourSemaine); // // l'evenement de mobilisation a generer (sur la meme ressouce) // Event* pNextEvent = new MobilisationAgent(); Process* pNextDP = pNextEvent->FirstProcess(); pNextDP->ProcessedEntity(pRsc); pCurrentEvent->SetNextEvent(pNextEvent); // // la date de la mobilisation generee // int dateMobilisation; char* flag = GetStringParameterValue("agent", "travailDimancheAutorise"); if(! strcmp(flag, "non")) { if(numJourSemaine == 0) { // dimanche printf("\nERREUR mobilisation Agent :\nla derniere immobilisation a eu lieu un dimanche.\n"); exit(0); } else if(numJourSemaine == 6) { // samedi pTm->tm_mday += 2; } else { // lundi, ..., vendredi pTm->tm_mday += 1; } } else { // lundi, ..., samedi pTm->tm_mday += 1; } pTm->tm_hour = GetIntParameterValue("revisionDuPlan", "heureMatin"); // // ajustement des autres composants de la date // mktime(pTm); // // attribution de cette date a la mobilisation // dateMobilisation = StructTmToClockValue(pTm); delete pTm; //printf("\nimmobilisationAgent_GNE dateMobilisation = %d", dateMobilisation); pNextEvent->SetOccurrenceClockTime(dateMobilisation); return true; }; //===================== § AXI_E2 ===================== //===================== § AXI_E3 ===================== // // Mobiliser cet ouvrier le jour de sa creation ... // (si le jour est un dimanche non travaillé, on decale au lundi) // Event* pMobilisation = new MobilisationAgent(); Process* pDP = pMobilisation->FirstProcess(); pDP->ProcessedEntity(this); int now = pCurrentSim->Clock(); tm* pTm_now = ClockValueToTm(now); int weekDay = pTm_now->tm_wday; if(weekDay == 0) {// dimanche char* flag = GetStringParameterValue("agent", "travailDimancheAutorise"); if(! strcmp(flag, "non")) { pTm_now->tm_mday += 1; } } // //... a l'heure de la revision du plan par le manager // pTm_now->tm_hour = GetIntParameterValue("revisionDuPlan", "heureMatin"); mktime(pTm_now); int instantMobilisation = StructTmToClockValue(pTm_now); delete pTm_now; pMobilisation->SetOccurrenceClockTime(instantMobilisation); // // programmation de la premiere mobilisation // Boolean planned = pCurrentSim->InsertInAgendaEvents(pMobilisation); if(! planned) { printf("\npour '%s' l'evenement de mobilisation initiale n'a pas pu etre programme, pour l'instant %d.\n", InstanceName(), instantMobilisation); pMobilisation->DeleteInDepth(); exit(0); } //printf("\na la creation de %s, mobilisation en %d", InstanceName(), instantMobilisation); //===================== § AXI_E3 ===================== //===================== § AXII_E1.2 ===================== // // le performer par défaut est spécifie ci-dessus (ANYONE par construction) // on installe ici eventuellement la variante MAX // pBE = GetEntityVarValue(PERFORMER_SPEC_ATTRIBUTE); Entity* pManager = (Entity*)GetEntityList(MANAGER)->get_nth(0); //printf("\nconstructeur ActiviteBle pManager : %s", pManager->InstanceName()); int option = pManager->GetIntConstValue(MODALITE_DEUX_AGENTS); if((option == MAX)) ((Entity*)pBE)->SetIntConstValue(SELECTOR_FCT_ID, option); // l'operation est specifiee dans les sous-classes // specification incomplete de l'objet opere, completee lors de la // valuation de UniteDeGestion de l'itineraire dans le fichier externe // Entity* pOOSpec = new OperatedObjectSpecification(); SetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE, pOOSpec); //===================== § AXII_E1.2 ===================== //===================== § AXII_E1.3 ===================== // // specification incomplete de l'objet opere, completee lors de la // valuation de UniteDeGestion de l'itineraire dans le fichier externe // Entity* pOOSpec = new OperatedObjectSpecification(); SetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE, pOOSpec); // si le manager prend l'option MAX pour ActiviteBle et CoupeLuzerne, // il faut que l'ApportFourage ait la priorite d'allocation, // pour que les deux autres ne prennent que ce qui reste disponible après. Entity* pManager = (Entity*)GetEntityList(MANAGER)->get_nth(0); int option = pManager->GetIntConstValue(MODALITE_DEUX_AGENTS); if(option == MAX) { SetIntConstValue(ALLOCATION_PRIORITY_DEGREE, 90); // 99 par defaut pour les autres } //===================== § AXII_E1.3 ===================== //===================== § AXII_E2.2.4 ===================== BasicEntity* pBE; pBE = GetEntityVarValue(PERFORMER_SPEC_ATTRIBUTE); delete (PerformerSpecification*)pBE; // alloué dans constructeur classe mère pBE = new UnAgent(); SetEntityVarValue(PERFORMER_SPEC_ATTRIBUTE, pBE); //===================== § AXII_E2.2.4 ===================== //===================== § AXII_E3.1.1a ===================== bool desherbageAutomne_openingPredicate_Body(EntityMethod* pM) { //-------------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre ouverte. //-------------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // récup date courante et jour julien courant // int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 320 atteint // if(jJulien >= 320) { result = TRUE; } //printf("\njj=%d '%s'_OP renvoie %d", jJulien, pInst->InstanceName(), result); return result; }; //===================== § AXII_E3.1.1a ===================== //===================== § AXII_E3.1.1b ===================== bool desherbageAutomne_closingPredicate_Body(EntityMethod* pM) { //-------------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre fermee. //-------------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // récup date courante et jour julien courant // int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 335 atteint // interprete comme la date de fin au plus tot // if(jJulien >= 335) { result = TRUE; } //printf("\njj=%d '%s'_CP renvoie %d", jJulien, pInst->InstanceName(), result); return result; }; //===================== § AXII_E3.1.1b ===================== //===================== § AXII_E3.1.2.1 ===================== bool apportAzote_openingPredicate_Body(EntityMethod* pM) { //-------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre ouverte. //-------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // récupération du numéro d'ordre de l'apport // Entity* pIterate = pInst->GetSuperSet(); int numero = pIterate->GetIntVarValue(REPLICATION_COUNTER); int jJulien = -9; if(numero == 0) { // // 1er apport : jour julien 53 // // // récup date courante et jour julien courant // int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int leMois = pTm->tm_mon; // JAN = 0 jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 53 atteint // if((leMois < 7) // avant JUL && (jJulien >= 53)) { result = TRUE; } } else { Entity* pOOSpec = pInst->GetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE); pEntityTab* ooList = pOOSpec->GetEntityTabVarValue(PRE_EXPANDED_LIST); Entity* pParcelle = (Entity*)ooList->get_nth(0); Entity* pBle = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); Entity* pAge = pBle->GetEntityConstValue(ATTRIBUT_AGE); int currentStage = pAge->GetIntVarValue(CURRENT_ELEMENT_INDEX); switch(numero) { case 1 : { // // 2ème apport : stade épi 1cm // if(currentStage == EPI_1CM) { result = TRUE; } } case 2 : { // // 3ème apport : stade gonflement // if(currentStage == GONFLEMENT) { result = TRUE; } } } } //printf("\njj=%d apportAzote_OP n° %d renvoie %d", jJulien, numero+1, result); return result; }; //===================== § AXII_E3.1.2.1 ===================== //===================== § AXII_E3.1.2.2 ===================== bool apportAzote_maxBegStatePredicate_Body(EntityMethod* pM) { //------------------------------------------------------------ // L'evolution de l'etat du systeme etant vue comme une horloge qui tourne, // doit retourner vrai si l'instant indique par cette sorte d'horloge // est posterieur a la fin de la fenetre d'ouverture de l'activite. //------------------------------------------------------------ Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // récupération du numéro d'ordre de l'apport // Entity* pIterate = pInst->GetSuperSet(); int numero = pIterate->GetIntVarValue(REPLICATION_COUNTER); int jJulien; // // récup date courante et jour julien courant // int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int leMois = pTm->tm_mon; // JAN = 0 jJulien = pTm->tm_yday; delete pTm; if(numero == 0) { // // 1er apport : jour julien 433/j+1 = 68/j atteint // if((leMois < 7) // avant JUL && (jJulien >= 68)) { result = TRUE; } } else { Entity* pOOSpec = pInst->GetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE); pEntityTab* ooList = pOOSpec->GetEntityTabVarValue(PRE_EXPANDED_LIST); Entity* pParcelle = (Entity*)ooList->get_nth(0); Entity* pBle = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); Entity* pAge = pBle->GetEntityConstValue(ATTRIBUT_AGE); int currentIndex = pAge->GetIntVarValue(CURRENT_ELEMENT_INDEX); int maxBegDate = D_INTMAX; switch(numero) { case 1 : { // // 2ème apport : stade épi 1cm + 7 jours // if(currentIndex == EPI_1CM) { pEntityTab* stageTab = pAge->GetEntityTabConstValue(TABLEAU_STADES); Entity* pStage = (Entity*)stageTab->get_nth(currentIndex); int jourAtteinte = pStage->GetIntConstValue(JOUR_JULIEN_QUAND_STADE_ATTEINT); maxBegDate = jourAtteinte + 7; } } case 2 : { // // 3ème apport : stade gonflement // if(currentIndex == GONFLEMENT) { pEntityTab* stageTab = pAge->GetEntityTabConstValue(TABLEAU_STADES); Entity* pStage = (Entity*)stageTab->get_nth(currentIndex); int jourAtteinte = pStage->GetIntConstValue(JOUR_JULIEN_QUAND_STADE_ATTEINT); maxBegDate = jourAtteinte + 7; } } } // // test : date au plus tard atteinte // if(jJulien >= maxBegDate) { result = TRUE; } } //printf("\njj=%d apportAzote_MBS n° %d renvoie %d", jJulien, numero+1, result); return result; }; //===================== § AXII_E3.1.2.2 ===================== //===================== § AXII_E3.1.4 ===================== bool moissonBle_openingPredicate_Body(EntityMethod* pM) { //------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre ouverte. //------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; int now = pCurrentSim->Clock(); //printf("\nt = %d entree moissonBle_OP sur '%s'", now, pInst->InstanceName()); // // jour julien 211/j // tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 53 atteint // if((jJulien < 247) // 31 AUG && (jJulien >= 211)) { result = TRUE; } //printf("\nt = %d moissonBle_OP returns %d", now, result); return result; }; //===================== § AXII_E3.1.4 ===================== //===================== § AXII_E3.2 ===================== bool recolteLuzerne_closingPredicate_Body(EntityMethod* pM) { //----------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre fermee. //----------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // recuperation date de debut de la recolte // int begDate = pInst->GetIntVarValue(BEG_DATE); // // recuperation du numero d'ordre de la recolte // Entity* pIterate = pInst->GetSuperSet(); int numero = pIterate->GetIntVarValue(REPLICATION_COUNTER); int now = pCurrentSim->Clock(); int dureeMax; if(numero == 0) { // // on arrete 10 jours apres le debut // dureeMax = 10; } else { // // on arrete 7 jours apres le debut // dureeMax = 7; } // // test // if(now > begDate + dureeMax) result = TRUE; if(gTraceOperations && result) { Entity* pOt = pInst->GetEntityVarValue(ALLOCATED_OPERATION); float achDegree = pOt->GetFloatVarValue(ACHIEVEMENT_DEGREE); if(achDegree < (float)1.0) printf("\nt = %d on arrete la recolte de luzerne", now); } //printf("\nt = %d recolteLuzerne_CP n° %d returns result", now, numero+1, result); return result; }; //===================== § AXII_E3.2 ===================== //===================== § AXII_E3.3.1 ===================== bool affouragement_openingPredicate_Body(EntityMethod* pM) { //---------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre ouverte. //---------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); int now = pCurrentSim->Clock(); //printf("\nt = %d entree affouragement_OP sur '%s'", now, pInst->InstanceName()); bool result = FALSE; // // renvoie 'vrai' ssi : // - la croissance nette de l'herbe est sous un seuil externalisé en paramètre // - on est au moins 5 jours après le précédent apport // float seuil = GetRealParameterValue("debutApportFourrage", "seuilCroissanceNette"); // // l'herbe paturee par le troupeau // Entity* pOpt = pInst->GetSuperSet(); Entity* pIterate = pOpt->GetSuperSet(); Entity* pTroupeau = pIterate->GetEntityVarValue(UNITE_DE_GESTION); Entity* pParcelle = pTroupeau->GetEntityConstValue(PARCELLE_SUPPORT); Entity* pHerbe = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); // // captage de la croissance nette // float currentNG = pHerbe->GetFloatVarValue(CROISSANCE_NETTE); // // date dernier apport // int previousClock = pTroupeau->GetIntConstValue(DATE_DERNIER_APPORT); // // test passage seuil (en descendant) // if((currentNG < (float)10.) && (now >= previousClock + 5*24)) { // 5 jours pTroupeau->SetIntConstValue(DATE_DERNIER_APPORT, now); pInst->SetIntVarValue(MIN_BEG_DATE, now); result = TRUE; } //printf("\nt = %d affouragement_OP returns %d (NG = %f)", now, result, currentNG); return result; }; //===================== § AXII_E3.3.1 ===================== //===================== § AXII_E3.3.2 ===================== bool affouragement_maxBegStatePredicate_Body(EntityMethod* pM) { //-------------------------------------------------------------- // L'evolution de l'etat du systeme etant vue comme une horloge qui tourne, // doit retourner vrai si l'instant indique par cette sorte d'horloge // est posterieur a la fin de la fenetre d'ouverture de l'activite. //-------------------------------------------------------------- Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // Ce prédicat (MBS) est testé après le test du prédicat d'ouverture (OP) // (lors du test d'ouverture de optional(affouragement)) // Si OP a autorise l'ouverture, ce predicat MBS doit renvoyer faux // parce qu'on a ouvert dès que possible. // (OP a donne a MinBegDate la valeur de l'instant courant) // Sinon, i.e. on n'a pas ouvert dès que possible, // on dit que c'est trop tard pour le faire (result devient TRUE). // (MinBegDate est resté à sa valeur par défaut -9) // int minBegDate = pInst->GetIntVarValue(MIN_BEG_DATE); if(minBegDate >= 0) { result = TRUE; } //printf("\nt = %d minBegDate = %d affouragement_MBS renvoie %d", now, minBegDate, result); return result; }; //===================== § AXII_E3.3.2 ===================== //===================== § AXIII_E1.1.1 ===================== Activity* pAct1, * pAct2; pAct1 = new TraitementFongicideBle(); AddElement(pAct1); // OP MBS :: assignation d'une fonction globale pAct1->AssignBody(OPENING_PREDICATE, traitementFongicide1_openingPredicate); pAct1->AssignBody(MAX_BEG_STATE_PREDICATE, traitementFongicide1_maxBegStatePredicate); pAct2 = new TraitementFongicideBle(); AddElement(pAct2); // OP MBS : assignation d'une fonction globale pAct2->AssignBody(OPENING_PREDICATE, traitementFongicide2_openingPredicate); pAct2->AssignBody(MAX_BEG_STATE_PREDICATE, traitementFongicide2_maxBegStatePredicate); //===================== § AXIII_E1.1.1 ===================== //===================== § AXIII_E1.1.2a ===================== bool traitementFongicide1_openingPredicate (EntityMethod* pM) //--------------------------------------------- // Description : // Precondition : // Retour : //--------------------------------------------- { Entity* pInst = pM->DescribedEntity(); bool result = FALSE; int now = pCurrentSim->Clock(); //printf("\nt = %d entree traitementFongicide1_OP sur '%s'", now, pInst->InstanceName()); // // 1er apport : jour julien 476/j+1 = 110/j // tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 110 atteint // if((jJulien < 216) // 31 JUL && (jJulien >= 110)) { result = TRUE; } //printf("\nt = %d traitementFongicide1_OP returns %d", now, result); return result; } //===================== § AXIII_E1.1.2a ===================== //===================== § AXIII_E1.1.2b ===================== bool traitementFongicide1_maxBegStatePredicate (EntityMethod* pM) //--------------------------------------------- // Description : // Precondition : // Retour : //--------------------------------------------- { Entity* pInst = pM->DescribedEntity(); bool result = FALSE; int now = pCurrentSim->Clock(); //printf("\nt = %d entree traitementFongicide1_MBS sur '%s'", now, pInst->InstanceName()); // // 1er apport : jour julien 481/j+1 = 115/j // tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // test : jour julien 115 atteint // if((jJulien < 216) // 31 JUL && (jJulien >= 115)) { result = TRUE; } //printf("\nt = %d traitementFongicide1_MBS returns %d", now, result); return result; } //===================== § AXIII_E1.1.2b ===================== //===================== § AXIII_E1.1.2c ===================== bool traitementFongicide2_openingPredicate (EntityMethod* pM) //--------------------------------------------- // Description : // Precondition : // Retour : //--------------------------------------------- { Entity* pInst = pM->DescribedEntity(); bool result = FALSE; int now = pCurrentSim->Clock(); //printf("\nt = %d entree traitementFongicide2_OP sur '%s'", now, pInst->InstanceName()); // // 2ème apport : stade floraison // Entity* pOOSpec = pInst->GetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE); pEntityTab* ooSpecList = pOOSpec->GetEntityTabVarValue(PRE_EXPANDED_LIST); Entity* pParcelle = (Entity*)ooSpecList->get_nth(0); Entity* pBle = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); Entity* pAge = pBle->GetEntityConstValue(ATTRIBUT_AGE); int currentStage = pAge->GetIntVarValue(CURRENT_ELEMENT_INDEX); if(currentStage == FLORAISON) { result = TRUE; } //printf("\nt = %d traitementFongicide2_OP returns %d", now, result); return result; } //===================== § AXIII_E1.1.2c ===================== //===================== § AXIII_E1.1.2d ===================== bool traitementFongicide2_maxBegStatePredicate (EntityMethod* pM) //--------------------------------------------- // Description : // Precondition : // Retour : //--------------------------------------------- { Entity* pInst = pM->DescribedEntity(); bool result = FALSE; // // récup date courante et jour julien courant // int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int jJulien = pTm->tm_yday; delete pTm; // // date au plus tard : 5 jours apres atteinte stade Floraison // Entity* pOOSpec = pInst->GetEntityVarValue(OPERATED_OBJECT_SPEC_ATTRIBUTE); pEntityTab* ooList = pOOSpec->GetEntityTabVarValue(PRE_EXPANDED_LIST); Entity* pParcelle = (Entity*)ooList->get_nth(0); Entity* pBle = pParcelle->GetEntityVarValue(COUVERT_VEGETAL); Entity* pAge = pBle->GetEntityConstValue(ATTRIBUT_AGE); int currentIndex = pAge->GetIntVarValue(CURRENT_ELEMENT_INDEX); if(currentIndex == FLORAISON) { pEntityTab* stageTab = pAge->GetEntityTabConstValue(TABLEAU_STADES); Entity* pStage = (Entity*)stageTab->get_nth(currentIndex); int jourAtteinte = pStage->GetIntConstValue(JOUR_JULIEN_QUAND_STADE_ATTEINT); int maxBegDate = jourAtteinte + 5; //printf("\nt = %d traitementFongicide2_MBS jour atteinte stade = %d", now, jourAtteinte); // // test : date au plus tard atteinte // if(jJulien >= maxBegDate) { result = TRUE; } } //printf("\nt = %d traitementFongicide2_MBS returns TRUE", now); return result; } //===================== § AXIII_E1.1.2d ===================== //===================== § AXIII_E1.2.1 ===================== Activity* pAct; pAct = new ApportAzote(); AddElement(pAct); //===================== § AXIII_E1.2.1 ===================== //===================== § AXIII_E2.1a ===================== bool iterationRecolteLuzerne_openingPredicate_Body(EntityMethod* pM) { //-------------------------------------------------------------------- // Doit renvoyer vrai pour que l'activite puisse etre ouverte. //-------------------------------------------------------------------- Entity* pE = pM->DescribedEntity(); bool result = FALSE; int now = pCurrentSim->Clock(); //printf("\nt = %d entree iterationRecolteLuzerne_OP sur '%s'", now, pInst->InstanceName()); // // récupération date du jour // tm* pTm = ClockValueToTm(now); int leMois = pTm->tm_mon; // JAN = 0 int lAnnee = pTm->tm_year; // 2000 -> 100 if(leMois > 6) { // AUG, etc lAnnee += 1; } // // début des coupes le 1er juin // pTm->tm_mon = 5; // JUN pTm->tm_mday = 1; pTm->tm_year = lAnnee; mktime(pTm); int seuilPourDebutCoupe = StructTmToClockValue(pTm); // // test : date début coupes atteinte ? // //printf("\nt = %d iterationRecolteLuzerne_OP seuilPourDebutCoupe = %d", now,seuilPourDebutCoupe); if(now >= seuilPourDebutCoupe) { result = TRUE; } //printf("\nt = %d iterationRecolteLuzerne_OP returns %d", now, result); return result; }; //===================== § AXIII_E2.1a ===================== //===================== § AXIII_E2.1b ===================== void iterationRecolteLuzerne_updateReactivatedSon_Body(EntityMethod* pM) { //------------------------------------------------------------------------ // Si les conditions d'une nouvelle mise en oeuvre de l'activite iteree // sont satisfaites, ce sera fait avec les proprietes qui lui sont donnees // dans cette fonction. //------------------------------------------------------------------------ Entity* pAct = pM->DescribedEntity(); Entity* pSon = pAct->GetElement(); // // ajout de X jours après le début de la coupe qui finit // X externalisé en paramètre // int begDateOfCurrent = pSon->GetIntVarValue(BEG_DATE); int delay = GetIntParameterValue("luzerne", "delaiRepousseApresCoupe") * 24;// en 1 HOUR int nextMinBeg = begDateOfCurrent + delay; // // affectation de la fenêtre de début de la coupe suivante // //printf("iterationRecolteLuzerne_update begDateOfCurrent = %d nextMinBeg = %d", begDateOfCurrent, nextMinBeg); pSon->SetIntValue(MAX_BEG_DATE, D_INTMAX); pSon->SetIntValue(MIN_BEG_DATE, nextMinBeg); }; //===================== § AXIII_E2.1b ===================== //===================== § AXIII_E2.1c ===================== Activity* pAct; pAct = new RecolteLuzerne(); AddElement(pAct); //===================== § AXIII_E2.1c ===================== //===================== § AXIII_E3.1 ===================== Activity* pAct; pAct = new Affouragement(); Activity* pOpt = new ActivityOptional(); pOpt->AddElement(pAct); pOpt->SetIntConstValue(IS_ONE_SHOT, 1); AddElement(pOpt); // --> iterate(optional(affouragement)) //===================== § AXIII_E3.1 ===================== //===================== § AXIV_E1.2 ===================== Entity* pOccurrenceDomain = new PluriOccupation(); Entity* pOccurrenceCrossDomain = new OccurrenceCrossDomain(); pOccurrenceCrossDomain->AddElement(pOccurrenceDomain); SetEntityConstValue(OCCURRENCE_CROSS_DOMAIN_ATTRIBUTE, pOccurrenceCrossDomain); //===================== § AXIV_E1.2 ===================== //===================== § AXIV_E2.2 ===================== bool agentMonoLocalise_holdingCondition_Body(EntityMethod* pM) { //-------------------------------------------------- // Methode d'une ActivityInconsistencyCondition (AIC), // ou d'une ResourceSharingViolationCondition (RSVC), // ou d'une ActivitiesResourcesInconsistentCommitment (ARIC. // Le corps examine l'etat du systeme et doit renvoyer vrai si et seulement si // l'etat justifie que la contrainte pE soit appliquee lors de l'allocation de // l'activite qui est la valeur de l'argument REFERENCEENTITY_ARGUMENT. // L'argument CANDIDATEENTITYTABVALUE_ARGUMENT est : // - cas AIC : un ensemble de ressources candidates a l'allocation. // - autres cas : NULL // L'argument CANDIDATEENTITYVALUE_ARGUMENT est : // - cas AIC : l'InstructionAllocation (structuve V) de l'activite // - cas RSVC : l'InstructionSetAllocation (structuve U) du jeu d'activites // - cas ARIC : NULL //-------------------------------------------------- Entity* pCte = pM->DescribedEntity(); bool result = FALSE; UserClassId constrainedId = pCte->GetIntVarValue(CONSTRAINED_ENTITY_CLASS_ID); // AGENT Entity* pInst = pM->GetEntityArgValue(REFERENCEENTITY_ARGUMENT); // semisBle_18 //printf("\nagentMonoLocalise_HC pour allocation de '%s'", pInst->InstanceName()); Entity* pU_alloc = pM->GetEntityArgValue(CANDIDATEENTITYVALUE_ARGUMENT); //printf("\npU_alloc : "); ((InstructionSetAllocation*)pU_alloc)->SpecialDisplay(); // // pU_alloc := ( pUI_0 ... pUI_n ) // resourceUsageItem operationUsageItem int nbUsageItems = pU_alloc->GetNumberOfElements(); for(int i=0;iGetElement(i); if(pUI_i->IsInstanceOf(RESOURCE_USAGE_ITEM)) { // only if // // pUI_i := (pRsc_i (pCEI_i_0 ... pCEI_i_n)) // paul // BasicEntity* pRsc_i = pUI_i->GetEntityConstValue(RESOURCE_USED); UserClassId id_i = pRsc_i->ClassSymbol(); //printf("\nid_%d = %s", i, ClassIdToCharTab[id_i]); int nbLoc = 0; if((id_i == constrainedId) || // on ne regarde que les pUI_i portant sur un AGENT IsAncestorOf(constrainedId, id_i)) { int nbCoengItems_i = pUI_i->GetNumberOfElements(); for(int j=0;jGetElement(j); // // pCEI_i_j := (classSymb_i_j (rsc_i_j_0,... rsc_i_j_n)) // RESOURCE // // pCEI_i_j := (classSymb_i_j (pOO_i_j_0,... pOO_i_j_n)) // OPERATED_OBJECT // monTroupeau parcelleBle // // pCEI_i_j := (classSymb_i_j (pOt_i_j_0)) // OPERATION // UserClassId classSymb_i_j = pCEI_i_j->GetIntVarValue(RESOURCE_ID); // if(IsAncestorOf(OPERATED_OBJECT, classSymb_i_j)) { // only if pEntityTab* pOOList = pCEI_i_j->GetEntityTabConstValue(RESOURCE_LIST); // // pOOList := (pOO_i_j_0,... pOO_i_j_n) // int nbRsc = pOOList->size(); for(int k=0;kget_element(k); BasicEntity* pRsc_k = pOO_i_j_k->GetEntityConstValue(RESOURCE_ENTITY); //printf("\ni = %d j = %d k = %d pRsc = '%s'", i, j, k, pRsc_k->InstanceName()); // // pRsc_k := monTroupeau // UserClassId pRscId_k = pRsc_k->ClassSymbol(); if((pRscId_k == TROUPEAU) || (pRscId_k == PARCELLE)) { nbLoc++; if(nbLoc > 1) { result_i = TRUE; break; // on arrete de parcourir les pOO_i_j_k } } } } if(result_i == TRUE) break; // on arrete de parcourir les pCEI_i_j } } } if(result_i == TRUE) { result = TRUE; break; // on arrete de parcourir les pUI_i } } //exit(0); //printf("\nagentMonoLocalise_HC returns %d", result); return result; }; //===================== § AXIV_E2.2 ===================== //===================== § AXIV_E3 ===================== BasicEntity* monManager_bestActivitySetSelector_Body(EntityMethod* pM) { //---------------------------------------------------------------------- // Choisit (et eventuellement modifie) le meilleur jeu d'activites // parmi des jeux vehicules par l'argument ACTIVITY_SETS_ARGUMENT. //---------------------------------------------------------------------- Entity* pManager = pM->DescribedEntity(); //printf("\n'%s'::bestActivitySetSelector(..)", pManager->InstanceName()); //Entity* pARB = pM->GetEntityArgValue(ACTIVITIES_RESOURCES_BLOCK_ARGUMENT); Entity* canditateSetsDisjunction = pM->GetEntityArgValue(ACTIVITY_SETS_ARGUMENT); //((InstructionSetDisjunction*)canditateSetsDisjunction)->SpecialDisplay(); BasicEntity* result = NULL; // ============================================================== // Reduction progressive de l'ensemble des alternatives, // par application de regles de priorites decroissantes. // Chaque regle doit donner une nouvelle valeur a currentResult. // ============================================================== InstructionSetDisjunction* currentResult = NULL; // // Regle 1 : priorite au jeu qui contient l'activite de plus forte priorite // ------------------------------------------------------------------------ Entity* pPS = pManager->GetSuperEntity(); OperatingSystem* pOS = (OperatingSystem*)pPS->GetComponent(OPERATING_SYSTEM); InstructionSetDisjunction* pISD = (InstructionSetDisjunction*)canditateSetsDisjunction; currentResult = pOS->SelectAlternativesOnMaxOperationPriority(pISD); // // Regle 2 : ........ // ------------------------------------------------------------------------ // ============================================================= // Apres l'application de toutes les regles, // on retourne aleatoirement un jeu parmi les restants ex-aequo // ============================================================= int nbSets = currentResult->GetNumberOfElements(); int randomIndex = RandomInteger(nbSets); result = currentResult->GetElement(randomIndex); //((InstructionSetConjunction*)result)->SpecialDisplay(); //printf("\nsortie '%s'::bestActivitySetSelector(..)", pManager->InstanceName()); return result; }; //===================== § AXIV_E3 ===================== //===================== § N2_E2.2.1a1 ===================== if(!strcmp(argv[i], "-f")) { gFileName_HeuresTravaillees = argv[i+1]; } //===================== § N2_E2.2.1a1 ===================== //===================== § N2_E2.2.1a2 ===================== if(!strcmp(argv[i], "-f")) { gFileName_HeuresTravaillees = argv[i+1]; } //===================== § N2_E2.2.1a2 ===================== printf("\n\t[-f ] : fichier de sortie des heures travaillees"); //===================== § N2_E2.2.1b ===================== // // Creation et ouverture du fichier de trace des heures travaillees // if(strlen(gFileName_HeuresTravaillees) > 0) { gFile_HeuresTravaillees = new OutputFile(gFileName_HeuresTravaillees, NEW); gFile_HeuresTravaillees->Open(); // // Ecriture de la ligne d'entete // fprintf(gFile_HeuresTravaillees->GetPhysicalFile(), "d m y h clock nbH_Trp nbH_Luz nbH_Ble\n"); // // Programmation du processus de trace // Event* pEv = new Event(); DiscreteProcess* pDP = new ProcessusMemorisationHeuresTravaillees(); Entity* pPS = pCurrentSim->SimulatedEntity(); Entity* pCS = pPS->GetComponent(CONTROLLED_SYSTEM); Entity* pEA = pCS->GetEntityConstValue(ATTACHED_ENTITY); pDP->ProcessedEntity(pEA); pEv->AddProcessAction(pDP, EXEC); pEv->IsAutoGenerate(TRUE); pEv->SetMinDelayNextEvent(24); pEv->SetMaxDelayNextEvent(24); int t = GetIntParameterValue("revisionDuPlan", "heureMatin") + 12; pEv->SetOccurrenceClockTime(t); pCurrentSim->InsertInAgendaEvents(pEv); } //===================== § N2_E2.2.1b ===================== //===================== § N2_E2.2.1c ===================== // // fermeture du fichier de trace des heures travaillees // if(gFile_HeuresTravaillees) { gFile_HeuresTravaillees->Close(); } // // désallocation des fichiers, enlevée du *.dir // DeleteFileInstances(); //===================== § N2_E2.2.1c ===================== //===================== § N2_E2.2.3 ===================== // -------------------------------------------------------- // tache 2) cumul des heures travaillees dans ce pas // dans les descripteurs a cet effet dans Exploitation // (seulement si un fichier a ete cree dans 'main') // -------------------------------------------------------- if(gFile_HeuresTravaillees) { Entity* pPS = pCurrentSim->SimulatedEntity(); Entity* pCS = pPS->GetComponent(CONTROLLED_SYSTEM); Entity* pEA = pCS->GetEntityConstValue(ATTACHED_ENTITY); UserClassId otId = pOt->ClassSymbol(); int qty = pOt->GetIntConstValue(STEP); Descriptor* pD; switch(otId) { case APPORTER_FOURRAGE : { pEA->IncreaseIntValue(NB_HEURES_APPORT_FOURRAGE, qty); break; } case COUPER_LUZERNE : { pEA->IncreaseIntValue(NB_HEURES_COUPE_LUZERNE, qty); break; } default : { if(IsAncestorOf(OPERATION_BLE, otId)) { pEA->IncreaseIntValue(NB_HEURES_OPERATION_BLE, qty); } else { printf("\npour inscription profil dans moniteur, classe d'operation non geree : %s\n", ClassIdToCharTab[otId]); exit(0); } } } } //===================== § N2_E2.2.3 ===================== //===================== § N2_E2.2.4 ===================== void processusMemorisationHeuresTravaillees_execProcess_Body(ProcessMethod* pM) //--------------------------------------------- // Definition de la fonction qui code l'execution du processus ponctuel. //--------------------------------------------- { DiscreteProcess* pDP = pM->DescribedDiscreteProcess(); Entity* pEA = pDP->ProcessedEntity(); // // Captage du cumul fait dans AchievementDegreeMonitor // int nbH_AF = pEA->GetIntVarValue(NB_HEURES_APPORT_FOURRAGE); int nbH_CL = pEA->GetIntVarValue(NB_HEURES_COUPE_LUZERNE); int nbH_OB = pEA->GetIntVarValue(NB_HEURES_OPERATION_BLE); int now = pCurrentSim->Clock(); tm* pTm = ClockValueToTm(now); int d = pTm->tm_mday; int m = pTm->tm_mon; int y = pTm->tm_year; int h = pTm->tm_hour; delete pTm; // // Le fichier est ouvert dans le prog. principal (main) // fprintf(gFile_HeuresTravaillees->GetPhysicalFile(), "%d %s %d %d %d %d %d %d\n", d, MonthToChar(m+1), y+1900, h, now, nbH_AF, nbH_CL, nbH_OB); // // RAZ pour nouveau cumul le lendemain // pEA->SetIntVarValue(NB_HEURES_APPORT_FOURRAGE, 0); pEA->SetIntVarValue(NB_HEURES_COUPE_LUZERNE, 0); pEA->SetIntVarValue(NB_HEURES_OPERATION_BLE, 0); }; //===================== § N2_E2.2.4 =====================