def affichage_2(hmax,infI,supI,temps):
    # Initialisation
    x=np.linspace(infI,supI,100);
    mp.plot(x,affecte_f(p2.spline_odessus,x),'k',linewidth=4);
    mp.plot(x,affecte_f(p2.spline_odessous,x),'k',linewidth=4);

    for i in np.arange(0.003,3*hmax,0.003):
        # Mise en place des coordonnees en vue de faire un plot
        f_up=airflow_family(i/(3*hmax),hmax,p2.spline_odessus);
        f_down=airflow_family(i/(3*hmax),hmax,p2.spline_odessous,False);
        f=airflow_family(1,hmax,p2.spline_odessus);

        fct_a_int_up=creer_int_dessus(hmax,i);
        fct_a_int_down=creer_int_dessous(hmax,i);
        fct_f=creer_int_dessus(hmax,3*hmax);
        # Partie integration
        l_up=p1.integrationSimpson(fct_a_int_up,infI,supI,1e-3,20)[0];
        l_down=p1.integrationSimpson(fct_a_int_down,infI,supI,1e-3,20)[0];
        l=p1.integrationSimpson(fct_f,infI,supI,1e-3,20)[0];
        # Partie force de Pression dynamique
        P_up=0.5*(l_up*l_up/(temps*temps));
        P_down=0.5*(l_down*l_down/(temps*temps));
        P=0.5*(l*l/(temps*temps));
        if (i==0.003) :
            if (P_up > P_down):
                Pmax=P_up;
            else :
                Pmax=P_down;
        if (P_up>Pmax):
            Pmax=P_up;
        # Affichage des courbes
        mp.plot(x,affecte_f(f_up,x),linewidth=3,color=((P_up-P)/(Pmax-P),0.0,0.0));
        mp.plot(x,affecte_f(f_down,x),linewidth=3,color=((P_down-P)/(Pmax-P),0.0,0.0));
    mp.savefig("BACNFLcolors1.png");
    mp.show();
def affichage_3(hmax,infI,supI,temps):
    
    x=np.linspace(infI,supI,100)
    mp.plot(x,affecte_f(p2.spline_odessus,x),'k',linewidth=4)
    mp.plot(x,affecte_f(p2.spline_odessous,x),'k',linewidth=4)
    
    def returnColor(nb,nbmax):
        #l'ajustement par une racine n-ieme de x
        #aurait permis de renforcer les couleurs proches du maximum
        #mais cela n'est pas assez visible
        if (nb < (nbmax/3.)):
            x = (3.*nb)/nbmax
            #print x
            return (pow(x,1.), 0., 0.)
        elif (nb < ((2. * nbmax)/3.)):
            x = (3.*nb-nbmax)/nbmax
            #print x
            return (1.,pow(x,1.), 0.)
        else :
            x = (3.*nb-2.*nbmax)/nbmax
            #print x
            return (1., 1., pow(x,1.))

#pression dynamique de reference :
    P = 0.5*(supI-infI)**2./temps**2
    ite = 0

    for i in np.arange(0.003,3*hmax,0.003):
        ite += 1
        f_up=airflow_family(i/(3.*hmax),hmax,p2.spline_odessus)
        f_down=airflow_family(i/(3.*hmax),hmax,p2.spline_odessous,False)
        f=airflow_family(1,hmax,p2.spline_odessus)
        
        fct_a_int_up=creer_int_dessus(hmax,i)
        fct_a_int_down=creer_int_dessous(hmax,i)
        #fct_f=creer_int_dessus(3*hmax,hmax)

        
        l_up=p1.integrationSimpson(fct_a_int_up,infI,supI,1e-3,20)[0]
        l_down=p1.integrationSimpson(fct_a_int_down,infI,supI,1e-3,20)[0]
        #l=p1.integrationSimpson(fct_f,infI,supI,1e-3,20)[0]
   
        P_up=0.5*(l_up*l_up/(temps*temps))
        P_down=0.5*(l_down*l_down/(temps*temps))
        #P=0.5*(l*l/(temps*temps))
        if (i==0.003) :
                Pmax=P_up


        mp.plot(x,affecte_f(f_up,x),linewidth=3,color=returnColor(P_up-P,Pmax-P))
        mp.plot(x,affecte_f(f_down,x),linewidth=3,color=returnColor(P_down-P,Pmax-P))
        print "Calcul de la ligne : %d fait" %(ite)
	# difference de la longueur entre la courbe du haut sa jumelle du bas
        print "Difference de longueur X 1e10 : %d" %(abs(l_up-l_down)*1e10)
    mp.savefig("BACNLFcolors.png");
    mp.show()
def test_p2(infI = -5, supI = 5., value_cons = 1):
    print "Test des methodes d'integration\n"
    print "Test des methodes d'integration sur une fonction constante"
    def ftest_const(value_cons):
        return value_cons;
    print "Rectangles Inf"
    print p1.trapezes_method(ftest_const, -5., 5., 100, True);
    print "Rectangles Sup"
    print p1.trapezes_method(ftest_const, -5., 5., 100, True, True);
    print "Methode des trapezes"
    print p1.integrationTrapez(ftest_const, -5., 5., 0.001, 100);
    print "Methode de Simpson"
    print p1.integrationSimpson(ftest_const, -5., 5., 0.001, 100);
    print "Methode de Boole"
    print p1.bool_rule(ftest_const, -5., 5., 100)
    print "Fin des tests sur fonction constante"
    print "Tests sur fonction generique x:->x2"
    def ftest_gen(x):
        return x**2;
    print "Methode des rectangles"
    print "Rectangles Inf"
    print p1.trapezes_method(ftest_gen, -5., 5., 100, True);
    print "Rectangles Sup"
    print p1.trapezes_method(ftest_gen, -5., 5., 100, True, True);
    print "Methode des trapezes"
    print p1.integrationTrapez(ftest_gen, -5., 5., 0.001, 100);
    print "Methode de Simpson"
    print p1.integrationSimpson(ftest_gen, -5., 5., 0.001, 100);
    print "Methode de Boole"
    print p1.bool_rule(ftest_gen, -5., 5., 100)
    print "Fin des tests sur fonctions generiques"
    
    print "Attention, temps avant affichage : 2 minutes" 
    print "Comparaison du nombre d'iterations sur les methodes de Simpson et des Trapezes"
    p1.showItNumber();
    print "Attention, temps avant affichage : 2 minutes"
    print "Comparaison de l'erreur entre la methode de Simpson et la methode des Trapezes"
    p1.showErr();
    print "Fin des tests sur la partie 2\n"
    return True