Projet

informatique
LENERGIE SOLAIRE

Table des matires

Introduction ..................................................................................................................................................................................3
Dcoupage fonctionnel du projet ..........................................................................................................................................3
Etude des fonctions de saisie ..................................................................................................................................................3
Travail du 1er groupe .................................................................................................................................................................4
Travail du 2me groupe............................................................................................................................................................ 10
Etude des fonctions de conversion .................................................................................................................................... 12
Travail du 3me groupe .......................................................................................................................................................... 13
Travail du 4me groupe............................................................................................................................................................ 17
Etude des fonctions de calcul .............................................................................................................................................. 20
Travail du 5me groupe............................................................................................................................................................ 21
Travail du 6me groupe............................................................................................................................................................ 23
Fonctions de prsentation du programme et daffichage des rsultats .............................................................. 26
Etude du programme principal........................................................................................................................................... 27
Exportation des rsultats sous forme de tableaux de donnes .............................................................................. 30
Conception .................................................................................................................................................................................. 30
Conclusion du projet ............................................................................................................................................................... 33
Annexe .......................................................................................................................................................................................... 34

Introduction
Lnergie solaire est une nergie renouvelable, mais malheureusement souvent peu rentable car base sur un grand
nombre de paramtres lis la fois aux conditions temporelles (date, heure) et mtorologiques (temps, humidit,
altitude...) ainsi que gographiques (latitude, longitude, inclinaison, orientation).
De plus, le panneau photovoltaque lui-mme possde un rendement faible (moins de 20% en gnral). Il est donc
difficile dobtenir de bonnes conditions de production dlectricit partir dnergie solaire.
Cependant, des calculs peuvent tre effectus en fonction de ces diffrents paramtres pour obtenir une production
optimale, notamment laide de loutil informatique. Le but de ce projet est justement de concevoir un programme
capable de prvoir partir de diffrents paramtres dentre le rayonnement solaire reu par un panneau. Pour
cela, on se placera dans le cas dun temps ensoleill.

Dcoupage fonctionnel du projet

La prise en compte dun grand nombre de paramtres pour cette dtermination implique un nombre important de
saisie dinformations de lutilisateur, puis de calculs utilisant les valeurs entres. Il faudra ventuellement convertir
certaines de ces informations, soit parce quelles sont plus parlantes sous une certaine forme pour lutilisateur et
quelles ne sont pas ncessairement sous la mme forme pour les calculs, soit parce que les valeurs utilises pour les
calculs sont inconnues de lutilisateur. Par exemple, lutilisateur est capable dentrer lheure lgale au moment de la
saisie, mais probablement pas lheure solaire vraie qui lui correspond.
Il sera galement ncessaire de communiquer lutilisateur la fonction du programme, ainsi que le rsultat (le
rayonnement solaire global) de manire parlante, et ventuellement en rcapitulant lensemble de ses saisies.

Etude des fonctions de saisie

Ltude de la mthode de calcul fournie par le document technique a abouti une liste de saisies par lutilisateur
ncessaires, qui sont les suivantes (de la manire la plus parlante possible pour lutilisateur) :

La date (sous la forme jj / mm/ aaaa)

Lheure lgale (sous la forme hh : mm : ss)
La latitude Nord et la longitude Est sous forme sexagsimale (degrs, minutes secondes dd : mm : ss)
Linclinaison et lorientation du panneau (en degrs)
Laltitude du lieu considr (en mtres)
La temprature (en C)
Le milieu auquel appartient le lieu considr (montagnard, rural, urbain ou industriel)
Le taux dhumidit en %

Pour cela, il tait utile de dclarer de nouveaux types (types composs) permettant de stocker les informations plus
facilement
Dabord, un type date compos de 3 entiers (jour, mois et anne) qui permettra de stocker la date entre par
lutilisateur
struct date
{
int j;
int m;
int a;
};

Un type heure compos de 3 entiers (heures, minutes, secondes) qui permettra de stocker lheure lgale entre par
lutilisateur
struct heure
{
int h;
int m;
int s;
};

Un type coordonnee compos de 3 entiers (degrs, minutes, secondes), qui permettra de stocker les valeurs
sexagsimales de latitude EST et de longitude NORD saisies par lutilisateur
struct coordonnee
{
int d;
int m;
int s;
};

Un type situation compos de 2 rels, qui contiendra la latitude et la longitude dcimales une fois converties
struct situation
{
float la;
float lo;
};

Deux groupes de travail se sont chargs de ces fonctions de saisie, cest--dire la fois assurer le respect des
conditions de saisie et parfois modifier la forme des informations reues.

Travail du 1er groupe

Membres du groupe :
- Clment Fayolle
- Antoine Peyrard
- Romain Velu
- Charles Gadeceau
Responsable : Corentin Faure
1re fonction : saisie de la date
Saisie_date : la fonction (vide) 1 date
R : Demande lutilisateur de saisir une date valide (dans le cas contraire, le programme doit redemander la date
jusqu ce quelle soit valide, en tenant compte des annes bissextiles)
E : vide
S : 1 date (type dclarer, compos de 3 champs : 3 entiers (jour, mois et anne sous la forme jj mm aaaa))
Le type compos permet dans ce cas de retourner les trois informations relatives la date en une seule
fonction.
On utilise une boucle do while qui redemandera de nouvelles valeurs pour le jour le mois et lanne tant que celleci seront incorrectes (quelles ne rpondront pas aux conditions nonc prcdemment).
Pour cette fonction les tests suivants ont t raliss : on compare si le jour le mois et lanne ne sont pas ngatifs
ou nuls, ou suprieurs leur valeur habituelle, on vrifie ensuite que le jour entr existe en prenant compte des
mois 30 ou 31 jours, et des annes bissextile concernant fvrier (pour savoir si lon a 28 ou 29 jours)

do {
cout << "Saisir un jour sous la forme jj :
";
cin >> j1;
cout << "Saisir un mois sous la forme mm :
";
cin >> m1;
cout << "Saisir une annee sour la forme aaaa : ";
cin >> a1;

On effectuera cette demande ainsi que toutes les vrifications suivantes tant que la saisie est mauvaise. Cest-dire :
Premirement, on vrifie si le mois entr est infrieur ou gal 12 :
if (m1 <= 12)

Dans ce cas, on initalise le boolen erreur false. Il passera true ds que la saisie sera incorrecte :
erreur = false;

Si le jour, mois ou anne est ngatif

if (m1 <= 0 || j1 <= 0)
{
erreur = true;
cout << "Date entree incorrecte" << endl << endl;
}

On limine tous les cas o la saisie est correcte sauf pour le mois de fvrier
else
{
if (!(m1
j1 <= 31
10 && j1
m1 == 06
30))

==
||
<=
&&

01
m1
31
j1

&&
==
||
<=

j1
07
m1
30

<=
&&
==
||

31
j1
12
m1

||
<=
&&
==

m1 == 03 && j1 <= 31 || m1 == 05 &&

31 || m1 == 8 && j1 <= 31 || m1 ==
j1 <= 31 || m1 == 04 && j1 <= 30 ||
9 && j1 <= 30 || m1 == 11 && j1 <=

Ensuite, on regarde si lanne nest pas bissextile. Dans ce cas, le jour associ fvrier ne doit pas tre suprieur
28. (Pour savoir si lanne est bissextile, on utilise une fonction cre par le groupe 3 que lon dtaillera ensuite)
{
if (!(est_bissextile(a1)))
{
if (j1 > 28)
{
erreur = true;
cout << "Date entree incorrecte"
<< endl<< endl;
}
}

Dans le cas contraire (lanne est bissextile), le jour ne doit pas tre suprieur 29.
else
{

if (j1 > 29
{
erreur = true;
cout << "Date entree incorrecte" << endl << endl;
}
}
}
}
}

Enfin, on prcise que lorsque la condition de dpart (mois infrieur 12) nest pas vrifie, le boolen passe
videmment true.
else
{
erreur = true;
cout << "Date entree incorrecte" << endl << endl;
}

On effectuera donc toutes les saisies et vrifications tant que les 3 donnes entres par lutilisateur seront
incorrectes :
} while (erreur == true);

Nb : il ny a pas de contrainte de saisie pour lanne (peut tre positive, ngative ou nulle)
Enfin, on affecte les diffrentes saisies la variable de type date que lon retourne ensuite.
dateprojet.j = j1;
dateprojet.m = m1;
dateprojet.a = a1;
return dateprojet;
}

