work_01.py

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
from mpl_toolkits.mplot3d import Axes3D
import mpl_toolkits.mplot3d.art3d as art3d
from sklearn.metrics import mean_squared_error, r2_score
from sklearn import preprocessing


import seaborn as sns

from scipy.interpolate import Rbf
from scipy import stats

import feature_extract_01


plt.rcParams.update({'font.size': 10})

Y_e2 = np.load('Y_e3.npy')
Y_p2 = np.load('Y_p3.npy')

Y_e = np.load('Y_e3.npy')
Y_p = np.load('Y_p3.npy')

U_e2, idx_2 = np.unique(Y_e2, return_index=True)
#U_p2 = Y_p2[idx_2]


#a = plt.gca()


U_e, idx = np.unique(Y_e, return_index=True)
#U_p = Y_p[idx]


#U_e2 = U_e2[:-1]
#U_p2 = U_p2[:-1]


print Y_e.shape
print Y_p.shape


plt.scatter(0.655*Y_e, Y_p*0.655,  marker='o', color='k')
#ax = sns.regplot(x=0.655*U_e2, y=U_p2*0.655, color='k', ci=None)
plt.plot(U_e2*0.655, U_e2*0.655, 'r-')
plt.xlabel('Pull-out force from MD simulation, $y_a$ (kcal/mol-$\AA$)')
plt.ylabel('Pull-out force predicted by CNN, $y_p$ (kcal/mol-$\AA$)')
plt.xlim([0, 0.3])
plt.ylim([0, 0.3])
plt.savefig('0128_a.svg')
plt.show()


print Y_p
print Y_e.shape

#plt.scatter(Y_e*0.655, Y_p*0.655, marker='o', color='k')
#ax = sns.regplot(x=0.655*U_e, y=U_p*0.655, color='k', ci=None)
#plt.plot(Y_e*0.655, Y_e*0.655, 'r-')
#plt.xlabel('')
#plt.xlabel('Pull-out force from MD simulation, $y_a$ (kcal/mol-$\AA$)')
#plt.ylabel('Pull-out force predicted by CNN, $y_p$ (kcal/mol-$\AA$)')
#plt.savefig('0128_b.eps')
#plt.show()



#ax = sns.regplot(x=0.655*Y_e, y=Y_p*0.655, color='k', ci=None)
#plt.plot(Y_e*0.655, Y_e*0.655, 'r-')
#plt.xlabel('')
#plt.xlabel('Pull-out force from MD simulation (kcal/mol-$\AA$)')
#plt.ylabel('Pull-out force predicted by CNN (kcal/mol-$\AA$)')
#plt.show()

#y_1 = np.asarray([0.0717, 0.0693, 0.24577, 0.1205, 0.1697, 0.1478, 0.1308, 0.099727, 0.13918, 0.177])
#y_2 = np.asarray([0.10471916, 0.0820471, 0.20471905, 0.11640011, 0.18526735, 0.16527307, 0.11741286, 0.08516027, 0.15739903])

y_1 = np.asarray([0.13676012, 0.130767, 0.135377, 0.168977, 0.0903, 0.11841, 0.09972674, 0.1025225, 0.1503119, 0.23511, 0.0693,
 0.10821, 0.1069, 0.11644325])
y_2 = np.asarray([0.14801316, 0.13605912, 0.12091247, 0.1154104,  0.0778389, 0.08565693, 0.05993234, 0.13176746, 0.14584205, 0.25972454, 0.087332,
 0.10474303, 0.11923737, 0.13317969])

y_3A = np.asarray([0.11841,    0.11644325, 0.07176875, 0.2998,     0.12051,    0.338,
 0.146,      0.16019738, 0.147832,   0.1069 ,    0.115 ,     0.1392725,
 0.11361,    0.139177,   0.09921,    0.23511]
)

y_3B = np.asarray([0.08849492, 0.14802898, 0.11080838, 0.2238362,  0.09711447, 0.20738711,
 0.12017283, 0.09355133, 0.14079202, 0.12878593, 0.11468612, 0.15513769,
 0.12270126, 0.14769386, 0.1145251,  0.26311175])

y_4A = np.asarray([0.1208,     0.27035,    0.10574159, 0.139177,   0.16970128, 0.135377,
 0.0668,     0.07176875, 0.12681,    0.0693,     0.09921,    0.12051,
 0.07176875, 0.193,      0.17711  ])


y_4B = np.asarray([0.11640675, 0.26320715, 0.0916954,  0.14874689, 0.19478929, 0.15105196,
 0.11656228, 0.1106748,  0.12403125, 0.1222185,  0.08147962, 0.11396863,
 0.07716906, 0.1725285,  0.21514875])


y_5A =  np.asarray([0.07176875, 0.26625,    0.1503119,  0.1601973, 0.11361,    0.24826,
 0.23511,    0.168977,   0.12051,    0.11361,    0.11841,    0.17711,
 0.16965833, 0.144397,   0.14964325,])

y_5B = np.asarray([0.09996263, 0.28518911, 0.12919339, 0.11890905, 0.1428282,  0.19916089,
 0.28447847, 0.12670528, 0.0723217,  0.12804088, 0.112175,   0.17544986,
 0.13216855, 0.11846693, 0.1186706 ])



#dense_1 = Dense(20, activation='relu')(merge_layer)
print y_1.shape, y_2.shape
R2_val = r2_score(y_1, y_2)
rel_err = np.sqrt(((y_1 - y_2)**2).mean())/np.sqrt(((y_1)**2).mean())
abs_err = np.sqrt(((y_1 - y_2)**2).mean())


R2_val2 = r2_score(y_3A, y_3B)
rel_err2 = np.sqrt(((y_3A - y_3B)**2).mean())/np.sqrt(((y_3A)**2).mean())
abs_err2 = np.sqrt(((y_3A - y_3B)**2).mean())

R2_val3 = r2_score(y_4A, y_4B)
rel_err3 = np.sqrt(((y_4A - y_4B)**2).mean())/np.sqrt(((y_4A)**2).mean())
abs_err3 = np.sqrt(((y_4A - y_4B)**2).mean())

R2_val4 = r2_score(y_5A, y_5B)
rel_err4 = np.sqrt(((y_5A - y_5B)**2).mean())/np.sqrt(((y_5A)**2).mean())
abs_err4 = np.sqrt(((y_5A - y_5B)**2).mean())


print "rel_error: "
print rel_err
print "abs err:"
print abs_err
print np.sqrt(((y_1)**2).mean())
print y_1.shape, y_2.shape
print "R2: ", R2_val

print "rel_error: "
print rel_err2
print "abs err:"
print abs_err2
print np.sqrt(((y_3A)**2).mean())
print "R2: ", R2_val2

print "rel_error: "
print rel_err3
print "abs err:"
print abs_err3
print np.sqrt(((y_4A)**2).mean())
print "R2: ", R2_val3


print "rel_error: "
print rel_err4
print "abs err:"
print abs_err4
print np.sqrt(((y_5A)**2).mean())
print "R2: ", R2_val4


#plt.scatter(y_1, y_2, marker='o', color='k')
#plt.plot(y_1, y_1, 'k-')
plt.scatter(y_5A, y_5B, marker='o', color='k')
plt.plot(y_5A, y_5A, 'k-')
#plt.scatter(y_5A, y_5B, marker='o', color='k')
#plt.plot(y_5A, y_5A, 'k-')
plt.xlabel('Pull-out force from MD simulation, $y_a$ (kcal/mol-$\AA$)')
plt.ylabel('Pull-out force predicted by CNN, $y_p$ (kcal/mol-$\AA$)')
plt.savefig('fig_A3.png')
plt.show()


#####with 5epo

Y_1A = np.asarray([0.1124725,  0.1646, 0.07176875, 0.11361, 0.12051, 0.1695,
 0.146,      0.12051,    0.13092042, 0.135377,   0.1025225,  0.33685,
 0.1069 ,    0.26625,    0.24826,    0.14398,    0.0708])

Y_1B = np.asarray([0.12682588, 0.23706008, 0.0837258,  0.12054308, 0.09465544, 0.10140882,
 0.08919624, 0.09586015, 0.10434677, 0.12690325, 0.14222423, 0.29056428,
 0.12681217, 0.24576758, 0.24443558, 0.1229873,  0.0804355])


Y_2A = np.asarray([0.1503119,  0.22755,    0.11644325, 0.0693,     0.10574159, 0.10491,
 0.153967,   0.20455,    0.21034154, 0.16019738, 0.0668,     0.23511,
 0.324,      0.07176875, 0.09857204])

Y_2B = np.asarray([0.12531392, 0.22371279, 0.13237655, 0.09266734, 0.14833791, 0.13110524,
 0.13799832, 0.25584649, 0.13330473, 0.1222569,  0.09351923, 0.29776998,
 0.26881845, 0.10357127, 0.16810466])

Y_3A = np.asarray([[0.21034154, 0.11841,    0.1069,     0.0708,     0.1991,     0.186,
 0.147832,   0.26625,    0.338,      0.335,      0.1124725,  0.12616,
 0.1069 ,    0.130767,   0.16970128]])

Y_3B = np.asarray([0.14607628, 0.10020559, 0.11507931, 0.07072939, 0.10420206, 0.17871563,
 0.15559948, 0.23765611, 0.17340301, 0.28180545, 0.11271504, 0.13234817,
 0.12924169, 0.13268033, 0.15992477])


y_4A = np.asarray([0.185,      0.1069,     0.146,      0.139177,   0.12681,    0.20455,
 0.11361,    0.12051,    0.27035,    0.152,      0.324,      0.2422,
 0.0903,     0.26475422, 0.10821])

