ia1 = (llon>=-55) & (llon<=-29) & (llat<=-70) & (llat>=-76)
ia2 = (llon>=-29) & (llon<=-21) & (llat<=-69) & (llat>=-73)
ia3 = (llon>=-37) & (llon<=-13) & (llat<=-67) & (llat>=-69)
ia4 = (llon>=-31) & (llon<=-13) & (llat<=-64) & (llat>=-67)
ia6 = (llon>=-13) & (llon<=0) & (llat<=-64) & (llat>=-69)
ia7 = (llon>=0) & (llon<=30) & (llat<=-64) & (llat>=-69)

iaa= ia1 | ia2 | ia3 | ia4 | ia6 | ia7
iaaa=iaa*1

######################
ia6 = (llon>=-31) & (llon<=0) & (llat<=-64) & (llat>=-69)
ia7 = (llon>=0) & (llon<=30) & (llat<=-64) & (llat>=-69)

ib= (llon>=-180) & (llon<=-130) & (llat<=-67) & (llat>=-73)
ibb=ib*1

iab= iaa | ib

#####################################
#amsub

igmv_ab1=(ambch1[0,:]>=-31) & (ambch1[0,:]<=0) & (ambch1[1,:]<=-64) & (ambch1[1,:]>=-69) | (ambch1[0,:]>=0) & (ambch1[0,:]<=30) & (ambch1[1,:]<=-64) & (ambch1[1,:]>=-69) | (ambch1[0,:]>=-180) & (ambch1[0,:]<=-130) & (ambch1[1,:]<=-67) & (ambch1[1,:]>=-73)

igmv_ab2=(ambch2[0,:]>=-31) & (ambch2[0,:]<=0) & (ambch2[1,:]<=-64) & (ambch2[1,:]>=-69) | (ambch2[0,:]>=0) & (ambch2[0,:]<=30) & (ambch2[1,:]<=-64) & (ambch2[1,:]>=-69) | (ambch2[0,:]>=-180) & (ambch2[0,:]<=-130) & (ambch2[1,:]<=-67) & (ambch2[1,:]>=-73)

igmv_ab3=(ambch3[0,:]>=-31) & (ambch3[0,:]<=0) & (ambch3[1,:]<=-64) & (ambch3[1,:]>=-69) | (ambch3[0,:]>=0) & (ambch3[0,:]<=30) & (ambch3[1,:]<=-64) & (ambch3[1,:]>=-69) | (ambch3[0,:]>=-180) & (ambch3[0,:]<=-130) & (ambch3[1,:]<=-67) & (ambch3[1,:]>=-73)

igmv_ab4=(ambch4[0,:]>=-31) & (ambch4[0,:]<=0) & (ambch4[1,:]<=-64) & (ambch4[1,:]>=-69) | (ambch4[0,:]>=0) & (ambch4[0,:]<=30) & (ambch4[1,:]<=-64) & (ambch4[1,:]>=-69) | (ambch4[0,:]>=-180) & (ambch4[0,:]<=-130) & (ambch4[1,:]<=-67) & (ambch4[1,:]>=-73)

igmv_ab5=(ambch5[0,:]>=-31) & (ambch5[0,:]<=0) & (ambch5[1,:]<=-64) & (ambch5[1,:]>=-69) | (ambch5[0,:]>=0) & (ambch5[0,:]<=30) & (ambch5[1,:]<=-64) & (ambch5[1,:]>=-69) | (ambch5[0,:]>=-180) & (ambch5[0,:]<=-130) & (ambch5[1,:]<=-67) & (ambch5[1,:]>=-73)

tup_gmab=np.zeros([5],float)
tup_gmab[0]=mean(ambch1[18,igmv_ab1])
tup_gmab[1]=mean(ambch2[18,igmv_ab2])
tup_gmab[2]=mean(ambch3[18,igmv_ab3])
tup_gmab[3]=mean(ambch4[18,igmv_ab4])
tup_gmab[4]=mean(ambch5[18,igmv_ab5])

#amsub angles faibles