En rouge : les valeurs fausses (pour les 2 dernires saisies, le 29/2/2015 nexiste pas car 2015 nest pas une anne
bissextile, et le 29/2/2016 existe car 2016 est une anne bissextile).

2me fonction : saisie de lheure lgale

Saisie_heure : la fonction (vide) 1 heure
R : Demande lutilisateur de saisir une heure lgale valide (dans le cas contraire, le programme doit redemander
lheure jusqu ce quelle soit valide)
E : vide
S : 1 heure (type dclarer, compos de 3 champs : 3 entiers (heures, minutes, secondes))
Pour cette fonction on vrifie que les couples heures/minutes/secondes saisie sont bien composs dheures
positives et strictement infrieur 24, pour les minutes nous avons vrifi quelles soient bien positives et
infrieures strictement 60 (ce qui reprsenterait une heure), et pour finir on rdite la mme opration pour les
secondes (de la mme faon que pour les minutes, car 60 secondes reprsenteraient une minute).
while (time.h < 0 || time.h > 23 || time.m < 0 || time.m > 59 || time.s < 0 || time.s > 59) {
cout << "Les heures, minutes ou secondes que vous avez entrees ne sont pas
valides, ressaisissez les : " << endl;
cin >> time.h;
cin >> time.m;
cin >> time.s;
}
return time;
}

On utilise une boucle while qui va afficher un message derreur et saisir une nouvelle valeur sous la forme heure
minutes secondes tant que les conditions ne seront pas respectes.
On utilise le type compos heure pour pouvoir retourner les trois saisies heures, minutes et secondes dans la mme
fonction.

3me fonction : saisie de la latitude NORD

Saisie_latitude : la fonction (vide) 1 coordonne
R : Demande lutilisateur de saisir une latitude Nord en degrs sexagsimaux valide (dans le cas contraire, le
programme doit redemander la latitude jusqu ce quelle soit valide)
E : vide
S : 1 coordonne (type compos des degrs, des minutes et des secondes (3 entiers))
On effectue des tests pour vrifier que les valeurs saisies par lutilisateur sont correctes. On vrifie donc que la partie
degrs de la latitude est bien comprise entre -90 et 90 degrs qui sont extremums atteignables. (voir figure)