y_4B = np.asarray([0.3527793,  0.14269936, 0.09204183, 0.12970757, 0.13232089, 0.23212216,
 0.15182377, 0.09282818, 0.20273064, 0.15151818, 0.27905096, 0.29120814,
 0.07546078, 0.19707989, 0.06124506])

y_5A = np.asarray([0.14091, 0.16019738, 0.12051,    0.2998,     0.0903,     0.1991,
 0.1695,    0.12616,    0.12051,    0.14964325, 0.130767,   0.0708,
 0.11644325, 0.12063,    0.2422])

y_5B = np.asarray([0.18734897, 0.10759266, 0.10045586, 0.27220927, 0.05845547, 0.11495599,
 0.15115263, 0.11656077, 0.09087567, 0.14292395, 0.11314673, 0.0675782,
 0.1292214,  0.11573128, 0.32226123])

y_6A = np.asarray([0.1394,     0.20455,   0.11361,    0.0668,     0.22755,    0.2422,
 0.26625,    0.0693,     0.111342,   0.1646,     0.01,       0.11644325,
 0.135377,   0.324,      0.0693    ])

y_6B = np.asarray([0.10342522, 0.20388074, 0.12384072, 0.08872045, 0.20902358, 0.32620015,
 0.26955484, 0.08758546, 0.18829081, 0.1967236,  0.09961804, 0.15304849,
 0.1340775,  0.33015327, 0.10041707])


y_7A = np.asarray([0.324,      0.1026,     0.0903,     0.14398,    0.10574159, 0.1208,
 0.11361,    0.11841,    0.33,      0.2998,     0.17711,    0.12051,
 0.07176875, 0.1991,     0.11361,    0.1124725 ])

y_7B = [0.24352094, 0.20789438, 0.10246172, 0.12868677, 0.0844872,  0.14020232,
 0.09805386, 0.10867383, 0.28031494, 0.29442149, 0.20845582, 0.07432412,
 0.09100325, 0.13994999, 0.13542526, 0.13103443]

y_8A = [0.1503119, 0.33685,   0.0708,    0.1208,    0.09921,   0.1069,    0.0951225,
 0.10821,   0.11361,   0.12616,   0.27035,   0.147832,  0.1882,    0.1646,
 0.152 ,    0.139177,  0.338    ]

y_8B = [0.12869292, 0.31873586, 0.10935188, 0.11994639, 0.08906315, 0.13196864,
 0.12682479, 0.11157209, 0.1338419,  0.14927759, 0.31437488, 0.147869,
 0.27832297, 0.19762799, 0.17325149, 0.13179287, 0.23058544]


y_8A = np.asarray([0.185,      0.11361,    0.135377,   0.13676012, 0.0951225,  0.0708,
0.1503119,  0.324,      0.1124725,  0.1882,     0.26475422, 0.11716104,
0.243,      0.236,      0.22755,    0.09857204, 0.2998    ])


y_8B = np.asarray([0.27282045, 0.13272505, 0.14832656, 0.12844399, 0.11427761, 0.0774655,
0.12402303, 0.29831048, 0.1187271,  0.15153102, 0.22301403, 0.13271555,
0.17853624, 0.15028761, 0.20805203, 0.09732312, 0.31325264])

#[0.1124725  0.10821    0.0708     0.1503119  0.13092042 0.09921
# 0.33685    0.20455    0.1695     0.1503119  0.175192   0.1646
# 0.22755    0.193      0.111342   0.130767   0.1260725 ]
#[0.15262683 0.08702462 0.07827152 0.13035881 0.1286883  0.07450552
# 0.29110596 0.2341237  0.13895628 0.12568595 0.16070677 0.26772662
# 0.20997689 0.21754361 0.15819217 0.12823099 0.14788963]


##3###best one
y_8A = np.asarray([0.135377,   0.24577575, 0.0903,     0.324,      0.1503119,  0.07176875,
0.11361,    0.1208,     0.236,      0.0693,     0.168977,   0.1394,
0.111342 ,  0.09921   ])
y_8B = np.asarray([0.16514783, 0.25402272, 0.08525028, 0.28673668, 0.11996168, 0.08413413,
0.14051339, 0.13663342, 0.20995584, 0.07105283 ,0.1479521 , 0.11858206,
0.15002922, 0.07250959])


y_9A = np.asarray([0.16019738, 0.236,      0.153967 ,  0.10491,    0.168977,   0.335,
 0.14091,    0.14964325, 0.12681,    0.26625,    0.11361,    0.0951225,
 0.22755,    0.26475422])


y_9B = np.asarray([0.08876235, 0.2213149,  0.14476413, 0.1730739,  0.14539481, 0.22506904,
 0.20324629, 0.12524823, 0.12691273, 0.23227088, 0.14444365, 0.14365006,
 0.24302395, 0.20516747])


y_10A = np.asarray([0.0675,     0.0693,     0.1991,     0.0668,     0.11716104, 0.1882,
 0.130767,   0.12051,    0.3366,     0.193,      0.1646,     0.10821,
 0.19,       0.1394    ])
y_10B = np.asarray([0.14409419, 0.07934853, 0.17272116, 0.10412355, 0.17464673, 0.18953324,
 0.13505762, 0.07385394, 0.25799852, 0.2046459,  0.17047066, 0.08060652,
 0.22231652, 0.11411107])


y_9A = np.asarray([0.12681,    0.2998,     0.1069,     0.153967,   0.135377,   0.0693,
0.243,      0.11644325, 0.1124725,  0.0693,     0.1260725,  0.12616,
0.146,      0.26625   ])
y_9B = np.asarray([0.13493084, 0.26125645, 0.13707364, 0.13931847, 0.16080593, 0.0924282,
0.16533596, 0.13436984, 0.1289197,  0.10860319, 0.14910614, 0.16764706,
0.09417011, 0.26629341])


y_10A = np.asarray([0.07176875, 0.16970128, 0.1394,     0.243072,   0.13092042, 0.18512274,
 0.09921,    0.16374363, 0.29896516, 0.11361,    0.144397,   0.1069,
 0.0903,     0.19531982, 0.139177,   0.33026266, 0.11361,    0.1392725,
 0.146,      0.147832  ])
y_10B = np.asarray([0.08427238, 0.20144223, 0.11566141, 0.23057701, 0.11640619, 0.24492728,
 0.11650637, 0.23751709, 0.29640166, 0.11865544, 0.12932477, 0.11876208,
 0.05399238, 0.20229107, 0.18244373, 0.24325376, 0.13768959, 0.17808626,
 0.17591401, 0.17651402])


y_11A = np.asarray([0.0903,     0.1025225,  0.19531982, 0.11361,    0.09972674, 0.281,
 0.1345,     0.21961598, 0.27035,    0.07176875, 0.11716104, 0.01,
 0.11841,    0.12624642, 0.27109977, 0.12063,    0.0693    ])
y_11B = np.asarray([0.21953151, 0.11755932, 0.16567766, 0.1298974,  0.07556194, 0.24987506,
 0.17303626, 0.21888881, 0.25634478, 0.09570776, 0.13451181, 0.0819504,
 0.11240596, 0.16000094, 0.22428472, 0.15244923, 0.11108694])



y_12A = np.asarray([0.1503119,  0.1688,     0.1695,     0.19321 ,   0.111342,   0.1375,
 0.144397,   0.23511,    0.12624642, 0.0668,     0.10491,    0.1069,
 0.12051 ,   0.1394 ,    0.12063,    0.27035,    0.01      ])
y_12B = [0.11521091, 0.18276622 , 0.26458314,  0.25280353, 0.10190147, 0.12117693,
 0.15293069, 0.22929676, 0.10078602 ,0.05697771, 0.08837516 ,0.07356329,
 0.05185125, 0.10141521, 0.11951869, 0.28308253, 0.08659298]


y_13A = np.asarray([0.0693,     0.12063 ,   0.14398,    0.11361,    0.11644325, 0.10821,
 0.1991,     0.1069,     0.1375,     0.13092042, 0.23616979, 0.135377,
 0.1260725,  0.27035,    0.12051,    0.1025225,  0.20456   ])
y_13B = np.asarray([0.12869222, 0.13778018, 0.1437838, 0.1110681,  0.15281522, 0.09236834,
 0.14238207, 0.09558471, 0.10098442, 0.134928,   0.2356251,  0.13292229,
 0.11361772, 0.27866045, 0.08525149, 0.13213585, 0.24598886])

#[0.12051    0.13092042 0.07176875 0.26475422 0.1503119  0.07176875
 #0.33501414 0.1646     0.135377   0.111342   0.20456    0.14091
 #0.10821    0.19531982 0.29896516 0.11644325 0.1392725 ]
#[0.07984078 0.09916246 0.07196473 0.34257692 0.13243855 0.0530972
 #0.28156316 0.21279347 0.13861748 0.12913688 0.24987005 0.15836655
 #0.10540141 0.16886497 0.26303972 0.12369805 0.12716063]



#[0.21961598 0.12624642 0.144397   0.24664327 0.13092042 0.121
# 0.13676012 0.1025225  0.256      0.03085    0.146      0.0708
# 0.18512274 0.33026266 0.16374363 0.32475782 0.12681   ]
#[0.23403213 0.15472955 0.16155365 0.24280564 0.15876195 0.12049204
# 0.11640302 0.11307581 0.20476217 0.02609834 0.12142074 0.09710565
# 0.27736856 0.22569623 0.23193861 0.35057382 0.11653729]