igmv_ab1n1= igmv_ab1 & (ambch1[7,:]<=13) | igmv_ab1 & (ambch1[7,:]>=78)
igmv_ab2n1= igmv_ab2 & (ambch2[7,:]<=13) | igmv_ab2 & (ambch2[7,:]>=78)
igmv_ab3n1= igmv_ab3 & (ambch3[7,:]<=13) | igmv_ab3 & (ambch3[7,:]>=78)
igmv_ab4n1= igmv_ab4 & (ambch4[7,:]<=13) | igmv_ab4 & (ambch4[7,:]>=78)
igmv_ab5n1= igmv_ab5 & (ambch5[7,:]<=13) | igmv_ab5 & (ambch5[7,:]>=78)


tup_gmabn1=np.zeros([5],float)
tup_gmabn1[0]=mean(ambch1[18,igmv_ab1n1])
tup_gmabn1[1]=mean(ambch2[18,igmv_ab2n1])
tup_gmabn1[2]=mean(ambch3[18,igmv_ab3n1])
tup_gmabn1[3]=mean(ambch4[18,igmv_ab4n1])
tup_gmabn1[4]=mean(ambch5[18,igmv_ab5n1])

#ecart types
tupet_gmabn1=np.zeros([5],float)
tupet_gmabn1[0]=sqrt(sum(ambch1[18,igmv_ab1n1]**2)/size(ambch1[18,igmv_ab1n1])-mean(ambch1[18,igmv_ab1n1])**2)
tupet_gmabn1[1]=sqrt(sum(ambch2[18,igmv_ab2n1]**2)/size(ambch2[18,igmv_ab2n1])-mean(ambch2[18,igmv_ab2n1])**2)
tupet_gmabn1[2]=sqrt(sum(ambch3[18,igmv_ab3n1]**2)/size(ambch3[18,igmv_ab3n1])-mean(ambch3[18,igmv_ab3n1])**2)
tupet_gmabn1[3]=sqrt(sum(ambch4[18,igmv_ab4n1]**2)/size(ambch4[18,igmv_ab4n1])-mean(ambch4[18,igmv_ab4n1])**2)
tupet_gmabn1[4]=sqrt(sum(ambch5[18,igmv_ab5n1]**2)/size(ambch5[18,igmv_ab5n1])-mean(ambch5[18,igmv_ab5n1])**2)

#ämsua

igmv_aa1=(amch1[0,:]>=-31) & (amch1[0,:]<=0) & (amch1[1,:]<=-64) & (amch1[1,:]>=-69) | (amch1[0,:]>=0) & (amch1[0,:]<=30) & (amch1[1,:]<=-64) & (amch1[1,:]>=-69) | (amch1[0,:]>=-180) & (amch1[0,:]<=-130) & (amch1[1,:]<=-67) & (amch1[1,:]>=-73)

igmv_aa2=(amch2[0,:]>=-31) & (amch2[0,:]<=0) & (amch2[1,:]<=-64) & (amch2[1,:]>=-69) | (amch2[0,:]>=0) & (amch2[0,:]<=30) & (amch2[1,:]<=-64) & (amch2[1,:]>=-69) | (amch2[0,:]>=-180) & (amch2[0,:]<=-130) & (amch2[1,:]<=-67) & (amch2[1,:]>=-73)

igmv_aa3=(amch3[0,:]>=-31) & (amch3[0,:]<=0) & (amch3[1,:]<=-64) & (amch3[1,:]>=-69) | (amch3[0,:]>=0) & (amch3[0,:]<=30) & (amch3[1,:]<=-64) & (amch3[1,:]>=-69) | (amch3[0,:]>=-180) & (amch3[0,:]<=-130) & (amch3[1,:]<=-67) & (amch3[1,:]>=-73)

igmv_aa4=(amch4[0,:]>=-31) & (amch4[0,:]<=0) & (amch4[1,:]<=-64) & (amch4[1,:]>=-69) | (amch4[0,:]>=0) & (amch4[0,:]<=30) & (amch4[1,:]<=-64) & (amch4[1,:]>=-69) | (amch4[0,:]>=-180) & (amch4[0,:]<=-130) & (amch4[1,:]<=-67) & (amch4[1,:]>=-73)

igmv_aa5=(amch5[0,:]>=-31) & (amch5[0,:]<=0) & (amch5[1,:]<=-64) & (amch5[1,:]>=-69) | (amch5[0,:]>=0) & (amch5[0,:]<=30) & (amch5[1,:]<=-64) & (amch5[1,:]>=-69) | (amch5[0,:]>=-180) & (amch5[0,:]<=-130) & (amch5[1,:]<=-67) & (amch5[1,:]>=-73)

