Annexe 1 : Diagramme UML de SisFRT.
Annexe 2 : Code de la nouvelle méthode de l’acquisition d’Azote.
Annexe 3 : Diagramme de GANT.
Annexe 2 : Code de la nouvelle méthode de l’acquisition d’Azote.
//====================================================// // toutTraite : // // regarde si toutes les especes de la map ont // // été traité // //====================================================//
bool Dieu::toutTraite(map<Vegetal *, pair <float,bool>> especeTraitee ) {
bool val =true;
for(map<Vegetal *, pair <float,bool>>::iterator it = especeTraitee.begin() ; it!=especeTraitee.end() ; ++it)
{
if(it->second.second == false) //si la racine de cette espece n'a pas été traitée
{
val = false; // alors on renvoie faux
break; } } return val; } //====================================================// // AquisitionsAzote : // // absorptions quotidiennes d'Azote par les racines // // modifications recentes: // // - changement de prise en compte du coef // // meteo // // - mise en place de limitation d'absoption // //====================================================//
OrganisedEvent * Dieu::acquisitionsAzote () {
stringstream commentRessources("");
commentRessources << "Acquisition d'Azote" << endl; GrilleTorique * grille = getGrille();
CelluleSisfrt * cell = NULL;
// map de stockage de l'Azote capté par talle
map<int,float> AzoteTotal; map<int,Talle *> lienVegetal;
float bin; int L = grille->getWidth(); int l = grille->getHeight(); int i,j; float qteDispo = 0; float qteUtilisee = 0; float capaciteAbsorptionTotale = 0;
float tailleCellule = CelluleSisfrt::GetLargeur() * CelluleSisfrt::GetLongueur();
float coefDisponibilite = getModele()->getMeteo()->getDisponibilite(getModele()->getJour());
float modifCoefTransfoAzote;
int OK; // variables de test
int supp;
float deltaAzote; // difference entre Azote dispo et le plus haut seuil d'Absorption
parmis les especes dans la cellule
float seuilMAx; // seuil absorption maximal ds la liste
float sommeCapaciteAbsorption;
float sommeCapaciteAbsorption2;
float deltaAzote2;
float res; //variable temporaire pour le calul de l'Azote
if (coefDisponibilite > 0) {
map<Vegetal *, float>::iterator racine, racineFin; map<Vegetal *, pair <float,bool>> listeTalle;
map<Vegetal *, pair <float,bool>>::iterator itListeTalle,itSeuilMax; // pour chaque cellule
for (i = 0; i < L; i++) {
for (j = 0; j < l; j++) {
bool aucun = true; cell = (*grille)(i,j);
qteDispo = cell->getAzote()->getQte(); capaciteAbsorptionTotale = 0;
//=================================================================//
//creation de la map (liste) des racines présentes dans la cellule //
//=================================================================//
for (racine = cell->getRacines()->begin(); racine != cell->getRacines()->end(); racine ++) {
pair <float,bool> pairTemp;
pairTemp.first = racine->second; //capamax
pairTemp.second = false; //valeur par defaut
listeTalle[racine->first] = pairTemp ; //creation de la map temporaire
}
//=================================================================//
// tant que toute les racines ne sont pas traitées, on recommence //
//=================================================================//
while ( toutTraite(listeTalle) == false ) {
//initialisation des variables
deltaAzote = 0; seuilMAx = 0; sommeCapaciteAbsorption = 0; sommeCapaciteAbsorption2 = 0; deltaAzote2 = 0; supp = 0; qteUtilisee = 0; //=====================================================================//
// calcul du seuil d'absorption max et de l'Azote dispo (delta Azote) //
//=====================================================================//
for(itListeTalle = listeTalle.begin() ; itListeTalle != listeTalle.end(); itListeTalle ++) {
if(itListeTalle->second.second == false) //si la racine n'a pas été traité
{
//si le seuil est inférieur à la qte d'Azote dispo
if(itListeTalle->first->getEspece()->getSeuilAzoteMin() < qteDispo ) {
if( itListeTalle->first->getEspece()->getSeuilAzoteMin() > seuilMAx ) {
// on passe au moins une fois ici par cellule (on a un seuil max par cellule)
aucun = false;
seuilMAx = itListeTalle->first->getEspece()->getSeuilAzoteMin(); itSeuilMax = itListeTalle;
}
sommeCapaciteAbsorption += itListeTalle->first->getEspece()->getTauxAquiAzote(); Talle * talle= dynamic_cast<Talle *>(itListeTalle->first);
//calcul de la quantite maximale absorbable par la talle
float Section = talle->getPhenotype()->getDiametre();
float Capamax = itListeTalle->first->getEspece()->getCoefCapaReserveAzote() * max( itListeTalle->first->getEspece()->getAgeCapaMaxAzote() ,talle->getNbPhyllochrone() )*Section ; itListeTalle->second.first = Capamax;
} else
{ //si le seuil est supérieur à la qte d'Azote dispo, on le traite pas
itListeTalle->second.second = true; }
} }
//==========================================================================================// // si on a au moins une racine avec un seuil max(et donc au moins une racine à traiter) // // augmente la vitesse de calcul si une cellule n'a pas assez d'Azote, même pour une racine // //==========================================================================================//
if(aucun == false) {
deltaAzote = qteDispo - seuilMAx ;
// fonction des densités de chacune x leur potentiel d’absorption, et du temps thermique écoulé)
sommeCapaciteAbsorption *= (temperature * tailleCellule); do
{
OK = 0;
itListeTalle = listeTalle.begin();
//=================================================//
// tant qu'on a pas listé toute la map d'espece //
//=================================================//
while ( itListeTalle != listeTalle.end() ) {
//si la racine n'a pas encore été traitée
if(itListeTalle->second.second == false) {
res = deltaAzote * itListeTalle->first->getEspece()- >getTauxAquiAzote()/sommeCapaciteAbsorption;
// si on est dans le cas où l'Azote absorbé est superieur à l'absorption max
if( (itListeTalle->first->getAzoteReserve() + itListeTalle->first->getAzoteTemp() + res) >= itListeTalle->second.first)
{
//on sauvegarde au passage le prochain delta et la prochaine capacité d'aborption
if((itListeTalle->first->getAzoteReserve() + itListeTalle->first->getAzoteTemp() + res) != itListeTalle->second.first)
{
sommeCapaciteAbsorption2 += itListeTalle->first->getEspece()->getTauxAquiAzote(); }
//calcul ce qu'il reste en Azote pour cette couche et le sauvegarde pour le prochain tour de boucle
deltaAzote2 += itListeTalle->first->getAzoteReserve() + itListeTalle->first- >getAzoteTemp() + res - itListeTalle->second.first ;
// on a au moins une espece qui a atteind son absorption max
OK = 1;
// mise a jour de la quantité d'Azote dispo si on supprime une racine de la liste
qteDispo = qteDispo + (itListeTalle->first->getAzoteReserve() + itListeTalle- >first->getAzoteTemp()) - itListeTalle->second.first ;
//on ajoute la maximum d'Azote pour atteindre l'absorption max en Azote
//qtedispo = qtedispo - (la différence entre l'absorption max et la qté déja absorbée)
itListeTalle->first->addAzote( res - deltaAzote2 ); cell->getAzote()->utiliser( res - deltaAzote2 ); if( itListeTalle == itSeuilMax)
{
supp = 1; // on interdit la suppression ultérieure de cet élément
}
itListeTalle->second.second = true; //on supprime cette espece de la liste
} else
{
qteDispo =qteDispo - res;
itListeTalle->first->addAzote(res); // on ajoute de l'Azote pour cette racine
cell->getAzote()->utiliser(res); // on retire l'Azote absorbé de la cellule
} }
itListeTalle++; //on avance dans la liste
}
sommeCapaciteAbsorption = sommeCapaciteAbsorption2; // on réinitialise pour le prochain tour de boucle
deltaAzote = deltaAzote2; sommeCapaciteAbsorption2 = 0; deltaAzote2 = 0;
} while (OK == 1); // on a au moins une racine qui a atteind son absorption max donc on recommence
if (supp == 0) {
//on supprime cette espece de la liste et on incremente espece
itSeuilMax->second.second = true; }
}
}// fin while touttraite
//==========================================================================================// // on met les quantité absorbé dans une map pour l'écrire plus tard dans le journal // //==========================================================================================//
for(itListeTalle = listeTalle.begin() ; itListeTalle != listeTalle.end(); itListeTalle ++) {
Talle * talle= dynamic_cast<Talle *>(itListeTalle->first);
if (talle && (i == (int) (talle->getX() / CelluleSisfrt::GetLargeur())) && (j == (int) (talle->getY()/CelluleSisfrt::GetLongueur())))
{
commentRessources << "\t\tquantite acquise par la talle " << talle->getId() << " sur la case " << i << " " << j << " : " << qteUtilisee << endl;
commentRessources << "\t\tdensité restant sur la case : " << (cell->getAzote()- >getQte()/tailleCellule) << endl << endl;
}
// Azote absorbé par talles
bin = AzoteTotal[talle->getId()]; AzoteTotal[talle->getId()] += qteUtilisee; lienVegetal[talle->getId()] = talle; }
}// fin grande boucle for j
}// fin grande boucle for i
}//fin if coef dispo
//===================================//
// on écrit dans le journal //
//===================================//
commentRessources << "\t\t##### quantite totales par talles jour " << getModele()- >getJour() << endl;
for ( map<int,float>::iterator it = AzoteTotal.begin() ; it != AzoteTotal.end() ; ++ it ) {
commentRessources << "\t\t$Azote$\ttalle " << it->first << " absorbe " << it->second << " d'Azote";
commentRessources << " : reserv_temp( pas de taxe ) = " << lienVegetal[it->first]- >getAzoteTemp() << endl;
}
getModele()->getJournal()->write(commentRessources.str(), Journal::Ressources_);
return NULL;