y_14A = np.asarray([0.01, 0.1375, 0.1026,     0.135377,   0.19321,    0.32475782,
 0.10821,    0.11361,    0.26625,    0.24220998, 0.33849298, 0.12051,
 0.12624642, 0.0903,     0.111342,   0.12616,    0.1503119 ])
y_14B = np.asarray([0.13880291, 0.10235913, 0.12890166, 0.11223853, 0.217957,   0.31648071,
 0.1118519,  0.13061224, 0.28862243, 0.2120916,  0.27995822, 0.11334281,
 0.1485842,  0.09508056, 0.135116,   0.15374443, 0.13728453])

y_15A = np.asarray([0.12681,    0.17711,    0.01,       0.10965,    0.12051,    0.06,
 0.146,      0.20174362, 0.07176875, 0.03085,    0.11716104, 0.1889725,
 0.30577007, 0.12464147, 0.0903,     0.27109977, 0.168977,   0.07176875,
 0.10821,    0.15965093])
y_15B = np.asarray([0.1404152,  0.1358079,  0.02665675, 0.09072792, 0.14188674, 0.09048563,
 0.15253368, 0.21246848, 0.09514361, 0.10713186, 0.13860023, 0.13090983,
 0.21524729, 0.15130363, 0.11574116, 0.23660619, 0.13489761, 0.10336392,
 0.13506715, 0.11637092])


y_16A = np.asarray([0.1503119,  0.33501414, 0.13623645, 0.0903,     0.1208,     0.21087716,
 0.01,       0.12132747, 0.11361,    0.15965093, 0.0668,     0.153967,
 0.243072,   0.10821,    0.1392725,  0.19323011, 0.33849298, 0.25926365,
 0.22755,    0.1991    ])
y_16B = np.asarray([0.15009542, 0.29789644, 0.10110619, 0.09931809, 0.11621888, 0.14371728,
 0.02947056, 0.15983989, 0.18727189, 0.12635094, 0.10571175, 0.11215903,
 0.31037547, 0.11829434, 0.12041459, 0.20848498, 0.26007277, 0.22848781,
 0.22499517, 0.20763326])


y_17A = np.asarray([0.1883,     0.09857204, 0.11716104, 0.09972674, 0.30577007, 0.23616979,
 0.21087716, 0.115,      0.13676012, 0.22045478, 0.243072,   0.1518,
 0.12063,    0.12398645, 0.15653,    0.23511,   0.19323011, 0.21961598,
 0.14091,    0.144397  ])
y_17B = np.asarray([0.16189443, 0.09295817, 0.1105768,  0.11778034, 0.24997109, 0.28976837,
 0.18416146, 0.10707854, 0.12044233, 0.19366502, 0.25332209, 0.14499223,
 0.12078395, 0.09252314, 0.1859822,  0.26405988, 0.17711887, 0.28299658,
 0.1965142,  0.14320018])

y_18A = np.asarray([0.11841, 0.1193, 0.07176875, 0.33685, 0.22459297, 0.18979901, 0.06985, 0.186, 0.26625, 0.135377,
                    0.1392725, 0.23616979, 0.15965093, 0.12681, 0.27791419, 0.14308172, 0.13275, 0.11644325, 0.13178599,
                    0.11361 ])

y_18B = np.asarray([0.16025178, 0.16687579, 0.10792266, 0.27735404, 0.15631797, 0.23664107, 0.10637438 ,0.1629052,
                    0.29252406, 0.13192593, 0.1573071, 0.28101202, 0.09301293, 0.10948511, 0.22954093, 0.14063834,
                    0.14410686, 0.12391235, 0.11613223, 0.20081433])


y_19A = np.asarray([0.2561, 0.10965,  0.29281093, 0.11716104, 0.01, 0.1193, 0.1688733,  0.0708,  0.1889725,
                     0.23899319, 0.0668, 0.24220998, 0.16226182, 0.0903, 0.03085, 0.27291309, 0.139177,  0.22755,
                     0.146, 0.06493551])
y_19B = np.asarray([0.2763596,  0.10318836, 0.18425373, 0.12128597, 0.06241409, 0.17174236,
                    0.13942518, 0.11482794, 0.11043784, 0.22129676, 0.1129926,  0.26355871, 0.10927984,
                    0.09618725, 0.08783374, 0.21543881, 0.11942142, 0.17156775, 0.11051448, 0.16105361])


y_20A = np.asarray([0.0903,     0.1069,     0.09972674, 0.10965,    0.33685,    0.1688733,
                    0.29281093, 0.1269,     0.27035,   0.139177,   0.15637746, 0.16902085,
                    0.0693,     0.1069,     0.10491,    0.14091,    0.23524806, 0.21087716,
                    0.13275,    0.10821   ])
y_20B = np.asarray([0.22333115, 0.12708578, 0.13485476, 0.10765399, 0.28193485, 0.14782152,
                    0.2658038,  0.171790,  0.26355639, 0.14969092, 0.15657085, 0.16719335,
                    0.09806514, 0.09749667, 0.17906716, 0.16254598, 0.26823495, 0.19153221,
                    0.14473338, 0.11643707])


y_21A = np.asarray([0.03,       0.152,      0.03,       0.20456,   0.24826,    0.12051,
 0.12132747, 0.26475422, 0.12132747, 0.13178599, 0.0903,     0.16019738,
 0.27035,    0.11716104, 0.1392725,  0.1695,     0.29896516, 0.16260671,
 0.1025225,  0.19321   ])
y_21B = np.asarray([0.1127527,  0.14656446, 0.07160317, 0.22735779, 0.22676432, 0.12600115,
 0.12030467, 0.23996579, 0.16363919, 0.20864901, 0.07847568, 0.22967483,
 0.25146592, 0.10551238, 0.14301955, 0.12899319, 0.27248025, 0.1774575,
 0.14937223, 0.2376745 ])

y_22A = np.asarray([0.22755,    0.168,      0.10491,    0.186,      0.1208,     0.28142641,
 0.152,      0.07176875, 0.19531982,  0.146,     0.115,     0.03085,
 0.11361,    0.17659483, 0.0693 ,    0.14964325, 0.147832,   0.18869297,
 0.10598097, 0.11841   ])
y_22B = np.asarray([0.17423962, 0.09850327, 0.12549889, 0.11306786, 0.16520819, 0.24251038,
 0.136439,   0.09794488, 0.16754232 ,0.13412744, 0.08949984, 0.07453275,
 0.20668046, 0.19276031, 0.14415431, 0.12547791, 0.14317043, 0.22905292,
 0.06972464, 0.14498933])


y_23A = np.asarray([0.10965,    0.152,      0.09857204, 0.18512274, 0.14125393, 0.19185636,
                    0.19277106, 0.06493551, 0.14091,    0.12132747 ,0.10863859, 0.0693,
                    0.01,       0.28142641, 0.27,       0.30577007, 0.13676012, 0.168977,
                    0.1503119,  0.19323011])
y_23B = np.asarray([0.11227625, 0.13517073, 0.19726297, 0.22316796, 0.21095702, 0.22304312,
                    0.20175126, 0.14287135, 0.15174257, 0.12962562, 0.13800142, 0.13117237,
                    0.09313634, 0.24470205, 0.27623544, 0.2558347,  0.14349594, 0.15687201,
                    0.14535286, 0.17362945])

y_24A = np.asarray([0.17711,    0.1688733,  0.111342,   0.135377,   0.15653,    0.09921,
 0.147832,   0.33501414, 0.01,       0.14398,    0.13275,    0.10965,
 0.152,      0.26475422, 0.1026,     0.24577575, 0.1883,     0.14308172,
 0.153967,   0.16226182])
y_24B = np.asarray([0.14582704, 0.15847997, 0.11900291, 0.14831986, 0.1116814,  0.13020842,
 0.13108707, 0.25156076, 0.06255409, 0.1225847,  0.1696279,  0.0754816,
 0.12137853, 0.19591631, 0.08430089, 0.20690725, 0.12774185, 0.12625899,
 0.1536873,  0.16173235])

y_25A = np.asarray([0.20456,    0.1124725,  0.1026,     0.29896516, 0.24577575, 0.10491,
                   0.29281093,  0.1503119,  0.26625,    0.22459297, 0.12112295, 0.13676012,
                   0.09972674, 0.11644325, 0.09857204, 0.13092042, 0.0693 ,    0.16226182,
                   0.03085,    0.13340093])
y_25B = np.asarray([0.23601126, 0.14492032, 0.0845883,  0.28059643, 0.2192203,  0.11445641,
                   0.21744805, 0.18336292, 0.30734852, 0.20644824, 0.17455266, 0.1532042,
                   0.15564744, 0.11490105, 0.11635548, 0.15406922, 0.12653583, 0.14095587,
                   0.08931562, 0.1089824 ])

y_26A = np.asarray([0.1688733,  0.23899319, 0.2561,     0.0675,     0.27791419, 0.144397,
 0.1991,     0.29281093, 0.12063,    0.15653,    0.18869297, 0.1646,
 0.168,      0.10491,    0.1025225,  0.17028645, 0.1269,     0.33685,
 0.06,       0.13178599])
y_26B = np.asarray([0.13850118, 0.20735931, 0.29048388, 0.08226015, 0.26616762, 0.1503305,
 0.1505035,  0.24410139, 0.13174871, 0.11908765, 0.22986823, 0.16241475,
 0.08289742, 0.14659807, 0.12411216, 0.14660708, 0.16651287, 0.26441075,
 0.1141119,  0.15776657])