igmv_aa6=(amch6[0,:]>=-31) & (amch6[0,:]<=0) & (amch6[1,:]<=-64) & (amch6[1,:]>=-69) | (amch6[0,:]>=0) & (amch6[0,:]<=30) & (amch6[1,:]<=-64) & (amch6[1,:]>=-69) | (amch6[0,:]>=-180) & (amch6[0,:]<=-130) & (amch6[1,:]<=-67) & (amch6[1,:]>=-73)

igmv_aa7=(amch7[0,:]>=-31) & (amch7[0,:]<=0) & (amch7[1,:]<=-64) & (amch7[1,:]>=-69) | (amch7[0,:]>=0) & (amch7[0,:]<=30) & (amch7[1,:]<=-64) & (amch7[1,:]>=-69) | (amch7[0,:]>=-180) & (amch7[0,:]<=-130) & (amch7[1,:]<=-67) & (amch7[1,:]>=-73)

igmv_aa15=(amch15[0,:]>=-31) & (amch15[0,:]<=0) & (amch15[1,:]<=-64) & (amch15[1,:]>=-69) | (amch15[0,:]>=0) & (amch15[0,:]<=30) & (amch15[1,:]<=-64) & (amch15[1,:]>=-69) | (amch15[0,:]>=-180) & (amch15[0,:]<=-130) & (amch15[1,:]<=-67) & (amch15[1,:]>=-73)

tup_gmaa=np.zeros([8],float)
tup_gmaa[0]=mean(amch1[18,igmv_aa1])
tup_gmaa[1]=mean(amch2[18,igmv_aa2])
tup_gmaa[2]=mean(amch3[18,igmv_aa3])
tup_gmaa[3]=mean(amch4[18,igmv_aa4])
tup_gmaa[4]=mean(amch5[18,igmv_aa5])
tup_gmaa[5]=mean(amch6[18,igmv_aa6])
tup_gmaa[6]=mean(amch7[18,igmv_aa7])
tup_gmaa[7]=mean(amch15[18,igmv_aa15])

#mansua angles faibles
igmv_aa1n1 = igmv_aa1 & (amch1[7,:]<=5) | igmv_aa1 & (amch1[7,:]>=26)
igmv_aa2n1 = igmv_aa2 & (amch2[7,:]<=5) | igmv_aa2 & (amch2[7,:]>=26)
igmv_aa3n1 = igmv_aa3 & (amch3[7,:]<=5) | igmv_aa3 & (amch3[7,:]>=26)
igmv_aa4n1 = igmv_aa4 & (amch4[7,:]<=5) | igmv_aa4 & (amch4[7,:]>=26)
igmv_aa5n1 = igmv_aa5 & (amch5[7,:]<=5) | igmv_aa5 & (amch5[7,:]>=26)
igmv_aa6n1 = igmv_aa6 & (amch6[7,:]<=5) | igmv_aa6 & (amch6[7,:]>=26)
igmv_aa7n1 = igmv_aa7 & (amch7[7,:]<=5) | igmv_aa7 & (amch7[7,:]>=26)
igmv_aa15n1 = igmv_aa15 & (amch15[7,:]<=5) | igmv_aa15 & (amch15[7,:]>=26)

tup_gmaan1=np.zeros([8],float)
tup_gmaan1[0]=mean(amch1[18,igmv_aa1n1])
tup_gmaan1[1]=mean(amch2[18,igmv_aa2n1])
tup_gmaan1[2]=mean(amch3[18,igmv_aa3n1])
tup_gmaan1[3]=mean(amch4[18,igmv_aa4n1])
tup_gmaan1[4]=mean(amch5[18,igmv_aa5n1])
tup_gmaan1[5]=mean(amch6[18,igmv_aa6n1])
tup_gmaan1[6]=mean(amch7[18,igmv_aa7n1])
tup_gmaan1[7]=mean(amch15[18,igmv_aa15n1])