while (lati.d > 90 || lati.d < -90 || lati.m <

lati.s > 59 || ((lati.d==90 || lati.d==-90) &&
{
cout << " La valeur que vous avez entre
secondes n'est pas valide. Veuillez les
cin >> lati.d;
cin >> lati.m;
cin >> lati.s;
}
return lati;

0 || lati.m > 59 || lati.s < 0 ||

(lati.m!=0 || lati.s!=0))
pour les degres, les minutes ou les
entrer a nouveau : " << endl;

On vrifie que les degrs sont bien compris entre -90 et +90, les minutes et secondes entre 0 et 59. Enfin, du fait de
la forme sexagsimale, lorsquon entre -90 ou +90, il faut que les champs minutes et secondes soient nuls, sinon on
dpasse -90 ou 90 degrs.
Le type compos coordonnee permet de retourner les trois informations sexagsimales relatives la latitude
(degrs, minutes, secondes) en une seule fonction.

4me fonction : saisie de la longitude EST

Saisie_longitude : la fonction (vide) 1 coordonne

R : Demande lutilisateur de saisir une longitude Est en degrs sexagsimaux valide (dans le cas contraire, le
programme doit redemander la longitude jusqu ce quelle soit valide)
E : vide
S : 1 coordonne (type compos des degrs, des minutes et des secondes (3 entiers))
Les tests effectus pour la fonction sont semblables ceux de celle de la latitude, lexception prs que la longitude
est, elle, comprise entre -180 et 180 degrs.

while (lng.d < -180 || lng.d > 180 || lng.m < 0 || lng.m > 59 || lng.s < 0 || lng.s >
59 || ((lng.d==180 || lng.d==-180) && (lng.m!=0 || lng.s!=0)) )
{
cout << " La valeur que vous avez entre pour les degres, les minutes ou les
secondes n'est pas valide. Veuillez les entrer a nouveau : " << endl;
cin >> lng.d;
cin >> lng.m;
cin >> lng.s;
}
return lng;

Le type compos coordonnee permet encore une fois de stocker des donnes sexagsimales et de les retourner en
une seule fonction (ici, pour les donnes de longitude).

5me fonction : saisie de linclinaison du panneau

Saisie_inclinaison : la fonction (vide) 1 rel

R : Demande lutilisateur de saisir une inclinaison en degrs dcimaux du panneau valide (dans le cas contraire, le
programme doit redemander linclinaison jusqu ce quelle soit valide)
E : vide
S : 1 rel (linclinaison du panneau en degrs)

while (incli > 90 || incli < 0)

{
cout << "Votre inclinaison n'est pas comprise entre 0 et +90 degres, ressaisissez la : " <<
endl;
cin >> incli;
}
return incli;

Linclinaison du panneau doit tre comprise entre 0 et 90 degrs, do le test effectu prcdemment dans la boucle
while.

Travail du 2me groupe

Membres du groupe :
- Hugo Morais-Costa
- Nicolas Galley
- Amine Khalis (dmission)

1re fonction : saisie de lorientation du panneau

Saisie_orientation : la fonction (vide) 1 rel
R : Demande lutilisateur de saisir une orientation en degrs dcimaux du panneau valide (dans le cas contraire, le
programme doit redemander lorientation jusqu ce quelle soit valide)
E : videS : 1 rel (lorientation en degrs)
La fonction Saisie_orientation permet de demander un utilisateur de saisir une orientation valable et
retourne la valeur de cette dernire l'algorithme principal si elle est valable. Afin de vrifier la fiabilit de la valeur
saisie, une boucle Tant que redemande l'utilisateur de saisir une orientation valable tant qu'elle n'est pas
comprise entre -180 et 180 degrs dcimaux.
while (orient > 180 || orient <= -180)
{
cout<<"Votre orientation n'est pas comprise entre -180 et +180 degres,
ressaisissez la : " << endl;
cin>>orient;
}

2me fonction : saisie de laltitude du lieu

Saisie_alt : la fonction (vide) 1 rel
R : Demande lutilisateur de saisir une altitude en mtres valide (dans le cas contraire, le programme doit
redemander laltitude jusqu ce quelle soit valide)
E : vide
S : 1 rel (laltitude)
La fonction Saisie_alt sert demander l'utilisateur de rentrer l'altitude voulue et vrifie si elle est valable par
l'intermdiaire d'une boucle Tant que . Si c'est le cas elle l'envoie l'algorithme principal. Sinon elle signale
l'erreur l'utilisateur et demande une nouvelle valeur l'utilisateur qui est vrifie de la mme manire. Nous avons
pris comme valeurs extrmes -422 mtres (Niveau de la mer morte, soit le plus bas) et 8848 mtres (Niveau de
l'Everest, soit le plus haut)
while (alt>8848 || alt<-422)
{
cout<< "Erreur: "<<alt<<" n'est pas une altitude valable, saisir une altitude
valable."<<endl;
cin>>alt;
}

10

3me fonction : saisie de la temprature

Saisie_temperature : la fonction (vide) 1 rel
R : Demande lutilisateur de saisir une temprature en C rationnelle (si elle ne lest pas, le programme doit
redemander la temprature jusqu ce quelle le soit)
E : vide
S : 1 rel (la temprature)
La fonction Saisie_temperature a pour but de permettre l'utilisateur d'entrer la temprature choisie,
ncessaire lexcution des calculs ultrieurs. L'algorithme de la fonction prcise l'utilisateur d'entrer une
temprature en degrs Celsius, et rationnelle (On considre qu'une temprature est rationnelle si elle est comprise
entre -70 et 70C). L'algorithme de la fonction comporte une boucle Tant que qui vrifie cette condition, afin
d'viter une erreur de saisie menant une temprature invraisemblable.
while (temp<-70 || temp>70
{
cout<<"Erreur,la temperature doit etre en degre celsius et rationnelle. Veuillez
recommencer"<<endl;
cin>>temp;
}

4me fonction : saisie du milieu

Saisie_coef : la fonction (vide) 1 rel
R : Demande lutilisateur de saisir un milieu (1 : rural, 2 : montagnard, 3 : urbain ou 4 : industriel) et redemande de
saisir ce milieu tant quil na pas saisi un de ces 4, puis selon le milieu saisi retourne le bon coefficient de trouble
atmosphrique
E : vide
S : 1 chane de caractres (le milieu)
La fonction Saisie_milieu permet l'utilisateur de saisir un milieu parmi les suivant:
-Montagnard : dans ce cas on retournera 0.01
-Rural : dans ce cas on retournera 0.05
-Urbain : dans ce cas on retournera 0.1
-Industriel : dans ce cas on retournera 0.2
La valeur correspond au coefficient de trouble atmosphrique (li la pollution), qui servira pour des calculs
ultrieurs.
Selon le milieu choisi, la fonction retourne le coefficient de trouble atmosphrique relatif ce dernier, ncessaire
des calculs ultrieurs. Une boucle Tant que permet de redemander l'utilisateur de choisir un des 4 milieux tant
qu'il ne le fait pas correctement, c'est dire tant qu'il ne rentre pas un numro correspondant un de ces milieux.
while (choix!=1 && choix!=2 && choix!=3 && choix!=4)
{
cout<<"Erreur dans la saisie du milieu choisi, veuillez saisir un chiffre
adequat"<<endl;
cin>>(choix);
}
switch (choix)
{case 1: coeff=0.02;
break;

11

case 2: coeff=0.05;
break;
case 3: coeff=0.1;
break;
case 4: coeff=0.2;
break;
}

5me fonction : saisie du taux dhumidit

Saisie_hum : la fonction (vide)1 rel
R : Demande lutilisateur de saisir un taux dhumidit relative en % valide (dans le cas contraire, le programme doit
redemander le taux jusqu ce quil soit valide), le convertit en taux pour 1 (entre 0 et 1) et le retourne
E : vide
S : 1 rel (le taux dhumidit relative (ex : 0,3))
La fonction Saisie_hum demande l'utilisateur de rentrer la valeur du taux d'humidit (en %) prsent dans le
milieu qu'il a choisi. Si ce dernier ne rentre pas une valeur correcte, c'est dire non comprise entre 0% et 100% alors
une boucle Tant que permet de lui demander de saisir de nouveau cette valeur. Lorsque la valeur est correcte, la
fonction la convertit sous forme dcimale et la retourne l'algorithme global.
while (h<0 || h>100)
{
cout<<"Erreur, veuillez saisir un taux en pourcentage correct"<<endl;
cin>>h;
}

Etude des fonctions de conversion

Aprs avoir garanti une saisie optimale des diffrentes informations par lutilisateur, il est ncessaire de convertir
certaines de ces saisies dans le but de traiter ces informations dans des calculs.
Tout dabord, les heures telles quelles ont t saisies ne sont pas directement interprtables car sous forme
compose (heures, minutes, secondes) : il faut donc les convertir en heures dcimales.
Cest aussi le cas de la saisie de la date : il faudra associer par exemple la date 15/02/2014 le rang du jour dans
lanne (dans ce cas, 31+15=46). Pour cela, il sera important de savoir si lanne est bissextile.
On fait de mme pour les coordonnes sexagsimales de la latitude et la longitude : on doit passer en coordonnes
dcimales pour les calculs.
Il faudra aussi pour des raisons pratiques, qui seront voques pour la partie concernant les calculs, pouvoir
convertir un angle en degrs en radians, et inversement.
Pour viter des calculs superflus par la suite, on dterminera galement si lheure solaire dtude est comprise dans
lintervalle entre lheure de lever et lheure de coucher du soleil.
Ces diffrentes tches ont t confies aux groupes de travail n3 et 4.

12

Travail du 3me groupe

Membres du groupe :
- Alexis Chaudier
- Bastien Chabal
- Mohamed Oudouni
Responsable : Louis Poy-Tardieu

1re fonction : conversion de lheure compose en heure dcimale

Heures_decimales : la fonction (h : 1 heure) 1 rel
R : Calcule le temps en heures correspondant une heure sous la forme heures, minutes, secondes
E : 1 heure (type compos des heures, des minutes et des secondes (3 entiers))
S : 1 rel
Pour pouvoir calculer l'heure sous forme dcimale il faut tout d'abord diviser le champ reprsentant les secondes
par 3600, puis on divise champ reprsentant les minutes par 60.
Enfin on additionne le type compos reprsentant les heures au rsultat des deux premires oprations et on
obtient une heure dcimale.
h1=(1.0/60)*h.m;
h2=(1.0/3600)*h.s;
htot=h.h+h1+h2;
return htot;

2me fonction : conversion de la latitude et de la longitude sexagsimales en deux valeurs dcimales

Situation_geo : la fonction (la : 1 latitude, lo : 1 longitude) 1 situation
R : Calcule partir de la latitude Nord et de la longitude Est sexagsimales leur quivalent respectif en degrs
dcimaux, les stocke sous une variable de type situation et la retourne
E : 2 coordonnes (type compos des degrs, minutes, secondes, pour la latitude Nord et la longitude Est ()
S : 1 situation (type compos de la latitude (1rel) et de la longitude (1rel) du lieu en degrs dcimaux
La conversion des degrs sexagsimaux en degrs dcimaux consiste : additionner la partie minute de la division
relle des minutes par 60 et des secondes par 3600.
Pour effectuer les conversions il a fallu crer 2 variables locales.
situ.la, de type rel permettant daccder la conversion en degrs sexagsimaux de la latitude Nord.
situ.lo, elle aussi de type rel permettant daccder la conversion en degrs sexagsimaux de la
longitude Est.
Ces deux conversions constituent le type compos de la situation gographique.
situ.la = latin.d + (latin.m / 60.0) + (latin.s / 3600.0);
situ.lo = longie.d + (longie.m / 60.0) + (longie.s / 3600.0);

13

return situ;

3me et 4me fonction : conversion dun angle en degrs en radians et inversement

Deg2Rad : la fonction (aD : 1 rel) 1 rel
R : Convertit un angle en degrs en radians
E : 1 rel (angle en degrs)
S : 1 rel (angle en radians)
Rad2Deg : la fonction (aR : 1 rel) 1 rel
R : Convertit un angle en degrs en radians
E : 1 rel (angle en degrs)
S : 1 rel (angle en radians)
Ces fonctions ne prsentent pas de difficults, elles consistent simplement en une dclaration dune
constante de conversion et dun calcul intermdiaire avant de renvoyer la valeur en radians ou en degrs.
rad=(deg*PI)/180;
return rad;
deg=rad*(180/PI);
return deg;

Rsultat du calcul pour la conversion de degrs vers radians :

5me fonction : dtermination des heures de lever et de coucher du soleil, et vrification par rapport
lheure solaire considre
Lever_coucher : la fonction (la : 1 rel, dec : 1 rel, h : 1 rel) 1 boolen
R : Calcule partir de la latitude Nord et de la dclinaison les heures de lever et de coucher de soleil, renvoie VRAI si
lheure saisie par lutilisateur est dans cet intervalle et FAUX sinon
E : 3 rels (la latitude et la dclinaison en degrs dcimaux et lheure en heures dcimales)
S : 1 boolen
Pour effectuer les calculs de cette fonction, il fallait incorporer math.h dans le .cpp. En effet, nous
devions avoir accs aux fonctions tangentes et arccosinus pour calculer les heures de lever et de coucher du
soleil. Cela constituait le seul vrai problme de la fonction. Le reste ne consistait quen lutilisation de Si et de
variable boolenne. On retourne finalement la variable res correspondant ltat de lheure solaire vraie
entre par lutilisateur : Soit lintrieur de lintervalle, soit lextrieur. Du fait que les fonctions
trigonomtriques travaillent en radians dans le module math.h , il fallait prendre en compte le fait que la
fonction tangente prend des radians en entre et arcosinus donne des radians en sortie, do lutilit des
deux fonctions Deg2Rad et Rad2Deg. La dclinaison est une quantit dont la mthode de calcul sera dtaille
dans la partie calcul .

14

h_lever = 12 - (Rad2deg (acos (-tan (Deg2rad (la)) * tan (Deg2rad (dec)))))/15;

h_coucher = 12 + (Rad2deg (acos (-tan (Deg2rad (la)) *tan (Deg2rad(dec)))))/15;
if (h_lever < h && h_coucher > h)
{
res = true;
}
else
{
res = false;
}
return res;

Ci-contre, vous pouvez observer le droulement de la fonction.

On entre dans ce cas des valeurs telles quon sait que lheure sera comprise dans lintervalle et donc le
boolen sera VRAI. (remarquons que lorsquon souhaite afficher la valeur dun boolen en C++, la fonction
cout affiche 0 ou 1 selon si sa valeur est false ou true)

6me fonction : dtermination du caractre bissextile dune anne

est_bissextile : la fonction (a : 1 entier) 1 boolen
R : Retourne VRAI si l'anne passe en paramtre est bissextile et FAUX sinon
E : l'anne considre (1 entier)
S : VRAI ou FAUX selon l'anne
Cette fonction a dj t vue auparavant dans le chapitre sur les structures conditionnelles du cours dinfo1. Cet
arbre dimbrication des si repose sur le fait quune anne bissextile doit tre divisible par 4. Si celle-ci est
sculaire, on doit galement vrifier si elle est divisible par 400 et pas par 4000.
if(r4!=0)
{
res=false;
}
else
{
if(r100!=0)
{
res=true;
}
else
{
if(r400==0 && r4000!=0)
{
res=true;
}
else
{
res=false;
}
}
}
return res;

15

7me fonction : calcul du rang du jour associ une date

La fonction pour rle de renvoyer le nombre entier correspondant la date passe en paramtres, en tenant compte
des annes bissextiles.
Tout dabord, on vrifie si lanne est bissextile ou non. (Fonction dj vue prcdemment)
Si lanne est bissextile, un boolen passe VRAI. Sinon, il est FAUX.
On observe ensuite deux conditions :
- Si le boolen est vrai, alors fvrier comptera 29 jours.
- Si il est faux, alors fvrier comptera 28 jours.
res = est_bissextile(d.a);

Aprs avoir trait lanne, le calcul de lentier renvoyer est diffrent selon le mois. On utilise donc la
fonction SELON.
Si le mois est gal 1, janvier, alors lentier correspond au nombre de jours, car janvier et le premier mois
de lanne.
Si le mois est gal 2, fvrier, alors lentier correspond au nombre de jours, plus le nombre de jours que
contient janvier. (soit 31+j)

switch(d.m)
{
case 1: jour=d.j;
break;
case 2: jour=31+d.j;
break;
case 3: jour=31+28+d.j;
break;
case 4: jour=31+28+31+d.j;
break;
case 5: jour=31+28+31+30+d.j;
break;
case 6: jour=31+28+31+30+31+d.j;
break;
case 7: jour=31+28+31+30+31+30+d.j;
break;
case 8: jour=31+28+31+30+31+30+31+d.j;
break;
case 9: jour=31+28+31+30+31+30+31+31+d.j;
break;
case 10: jour=31+28+31+30+31+30+31+31+30+d.j;
break;
case 11: jour=31+28+31+30+31+30+31+31+30+31+d.j;
break;
case 12: jour=31+28+31+30+31+30+31+31+30+31+30+d.j;
break;
default: cout<<"Erreur de saisie"<<endl;
}

Le boolen intervient partir du mois 3 (mars), car il change le nombre de jours que contient fvrier. On
ajoutera alors 28 ou 29. Le systme est le mme pour tous les mois suivants, on prend le nombre de jours pass en
paramtre (dans le type compos de la date), et on y ajoute le nombre de jours que contiennent les mois
prcdents.
if(res==true)
{
if(d.m>=3)
{
jour=jour+1;

16

}
}

La fonction retourne finalement lentier correspondant au nombre de jours.

Travail du 4me groupe

Membres :
- Charles Silvestre
- Damien Ciprelli
Responsable : Tho Basty
Afin de calculer lensoleillement, il est ncessaire de calculer lheure solaire correspondante lheure lgale choisie
par lutilisateur.

Pour cela il a fallu crer la fonction heure_solaire_vraie :

Heure_solaire_vraie : la fonction (lon : 1 rel, heure_dec : 1 rel, date : 1 date) 1 rel
R : Calcule partir de la longitude en degrs dcimaux, de lheure lgale en heures dcimales (ex : 1,23 h et pas 1h
20min 5s) et de la date (pour connatre si cest lheure dhiver ou lheure dt, sachant que les dates de passage
heure dhiver/t et t/hiver varient selon lanne considre), lheure solaire vraie (en heures dcimales galement)
Ps : on considre quon utilise le systme heure dt / heure dhiver franais
E : 2 rels (longitude en degrs dcimaux et heure lgale en heures dcimales), 1 date (type compos de 3 entiers :
jour (jj), mois (mm) et anne (aaaa))
S : 1 rel (heure solaire vraie)
Lheure solaire se calcule en soustrayant diffrents lments lheure lgale, calculs chacun laide dune sousfonction :

Le fuseau horaire qui peut tre soustrait directement lheure lgale

Saisie_fuseau : la fonction (vide) 1 entier
Lheure dt qui rajoute une heure au fuseau horaire :
Corr_tpsUniversel : la fonction (today : 1 date) 1 entier
o Cependant, en France, la priode de lheure dt commence le dernier dimanche du mois de mars
et se termine le dernier dimanche du mois doctobre. Il a donc fallu crer une autre sous fonction
pour terminer le rang du dernier dimanche dans le mois :
Dernier_dimanche : la fonction (d : 1 date) 1 entier
Le dcalage d linclinaison par rapport au mridien de rfrence
Corr_longitude : la fonction (lon : 1 rel) 1 rel
Lquation du temps qui permet de corriger les irrgularits du mouvement de la terre en fonction du jour :
Corr_eqTemps : la fonction (date_in : 1 date) 1 rel
o Dans le document fournis, lquation du temps est dcoupe en deux sous fonctions, lellipticit, et
loblicit. Afin dtre plus clair, on a prfr crer deux fonctions qui calculent ces deux rsultats
indpendamment :
Ellipticite : la fonction (j : un entier non sign) 1 rel
Oblicite : la fonction (j : un entier non sign) 1 rel

17

Lappel de ces fonctions seffectue de la manire suivante :

Le principal problme rencontr a t de redcouper la fonction heure_solaire_vraie en dautres sous fonctions plus
simple.
Pour Saisie_fuseau, il fallait tester si le fuseau entr tait correct. Pour cela on utilise une boucle FAIRE TANT QUE,
avec un boolen error que lon fait passer true lorsque la saisie est mauvaise et false lorsque la valeur est juste en
utilisant un SI
do
{
cout << "Saisissez le fuseau horaire correspondant l'heure saisie (Ex.: 1 ou -1) : ";
cin >> fuseau;
if (fuseau < -12 || fuseau > 12)
{
error = true;
cout << "la valeur saisie est incorrecte !" << endl << endl;
}
else
{
error = false;
}
} while (error);

Pour Dernier_dimanche, on utilise une quation permettant de dterminer quel est le dernier jour du mois (0 pour
le dimanche, 1 pour le lundi ) puis on soustrait cette valeur au nombre de jour dans le mois (31 pour mars et
octobre). Lquation demande cependant de calculer un modulo dun rel ce qui est impossible en C, on affecte donc
la valeur dans une variable entire intermdiaire.
intermed = ceil(31 + d.a + (d.a / 4.0) - (d.a / 100.0) + (d.a / 400.0) + 31 * (d.m / 12.0));
j = 31 - (intermed % 7);

Pour Corr_tpsUniversel, On effectue diffrents tests sur le mois pour dterminer si cest un mois bascule (mars ou
octobre), un mois dt ou un mois dhiver. Si cest un mois bascule, on vrifie si le jour se situe avant ou aprs le
dernier dimanche du mois puis on affecte la valeur retourner en fonction de la priode.
if (today.m > 3 && today.m < 10) {
corr_periode = 1;
} else if (today.m == 3) {
if (today.j < dernier_dimanche(today)) {
corr_periode = 0;
} else {

18

corr_periode = 1;
}
} else if (today.m == 10) {
if (today.j >= dernier_dimanche(today)) {
corr_periode = 0;
} else {
corr_periode = 1;
}
} else {
corr_periode = 0;
}

Pour Corr_longitude, on applique simplement lquation t = -4* qui donne le dcalage en minutes puis on le
convertit en heures en divisant par 60.
En effet, la longitude EST est compte ngativement dans ce calcul, contrairement la faon habituelle de signer la
longitude (o elle est positive et la longitude OUEST ngative)
delta=-4*lon;
t=delta/60.0;

Pour Corr_eqTemps, on commence par convertir la date en nombre de jours grce la fonction Nb_jours puis on
appelle les deux fonctions Oblicite et Ellipticite retournant chacune une composante de lquation de
Temps dont on fait la somme, puis que lon divise par 60 pour lavoir en heures.
Ellipticite
const float A = 0.98560028;
const float B = 357.5261;
//algo local
C = (1.9148*sin(Deg2rad(B + A + j)) + 0.02*sin(Deg2rad(2 * (B + A*j))) + 0.0003*sin(Deg2rad(3 * (B
+ A*j)))) * 4;

Oblicite
const float T = 0.98564736;
const float R = 280.4665;
float O;

//algo local
O = (-2.468*sin(Deg2rad(2 * (R + T*j))) + 0.053*sin(Deg2rad(4 * (R + T*j))) - 0.0014*sin(Deg2rad(6
* (R + T*j)))) * 4;

Corr_eqTemps
j = Nb_jours(date_in);
c = Ellipticite(j);
o = Oblicite(j);
Eq = (c + o)/60;

Enfin, Heure_Solaire_Vraie appelle les 3 fonctions Corr_tpsUniversel, Corr_longitude et

Corr_eqTemps puis convertit lheure lgale en heure solaire vraie en soustrayant les 3 valeurs obtenues grce aux
fonctions appeles et le fuseau horaire lheure lgale.
eqTemps = Corr_eqTemps(d);
longi = corr_longitude(longitude);
ete_hiver = Corr_tpsUniversel(d);
heure_solaire_vraie = heure - fuseau - ete_hiver - longi - eqTemps;

19

Etude des fonctions de calcul

Une fois toutes les diffrentes valeurs saisies et converties de manire optimale, il faut procder aux calculs
ncessaires la dtermination du rayonnement solaire global. Cela ncessitait la dtermination des quantits
suivantes :

La dclinaison
Langle horaire
La hauteur solaire
Lazimut
Le coefficient dincidence
Lnergie solaire
La masse dair optique relative
Lpaisseur optique de Rayleigh
Le coefficient de trouble de Linke
Le rayonnement solaire direct
Le rayonnement solaire diffus

On peut distinguer deux parties dans le raisonnement bien quelles soient lies :
La premire concerne des calculs plutt angulaires. En effet, la dclinaison, langle horaire, la hauteur solaire et
lazimut constituent des angles lis la position du soleil en fonction de lheure de la journe et de la situation
gographique. Le coefficient dincidence est li aux angles dinclinaison et dorientation du panneau solaire.
Tout dabord, la dclinaison se calcule par rapport au jour de lanne.
On calcule langle horaire en fonction de lheure solaire vraie associe au cas donn.
Grce ces deux quantits ainsi qu la latitude du lieu considr, on en dduit la hauteur solaire correspondante.
Enfin, partir de ces trois valeurs calcules (dclinaison, angle horaire et hauteur solaire), on en dduit lazimut du
soleil.
Le coefficient dincidence du panneau est ensuite calcul laide de ce mme azimut ainsi que de la hauteur solaire.
Entrent galement en considration linclinaison et lorientation du panneau photovoltaque.
Cela a constitu lensemble du travail du 5me groupe.
On a ensuite une deuxime partie de calculs lis plutt des conditions climatiques et mtorologiques mais qui
utilisent aussi les calculs prcdents pour arriver au rsultat final du rayonnement solaire global.
On calcule dabord lnergie solaire partir du jour de lanne considre.
Ensuite, partir de laltitude du lieu considr, on calcule la masse dair optique relative puis directement partir de
celle-ci on dtermine lpaisseur optique de Rayleigh.
Paralllement, on utilise, la temprature, le coefficient de trouble atmosphrique ainsi que le taux dhumidit
relative saisis par lutilisateur pour calculer le facteur de trouble de Linke.
A partir de cette mme quantit ainsi que de la masse dair optique relative, lpaisseur optique de Rayleigh,
lnergie solaire et le coefficient dincidence, on peut ensuite calculer le rayonnement solaire direct.
On utilise aussi linclinaison ainsi que la hauteur solaire pour dterminer le rayonnement solaire diffus, puis la
somme de ces deux rsultats constitue le rayonnement solaire global reu par le panneau.
Cela a constitu lensemble du travail du 6me groupe.
Ce raisonnement est rsum via le schma en annexe.
Ces calculs utilisent les fonctions trigonomtriques de la librairie math.h . On doit donc encore une fois utiliser les
fonctions Deg2Rad (pour les fonctions travaillant avec des paramtres en radians comme cos, sin, tan) et Rad2Deg
(pour les fonctions renvoyant un rsultat en radians comme arcos, arcsin, arctan).
Par la suite, les variables avec le suffixe rad seront des valeurs en radians (pralablement converties de degrs vers
radians grce la fonction Deg2Rad) et les valeurs avec le suffixe deg seront en degrs. Cest un choix des deux
groupes de travail pour bien distinguer valeurs en degrs et valeurs en radians.

20

Travail du 5me groupe

Membres :
-

Alix Jeannerot
Paul Bouchillou
Sbastien Cizeron

Responsable : Fabien Bouteyre

1re fonction : calcul de la dclinaison

Declinaison : la fonction (jour : 1 entier) 1 rel
R : Calcule partir du jour de lanne la dclinaison correspondante
E : 1 entier (le jour)
S : 1 rel (la dclinaison en degrs dcimaux)
Cette fonction utilise arcsinus (asin en C), donc Rad2deg est encore prsente. La dclinaison se calcule de la manire
suivante :
decrad=asin(0.398*sin(Deg2rad(0.989*jour-80)));
decdeg=Rad2deg(decrad);
return decdeg;

2me fonction : calcul de langle horaire

Angle_horaire : la fonction (hsv : 1 rel) 1 rel
R : Calcule partir de lheure solaire vraie langle horaire correspondant
E : 1 rel (lheure solaire vraie en heures dcimales)
S : 1 rel (langle horaire en degrs dcimaux)
Langle horaire se calcule de la manire suivante :
ang=180*(heuresolairev/12.0-1);
return ang;

3me fonction : calcul de la hauteur solaire

Hauteur_solaire : la fonction (lat : 1 rel, dec : 1 rel, ah : 1 rel) 1 rel
R : Calcule partir de la latitude, de la dclinaison et de langle horaire la hauteur solaire
E : 3 rels (latitude, dclinaison et angle horaire en degrs dcimaux)

21

S : 1 rel (hauteur solaire)

Cette fonction utilise la fonction arcsinus, et donc ncessairement Rad2deg pour retourner un rsultat final en
degrs. La hauteur solaire se calcule de la manire suivante :
hauteurrad=asin(sin(latituderad)*sin(declinaisonrad)+cos(latituderad)*cos(declinaisonrad)*cos
(anglerad)) ;

hauteurdeg=Rad2deg(hauteurrad) ;
return hauteurdeg;

4me fonction : calcul de lazimut

Azimut : la fonction (dec : 1 rel, ah : 1 rel, hs : 1 rel) 1 rel
R : Calcule partir de la dclinaison, de langle horaire et de la hauteur solaire lazimut correspondant
E : 3 rels (dclinaison, angle horaire, hauteur solaire en degrs dcimaux)
S : 1 rel (lazimut en degrs dcimaux)
La ncessit dun calcul darcsinus demande encore une fois la prsence de la fonction Rad2deg avant de retourner
lazimut.
arad=asin((cos(decrad)*sin(ahrad))/(cos(hsrad)));
adeg=Rad2deg(arad);
return adeg;

5me fonction : calcul du coefficient dincidence li la position du panneau

Coef_incidence : la fonction (i : 1 rel, o : 1 rel, a : 1 rel, hs : 1 rel) 1 rel
R : Calcule partir de linclinaison, de lorientation, de lazimut et de la hauteur solaire le coefficient dincidence
correspondant
E : 4 rels (inclinaison, orientation, azimut et hauteur solaire en degrs dcimaux)

22

S : 1 rel (coefficient dincidence)

Le coefficient dincidence se calcule de la manire suivante :
coeff_incid=sin(inclinaisonrad)*cos(hautsolrad)*cos(orientationradazimutrad)+cos(inclinaisonrad)*sin(hautsolrad);
return coeff_incid;

Les valeurs attendues ont t soit calcules par ce groupe de travail avec excel, soit prises dans le fascicule. Excel
fonctionne aussi en radians, il devait donc y avoir le mme raisonnement que lors de la programmation (conversions
degrs / radians pour cosinus, sinus et radians / degrs pour arcsinus)

Travail du 6me groupe

Membres :
-

Grgoire Bouland
Charles Royer
Geoffrey Dumon
Nour Hassoun

Responsable : Manon Portay

1re fonction : calcul de lnergie solaire

Energie_solaire : la fonction (j : 1 entier) 1 rel
R : Calcule partir du nombre de jours correspondant la date saisie prcdemment lnergie solaire correspondante
E : 1 entier (nime jour de lanne)
S : 1 rel (lnergie solaire en W/m)
On utilise la fonction de conversion Deg2rad afin de convertir les rsultats en degrs en radians.
Le calcul seffectue de la manire suivante :
deg = 360 * (j - 2.7206) / 365.25;
rad = Deg2rad(deg);
Esol = 1367 * (1 + 0.0334*cos(rad));

23

2me fonction : calcul de la masse dair optique relative

Masse_air : la fonction (z : 1 rel, hs : 1 rel) 1 rel
R : Calcule partir de laltitude et de la hauteur solaire la masse dair optique relative correspondante
E : 2 rels (altitude en m et hauteur solaire en degrs dcimaux)
S : 1 rel (masse dair optique relative)
On utilise donc la fonction de conversion Deg2rad afin de convertir les rsultats en degrs en radians.
Cette fonction ncessite dutiliser la fonction exponentielle pour coder e^x, le code est : exp(x) disponible dans le
rpertoire math.h.
Pour calculer la masse dair doptique, on a besoin de la pression atmosphrique calcule partir de laltitude, et de
la hauteur solaire en degrs dcimaux.
patm = 101325 * pow((1 - 2.26*0.00001*z), 5.26);
radh = Deg2rad(hs);
m = patm / (101325 * sin(radh) + 15198.75*pow((3.885 + hs), -1.253));
return m;

3me fonction : calcul de lpaisseur optique de Rayleigh

Epaisseur_optique : la fonction (m : 1 rel) 1 rel
R : Calcule partir de la masse dair optique relative lpaisseur optique de Rayleigh correspondante
E : 1 rel (masse dair optique relative)
S : 1 rel (paisseur optique de Rayleigh)
Le calcul de lpaisseur optique seffectue de la manire suivante :
er = 1 / (0.9*m + 9.4);
return er;

4me fonction : calcul du coefficient de trouble de Linke

Trouble_Linke : la fonction (t : 1 rel, b : 1 rel, hu : 1 rel) 1 rel
R : Calcule partir de la temprature, du coefficient de trouble atmosphrique et du taux dhumidit relative le
facteur de trouble de Linke correspondant

24

E : 2 rels (temprature en C , coefficient de trouble atmosphrique et taux dhumidit entre 0 et 1)

S : 1 rel (facteur de trouble de Linke)
Le calcul du coefficient de trouble de Linke partir de la temprature, du coefficient de trouble atmosphrique et du
taux dhumidit relative a t divis en 3 calculs.
Premirement, la pression de vapeur saturante est calcule partir de la temprature. Ensuite, la pression partielle
de vapeur deau est calcule partir de la pression de vapeur saturante et du taux dhumidit. Finalement, le trouble
Linke est calcul grce la pression partielle de vapeur deau et du coefficient de trouble atmosphrique.
Cette fonction ncessite dutiliser la fonction puissance : pour coder x^y, le code est : pow(x,y) disponible dans le
rpertoire math.h.
Cette fonction ncessite galement d'utiliser la fonction logarithme nprien : pour coder ln(x), le code est log(x)
disponible dans le rpertoire math.h.
pvs = 2.165*pow(1.089 + (temp / 100), 8.02);
pv = pvs*hu;
tl = 2.4 + 14.6*b + 0.4*(1 + 2 * b)*log(pv);
return tl;

5me fonction : calcul du rayonnement solaire direct

Solaire_direct : la fonction (Esol : 1 rel, eR : 1 rel, m : 1 rel, tL : 1 rel, ci : 1 rel) 1 rel
R : Calcule partir de lnergie solaire, de lpaisseur optique de Rayleigh, de la masse dair optique relative, du
facteur de trouble de Linke et du coefficient dincidence le rayonnement solaire direct (S*) sur un plan rcepteur (o, i)
E : 1 entier (nombre de jours) et 4 rels (paisseur optique de Rayleigh, masse dair optique relative, facteur de
trouble de Linke et coefficient dincidence)
S : 1 rel (rayonnement solaire direct S* en W/m)
Pour le calcul du rayonnement solaire direct, on calcule dabord le rayonnement solaire sur un plan normal ce
rayonnement partir de lnergie solaire, de lpaisseur optique de Rayleigh, de la masse dair optique et facteur de
trouble de Linke.
Le rayonnement solaire direct est obtenu grce au rayonnement solaire sur un plan normal ce rayonnement et au
coefficient dincidence.
Cette fonction ncessite dutiliser la fonction exponentielle, pour coder e^x, le code est : exp(x) disponible dans le
rpertoire math.h.
i = Esol * exp(-eR *m*tL);
Sd = i*ci;
return Sd;

25

6me fonction : calcul du rayonnement solaire global

Solaire_global : la fonction (sdirect : 1 rel, h : 1 rel, i : un rel) 1 rel
R : Calcule partir du rayonnement solaire direct S*, de la hauteur solaire et de linclinaison du panneau le
rayonnement solaire global G* correspondant
E : 3 rels (rayonnement solaire direct en W/m, hauteur solaire et inclinaison du panneau en degrs dcimaux)
S : 1 rel (rayonnement solaire global en W/m)
On utilise encore une fois la fonction de conversion Deg2rad afin de convertir les rsultats de degrs radians pour la
fonction cos(x).
Afin de calculer le rayonnement solaire global on calcule dabord le rayonnement solaire diffus partir de la hauteur
solaire et de linclinaison du panneau puis le rayonnement solaire global partir de ce rayonnement solaire diffus et
du rayonnement solaire direct.
hrad = Deg2rad(h);
irad = Deg2rad(i); snh = sin(hrad);
D = 125 * (pow(snh, 0.4))*((1 + (cos(irad))) / 2.0) + 211.86*(pow(snh, 1.22))*((1 cos(irad)) / 2.0);
G = D + sdirect;
return G;

Fonctions de prsentation du programme et daffichage des rsultats

Une fois le raisonnement achev et le programme fonctionnel, il est ncessaire de prsenter le programme
lutilisateur et ensuite lui communiquer le rsultat obtenu. Les chefs de projet se sont chargs de crer deux
fonctions dans ce but.

1re fonction : prsentation du programme

Presentation : la fonction (vide) vide
R : Prsenter au mieux quoi sert le programme (informations ncessaires, utilit, etc.)
E : vide
S : vide
Dans cette fonction, on communique tout simplement lutilisateur le rle du programme ainsi que les informations
quil devra entrer :
void Presentation(void)
{
cout << "Ce programme vous permet de calculer le rayonnement solaire global potentiel sur
votre panneau. Pour cela, vous devrez renseigner differentes informations :" << endl << endl;
cout << "- La date (jour, mois, annee)" << endl;
cout << "- L'heure (heures, minutes, secondes" << endl;
cout << "- La latitude Nord et la longitude Est du lieu sous forme sexagesimale (degres,
minutes, secondes)" << endl;
cout << "- L'inclinaison et l'orientation de votre panneau en degres decimaux" << endl;

26

cout << "cout << "cout << "<< endl;

cout << "-

L'altitude du lieu en m" << endl;

La temperature en C" << endl;
Le milieu dans lequel vous vous trouvez (montagnard, rural, urbain, industriel)"
Le taux d'humidite du lieu en %" << endl << endl;

2me fonction : affichage du rsultat

Affiche_res : la fonction (sglobal : 1 rel, d : 1 date, h : 1 heure, lat : 1 coordonnee, lon : 1 coordonnee, i : 1 rel,
o : 1 rel, z : 1 rel, temp : 1 rel, coef : 1 rel, hu : 1 rel) vide
R : Affiche de manire parlante le rayonnement global et rcapitule les saisies passes en paramtre (unit, etc.)
E : 1 rel (le rayonnement global)
S : vide
On rcapitule les saisies effectues par lutilisateur, puis on affiche le rsultat (rayonnement solaire globlal) associ
ses saisies.
void Affiche_res(float res, date d, heure h, coordonnee lat, coordonnee lon, float i, float o, float
z, float temp, float coef, float hu)
{
cout<<endl<<"Vous avez saisi les valeurs suivantes :"<<endl;
cout<<"Date : "<<d.j<<"/"<<d.m<<"/"<<d.a<<endl;
cout<<"Heure : "<<h.h<<":"<<h.m<<":"<<h.s<<endl;
cout<<"Latitude du lieu : "<<lat.d<<" degres "<<lat.m<<" minutes "<<lat.s<<" secondes
EST"<<endl;
cout<<"Longitude du lieu : "<<lon.d<<" degres "<<lon.m<<" minutes "<<lon.s<<" secondes
NORD"<<endl;
cout<<"Inclinaison du panneau : "<<i<<" degres"<<endl;
cout<<"Orientation du panneau : "<<o<<" degres"<<endl;
cout<<"Altitude du lieu : "<<z<<" m"<<endl;
cout<<"Temprature : "<<temp<<" degres Celsius"<<endl;
cout<<"Coefficient de trouble atmospherique associe au milieu : "<<coef<<endl;
cout<<"Taux d'humidite : "<<hu<<endl<<endl;
cout << "Le rayonnement solaire global sur votre panneau obtenu (en cas de beau temps) est de
" << res << "W/m^2, (watt par metre^2)." << endl;
}

Etude du programme principal

Aprs avoir tabli lensemble des fonctions, il faut videmment crer un programme principal qui les excute selon
leur utilit dans le calcul du rayonnement solaire global.
Il tait dabord ncessaire de dclarer dans le lexique les diffrentes variables lies la saisie (le suffixe comp
correspond une variable sous forme de type compos) :
date d_comp;
heure h_comp;
coordonnee lat_comp,lon_comp;
float inclinaison, orientation;
float altitude;
float temperature;
float coef_trouble;
float humidite;

Ensuite, les variables lies aux conversions :

float h_dec;
int nombre_j;
situation s_geo;
float hs_vraie;

27

Le boolen indiquant directement si lon a un rayonnement nul :

bool rayon_nul;

Enfin, les diffrentes quantits calcules jusquau rayonnement solaire global :

float
float
float
float
float
float
float
float
float
float
float

decl;
a_horaire;
h_solaire;
az;
c_incidence;
ener_sol;
m_air;
e_optique;
t_linke;
s_direct;
s_global;

Arrive lalgorithme principal. On commence par effectuer les diffrentes saisies aprs avoir prsent le programme :
Presentation();
d_comp=Saisie_date();
h_comp=Saisie_heure();
lat_comp=Saisie_latitude();
lon_comp=Saisie_longitude();
inclinaison=Saisie_inclinaison();
orientation=Saisie_orientation();
altitude=saisie_alt();
temperature=Saisie_temperature();
coef_trouble=saisie_milieu();
humidite=Saisie_hum();

On effectue ensuite les diffrentes conversions ncessaires :

h_dec=Heures_decimales(h_comp);
nombre_j=Nb_jours(d_comp);
s_geo=Situation_geo(lat_comp, lon_comp);
hs_vraie=Heure_solaire_vraie(s_geo.lo, h_dec, d_comp);

Ensuite, on effectue dabord les calculs utiles pour reconnatre directement si le rayonnement correspondant la
saisie sera nul (on connat par les conversions le paramtre lheure solaire vraie, il reste calculer la dclinaison pour
pouvoir faire fonctionner lever_coucher) :
decl=Declinaison(nombre_j);
rayon_nul=lever_coucher(s_geo.la, decl, hs_vraie);

Si le boolen retourn a pour valeur false, cela signifie que lheure saisie est durant la nuit donc on indique
directement lutilisateur que le rayonnement sera nul :
if (rayon_nul==false)
{
cout<<"L'heure que vous avez saisie correspond a une heure d'ensoleillement
nul. Vous n'aurez aucun rayonnement sur votre panneau."<<endl;
}

Sinon, on poursuit les calculs jusquau rayonnement solaire global puis on affiche le rsultat :
else
{
a_horaire=Angle_horaire(hs_vraie);
h_solaire=Hauteur_solaire(s_geo.la, decl, a_horaire);
az = Azimut(decl, a_horaire, h_solaire);
c_incidence=Coef_incidence(inclinaison, orientation, az, h_solaire);
ener_sol=Energie_solaire(nombre_j);

28

m_air=Masse_air(altitude, h_solaire);
e_optique=Epaisseur_optique(m_air);
t_linke=trouble_linke(temperature, coef_trouble, humidite);
s_direct=solaire_direct(ener_sol, e_optique, m_air, t_linke, c_incidence);
s_global=Solaire_global(s_direct, h_solaire, inclinaison);
Affiche_res(s_global, d_comp, h_comp, lat_comp, lon_comp, inclinaison,
orientation, altitude, temperature, coef_trouble, humidite);
}

On peut ensuite tester le programme avec les valeurs du fascicule (ville de Mulhouse). Pour cela, il faut convertir les
10h heure solaire vraie utilises en heure lgale (car dans le fascicule les calculs ont t faits directement partir
dune heure solaire vraie). On obtient grce cet algorithme disponible sur le site :
http://michel.lalos.free.fr/cadrans_solaires/outils/Tables-hs-hl.php

Le calcul du nombre de jours associ au 1er juillet a t fait dans le cas dune anne non bissextile (il est compt 28
jours fvrier) donc 2013 a t saisi pour respecter cette condition.
Nb : il y a une erreur dans le fascicule au niveau du nombre de jours correspondant au 1er juillet (il est de 181 dans
celui-ci au lieu de 182 en ralit, car 30 jours ont t compts janvier)
Le rsultat avec lensemble des valeurs donne le rsultat suivant :

En faisant en sorte davoir 181 jours (comme dans le fascicule), le rsultat obtenu est 871.288 W/m pour 871.66
dans le fascicule.
On obtient donc un rsultat dune prcision convenable.

29

Exportation des rsultats sous forme de tableaux de donnes

(propos par Tho Basty)
Nous souhaitions au final que le programme soit capable de gnrer un fichier contenant diverses donnes et
pouvant tre ouvert laide dun tableur.
Pour cela, il a fallu revoir un peu le dcoupage fonctionnel du programme :
-

Une fonction regroupant tous les appels des fonctions de calculs situes prcdemment dans la fonction
main a t cre pour pouvoir facilement insrer une boucle pour calculer lensoleillement pour plusieurs
valeurs conscutive de manire rapide.
double Ensoleillement(date d_comp, heure h_comp, coordonnee lat_comp, coordonnee
lon_comp, float inclinaison, float orientation, float altitude, float temperature,
float coef_trouble, float humidite, int fuseau)

Une autre fonction a t cre, contenant un menu pour demander lutilisateur sil dsire gnrer un
rapport.
bool menu_rapport()

Une dernire fonction a enfin t cre pour gnrer ce fichier de rapport.

void rapport_build(date d_comp, heure h_comp, coordonnee lat_comp, coordonnee
lon_comp, float inclinaison, float orientation, float altitude, float temperature,
float coef_trouble, float humidite, int fuseau);

Conception
La fonction Ensoleillement reprend donc les appels conscutifs de toutes les fonctions de calcul et de traitement. Les
paramtres sont toutes les valeurs saisies par lutilisateur pour dcrire les conditions dinstallation de son panneau
solaire.
La petite particularit est le rayon nul. Durant la nuit, lensoleillement dun panneau solaire est trs faible. Dans ce
cas, on ne calcule pas lensoleillement en retournant simplement un 0.
bool rayon_nul; //Boolen renvoyant TRUE si rayonnement non nul et FALSE sinon
if (rayon_nul == false)
{
s_global = 0;
}

On se sert dailleurs de ce 0 dans le main afin dafficher un message spcifique

ens_global = Ensoleillement(d_comp, h_comp, lat_comp, lon_comp, inclinaison, orientation, altitude,
temperature, coef_trouble, humidite, fuseau);
if (ens_global != 0)
{
Affiche_res(ens_global, d_comp, h_comp, lat_comp, lon_comp, inclinaison, orientation, altitude,
temperature, coef_trouble, humidite);
}

La fonction menu_rapport est une simple fonction de saisie en menu. Deux choix soffrent lutilisateur et elle
renvoie un boolen signifiant oui ou non en fonction du choix de lutilisateur pour rpondre la question.
do{
cout << endl << "Voulez vous generer un tableau d'ensoleillement au format csv ?" <<
endl
<< "1 : oui" << endl
<< "0 : non" << endl
<< "Votre choix (0 ou 1):";

30

cin >> entree;

} while (entree != 0 && entree != 1); //Attente d'une saisie juste
//correspondance de la sortie avec le choix
if (entree == 0){
choix = false;
}else{
choix = true;
}

La fonction build_rapport est plus complique. En effet, elle crit des donnes dans un fichier. On utilise donc une
bibliothque spciale : #include<fstream>
On commence par ouvrir le fichier, puis on vrifie si il a bien t ouvert (si par exemple le fichier est dj ouvert, le
programme ne peut pas louvrir en criture). Sinon on affiche un message derreur et on propose lutilisateur de
ressayer ou dabandonner car parfois la raison est plus complexe.
do
{
ofstream myFile("Ensoleillement.csv");
if (myFile)
{
//Gnration du fichier
}
else
{
cout << "ERREUR: Impossible d'ouvrir le fichier." << endl
<< "Verifiez qu'il ne soit pas ouvert par un autre programme" << endl <<
endl;
do
{
cout << "Voulez vous reessayer de l'ouvrir ? [o/n] ";
cin >> retry_in;
switch (retry_in)
{
case 'o':
retry = true;
break;
case 'n':
retry = false;
cout << "Abandon de l'ecriture du rapport..." << endl;
}
} while ((retry_in != 'o') && (retry_in != 'n'));
}
} while (retry);

Ensuite, il existe un format de fichier nomm CSV (comma separated value) qui permet de reprsenter des tables de
donnes et qui peut tre ouvert par Excel. Il sagt en fait dun fichier texte basique contenant des valeurs spares
par un caractre dfinit dans les paramtres de rgions de lordinateur (pour sparer les colonnes) sur plusieurs
lignes (pour sparer les lignes du tableau). Ils sont donc faciles gnrer.

31

De plus, lcriture dans un fichier fonctionne de la mme manire que la fonction cout. La gnration dun fichier
CSV est donc trs facile. Il suffit juste dappliquer une boucle sur la fonction de calcul Ensoleillement() puis
denregistrer les valeurs dans le fichier ouvert. On cre une constante SEPARATOR de type caractre afin de stocker
le sparateur de colonnes.
Nous avons cr plusieurs boucles afin de pouvoir tracer plusieurs graphiques intressants en fonction de diffrents
paramtres laide dun tableur.
Pour les tableaux en fonctions de lhumidit, de la temprature, de lorientation et de linclinaison, les boucles sont
quasiment identiques part la plage parcourue par la boucle. On utilise une boucle for car elle permet facilement de
dclarer une variable indice, de tester une condition et dincrmenter lindice. On appel juste Ensoleillement avec la
valeur de lindice pour obtenir lensoleillement global avant de lcrire dans le fichier aprs lindice.
//Tableau orientation
myFile << "orientation" << SEPARATOR << "ensoleillement" << SEPARATOR <<
"Energie convertie"; //criture des enttes de colonnes
for (int ori = -170; ori <= 180; ori = ori + 10)
{
ens_loop = Ensoleillement(d_comp, h_comp, lat_comp, lon_comp,
inclinaison, ori, altitude, temperature, coef_trouble, humidite, fuseau);
if (ens_loop != 0)
{
myFile << endl << ori << SEPARATOR << ens_loop << SEPARATOR <<
ens_loop * 0.2 * 0.97;
}
}

Pour le tableau en fonction du mois, le principe est le mme que prcdemment. On intgre juste lindice de la
boucle dans un type complexe date avant de lenvoyer Ensoleillement.
d_loop.a = d_comp.a;
d_loop.j = d_comp.j;
for (int m = 1; m <= 12; m++)
{
d_loop.m = m;

Pour le jour, on reste dans le mme fonctionnement que le mois. Mais le nombre de jours tant diffrents dans
chaque mois, il est ncessaire de dterminer la borne maximale avant la boucle.
if (d_comp.m == 1 || d_comp.m == 3 || d_comp.m == 5 || d_comp.m == 7 ||
d_comp.m == 8 || d_comp.m == 10 || d_comp.m == 12){
d_max = 31;
}else{
if (d_comp.m == 4 || d_comp.m == 6 || d_comp.m == 9 || d_comp.m == 11){
d_max = 30;
}else{
if (est_bissextile(d_comp.a)){
d_max = 29;
}else{
d_max = 28;
}
}
}
d_loop.a = d_comp.a;
d_loop.m = d_comp.m;
for (int j = 1; j <= d_max; j++)
{
d_loop.j = j;

Pour lheure, afin dobtenir un nombre suffisant de valeurs, il est ncessaire de calculer un ensoleillement tous les
quarts dheures. On utilise deux boucles for embotes pour gnrer indice de lheure et lindice du quart dheure.
On multiplie lindice du quart dheure par 15 pour obtenir le nombre de minutes affecter au type compos pass
en paramtre la fonction Ensoleillement.

32

h_loop.s = 0;
for (int h = 0; h < 24; h++){
h_loop.h = h;
for (int m = 0; m < 4; m++){
h_loop.m = m * 15;
ens_loop = Ensoleillement(d_comp, h_loop, lat_comp, lon_comp,
inclinaison, orientation, altitude, temperature, coef_trouble, humidite, fuseau);
if (ens_loop != 0){
myFile << endl << h_loop.h << ":" << h_loop.m << SEPARATOR
<< ens_loop << SEPARATOR << ens_loop * 0.2 * 0.97;
}
}
}

On spare enfin les diffrents tableaux par une ligne vide :

myFile << endl << endl;

Conclusion du projet
Tout dabord, le bilan de ralisation du projet est plutt positif : en effet, nous sommes arrivs au but principal, celui
dexprimer le rayonnement solaire global mais nous avons galement pu approfondir la problmatique.
Nous avons ensuite pu utiliser le programme dans le but de gnrer un fichier Excel (.csv) afin dcrire des donnes
dans un tableur. Cela a permis dexprimer le rayonnement solaire global pour un lieu donn en fonction de lun de
ses paramtres, notamment le jour de lanne considr, lheure dans la journe ou encore lorientation du panneau
photovoltaque. Le programme possde donc une relle utilit par rapport la problmatique de base : prvoir un
fonctionnement optimal pour un panneau solaire.
De plus, ce projet nous a permis de matriser la plupart des concepts algorithmiques de base :
-

Il ncessitait dabord lutilisation de structures conditionnelles et itratives. Les structures conditionnelles

taient importantes pour distinguer les diffrents cas possibles sur une saisie par exemple, avec les annes
bissextiles et non-bissextiles. Les structures itratives ont t indispensables au niveau de la saisie. Elles ont
permis de mettre en place un systme de saisie de manire viter que des erreurs de saisie soient
commises par lutilisateur.
Les types composs ont aussi jou un rle important. Ils ont permis de faciliter les fonctions de saisie pour
les dates par exemple, composes de plusieurs informations, dont on ne peut retourner quune information
si lon nutilise pas de type compos. Cela possde aussi un autre avantage : par exemple, la latitude et la
longitude sont souvent exprimes de manire sexagsimale, ainsi un type compos des degrs, minutes et
secondes a permis lutilisateur dentrer ses informations de manire plus parlante, et dans ce cas prcis
quil nait pas chercher la correspondance dcimale de ses coordonnes
Lutilisation de boolens tait judicieuse pour la rsolution du problme. En effet, ils permettent de
distinguer deux cas lorsquil ny a que deux issues possibles, notamment saisie correcte ou saisie
incorrecte .
Le raisonnement du dcoupage fonctionnel a t essentiel au bon droulement du projet. Il sagissait
dtudier de manire prcise le besoin et le raisonnement de rsolution du problme pour tablir une liste
de fonctions permettant sa rsolution en C++.

Enfin, nous avons pu approfondir les possibilits offertes par le langage C en gnrant un fichier Excel avec les
donnes du programme, ainsi quen utilisant une librairie complmentaire math.h contenant les principales
fonctions usuelles de mathmatiques pour les calculs.

33

Annexe

34