y_27A = np.asarray([0.11841,    0.11361,    0.199,      0.115,      0.29896516, 0.16260671,
 0.13448912, 0.33685,    0.111342,   0.26475422, 0.13623645, 0.27,
 0.10965,    0.14398,    0.10821,    0.12464147, 0.27291309, 0.24220998,
 0.22755,    0.361     ])
y_27B = np.asarray([0.13520672, 0.16987338, 0.20262899, 0.12790678, 0.27384474, 0.17980241,
 0.14273005, 0.24827559, 0.13554595, 0.25431063, 0.14731175, 0.21923213,
 0.10676008, 0.13083768, 0.12439422, 0.15002017, 0.23665239, 0.26608432,
 0.18980592, 0.30380514])

y_28A = np.asarray([0.10574159, 0.26475422, 0.11361,    0.10821,    0.199,      0.30577007,
 0.26625,    0.1493,     0.130767,   0.15360647, 0.01,       0.18869297,
 0.12464147, 0.2004274,  0.16902085, 0.12616,    0.33501414, 0.144397,
 0.21034154, 0.13676012])
y_28B = np.asarray([0.11287082, 0.23935569, 0.21229845, 0.10673607, 0.22803274, 0.24922132,
 0.26234249, 0.16931915, 0.14162438, 0.20493627, 0.09989213, 0.22886944,
 0.15446856, 0.16701002, 0.1461213,  0.11714833, 0.26386966, 0.14933516,
 0.20141871, 0.1208773 ])


y_29A = np.asarray([0.2561,     0.16965833, 0.19321,    0.16970128, 0.18512274, 0.06,
 0.16374363, 0.12398645, 0.33501414, 0.1025225,  0.12051,    0.1208,
 0.18979901, 0.17711,    0.23616979, 0.26625,   0.12681,    0.07176875,
 0.09857204, 0.139177  ])
y_29B = np.asarray([0.24790707, 0.13269266, 0.22022795, 0.15222802, 0.21791723, 0.12085745,
 0.19143489, 0.14265227, 0.27232978, 0.14348759, 0.1381713,  0.13552912,
 0.21484745, 0.15271407, 0.25647989, 0.29258674, 0.12248285, 0.09389002,
 0.16581209, 0.13803909])

##************************************GCN***************************************************************
y_30A = np.asarray([0.11509532, 0.09040624, 0.1102284,  0.09094289, 0.21632129, 0.32331434,
 0.17460988, 0.17293264, 0.18429983, 0.1703756,  0.14878893, 0.137136,
 0.22615899, 0.19729008, 0.11548608, 0.16084436, 0.12053805, 0.1180336,
 0.29652092, 0.14669146, 0.17938283])

y_30B =np.asarray([0.11509532, 0.09040624, 0.1102284,  0.09094289, 0.21632129, 0.32331434,
 0.17460988 ,0.17293264, 0.18429983, 0.1703756,  0.14878893, 0.137136,
 0.22615899, 0.19729008, 0.11548608, 0.16084436, 0.12053805, 0.1180336,
 0.29652092, 0.14669146, 0.17938283])


y_31A = np.asarray([0.130767,   0.111342,   0.30831938, 0.1025225,  0.27109977, 0.14952085,
 0.12051,    0.16374363, 0.17028645, 0.22755,    0.1688733,  0.15653,
 0.12132747, 0.20174362, 0.11361,    0.192,      0.13676012, 0.14964325,
 0.23524806, 0.2649,     0.243072])

y_31B = np.asarray([0.13641943, 0.11379279, 0.3336218,  0.12492086, 0.30530575, 0.21581145,
 0.1200816,  0.1591619,  0.29446456, 0.19083884, 0.19689792, 0.10961945,
 0.0964705,  0.18804385, 0.251772,   0.22374788, 0.1776945,  0.11370226,
 0.2231456,  0.18538448, 0.3559578])


y_32A = np.asarray([0.27035,    0.28683111, 0.1518,     0.11841,    0.16423111, 0.16260671,
 0.168977,   0.361,      0.16970128, 0.3,        0.1069,     0.16226182,
 0.12624642, 0.111342,   0.2371,     0.2796,     0.14964325,
 0.0317,     0.21961598, 0.146     ])
y_32B = np.asarray([0.3149802,  0.2401184,  0.10616995, 0.15069407, 0.09140088, 0.19491772,
 0.22902638, 0.27353176, 0.1957332,  0.24635862, 0.07805321, 0.16087948,
 0.17149632, 0.1254301,  0.20468836, 0.28207892, 0.18689293,
 0.05658713, 0.33632922, 0.17523505])

y_33A = np.asarray([0.14964325, 0.07176875, 0.146,      0.19323011, 0.11716104, 0.23524806,
 0.0317,     0.1025225,  0.12398645,    0.16970128, 0.18512274,
 0.10821,    0.20174362, 0.11644325, 0.27109977, 0.11841,    0.14308172,
 0.0693,     0.1688733,  0.111342  ])
y_33B = np.asarray([0.1396978,  0.09990993, 0.10856082, 0.14810118, 0.09528863, 0.23796557,
 0.04300107, 0.16456385, 0.08214935, 0.14519428, 0.17977576,
 0.06626219, 0.16564381, 0.09032193, 0.34696162, 0.10807028, 0.09275129,
 0.09136187, 0.19252735, 0.09877382])

y_34A = np.asarray([0.22045478, 0.0951225,  0.11644325, 0.13178599,0.19277106, 0.3362,
 0.14074635, 0.06,       0.19323011, 0.26084297, 0.0693,     0.12464147,
 0.11716104, 0.14125393, 0.12624642, 0.13275,    0.13623645, 0.13178599,
 0.11291331, 0.33026266 ])
y_34B = np.asarray([0.17599241, 0.10939213, 0.108762,   0.20432901, 0.19658428, 0.26555926,
 0.19180809, 0.11405504, 0.1735291,  0.197633 ,  0.15366569, 0.13955574,
 0.1127706,  0.19322883, 0.18198206, 0.10485356, 0.11030684, 0.1041114,
 0.16585669, 0.3013299])

y_35A = np.asarray([0.23524806, 0.19531982, 0.2841,     0.10491,    0.16965833, 0.21034154,
 0.12112295, 0.11716104, 0.09972674, 0.27791419, 0.26084297,
 0.146,      0.16019738, 0.2552,     0.24577575, 0.15614682, 0.14308172,
 0.29896516, 0.25293867, 0.10598097])
y_35B = np.asarray([0.1971011,  0.19861591, 0.21292944, 0.11963277, 0.22342342, 0.23321544,
 0.18037774, 0.13257602, 0.14002386, 0.25537708, 0.29664147,
 0.13592973, 0.19755583, 0.24317698, 0.2319053,  0.19002044, 0.13453402,
 0.30452746, 0.2755264 , 0.07686298])

y_36A = np.asarray([0.18979901, 0.192,      0.139177,   0.14964325, 0.14125393, 0.03085,
 0.26625,    0.13275,    0.12132747, 0.1518,     0.29281093, 0.1025225,
 0.13623645, 0.27291309, 0.23524806, 0.1503119,  0.3362,     0.16374363,
 0.2004274,  0.20456,    0.17659483])
y_36B = np.asarray([0.20536251, 0.22600752, 0.1638793,  0.17971309, 0.17506026, 0.04701614,
 0.2620558,  0.12866503, 0.11516902, 0.14362256, 0.20631146, 0.11614678,
 0.14822851, 0.19523032, 0.27766192, 0.17732985, 0.26368514, 0.20416592,
 0.20354432, 0.23681425, 0.19707611])


y_37A = np.asarray([0.13178599, 0.1269,     0.0675,     0.29281093, 0.1394,     0.33501414,
 0.144397,   0.147832,   0.13448912, 0.28683111, 0.29281093, 0.19531982,
 0.1193,     0.01,       0.11361,    0.23511,    0.1688733,  0.25293867,
 0.12063,    0.02905,    0.19323011])
y_37B =  np.asarray([0.12679099, 0.13626222, 0.08632748, 0.24092834, 0.11935353, 0.30701917,
 0.15793937, 0.1509124,  0.0764413,  0.22126383, 0.2142009,  0.18396409,
 0.1728011,  0.06289718, 0.14062391, 0.18984286, 0.21542144, 0.26439384,
 0.15592526, 0.06289718, 0.23709756])

y_38A =  np.asarray([0.10598097, 0.12616,    0.13275,    0.1646,     0.1208,     0.24664327,
 0.19323011, 0.153967,   0.21034154, 0.10491,    0.24826,    0.22755,
 0.19277106, 0.14398,    0.23616979, 0.2841,     0.17711,    0.12681,
 0.33663681, 0.11291331, 0.1260725 ])
y_38B =  np.asarray([0.04753855, 0.10666815, 0.12930013, 0.16076499, 0.12352651, 0.18491657,
 0.13429688, 0.18665893, 0.21436924, 0.1278518,  0.23632017, 0.20227312,
 0.21903302, 0.13630669, 0.25525013, 0.22850342, 0.16277629, 0.11114527,
 0.3036204,  0.1770637,  0.10834841])

y_39A =  np.asarray([0.16496995, 0.2004274,  0.0693,     0.09857204, 0.10965,    0.1392725,
 0.13676012, 0.24664327, 0.2649,     0.19321,    0.18512274, 0.19531982,
 0.29281093, 0.2633,     0.11644325, 0.01,       0.06,       0.27924734,
 0.2802,     0.1260725,  0.20174362])