#ecart types
tupet_gmaan1=np.zeros([8],float)
tupet_gmaan1[0]=sqrt(sum(amch1[18,igmv_aa1n1]**2)/size(amch1[18,igmv_aa1n1])-mean(amch1[18,igmv_aa1n1])**2)
tupet_gmaan1[1]=sqrt(sum(amch2[18,igmv_aa2n1]**2)/size(amch2[18,igmv_aa2n1])-mean(amch2[18,igmv_aa2n1])**2)
tupet_gmaan1[2]=sqrt(sum(amch3[18,igmv_aa3n1]**2)/size(amch3[18,igmv_aa3n1])-mean(amch3[18,igmv_aa3n1])**2)
tupet_gmaan1[3]=sqrt(sum(amch4[18,igmv_aa4n1]**2)/size(amch4[18,igmv_aa4n1])-mean(amch4[18,igmv_aa4n1])**2)
tupet_gmaan1[4]=sqrt(sum(amch5[18,igmv_aa5n1]**2)/size(amch5[18,igmv_aa5n1])-mean(amch5[18,igmv_aa5n1])**2)
tupet_gmaan1[5]=sqrt(sum(amch6[18,igmv_aa6n1]**2)/size(amch6[18,igmv_aa6n1])-mean(amch6[18,igmv_aa6n1])**2)
tupet_gmaan1[6]=sqrt(sum(amch7[18,igmv_aa7n1]**2)/size(amch7[18,igmv_aa7n1])-mean(amch7[18,igmv_aa7n1])**2)
tupet_gmaan1[7]=sqrt(sum(amch15[18,igmv_aa15n1]**2)/size(amch15[18,igmv_aa15n1])-mean(amch15[18,igmv_aa15n1])**2)

#ssmis
igmv_ss1=(ssch1[0,:]>=-31) & (ssch1[0,:]<=0) & (ssch1[1,:]<=-64) & (ssch1[1,:]>=-69) | (ssch1[0,:]>=0) & (ssch1[0,:]<=30) & (ssch1[1,:]<=-64) & (ssch1[1,:]>=-69) | (ssch1[0,:]>=-180) & (ssch1[0,:]<=-130) & (ssch1[1,:]<=-67) & (ssch1[1,:]>=-73)

igmv_ss2=(ssch2[0,:]>=-31) & (ssch2[0,:]<=0) & (ssch2[1,:]<=-64) & (ssch2[1,:]>=-69) | (ssch2[0,:]>=0) & (ssch2[0,:]<=30) & (ssch2[1,:]<=-64) & (ssch2[1,:]>=-69) | (ssch2[0,:]>=-180) & (ssch2[0,:]<=-130) & (ssch2[1,:]<=-67) & (ssch2[1,:]>=-73)

igmv_ss3=(ssch3[0,:]>=-31) & (ssch3[0,:]<=0) & (ssch3[1,:]<=-64) & (ssch3[1,:]>=-69) | (ssch3[0,:]>=0) & (ssch3[0,:]<=30) & (ssch3[1,:]<=-64) & (ssch3[1,:]>=-69) | (ssch3[0,:]>=-180) & (ssch3[0,:]<=-130) & (ssch3[1,:]<=-67) & (ssch3[1,:]>=-73)

igmv_ss4=(ssch4[0,:]>=-31) & (ssch4[0,:]<=0) & (ssch4[1,:]<=-64) & (ssch4[1,:]>=-69) | (ssch4[0,:]>=0) & (ssch4[0,:]<=30) & (ssch4[1,:]<=-64) & (ssch4[1,:]>=-69) | (ssch4[0,:]>=-180) & (ssch4[0,:]<=-130) & (ssch4[1,:]<=-67) & (ssch4[1,:]>=-73)

igmv_ss5=(ssch5[0,:]>=-31) & (ssch5[0,:]<=0) & (ssch5[1,:]<=-64) & (ssch5[1,:]>=-69) | (ssch5[0,:]>=0) & (ssch5[0,:]<=30) & (ssch5[1,:]<=-64) & (ssch5[1,:]>=-69) | (ssch5[0,:]>=-180) & (ssch5[0,:]<=-130) & (ssch5[1,:]<=-67) & (ssch5[1,:]>=-73)