y_39B =  np.asarray( [0.11417183, 0.18253933, 0.07733008, 0.11857441, 0.05071099, 0.12575884,
 0.13132934, 0.23054798, 0.17485648, 0.1852287,  0.22985734, 0.17098118,
 0.2704544,  0.22364175, 0.1209208,  0.05071099, 0.0774976,  0.28389782,
 0.25457335, 0.10387324, 0.16821489])

y_40A = np.asarray( [0.192,      0.27791419, 0.30577007, 0.18789782, 0.186,      0.1208,
 0.07176875, 0.111342,   0.0317,     0.3,        0.16496995, 0.12132747,
 0.01,       0.1026,     0.26516467, 0.29281093, 0.1503119,  0.30831938,
 0.20174362, 0.1025225,  0.21034154])
y_40B = np.asarray( [0.23722273, 0.21316403, 0.37725866, 0.24250606, 0.12358411, 0.12863044,
 0.07649297, 0.06973009, 0.049466,   0.32347542, 0.1279048,  0.10100104,
 0.049466,   0.049466,   0.19901156, 0.15165466, 0.15951891, 0.32162356,
 0.16688244, 0.12625197, 0.20340466])

y_41A = np.asarray([0.199,      0.13623645, 0.14091,    0.22554297, 0.11291331, 0.17711,
 0.14125393, 0.28142641, 0.11361,    0.16226182, 0.2409807,  0.2004274,
 0.20174362, 0.19185636, 0.11527881, 0.130767,   0.17028645, 0.2889,
 0.11716104, 0.27291309, 0.12464147])
y_41B = np.asarray([0.21520522, 0.15528753, 0.13756503, 0.17657149, 0.14286701, 0.13525154,
 0.23110726, 0.25613326, 0.12793967, 0.16046628, 0.188895,   0.17953621,
 0.21700601, 0.26776513, 0.15243511, 0.13316907, 0.18260732, 0.2279689,
 0.11461472, 0.25221923, 0.17219946])

y_42A = np.asarray( [0.24577575, 0.1504,     0.18789782, 0.22755,    0.16970128, 0.192,
 0.111342,   0.12063,    0.17711,    0.26516467, 0.361,      0.12464147,
 0.23524806, 0.1646,     0.33849298, 0.1503119,  0.22554297, 0.11644325,
 0.2761,     0.16496995, 0.23899319])
y_42B = np.asarray([0.2353263,  0.15008278, 0.19797021, 0.1989999,  0.14861481, 0.27667886,
 0.09428109, 0.1079834,  0.14121757, 0.17261083, 0.28962487, 0.15724938,
 0.26073444, 0.1813039,  0.27098024, 0.19949475, 0.15796915, 0.13988052,
 0.3088745,  0.12170854, 0.2461392 ])


y_43A = np.asarray([0.33849298, 0.18512274, 0.29281093, 0.16496995, 0.2435,     0.32475782,
 0.11841,    0.22459297, 0.28683111, 0.4109,     0.23524806, 0.18979901,
 0.299,      0.33026266, 0.1208,     0.168977,   0.19531982, 0.09972674,
 0.1394,     0.10965,    0.29896516])
y_43B = np.asarray([0.29089326, 0.21967712, 0.2521395,  0.11687248, 0.20777163, 0.28619123,
 0.13496198, 0.17827034, 0.2102867,  0.36765096, 0.26398903, 0.15093553,
 0.2081437,  0.28655827, 0.15848224, 0.17325076, 0.19747175, 0.14312905,
 0.12283538, 0.04876036, 0.29705608])

y_44A = np.asarray([0.33501414, 0.23899319, 0.12624642, 0.168977,   0.199,      0.13340093,
 0.27109977, 0.0882,     0.12616,    0.2409807,  0.1758,     0.1649699,
 0.15965093, 0.19277106, 0.2796,     0.1991,     0.11716104, 0.22554297,
 0.19185636, 0.2435,     0.1208    ])
y_44B = np.asarray([0.282104,   0.2748517,  0.09210577, 0.1577556,  0.19782951, 0.11133205,
 0.2682805,  0.09291447, 0.10634846, 0.17539467, 0.11305146, 0.1699857,
 0.13655458, 0.2209775,  0.30795673, 0.19731498, 0.12176859, 0.20922856,
 0.24398635, 0.2068153,  0.09488818])


y_45A = np.asarray([0.33501414, 0.23899319, 0.12624642, 0.168977,   0.199,      0.13340093,
 0.27109977, 0.0882,     0.12616,    0.2409807,  0.1758,     0.16496995,
 0.15965093, 0.19277106, 0.2796,     0.1991,     0.11716104, 0.22554297,
 0.19185636, 0.2435,     0.1208    ])
y_45B = np.asarray([0.282104,   0.2748517,  0.09210577, 0.1577556,  0.19782951, 0.11133205,
 0.2682805,  0.09291447, 0.10634846, 0.17539467, 0.11305146, 0.1699857,
 0.13655458, 0.2209775,  0.30795673, 0.19731498, 0.12176859, 0.20922856,
 0.24398635, 0.2068153,  0.09488818])

y_46A = np.asarray([0.33501414, 0.23899319, 0.12624642, 0.168977,   0.199,      0.13340093,
 0.27109977, 0.0882,     0.12616,    0.2409807,  0.1758,     0.16496995,
 0.15965093, 0.19277106, 0.2796,     0.1991,     0.11716104, 0.22554297,
 0.19185636, 0.2435,     0.1208    ])
y_46B = np.asarray([0.282104,   0.2748517,  0.09210577, 0.1577556,  0.19782951, 0.11133205,
 0.2682805,  0.09291447, 0.10634846, 0.17539467, 0.11305146, 0.1699857,
 0.13655458, 0.2209775,  0.30795673, 0.19731498, 0.12176859, 0.20922856,
 0.24398635, 0.2068153,  0.09488818])

y_47A = np.asarray([0.147832,   0.14952085, 0.15965093, 0.23616979, 0.0882,     0.16374363,
 0.1518,     0.12051,    0.25926365, 0.33663681, 0.25293867, 0.21087716,
 0.1758,     0.22755,    0.1695,     0.168977,   0.0693,     0.26084297,
 0.29896516, 0.27035,    0.01      ])
y_47B = np.asarray([0.13874952, 0.18027838, 0.13249584, 0.258292,   0.0993659,  0.16896996,
 0.10733509, 0.14128016, 0.2485491,  0.27596554, 0.27847433, 0.16972566,
 0.12292638, 0.19520062, 0.13913947, 0.18124753, 0.08851764, 0.2699677,
 0.3012429,  0.2579907,  0.05478704])

y_48A = np.asarray([0.33849298, 0.2409807,  0.26475422, 0.1124725,  0.1688733,  0.28142641,
 0.30831938, 0.1758,     0.12681,    0.12616,    0.186,      0.12112295,
 0.0708,     0.2004274,  0.19531982, 0.22045478, 0.06985,    0.111342,
 0.152,      0.0693,     0.2702    ])
y_48B =  np.asarray([0.33014607, 0.1883436,  0.2058772,  0.1288517,  0.16952655, 0.25488913,
 0.31584153, 0.12497412, 0.09827481, 0.10692509, 0.09594642, 0.2001181,
 0.08730817, 0.14976372, 0.19281277, 0.18663305, 0.11595629, 0.11604975,
 0.13024348, 0.07800278, 0.19164132])

y_49A = np.asarray([0.130767,   0.1518,     0.0317,     0.2889,     0.1504,     0.25293867,
 0.13676012, 0.243072,   0.10965,    0.03085,    0.16019738, 0.19321,
 0.26475422, 0.153967,   0.28683111, 0.28142641, 0.2435,     0.1991,
 0.19277106, 0.27791419, 0.13275   ])
y_49B = np.asarray([0.17443338, 0.16671441, 0.02732444, 0.30326995, 0.11276693, 0.2987311,
 0.11847726, 0.28643957, 0.03824148, 0.03013459, 0.15958506, 0.20821261,
 0.23784411, 0.1745609,  0.2777786,  0.2650436,  0.2248029,  0.20890877,
 0.18557765, 0.26672515, 0.12225703])


#####-----------------------__RBF-CNN----------------------------

y_50A = np.asarray([0.29281093, 0.11361,    0.22755,    0.01,       0.2577 ,    0.13676012,
 0.1991,     0.11644325, 0.175192,   0.1260725,  0.243072,   0.2633,
 0.16226182, 0.2552,     0.13340093, 0.21961598, 0.33026266, 0.27109977,
 0.23511,    0.17659483, 0.09972674])
y_50B = np.asarray([0.30392518, 0.1963033,  0.19297048, 0.11249272, 0.28274278 ,0.1467538,
 0.2000864 , 0.13038178, 0.14637865 , 0.13424877 , 0.29233793, 0.27088735,
 0.24772244, 0.25722646, 0.10867662, 0.28219623, 0.24395209, 0.28528182,
 0.21313528, 0.19201735, 0.12171795])


y_51A = np.asarray([0.11716104, 0.28683111, 0.25293867, 0.16496995, 0.27924734, 0.10965,
 0.27109977, 0.1883,     0.168,      0.2802,     0.13448912, 0.12051,
 0.12132747, 0.152 ,     0.2796,     0.11361,    0.1025225 , 0.1394,
 0.10598097, 0.26084297, 0.15614682])
y_51B = np.asarray([0.14249992, 0.23659698, 0.30778394, 0.11953703, 0.24111787, 0.07437315,
 0.28588216, 0.11757663, 0.09099885, 0.31121391, 0.13984865, 0.15779077,
 0.19685993, 0.14738999, 0.25648328, 0.17873604, 0.13903766, 0.13231966,
 0.08164039, 0.22782239, 0.17605845])


y_52A = np.asarray([0.111342,   0.2796,     0.14074635, 0.2889,     0.0951225,  0.23511,
 0.06985,    0.17659483, 0.2552,     0.2841,     0.11644325, 0.11361,
 0.168977,   0.13448912, 0.139177,   0.18789782, 0.12464147, 0.0708,
 0.16496995, 0.19185636, 0.26475422])
y_52B = [0.12819533, 0.26713552, 0.19833332, 0.25495337, 0.11320955, 0.22793958,
 0.08490862, 0.18864297, 0.20610654, 0.22036655, 0.11992243, 0.15392,
 0.14428626, 0.13793711, 0.13737465, 0.23716271, 0.15561825, 0.10665413,
 0.12576768, 0.23246785, 0.25802096]

y_53A = np.asarray([0.1695,     0.3 ,       0.29281093, 0.2633,     0.23511,    0.18789782,
 0.10821,    0.0708,     0.135377,   0.27791419, 0.13092042, 0.1503119,
 0.2577,     0.26084297, 0.12464147, 0.0317,     0.26625,    0.2409807,
 0.13275,    0.1269,     0.146     ])
y_53B = np.asarray([0.15101338, 0.25249332, 0.23927126, 0.24465421, 0.21061593, 0.21794395,
 0.10472927, 0.09025799, 0.15095272, 0.22515703, 0.12772,    0.16787103,
 0.28335237, 0.2086255,  0.16069001, 0.09221828, 0.24371814, 0.1911179,
 0.13872433, 0.22285553, 0.11410781])


y_54A = np.asarray([0.1932,   0.16423111, 0.2633,     0.1503119,  0.12857678, 0.12398645,
 0.03085,    0.199 ,     0.11841,    0.13676012, 0.243072,   0.27,
 0.14091,    0.01  ,     0.2409807,  0.18789782, 0.1991,     0.153967,
 0.16260671, 0.237,1 ,    0.01      ])
y_54B = np.asarray([0.2135906,  0.17562668, 0.26489074, 0.15474548, 0.14660391, 0.12987458,
 0.10020686, 0.17102181, 0.13041565, 0.15308458, 0.29399714, 0.23391976,
 0.14590889, 0.10838387, 0.18364622, 0.21365952, 0.18281363, 0.14575176,
 0.19980471, 0.24010899, 0.10430649])

y_55A = np.asarray([0.19531982, 0.26625,    0.3362,     0.11716104, 0.0903,     0.1695,
 0.26475422, 0.13092042, 0.12063,    0.14125393, 0.10965,    0.1883,
 0.27791419, 0.15965093, 0.20456,    0.11841,    0.17028645, 0.06985,
 0.13340093, 0.29281093, 0.1026    ])
y_55B = np.asarray([0.19464484, 0.31273922, 0.26103193, 0.14719359, 0.09106043, 0.12402801,
 0.22892309, 0.17008945, 0.14312249, 0.25179212, 0.08593333, 0.13018888,
 0.27275395, 0.16995799, 0.23760099, 0.15831494, 0.16820345, 0.08363832,
 0.12200297, 0.23839498, 0.08572112])

y_56A = np.asarray([0.1503119,  0.1069,    0.13092042, 0.14308172, 0.12857678, 0.147832,
 0.16496995, 0.20456,    0.24220998, 0.16226182, 0.19531982, 0.11644325,
 0.33663681, 0.2577,     0.01 ,      0.16260671, 0.11644325, 0.19531982,
 0.33849298, 0.16902085, 0.13623645])
y_56B = np.asarray([0.18583996, 0.12779128, 0.13540324, 0.15835963, 0.16083626, 0.13801076,
 0.15932316, 0.25339071, 0.28678509, 0.22445106, 0.18504325, 0.1483012,
 0.22631134, 0.30198305, 0.09000067, 0.19551047, 0.1674093,  0.18208281,
 0.30078859, 0.17596663, 0.16785993])

y_57A = np.asarray([0.07176875, 0.3,        0.2351,   0.0693 ,    0.07176875, 0.24826,
 0.01  ,     0.29281093, 0.15653,    0.146,      0.11644325, 0.33849298,
 0.1208,     0.22755,    0.09857204 ,0.2435 ,    0.1069,     0.07176875,
 0.0675 ,    0.15614682, 0.16423111])
y_57B = np.asarray([0.09320735, 0.26531802, 0.22228042, 0.13832258, 0.09246767, 0.1807633,
 0.2176451,  0.24703743 ,0.13020383, 0.15131702 ,0.12782189, 0.26628691,
 0.14496974, 0.16266524 ,0.13328203, 0.29945963, 0.09751962, 0.08430668,
 0.08733154, 0.1978519, 0.19934445])

y_58A = np.asarray([0.1260725,  0.07176875, 0.299,      0.32475782, 0.11716104, 0.0708,
 0.1503119,  0.09857204, 0.22045478, 0.12051,    0.12132747, 0.2435,
 0.01,       0.26475422, 0.16226182, 0.152,      0.186,      0.02905,
 0.2552,     0.13448912, 0.2761    ])
y_58B = np.asarray([0.14750753, 0.1137594,  0.24658116, 0.23587965, 0.13898938, 0.10937285,
 0.18327427, 0.12288833, 0.12681216, 0.14276923, 0.18559387, 0.28486333,
 0.06470777, 0.25460322, 0.17289575, 0.14375196, 0.13550495, 0.09696629,
 0.22270023, 0.12851639, 0.26651781])

y_59A = np.asarray([0.24577575, 0.153967,   0.152,      0.23616979, 0.25293867, 0.24826,
 0.10598097, 0.23899319, 0.12051,    0.16614491, 0.26475422, 0.19531982,
 0.1392725,  0.07176875, 0.17028645, 0.26516467, 0.192,      0.23524806,
 0.27291309, 0.1069,     0.07176875])
y_59B = np.asarray([0.20229865, 0.15817906, 0.13255485, 0.25718127, 0.2731274,  0.19958844,
 0.09656343, 0.26997913, 0.13761118, 0.16949308, 0.2068999,  0.17140364,
 0.13887308, 0.10269124, 0.1758895,  0.21581059, 0.2101971,  0.26432215,
 0.21956543, 0.12893101, 0.10052644])


y_60A = np.asarray([0.17028645, 0.29281093, 0.2004274,  0.19531982, 0.27,       0.02905,
 0.12616,    0.12624642, 0.33685,    0.1069,     0.13178599, 0.27291309,
 0.2702,     0.11291331, 0.4109,     0.1213274, 0.26475422, 0.23616979,
 0.14964325, 0.1646,     0.30831938])
y_60B = np.asarray([0.18158163, 0.26469425, 0.20513741, 0.20487548, 0.2772773,  0.12127899,
 0.12507736, 0.16660098, 0.23508017, 0.1199375,  0.20977793, 0.22441572,
 0.20685417, 0.19164889, 0.3193259,  0.20734107, 0.2252088,  0.25594859,
 0.13910015, 0.1593044,  0.21322073])

y_61A = np.asarray([0.130767,   0.1269,     0.1504,     0.1695,     0.2435,     0.27924734,
 0.10491,    0.02905,    0.29281093, 0.115,      0.27035,    0.0951225,
 0.12616,    0.2577,     0.2889,     0.152,      0.13340093, 0.299,
 0.09921,    0.27291309, 0.2761    ])
y_61B = np.asarray([0.14430026, 0.18338888, 0.14087893, 0.14957292, 0.26965984, 0.24064754,
 0.14287947, 0.08059196, 0.25069603, 0.08217012, 0.24364452, 0.11872343,
 0.12267654, 0.23203308, 0.20868259, 0.13840325, 0.10615558, 0.18718592,
 0.12066251, 0.19316031, 0.26219844])

##################################################################################################################

y_62A = np.asarray([0.2715425,  0.25484724, 0.24099358, 0.16715629, 0.16144693, 0.19942083,
 0.33494619, 0.07044444, 0.32312686, 0.26864211, 0.14054454, 0.16414146,
 0.26884303, 0.10636314, 0.03069507, 0.17193128, 0.19180295, 0.20073045,
 0.11303944, 0.26491287, 0.18884583, 0.11303944, 0.07140832, 0.19132726,
 0.23779295])
y_62B =  np.asarray([0.20439516, 0.34319114, 0.28418939, 0.09000368, 0.15892294, 0.16064647,
0.25675369, 0.08331681, 0.19683381, 0.27924876, 0.21531167, 0.15111642,
0.21448147, 0.11992198, 0.12277026, 0.15363722, 0.1783491,  0.20641407,
0.15241007, 0.2439201,  0.20743827, 0.2193298,  0.07712579, 0.19104476,
 0.24723312])

y_63A = np.asarray([0.19132726, 0.25484724, 0.32860406, 0.10636314, 0.18884583, 0.24185127,
 0.19805488, 0.12336378, 0.27784493, 0.18506589, 0.26491287, 0.11585846,
 0.16817202, 0.28480916, 0.1256124,  0.12071816, 0.20842823, 0.108093,
 0.15559212, 0.15319376, 0.09922591, 0.10200762, 0.08984651, 0.24701322,
 0.24509402])
y_63B = np.asarray([0.26094701, 0.30314605, 0.23817903, 0.09911321, 0.21329019, 0.31044201,
 0.17517227, 0.09210288, 0.27391567, 0.11076629, 0.28154047, 0.14488886,
 0.15075902, 0.24518105, 0.14048823, 0.18817331, 0.27291347, 0.12830584,
 0.15035252, 0.1403047,  0.12726562, 0.14441825, 0.10008462, 0.23132322,
 0.2430549 ])