igmv_ss8=(ssch8[0,:]>=-31) & (ssch8[0,:]<=0) & (ssch8[1,:]<=-64) & (ssch8[1,:]>=-69) | (ssch8[0,:]>=0) & (ssch8[0,:]<=30) & (ssch8[1,:]<=-64) & (ssch8[1,:]>=-69) | (ssch8[0,:]>=-180) & (ssch8[0,:]<=-130) & (ssch8[1,:]<=-67) & (ssch8[1,:]>=-73)

igmv_ss9=(ssch9[0,:]>=-31) & (ssch9[0,:]<=0) & (ssch9[1,:]<=-64) & (ssch9[1,:]>=-69) | (ssch9[0,:]>=0) & (ssch9[0,:]<=30) & (ssch9[1,:]<=-64) & (ssch9[1,:]>=-69) | (ssch9[0,:]>=-180) & (ssch9[0,:]<=-130) & (ssch9[1,:]<=-67) & (ssch9[1,:]>=-73)

igmv_ss10=(ssch10[0,:]>=-31) & (ssch10[0,:]<=0) & (ssch10[1,:]<=-64) & (ssch10[1,:]>=-69) | (ssch10[0,:]>=0) & (ssch10[0,:]<=30) & (ssch10[1,:]<=-64) & (ssch10[1,:]>=-69) | (ssch10[0,:]>=-180) & (ssch10[0,:]<=-130) & (ssch10[1,:]<=-67) & (ssch10[1,:]>=-73)

igmv_ss11=(ssch11[0,:]>=-31) & (ssch11[0,:]<=0) & (ssch11[1,:]<=-64) & (ssch11[1,:]>=-69) | (ssch11[0,:]>=0) & (ssch11[0,:]<=30) & (ssch11[1,:]<=-64) & (ssch11[1,:]>=-69) | (ssch11[0,:]>=-180) & (ssch11[0,:]<=-130) & (ssch11[1,:]<=-67) & (ssch11[1,:]>=-73)

igmv_ss12=(ssch12[0,:]>=-31) & (ssch12[0,:]<=0) & (ssch12[1,:]<=-64) & (ssch12[1,:]>=-69) | (ssch12[0,:]>=0) & (ssch12[0,:]<=30) & (ssch12[1,:]<=-64) & (ssch12[1,:]>=-69) | (ssch12[0,:]>=-180) & (ssch12[0,:]<=-130) & (ssch12[1,:]<=-67) & (ssch12[1,:]>=-73)

igmv_ss13=(ssch13[0,:]>=-31) & (ssch13[0,:]<=0) & (ssch13[1,:]<=-64) & (ssch13[1,:]>=-69) | (ssch13[0,:]>=0) & (ssch13[0,:]<=30) & (ssch13[1,:]<=-64) & (ssch13[1,:]>=-69) | (ssch13[0,:]>=-180) & (ssch13[0,:]<=-130) & (ssch13[1,:]<=-67) & (ssch13[1,:]>=-73)

igmv_ss14=(ssch14[0,:]>=-31) & (ssch14[0,:]<=0) & (ssch14[1,:]<=-64) & (ssch14[1,:]>=-69) | (ssch14[0,:]>=0) & (ssch14[0,:]<=30) & (ssch14[1,:]<=-64) & (ssch14[1,:]>=-69) | (ssch14[0,:]>=-180) & (ssch14[0,:]<=-130) & (ssch14[1,:]<=-67) & (ssch14[1,:]>=-73)

igmv_ss15=(ssch15[0,:]>=-31) & (ssch15[0,:]<=0) & (ssch15[1,:]<=-64) & (ssch15[1,:]>=-69) | (ssch15[0,:]>=0) & (ssch15[0,:]<=30) & (ssch15[1,:]<=-64) & (ssch15[1,:]>=-69) | (ssch15[0,:]>=-180) & (ssch15[0,:]<=-130) & (ssch15[1,:]<=-67) & (ssch15[1,:]>=-73)

igmv_ss16=(ssch16[0,:]>=-31) & (ssch16[0,:]<=0) & (ssch16[1,:]<=-64) & (ssch16[1,:]>=-69) | (ssch16[0,:]>=0) & (ssch16[0,:]<=30) & (ssch16[1,:]<=-64) & (ssch16[1,:]>=-69) | (ssch16[0,:]>=-180) & (ssch16[0,:]<=-130) & (ssch16[1,:]<=-67) & (ssch16[1,:]>=-73)

igmv_ss17=(ssch17[0,:]>=-31) & (ssch17[0,:]<=0) & (ssch17[1,:]<=-64) & (ssch17[1,:]>=-69) | (ssch17[0,:]>=0) & (ssch17[0,:]<=30) & (ssch17[1,:]<=-64) & (ssch17[1,:]>=-69) | (ssch17[0,:]>=-180) & (ssch17[0,:]<=-130) & (ssch17[1,:]<=-67) & (ssch17[1,:]>=-73)

igmv_ss18=(ssch18[0,:]>=-31) & (ssch18[0,:]<=0) & (ssch18[1,:]<=-64) & (ssch18[1,:]>=-69) | (ssch18[0,:]>=0) & (ssch18[0,:]<=30) & (ssch18[1,:]<=-64) & (ssch18[1,:]>=-69) | (ssch18[0,:]>=-180) & (ssch18[0,:]<=-130) & (ssch18[1,:]<=-67) & (ssch18[1,:]>=-73)

tup_gmss=np.zeros([16],float)
tup_gmss[0]=mean(ssch1[16,igmv_ss1])
tup_gmss[1]=mean(ssch2[16,igmv_ss2])
tup_gmss[2]=mean(ssch3[16,igmv_ss3])
tup_gmss[3]=mean(ssch4[16,igmv_ss4])
tup_gmss[4]=mean(ssch5[16,igmv_ss5])
tup_gmss[5]=mean(ssch8[16,igmv_ss8])
tup_gmss[6]=mean(ssch9[16,igmv_ss9])
tup_gmss[7]=mean(ssch10[16,igmv_ss10])
tup_gmss[8]=mean(ssch11[16,igmv_ss11])
tup_gmss[9]=mean(ssch12[16,igmv_ss12])
tup_gmss[10]=mean(ssch13[16,igmv_ss13])
tup_gmss[11]=mean(ssch14[16,igmv_ss14])
tup_gmss[12]=mean(ssch15[16,igmv_ss15])
tup_gmss[13]=mean(ssch16[16,igmv_ss16])
tup_gmss[14]=mean(ssch17[16,igmv_ss17])
tup_gmss[15]=mean(ssch18[16,igmv_ss18])


#ecart types
tupet_gmss=np.zeros([16],float)
tupet_gmss[0]=sqrt(sum(ssch1[16,igmv_ss1]**2)/size(ssch1[16,igmv_ss1])-mean(ssch1[16,igmv_ss1])**2)
tupet_gmss[1]=sqrt(sum(ssch2[16,igmv_ss2]**2)/size(ssch2[16,igmv_ss2])-mean(ssch2[16,igmv_ss2])**2)
tupet_gmss[2]=sqrt(sum(ssch3[16,igmv_ss3]**2)/size(ssch3[16,igmv_ss3])-mean(ssch3[16,igmv_ss3])**2)
tupet_gmss[3]=sqrt(sum(ssch4[16,igmv_ss4]**2)/size(ssch4[16,igmv_ss4])-mean(ssch4[16,igmv_ss4])**2)
tupet_gmss[4]=sqrt(sum(ssch5[16,igmv_ss5]**2)/size(ssch5[16,igmv_ss5])-mean(ssch5[16,igmv_ss5])**2)
tupet_gmss[5]=sqrt(sum(ssch8[16,igmv_ss8]**2)/size(ssch8[16,igmv_ss8])-mean(ssch8[16,igmv_ss8])**2)
tupet_gmss[6]=sqrt(sum(ssch9[16,igmv_ss9]**2)/size(ssch9[16,igmv_ss9])-mean(ssch9[16,igmv_ss9])**2)
tupet_gmss[7]=sqrt(sum(ssch10[16,igmv_ss10]**2)/size(ssch10[16,igmv_ss10])-mean(ssch10[16,igmv_ss10])**2)
tupet_gmss[8]=sqrt(sum(ssch11[16,igmv_ss11]**2)/size(ssch11[16,igmv_ss11])-mean(ssch11[16,igmv_ss11])**2)
tupet_gmss[9]=sqrt(sum(ssch12[16,igmv_ss12]**2)/size(ssch12[16,igmv_ss12])-mean(ssch12[16,igmv_ss12])**2)
tupet_gmss[10]=sqrt(sum(ssch13[16,igmv_ss13]**2)/size(ssch13[16,igmv_ss13])-mean(ssch13[16,igmv_ss13])**2)
tupet_gmss[11]=sqrt(sum(ssch14[16,igmv_ss14]**2)/size(ssch14[16,igmv_ss14])-mean(ssch14[16,igmv_ss14])**2)
tupet_gmss[12]=sqrt(sum(ssch15[16,igmv_ss15]**2)/size(ssch15[16,igmv_ss15])-mean(ssch15[16,igmv_ss15])**2)
tupet_gmss[13]=sqrt(sum(ssch16[16,igmv_ss16]**2)/size(ssch16[16,igmv_ss16])-mean(ssch16[16,igmv_ss16])**2)
tupet_gmss[14]=sqrt(sum(ssch17[16,igmv_ss17]**2)/size(ssch17[16,igmv_ss17])-mean(ssch17[16,igmv_ss17])**2)
tupet_gmss[15]=sqrt(sum(ssch18[16,igmv_ss18]**2)/size(ssch18[16,igmv_ss18])-mean(ssch18[16,igmv_ss18])**2)