y_64A = np.asarray([0.12543935, 0.14325692, 0.12051467, 0.32312686, 0.27470042, 0.11990479,
 0.10521055, 0.06646453, 0.23594022, 0.26356965, 0.18802346, 0.10544872,
 0.16414146, 0.12019333, 0.16817202, 0.14003951, 0.14876994, 0.1256124,
 0.14526678, 0.24509402, 0.16715629, 0.13208332, 0.14367182, 0.20928519,
 0.26200695])
y_64B = np.asarray([0.11508897, 0.12291117, 0.17701923, 0.25033999, 0.25800537, 0.11297297,
0.11476903, 0.07494207, 0.23063697, 0.17057688, 0.11811335, 0.23763342,
0.15173101, 0.13355515, 0.16621997, 0.19150025, 0.16574831, 0.14804094,
0.12634282, 0.23386547, 0.07995187, 0.1304323,  0.13834321, 0.17600991,
0.22634382])


###-------------nodes----------------------------------
#[0.135377   0.19531982 0.12051    0.14398    0.20174362 0.11361
 #0.26332941 0.41068111 0.13178599 0.13092042 0.14091    0.17711
 #0.23616979 0.41206945 0.28142641 0.13178599 0.147832   0.168
 #0.12616    0.33685    0.14308172 0.144397   0.1503119  0.02905
 #0.1208    ]
#y_p:  [0.16438018 0.1699243  0.12202019 0.12553053 0.20718335 0.1628855
 #0.20717306 0.34893647 0.1226577  0.1344103  0.1591235  0.16747743
 #0.23328312 0.41183022 0.27761644 0.17696868 0.14575587 0.1366607
 #0.13088696 0.27961823 0.12102865 0.14924735 0.16785735 0.07029369
 #0.13039966]

###---GCN-----------------
idx_65A = np.asarray([ 14,  73,  97, 212, 128,  52, 107, 197, 118,  69, 123, 144,   8,  49,  57, 216, 103, 218,
  21,  88, 206, 120,   5, 198, 138])
y_65A  = np.asarray([0.1025225,  0.26475422, 0.03085,    0.26332941, 0.12132747, 0.07176875,
 0.24633111, 0.19905455, 0.1688733,  0.1646,     0.13340093, 0.07319827,
 0.146,      0.1392725,  0.147832,   0.13509319, 0.20948025, 0.39915258,
 0.12051,    0.18512274, 0.41068111, 0.12132747, 0.115,      0.36136434,
 0.21577673])
y_65B = np.asarray([0.16222191, 0.206212,   0.06012762, 0.22385636, 0.18399513, 0.07411217,
 0.205877,   0.2018371,  0.16841188, 0.15571629, 0.13854323, 0.09094416,
 0.15932977, 0.13794892, 0.13885587, 0.18015915, 0.21502067, 0.32365838,
 0.11001644, 0.23009406, 0.31840745, 0.1348932,  0.09724113, 0.31207106,
 0.21406993])

y_66A = np.asarray([0.10598097, 0.10965,    0.1394,     0.29864806, 0.1889725,  0.1883,
 0.0903,    0.32475782, 0.18415,    0.153967,   0.17204297, 0.146,
 0.147832,   0.11841,    0.31157549, 0.0951225,  0.11644325, 0.13275,
 0.11361,    0.2078002,  0.13509319, 0.11361,    0.18512274, 0.12398645,
 0.11361   ])
y_66B = np.asarray([0.06451318, 0.08052349, 0.11172216, 0.27432474, 0.12408961, 0.16955854,
 0.08610511, 0.26842275, 0.09299345, 0.16121228, 0.1569291,  0.10879027,
 0.12266614, 0.11671053, 0.29052922, 0.10818917, 0.12060123, 0.13639113,
 0.15628661, 0.15416472, 0.19917431, 0.20731446, 0.17787659 ,0.12346729,
 0.16707495])

y_67A = np.asarray([0.18789782, 0.06985,    0.14125393, 0.19321,    0.30577007, 0.12051,
 0.0693,     0.21961598, 0.31157549, 0.11361,    0.29281093, 0.33663681,
 0.16019738, 0.28142641, 0.175192,   0.30831938, 0.16496995, 0.1579098,
 0.33685,    0.28624671, 0.146,      0.19531982, 0.29896516, 0.16226182,
 0.17711   ])
y_67B = np.asarray([0.25621995, 0.07150636, 0.21688247, 0.1305102,  0.33789927, 0.09831516,
 0.16369036, 0.2906045,  0.28907043, 0.21314186, 0.31532887, 0.29932284,
 0.14524086, 0.19253078, 0.11788733, 0.28222433, 0.17863408, 0.15777713,
 0.2706873,  0.23965585, 0.15758981, 0.17985126, 0.29374415, 0.23582499,
 0.13595363])

y_68A = np.asarray([0.12051,    0.12051,    0.1069,     0.07176875, 0.17528611, 0.19277106,
 0.23616979, 0.14091,    0.243072,   0.16226182, 0.1208,     0.135377,
 0.26084297, 0.0693,     0.26999806, 0.16965833, 0.14952085, 0.27924734,
 0.28894899, 0.10965,    0.10863859, 0.27791419, 0.30577007, 0.1026,
 0.186     ])
y_68B = np.asarray([0.10332422, 0.10326859, 0.12633383, 0.07168964, 0.16818,    0.21374865,
 0.2611853,  0.16876814, 0.28286773, 0.19715278, 0.12203068, 0.160579,
 0.22616462, 0.12357088, 0.27288142, 0.16272715, 0.18116057, 0.2573518,
 0.24123998, 0.01980942, 0.16199735, 0.21970826, 0.305359,   0.0301749,
 0.13570441])

y_69A = np.asarray([0.10863859, 0.0693,     0.21577673, 0.1394,     0.23899319, 0.12398645,
 0.28142641, 0.19321,    0.11841,    0.16374363, 0.11291331, 0.11716104,
 0.1069,     0.27791419, 0.13178599, 0.1208,     0.14091,    0.33685,
 0.12051,    0.27924734, 0.13448912, 0.39915258, 0.19323011, 0.186,
 0.13340093])
y_69B = np.asarray([0.12635925, 0.13965534, 0.16887002, 0.15386206, 0.22789033, 0.15978508,
 0.26172253, 0.1543069,  0.14480712, 0.1558415,  0.18012959, 0.14851913,
 0.1421757,  0.3478488,  0.14279434, 0.13905714, 0.17180598, 0.26642084,
 0.136625,  0.34969842, 0.07602679, 0.27612382, 0.18577178, 0.0920167,
 0.10118555])

y_70A = np.asarray([0.0903,     0.24349806, 0.1518,     0.12063,    0.1695,     0.27109977,
 0.2409807,  0.33849298, 0.27965328, 0.1579098,  0.111342,   0.16226182,
 0.19905455, 0.12051,    0.26332941, 0.12624642, 0.18512274, 0.12051,
 0.06493551, 0.29281093, 0.14308172, 0.06,       0.41068111, 0.10965,
 0.11361   ])
y_70B = np.asarray([0.15047982, 0.16829315, 0.1534745,  0.1171117,  0.1849952,  0.23819958,
 0.18814579, 0.27298102, 0.3383716,  0.20537944, 0.107379,   0.18713707,
 0.20984364, 0.0961417,  0.23887834, 0.17259263, 0.1927386,  0.10627047,
 0.07463434, 0.2269621,  0.13784078, 0.1038844,  0.35854578, 0.03980904,
 0.15354274])
#y_21A = y_20A.copy()
#y_22B = y_20B.copy()
#y_21A = y_22A.copy()
#y_22A = y_22B.copy()
#y_18A = preprocessing.scale(y_18A)
#y_18B = preprocessing.scale(y_18B)
#Y_20A = (y_20A - np.mean(y_20A))/np.std(y_20A)
#Y_20B = (y_20B- np.mean(y_20A))/np.std(y_20A)
#Y_20A = (y_20A - np.amin(y_20A))/(np.amax(y_20A) - np.amin(y_20A))
#Y_20B = (y_20B - np.amin(y_20A))/(np.amax(y_20A) - np.amin(y_20A))

#y_19A = y_19A/np.amax(y_19A)
#y_19B = y_19B/np.amax(y_19B)

R2_val5 = r2_score(y_68A, y_68B)
rel_err5 = np.sqrt(((y_68A - y_68B)**2).mean())/np.sqrt(((y_68A)**2).mean())
abs_err5 = np.sqrt(((y_68A - y_68B)**2).mean())

print "68"
print "rel_error: ", rel_err5
print "abs err:", abs_err5
print "R2: ", R2_val5

#e_1 = np.load('rel_err_D300.npy')
#e_2 = np.load('abs_err_D300.npy')
#e_3 = np.load('r2_s_D300.npy')

e_1a = np.load('RE_RDF_50A.npy')
e_2a = np.load('AE_RDF_50A.npy')
e_3a = np.load('R2_RDF_50A.npy')
e_1b = np.load('RE_RDF_50B.npy')
e_2b = np.load('AE_RDF_50B.npy')
e_3b = np.load('R2_RDF_50C.npy')
e_1c = np.load('RE_RDF_50C.npy')
e_2c = np.load('AE_RDF_50C.npy')
e_3c = np.load('R2_RDF_50C.npy')

e_1 = np.concatenate((e_1a, e_1b, e_1c), axis=0)
e_2 = np.concatenate((e_2a, e_2b, e_2c), axis=0)
e_3 = np.concatenate((e_3a, e_3b, e_3c), axis=0)