for i in range(0,16):
    ti=str(ssmisch[i])
    t='tupet_gmss['+str(i)+']=sqrt(sum(ssch'+ti+'[16,igmv_ss'+ti+']**2)/size(ssch'+ti+'[16,igmv_ss'+ti+'])-mean(ssch'+ti+'[16,igmv_ss'+ti+'])**2)'
    print t





















# on recupere les coordonnes xy de la projection orth standard
m1 = Basemap(projection='ortho', lat_0 = -90, lon_0 = 0,
resolution = 'l')

xii, yii = m1(*np.meshgrid(xvec,yvec))
width = m1.urcrnrx - m1.llcrnrx
height = m1.urcrnry - m1.llcrnry

coef = 0.6
width = width*coef
height = height*coef

# on fait une nouvelle projection en zoomant sur l'antarctique

map = Basemap(projection='ortho',lon_0=0,lat_0=-90,resolution='l',\

llcrnrx=-0.5*width,llcrnry=-0.5*height,urcrnrx=0.5*width,urcrnry=0.5*height)
xii, yii = map(*np.meshgrid(xvec,yvec))
#, clevs, cmap=my_cmap)
cs=map.pcolor(xii,yii,iaaa)
#cmap=cm.s3pcpn_l_r)
#sstanom)
#s3pcpn_l_r)
cbar =colorbar(cs)
plt.title('plateformes)

# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=1)
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(np.arange(0, 360, 1), labels=[0, 0, 0, 1])
map.drawparallels(np.arange(-90, 90, 11), labels=[1, 0, 0, 0])
plt.show()





#################"

# on recupere les coordonnes xy de la projection orth standard
m1 = Basemap(projection='ortho', lat_0 = -90, lon_0 = 0,
resolution = 'l')

xii, yii = m1(*np.meshgrid(xvec,yvec))
width = m1.urcrnrx - m1.llcrnrx
height = m1.urcrnry - m1.llcrnry

coef = 0.5
width = width*coef
height = height*coef

# on fait une nouvelle projection en zoomant sur l'antarctique

map = Basemap(projection='ortho',lon_0=0,lat_0=-90,resolution='l',\

llcrnrx=-0.5*width,llcrnry=-0.5*height,urcrnrx=0.5*width,urcrnry=0.5*height)
xii, yii = map(*np.meshgrid(xvec,yvec))
#, clevs, cmap=my_cmap)
clevs=arange(100,300,1)#star, stop, step
map.pcolor(xii,yii,iab)
cs=map.contour(xii,yii,tbpgrid_ta2, clevs, cmap=cm.s3pcpn_l_r)
#cmap=cm.s3pcpn_l_r)
#sstanom)
#s3pcpn_l_r)
cbar =colorbar(cs)
#plt.title(tt1)
# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=1)
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(np.arange(0, 360, 1), labels=[0, 0, 0, 1])
map.drawparallels(np.arange(-90, 90, 1), labels=[1, 0, 0, 0])
plt.show()
plt.savefig(t1)
close()