plt.hist(e_1, bins=20)
plt.xlabel('Rel. Error (%)')
plt.ylabel('Counts')
#plt.savefig('e_1D_hist.png')
#plt.savefig('e_1_hist.png')
plt.show()


plt.scatter(y_67A, y_67B, marker='o', color='k', s=75)
plt.plot(y_67A, y_67A, 'k-')
#plt.scatter(y_5A, y_5B, marker='o', color='k')
#plt.plot(y_5A, y_5A, 'k-')
#plt.xlabel('Pull-out force from MD simulation, $y_a$ (kcal/mol-$\AA$)', fontsize=14)
#plt.ylabel('Pull-out force predicted by ML, $y_p$ (kcal/mol-$\AA$)', fontsize=14)
plt.xticks(np.arange(0.05, 0.42, step=0.1))
plt.yticks(np.arange(0.05, 0.42, step=0.1))
plt.xticks(fontsize=24)
plt.yticks(fontsize=24)
plt.savefig('fig_67A.svg', bbox_inches="tight")
plt.show()


#####with 5e
###histogram
#ye = np.load('ye_s_250.npy')
#yp = np.load('yp_s_250.npy')

ye_a = np.load('ye_RDF_50A.npy')
ye_b = np.load('ye_RDF_50B.npy')
ye_c = np.load('ye_RDF_50C.npy')
yp_a = np.load('yp_RDF_50A.npy')
yp_b = np.load('yp_RDF_50B.npy')
yp_c = np.load('yp_RDF_50C.npy')

ye = np.concatenate((ye_a, ye_b, ye_c), axis=0)
yp = np.concatenate((yp_a, yp_b, yp_c), axis=0)

print "shapes: ", ye.shape, yp.shape

plt.tight_layout()
plt.scatter(ye.flatten(), yp.flatten(), marker='o', color='k')
plt.plot(ye.flatten(), ye.flatten(), 'k-')
#plt.scatter(y_5A, y_5B, marker='o', color='k')
#plt.plot(y_5A, y_5A, 'k-')
plt.xlabel('Pull-out force from MD simulation, $y_a$ (kcal/mol-$\AA$)', fontsize=14)
plt.ylabel('Pull-out force predicted by CNN, $y_p$ (kcal/mol-$\AA$)', fontsize=14)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.savefig('fig_R2_all.eps', bbox_inches="tight")
plt.show()

print "R2 score: ", r2_score(ye.flatten(), yp.flatten())

plt.hist(np.abs(ye.flatten() - yp.flatten()), bins=40, cumulative=False, density=True)
plt.xlabel('Absolute error (kcal/mol-A)', fontsize=14)
plt.ylabel('Counts', fontsize=14)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
#plt.savefig('e_1D_hist.png')
plt.show()


##-------------------------normal distribution

plt.hist((ye.flatten() - yp.flatten()), bins=100, cumulative=False, density=True)
plt.xlabel('Absolute error (kcal/mol-$\AA$)', fontsize=14)
plt.ylabel('Probability Density Function', fontsize=14)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
plt.savefig('residual_1D_hist.eps', bbox_inches="tight")
plt.show()

print "numpy mean: ", np.mean((ye.flatten() - yp.flatten()))
print "std: ", np.std((ye.flatten() - yp.flatten()))
print "numpy mean: ", np.mean((ye.flatten()))

##-------------------GCN distribution----------------
ye_a = np.load('ye_s_012A.npy')
ye_b = np.load('ye_s_012B.npy')
yp_a = np.load('yp_s_012A.npy')
yp_b = np.load('yp_s_012B.npy')


ye = np.concatenate((ye_a, ye_b), axis=0)
yp = np.concatenate((yp_a, yp_b), axis=0)

plt.hist((ye.flatten() - yp.flatten()), bins=100, cumulative=False, density=True)
plt.xlabel('Error Residual (kcal/mol-$\AA$)', fontsize=24)
plt.ylabel('Probability Density Function', fontsize=24)
#plt.xticks(np.arange(0.05, 0.42, step=0.1))
plt.xticks(np.arange(-0.20, 0.15, step=0.1))
plt.xticks(fontsize=24)
plt.yticks(fontsize=24)
plt.savefig('residual_gcn.svg', bbox_inches="tight")
plt.show()

print 'GCN: error analysis'
print "numpy mean: ", np.mean((ye.flatten() - yp.flatten()))
print "std: ", np.std((ye.flatten() - yp.flatten()))

f1, f2 , f3 = feature_extract_01.error_metric(ye, yp)
f3 = 100*f3

print "R2 score: ", r2_score(ye.flatten(), yp.flatten())

a1, a2 = stats.expon.fit(f3.flatten())
x_min, x_max = np.amin(f3.flatten()), np.amax(f3.flatten())
lnspc = np.linspace(x_min, x_max, len(f3.flatten()))
pdf_exp = stats.expon.pdf(lnspc, a1, a2)
cdf_exp = stats.expon.cdf(lnspc, a1, a2)

print "a1-a4: ", a1, a2
plt.hist(f3.flatten(), bins=50, density=True, cumulative=False)
plt.xlabel('Relative error, $e$ (%)', fontsize=14)
plt.ylabel('$\\rho$ $(e)$', fontsize=14)
plt.plot(lnspc, pdf_exp, 'k-')
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
#a.set_xticklabels(a.get_xticks(), fontdict={'size': 14})
#plt.plot(lnspc, cdf_exp, 'r-', label='Cumulative distribution fit')
plt.legend()
#plt.savefig('e_f3.eps', bbox_inches="tight")
plt.show()


#####perform students t-test
print "student t-distribution"
print stats.kstest((ye.flatten() - yp.flatten()), 'norm')
print stats.ttest_1samp((ye.flatten() - yp.flatten()), 0.005)
print stats.ttest_1samp(0.005, (ye.flatten() - yp.flatten()))



print "Levene's test: "
sigma = 0.05
sample_dist = np.random.normal(loc=0.005, scale=sigma, size=(len(yp.flatten()),))


print stats.levene((ye.flatten() - yp.flatten()), sample_dist, center='trimmed')
print stats.bartlett((ye.flatten() - yp.flatten()), sample_dist)
print "median: "
print stats.median_test((ye.flatten() - yp.flatten()), sample_dist)


#####count residuals:
residuals = (ye.flatten() - yp.flatten())
r_1 = residuals[(residuals < (sigma)) & (residuals> (-sigma))]

print "r_1 length: ", len(r_1)
print "total length:", len(residuals)
print "fraction: ", float(len(r_1))/float(len(residuals))
print "fraction 2: ", 0.045/np.mean(ye.flatten())

plt.plot(lnspc, cdf_exp, 'r-',  linewidth=3.0)
a = plt.gca()
plt.axhline(y=.655, xmin=0, xmax=0.2, linewidth=3, color='k', linestyle='--')
plt.axhline(y=.736, xmin=0, xmax=0.25, linewidth=3, color='k', linestyle='--')

plt.axvline(x=20, ymin=0, ymax=0.655, linewidth=3, color='k', linestyle='--')
plt.axvline(x=25, ymin=0, ymax=0.736, linewidth=3, color='k', linestyle='--')

plt.xlim([0, 100])
plt.ylim([0, 1.0])
plt.xlabel('Relative error, $e$ (%)', fontsize=14)
plt.ylabel('Cummulative Denisty Function (CDF)', fontsize=14)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
#a.set_xticklabels(a.get_xticks(), fontdict={'size': 12})
#a.set_yticklabels(a.get_yticks(), fontdict={'size': 12})
#plt.savefig('fig_CDF.svg')
plt.show()

###let's try to visualize the weights
W0 = np.load('W0_c.npy')
col_dropped = np.load('col_dropped.npy')
R_v = np.load('R_v.npy')
R_v = R_v[0, :]

W0[W0 < 0.0001] = 0


#reshape W0
W0 = np.reshape(W0, (W0.shape[2], W0.shape[3]))
W0 = feature_extract_01.vis_main01(R_v=R_v, col_dropped=col_dropped, W=W0)
print W0
print W0.shape
print R_v


#decide channel length
#channel_legth = int(len(W0)/len(R_v))
channel_legth = 7


Z = np.zeros((W0.shape[1], len(R_v), channel_legth))

print "W0 shape: ", W0.shape
print "R_v.shape", R_v.shape



for j in range(0, W0.shape[1]):
    A = W0[0:98, j]
    A = np.reshape(A, (len(R_v), channel_legth))

    Z[j, :, :] = A



print Z
print Z.shape


#now let's plot the intermediate featre
filter_idx =3
color_mat = ['b', 'g', 'r', 'c', 'k', 'm', 'y']
label_mat = ['Alkane C', 'Aromatic C', 'N in primary amine', 'C in epoxide', 'N in secondary Amine', 'O  in Epixide', 'N in tertiary amine']
plt.figure()

R_max = 6.0
del_r = 0.1
r_l = np.linspace(0, 6.0, 60)

for j in range(Z.shape[2]-2):

    rbfi = Rbf(R_v, Z[filter_idx, :, j])  # radial basis function interpolator instance
    di = rbfi(r_l)
    di[di <= 0] = 0
    plt.scatter(R_v, Z[filter_idx, :, j], marker='o', color=color_mat[j], label=label_mat[j])
    plt.plot(r_l, di, color=color_mat[j])


plt.xlabel('Radial distance from CNT atom ($\AA$)')
plt.ylabel('Weight value')
plt.legend(loc='upper left')
plt.savefig('filter_3.svg')
plt.show()