scf1d_test.py

# -*- coding: utf-8 -*-
"""
Created on Mon Sep 15 21:08:34 2014

@author: Richard Sheridan

These tests were generated using the code as of 6/19/15.
No guarantee is made regarding absolute correctness, only that the results
haven't changed since that version.
"""

from __future__ import division, print_function
import numpy as np

from util import schultz_zimm, Propagator
from scf1d import (SCFprofile, SCFsqueeze, BasicSystem, VaporSwollenSystem,
                   SCFsolve, SCFeqns, SCFeqns_multi, NoConvergence)

g_zs_data=np.array((
   ( 0.90000000,  0.67833333,  0.53457407,  0.43538321,  0.36346252,
     0.30925318,  0.26714431,  0.23365571,  0.20652162,  0.18420452,
     0.16562391,  0.14999788,  0.13674637,  0.12542991,  0.11570948,
     0.10731936,  0.10004837,  0.0937266 ,  0.08821584,  0.08340252),
   ( 0.92222222,  0.85049383,  0.76425846,  0.68155058,  0.60783778,
     0.54394935,  0.4891275 ,  0.44218798,  0.40194363,  0.36734135,
     0.33749022,  0.31165092,  0.28921394,  0.26967689,  0.25262446,
     0.23771168,  0.22465053,  0.21319918,  0.20315348,  0.19434016),
   ( 0.94444444,  0.89197531,  0.84257659,  0.7930217 ,  0.74413393,
     0.69722471,  0.65323138,  0.61264733,  0.57563553,  0.54214957,
     0.5120236 ,  0.4850313 ,  0.46092225,  0.43944331,  0.42035059,
     0.4034157 ,  0.38842854,  0.37519809,  0.36355202,  0.3533357 ),
   ( 0.96666667,  0.93444444,  0.90345542,  0.87380169,  0.84505407,
     0.81709233,  0.79005942,  0.76420135,  0.73975859,  0.71691616,
     0.69579069,  0.67643584,  0.65885458,  0.64301244,  0.62884938,
     0.61628918,  0.6052467 ,  0.59563309,  0.58735937,  0.58033893),
   ( 0.98888889,  0.97790123,  0.96719845,  0.95693471,  0.94725739,
     0.93822305,  0.92984965,  0.92215235,  0.91515455,  0.90888661,
     0.90338093,  0.89866754,  0.89477117,  0.89170994,  0.88949506,
     0.88813126,  0.8876176 ,  0.88794842,  0.88911423,  0.89110265),
   ( 1.01111111,  1.02234568,  1.03387151,  1.04586384,  1.05850568,
     1.07179988,  1.08562363,  1.09981238,  1.11421611,  1.12872507,
     1.14327513,  1.1578427 ,  1.17243568,  1.18708411,  1.20183196,
     1.2167308 ,  1.23183506,  1.24719889,  1.26287398,  1.27890843),
   ( 1.03333333,  1.06777778,  1.10354047,  1.14085245,  1.17885107,
     1.21673962,  1.25401498,  1.29043   ,  1.32591   ,  1.36048312,
     1.39423345,  1.42727231,  1.45972146,  1.49170372,  1.52333786,
     1.55473604,  1.58600256,  1.6172335 ,  1.64851681,  1.67993261),
   ( 1.05555556,  1.11419753,  1.17627115,  1.23566805,  1.29102979,
     1.34261892,  1.39113583,  1.43729989,  1.48172328,  1.52489154,
     1.56717868,  1.60887008,  1.65018392,  1.69128862,  1.7323162 ,
     1.77337216,  1.81454277,  1.85590018,  1.8975062 ,  1.93941493),
   ( 1.07777778,  1.16160494,  1.21517227,  1.25496048,  1.28875838,
     1.32029364,  1.35135685,  1.38279751,  1.41500143,  1.44812428,
     1.48220808,  1.51724019,  1.55318343,  1.58999174,  1.62761807,
     1.66601842,  1.70515369,  1.74499047,  1.78550116,  1.82666377),
   ( 1.1       ,  1.00425926,  0.9494177 ,  0.91902123,  0.90402499,
     0.89922403,  0.90148479,  0.9088376 ,  0.91999378,  0.93407904,
     0.95048074,  0.96875736,  0.98858277,  1.00971099,  1.03195321,
     1.05516234,  1.07922242,  1.10404129,  1.1295452 ,  1.15567502)))

g_zs_ta_data = np.array((
       (  9.00000000e-01,   5.40000000e-01,   3.44750000e-01,
          2.32057407e-01,   1.63182762e-01,   1.18909613e-01,
          8.91942729e-02,   6.85112896e-02,   5.36702862e-02,
          4.27458873e-02,   3.45293323e-02,   2.82349142e-02,
          2.33361729e-02,   1.94708968e-02,   1.63840546e-02,
          1.38924051e-02,   1.18619166e-02,   1.01929871e-02,
          8.81054699e-03,   7.65729535e-03),
       (  0.00000000e+00,   1.38333333e-01,   1.68049383e-01,
          1.59655453e-01,   1.39999701e-01,   1.18990036e-01,
          9.99648391e-02,   8.37567498e-02,   7.02914374e-02,
          5.92119992e-02,   5.01154320e-02,   4.26348293e-02,
          3.64612874e-02,   3.13434433e-02,   2.70798154e-02,
          2.35098237e-02,   2.05055808e-02,   1.79650316e-02,
          1.58064477e-02,   1.39640932e-02),
       (  0.00000000e+00,   0.00000000e+00,   2.17746914e-02,
          4.01622085e-02,   5.09704753e-02,   5.55038957e-02,
          5.58698032e-02,   5.37794965e-02,   5.03986580e-02,
          4.64583240e-02,   4.23921664e-02,   3.84437829e-02,
          3.47398749e-02,   3.13372615e-02,   2.82521634e-02,
          2.54781029e-02,   2.29966886e-02,   2.07840162e-02,
          1.88143888e-02,   1.70624124e-02),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          3.50814472e-03,   8.73138241e-03,   1.39319543e-02,
          1.82139259e-02,   2.13049739e-02,   2.32609305e-02,
          2.42696439e-02,   2.45469939e-02,   2.42904207e-02,
          2.36629921e-02,   2.27918432e-02,   2.17724199e-02,
          2.06743749e-02,   1.95472967e-02,   1.84256090e-02,
          1.73324995e-02,   1.62829586e-02),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   5.78194222e-04,   1.82024107e-03,
          3.51226222e-03,   5.37879716e-03,   7.19678933e-03,
          8.82375170e-03,   1.01879864e-02,   1.12682785e-02,
          1.20747695e-02,   1.26345241e-02,   1.29818629e-02,
          1.31524460e-02,   1.31799736e-02,   1.30945794e-02,
          1.29222527e-02,   1.26848446e-02),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   9.74364337e-05,
          3.72423702e-04,   8.45750250e-04,   1.48928204e-03,
          2.25009829e-03,   3.07039056e-03,   3.89911195e-03,
          4.69684009e-03,   5.43641967e-03,   6.10148618e-03,
          6.68422006e-03,   7.18306621e-03,   7.60075285e-03,
          7.94271547e-03,   8.21591641e-03),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          1.67807191e-05,   7.56996886e-05,   1.98314090e-04,
          3.95755195e-04,   6.68038713e-04,   1.00663252e-03,
          1.39794287e-03,   1.82641850e-03,   2.27679495e-03,
          2.73546224e-03,   3.19113019e-03,   3.63500643e-03,
          4.06067510e-03,   4.46381663e-03),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   2.95216355e-06,   1.53949862e-05,
          4.58153916e-05,   1.02417597e-04,   1.91445606e-04,
          3.16399051e-04,   4.78006078e-04,   6.74663168e-04,
          9.03073979e-04,   1.15890201e-03,   1.43733487e-03,
          1.73351944e-03,   2.04286531e-03),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   5.30296046e-07,
          3.14642320e-06,   1.05080289e-05,   2.60638735e-05,
          5.35481090e-05,   9.64846722e-05,   1.57814991e-04,
          2.39684868e-04,   3.43375784e-04,   4.69343535e-04,
          6.17323631e-04,   7.86469082e-04),
       (  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          9.72209417e-08,   6.48139611e-07,   2.40177435e-06,
          6.53967800e-06,   1.46129172e-05,   2.84049958e-05,
          4.97630787e-05,   8.04351502e-05,   1.21938004e-04,
          1.75467518e-04,   2.41852179e-04)))

def calc_g_zs_ta_test():
    layers=10
    segments=20
    g_z = np.linspace(.9,1.1,layers)
    g_zs = Propagator(g_z,segments)
    assert np.allclose(g_zs.ta(), g_zs_ta_data, atol=1e-14)


def calc_g_zs_ngts_u_test():
    layers=10
    segments=20
    g_z = np.linspace(.9,1.1,layers)
    c = 1.0
    g_zs = Propagator(g_z,segments)
    assert np.allclose(g_zs.ngts_u(c), g_zs_data, atol=1e-14)

def calc_g_zs_ngts_test():
    layers=10
    segments=20
    g_z = np.linspace(.9,1.1,layers)
    c_i = np.zeros(segments)
    c_i[-1]= 1.0
    g_zs = Propagator(g_z,segments)
    assert np.allclose(g_zs.ngts(c_i), g_zs_data, atol=1e-14)

def calc_g_zs_free_test():
    layers=10
    segments=20
    g_z = np.linspace(.9,1.1,layers)
    g_zs = Propagator(g_z,segments)
    assert np.allclose(g_zs.free(), g_zs_data, atol=1e-14)

def SCFeqns_test():

    # away from solution
    phi_z = np.linspace(.5,0,50)
    chi = 0.1
    chi_s = 0.05
    sigma = .1
    navgsegments = 95.5
    pdi = 1.2
    p_i = schultz_zimm(pdi,navgsegments)
    data = np.array([  4.56885753e+00,   1.27473567e+01,   1.29799866e+01,
         1.25941193e+01,   1.20030366e+01,   1.54353170e+00,
         8.20490367e-01,   5.85342697e-01,   4.84869467e-01,
         4.36478200e-01,   4.09949567e-01,   3.92782245e-01,
         3.79629333e-01,   3.68190711e-01,   3.57478065e-01,
         3.47068739e-01,   3.36783786e-01,   3.26548662e-01,
         3.16332987e-01,   3.06124696e-01,   2.95919128e-01,
         2.85714537e-01,   2.75510285e-01,   2.65306148e-01,
         2.55102048e-01,   2.44897961e-01,   2.34693878e-01,
         2.24489796e-01,   2.14285714e-01,   2.04081633e-01,
         1.93877551e-01,   1.83673469e-01,   1.73469388e-01,
         1.63265306e-01,   1.53061224e-01,   1.42857143e-01,
         1.32653061e-01,   1.22448980e-01,   1.12244898e-01,
         1.02040816e-01,   9.18367347e-02,   8.16326531e-02,
         7.14285714e-02,   6.12244898e-02,   5.10204082e-02,
         4.08163265e-02,   3.06122449e-02,   2.04081633e-02,
         1.02040816e-02,  -2.60349244e-25])
    result = SCFeqns(phi_z,chi,chi_s,sigma,navgsegments,p_i)

    assert np.allclose(result, data, atol=1e-14)

    # at solution
    phi_z = np.array([  3.65555778e-01,   3.97530942e-01,   3.95177593e-01,
         3.88755392e-01,   3.80784804e-01,   3.72128254e-01,
         3.63090353e-01,   3.53797489e-01,   3.44313620e-01,
         3.34678411e-01,   3.24920384e-01,   3.15062002e-01,
         3.05122091e-01,   2.95117245e-01,   2.85062724e-01,
         2.74973026e-01,   2.64862253e-01,   2.54744317e-01,
         2.44633057e-01,   2.34542304e-01,   2.24485900e-01,
         2.14477710e-01,   2.04531625e-01,   1.94661559e-01,
         1.84881453e-01,   1.75205269e-01,   1.65646998e-01,
         1.56220661e-01,   1.46940309e-01,   1.37820027e-01,
         1.28873934e-01,   1.20116183e-01,   1.11560959e-01,
         1.03222487e-01,   9.51150272e-02,   8.72528915e-02,
         7.96504609e-02,   7.23222205e-02,   6.52828140e-02,
         5.85471226e-02,   5.21303666e-02,   4.60482169e-02,
         4.03168798e-02,   3.49530831e-02,   2.99738486e-02,
         2.53958999e-02,   2.12345582e-02,   1.75020558e-02,
         1.42053630e-02,   1.13438569e-02,   8.90736329e-03,
         6.87516042e-03,   5.21636994e-03,   3.89180122e-03,
         2.85690535e-03,   2.06521082e-03,   1.47156065e-03,
         1.03463569e-03,   7.18524401e-04,   4.93361836e-04,
         3.35231541e-04,   2.25588058e-04,   1.50440247e-04,
         9.94770155e-05,   6.52498334e-05,   4.24697365e-05,
         2.74367658e-05,   1.75962019e-05,   1.12044893e-05,
         6.43768632e-07,   3.90023255e-07,   2.34559779e-07,
         1.40008161e-07,   8.29272726e-08,   4.87244589e-08,
         2.83845206e-08,   1.63805733e-08,   9.35038310e-09,
         5.26436221e-09,   2.90675760e-09,   1.55475537e-09,
         7.81883338e-10,   3.39857917e-10,   9.31247294e-11])
    data = np.array([  1.38858813e+00,   1.22712170e+01,   1.27152996e+01,
         1.25948180e+01,   1.21308339e+01,   2.77822712e+00,
         1.00037091e+00,   6.14461712e-01,   4.57514843e-01,
         3.84265846e-01,   3.46503169e-01,   3.24346931e-01,
         3.09058361e-01,   2.96756860e-01,   2.85731743e-01,
         2.75239734e-01,   2.64965933e-01,   2.54783573e-01,
         2.44647525e-01,   2.34547494e-01,   2.24487712e-01,
         2.14478326e-01,   2.04531829e-01,   1.94661625e-01,
         1.84881474e-01,   1.75205275e-01,   1.65647000e-01,
         1.56220662e-01,   1.46940309e-01,   1.37820027e-01,
         1.28873934e-01,   1.20116183e-01,   1.11560959e-01,
         1.03222487e-01,   9.51150272e-02,   8.72528915e-02,
         7.96504609e-02,   7.23222205e-02,   6.52828140e-02,
         5.85471226e-02,   5.21303666e-02,   4.60482169e-02,
         4.03168798e-02,   3.49530831e-02,   2.99738486e-02,
         2.53958999e-02,   2.12345582e-02,   1.75020558e-02,
         1.42053630e-02,   1.13438569e-02,   8.90736329e-03,
         6.87516042e-03,   5.21636994e-03,   3.89180122e-03,
         2.85690535e-03,   2.06521082e-03,   1.47156065e-03,
         1.03463569e-03,   7.18524401e-04,   4.93361836e-04,
         3.35231541e-04,   2.25588058e-04,   1.50440247e-04,
         9.94770155e-05,   6.52498334e-05,   4.24697365e-05,
         2.74367658e-05,   1.75962019e-05,   1.12044893e-05,
         6.43768632e-07,   3.90023255e-07,   2.34559779e-07,
         1.40008161e-07,   8.29272726e-08,   4.87244589e-08,
         2.83845206e-08,   1.63805733e-08,   9.35038310e-09,
         5.26436221e-09,   2.90675760e-09,   1.55475537e-09,
         7.81883338e-10,   3.39857917e-10,   9.31247294e-11])
    result = SCFeqns(phi_z,chi,chi_s,sigma,navgsegments,p_i)

    assert np.allclose(result, data, atol=1e-14)

    #TODO: check float overflow handling

def SCFeqns_multi_test():
    u_jz0 = np.zeros((3,50))
    chi_jk = (1-np.eye(4))*0.10
    sigma_j = np.array((0,0,.01,0))
    phi_b_j = np.array((0,0.1,0,.9))
    n_avg_j = np.array((0,1,75,1))
    data = np.array([[ -5.52314290e-02,  -1.03134227e-01,  -1.23902379e-01,
         -1.22509546e-01,  -1.06273052e-01,  -8.37906912e-02,
         -6.14775076e-02,  -4.26557546e-02,  -2.82764492e-02,
         -1.80107679e-02,  -1.10521437e-02,  -6.53981797e-03,
         -3.73196876e-03,  -2.05342896e-03,  -1.08910584e-03,
         -5.56654539e-04,  -2.74100305e-04,  -1.29996454e-04,
         -5.93673960e-05,  -2.61011669e-05,  -1.10451439e-05,
         -4.49767739e-06,  -1.76204598e-06,  -6.63994071e-07,
         -2.40621051e-07,  -8.38353786e-08,  -2.80765437e-08,
         -9.03600415e-09,  -2.79392144e-09,  -8.29734542e-10,
         -2.36606623e-10,  -6.47656499e-11,  -1.70117891e-11,
         -4.28644351e-12,  -1.03569370e-12,  -2.39799723e-13,
         -5.33117863e-14,  -1.14174698e-14,  -2.33501732e-15,
         -4.69846300e-16,  -7.89946904e-18,  -4.46512879e-18,
         -3.83374067e-18,  -3.72284436e-18,  -3.70424847e-18,
         -3.70127350e-18,  -3.70081979e-18,  -3.70075388e-18,
         -3.70074477e-18,   3.88888889e-03],
       [ -4.80798201e-02,  -9.35171085e-02,  -1.12258255e-01,
         -1.10885581e-01,  -9.60858691e-02,  -7.56790137e-02,
         -5.54733754e-02,  -3.84583301e-02,  -2.54757702e-02,
         -1.62161669e-02,  -9.94440779e-03,  -5.88034163e-03,
         -3.35319684e-03,  -1.84357314e-03,  -9.76975949e-04,
         -4.98890083e-04,  -2.45417330e-04,  -1.16271723e-04,
         -5.30403986e-05,  -2.32918008e-05,  -9.84387025e-06,
         -4.00313149e-06,  -1.56606621e-06,  -5.89252096e-07,
         -2.13194325e-07,  -7.41538364e-08,  -2.47897057e-08,
         -7.96306979e-09,  -2.45723773e-09,  -7.28200323e-10,
         -2.07187834e-10,  -5.65785055e-11,  -1.48240256e-11,
         -3.72528658e-12,  -8.97582123e-13,  -2.07195619e-13,
         -4.59321732e-14,  -9.81671965e-15,  -2.00240574e-15,
         -4.03677261e-16,   4.69670784e-18,  -2.17197266e-18,
         -3.43474891e-18,  -3.65654152e-18,  -3.69373330e-18,
         -3.69968325e-18,  -3.70059067e-18,  -3.70072248e-18,
         -3.70074070e-18,   5.55555556e-03],
       [ -6.85647624e-02,  -1.03134227e-01,  -1.23902379e-01,
         -1.22509546e-01,  -1.06273052e-01,  -8.37906912e-02,
         -6.14775076e-02,  -4.26557546e-02,  -2.82764492e-02,
         -1.80107679e-02,  -1.10521437e-02,  -6.53981797e-03,
         -3.73196876e-03,  -2.05342896e-03,  -1.08910584e-03,
         -5.56654539e-04,  -2.74100305e-04,  -1.29996454e-04,
         -5.93673960e-05,  -2.61011669e-05,  -1.10451439e-05,
         -4.49767739e-06,  -1.76204598e-06,  -6.63994071e-07,
         -2.40621051e-07,  -8.38353786e-08,  -2.80765437e-08,
         -9.03600414e-09,  -2.79392143e-09,  -8.29734531e-10,
         -2.36606612e-10,  -6.47656388e-11,  -1.70117780e-11,
         -4.28643240e-12,  -1.03568259e-12,  -2.39788621e-13,
         -5.33006841e-14,  -1.14063675e-14,  -2.32391509e-15,
         -4.58744069e-16,   3.20276120e-18,   6.63710145e-18,
          7.26848958e-18,   7.37938588e-18,   7.39798177e-18,
          7.40095675e-18,   7.40141046e-18,   7.40147636e-18,
          7.40148547e-18,  -9.44444444e-03]])
    result=SCFeqns_multi(u_jz0,chi_jk, sigma_j, phi_b_j, n_avg_j)

    assert np.allclose(result, data, atol=1e-14)

def BasicSystem_test():
    bs = BasicSystem()
    p = (0,0,0,.1,.1,.1)
    pu = bs.unscale_parameters(p)
    ps = bs.scale_parameters(pu)
    assert p == ps

    data = np.array([[ -3.19411156e-01,  -3.89647496e-01,  -3.90270490e-01,
         -3.80437095e-01,  -3.66248523e-01,  -3.49113842e-01,
         -3.29405818e-01,  -3.07163773e-01,  -2.82352428e-01,
         -2.54947843e-01,  -2.24954033e-01,  -1.92409097e-01,
         -1.57423105e-01,  -1.20353697e-01,  -8.24002663e-02,
         -4.67742483e-02,  -1.89552925e-02,  -3.13814480e-03,
          2.20142759e-03,   2.33601298e-03,   1.27362894e-03,
          4.78180180e-04,   1.01461807e-04,  -2.28751258e-05,
         -4.03110165e-05,  -2.72147649e-05,  -1.29240987e-05,
         -4.34991911e-06,  -6.23042161e-07,   4.71031176e-07,
          5.19910136e-07,   3.10938037e-07,   1.25956526e-07,
          1.91118624e-08,  -1.98483557e-08,   1.09435627e-08,
          1.54790041e-07,   4.90421456e-07,   1.06073610e-06,
          1.65850312e-06,   1.35452362e-06,  -2.32030224e-06,
         -1.44224450e-05,  -4.31248700e-05,  -9.72715000e-05,
         -1.73314733e-04,  -2.06006729e-04,   1.04529244e-04,
          1.86380525e-03,   8.63386675e-03,   2.93905435e-02,
          7.27777687e-02]])
    result = bs.from_cache((0,0,0,.1,.1,.1))

    assert np.allclose(result, data)

def VaporSwollenSystem_test():
    vs = VaporSwollenSystem()

    data = np.array([[ -1.20510893e+00,  -9.04101355e-01,  -5.89171999e-01,
         -2.71276657e-01,  -8.99609997e-02,  -2.50419154e-02,
         -6.98763003e-03,  -2.18237962e-03,  -7.74474214e-04,
         -2.99422271e-04,  -1.20665011e-04,  -4.93526536e-05,
         -2.02181568e-05,  -8.24285689e-06,  -3.33228970e-06,
         -1.33234143e-06,  -5.25699163e-07,  -2.04263205e-07,
         -7.80221902e-08,  -2.93667664e-08,  -1.20228613e-08,
         -1.58448828e-08,  -1.12060525e-07,  -1.02184897e-06,
         -9.42237988e-06,  -8.69155862e-05,  -8.01458724e-04,
         -7.36536200e-03,  -6.56689505e-02,  -4.69992867e-01],
       [ -3.15551231e-01,  -1.56592741e-01,  -1.46901351e-01,
         -8.77023889e-02,  -3.28473520e-02,  -9.43682859e-03,
         -2.54246628e-03,  -7.40614326e-04,  -2.46786999e-04,
         -9.19059074e-05,  -3.64255485e-05,  -1.48199325e-05,
         -6.07242214e-06,  -2.48296233e-06,  -1.00838610e-06,
         -4.05550568e-07,  -1.61142006e-07,  -6.31246937e-08,
         -2.43367066e-08,  -9.28660332e-09,  -4.16648569e-09,
         -8.17318115e-09,  -6.44107228e-08,  -5.90291370e-07,
         -5.44400394e-06,  -5.02177064e-05,  -4.63049967e-04,
         -4.25426616e-03,  -3.78381339e-02,  -1.06845732e-01],
       [  8.29114229e-01,   6.01102657e-01,   2.90486287e-01,
          9.61065738e-02,   2.58193027e-02,   6.83392570e-03,
          2.02539555e-03,   6.93295261e-04,   2.63294482e-04,
          1.05445366e-04,   4.31094778e-05,   1.77032342e-05,
          7.24661687e-06,   2.94473697e-06,   1.18465157e-06,
          4.70726089e-07,   1.84349587e-07,   7.10088296e-08,
          2.68495391e-08,   9.96204852e-09,   3.74676468e-09,
          2.60741779e-09,   1.27392937e-08,   1.13631771e-07,
          1.04696696e-06,   9.65776456e-06,   8.90906362e-05,
          8.21732307e-04,   7.57004056e-03,   6.89908215e-02]])
    result = vs.from_cache((1, -.6, 2.5, .01, .1, 75, 1))

    assert np.allclose(result, data)

def SCFsolve_test():

    #find the solution used in the previous test without an initial guess
    chi = 0.1
    chi_s = 0.05
    sigma = .1
    phi_b = 0
    navgsegments = 95.5
    pdi = 1.2
    parameters = (chi,chi_s,pdi,sigma,phi_b,navgsegments)
    bs = BasicSystem()
    data = np.array([[ -3.43014103e-01,  -4.28357067e-01,  -4.23920517e-01,
         -4.14558595e-01,  -4.03168321e-01,  -3.91006421e-01,
         -3.78517904e-01,  -3.65889210e-01,  -3.53215005e-01,
         -3.40553175e-01,  -3.27943914e-01,  -3.15417276e-01,
         -3.02996866e-01,  -2.90702002e-01,  -2.78549094e-01,
         -2.66552518e-01,  -2.54725176e-01,  -2.43078835e-01,
         -2.31624337e-01,  -2.20371724e-01,  -2.09330328e-01,
         -1.98508833e-01,  -1.87915328e-01,  -1.77557357e-01,
         -1.67441965e-01,  -1.57575750e-01,  -1.47964906e-01,
         -1.38615267e-01,  -1.29532360e-01,  -1.20721434e-01,
         -1.12187512e-01,  -1.03935419e-01,  -9.59698270e-02,
         -8.82952852e-02,  -8.09162631e-02,  -7.38371921e-02,
         -6.70625164e-02,  -6.05967560e-02,  -5.44445848e-02,
         -4.86109281e-02,  -4.31010780e-02,  -3.79208148e-02,
         -3.30765063e-02,  -2.85751267e-02,  -2.44241038e-02,
         -2.06308770e-02,  -1.72020511e-02,  -1.41420925e-02,
         -1.14516494e-02,  -9.12575419e-03,  -7.15232551e-03,
         -5.51142747e-03,  -4.17561113e-03,  -3.11138072e-03,
         -2.28150853e-03,  -1.64770430e-03,  -1.17310919e-03,
         -8.24217491e-04,  -5.72046084e-04,  -3.92576261e-04,
         -2.66624270e-04,  -1.79344774e-04,  -1.19555834e-04,
         -7.90269570e-05,  -5.18185316e-05,  -3.37164382e-05,
         -2.17746033e-05,  -1.39599829e-05,  -8.33278462e-07,
         -5.07442526e-07,  -3.06408616e-07,  -1.83272136e-07,
         -1.08394068e-07,  -6.31845181e-08,  -3.60683806e-08,
         -1.98887772e-08,  -1.02540933e-08,  -4.51295977e-09,
         -1.18629412e-09]])

    result = SCFsolve(bs.field_equations(parameters),np.zeros((1,40)))

    assert np.allclose(result, data)

    # try a very hard one using the answer as an initial guess
    chi = 1
    chi_s = .5
    parameters = (chi,chi_s,pdi,sigma,phi_b,navgsegments)

    try:
        SCFsolve(bs.field_equations(parameters),np.zeros((1,40)))
    except NoConvergence:
        pass
    else: # Belongs to try, executes if no exception is raised
        assert False, 'should not arrive here'

    data = np.array([[  3.07254929e-01,   1.41259529e-01,   1.62795764e-01,
          1.68991420e-01,   1.76513700e-01,   1.83949395e-01,
          1.91169043e-01,   1.98034330e-01,   2.04468663e-01,
          2.10498735e-01,   2.16628713e-01,   2.25451759e-01,
          2.46568079e-01,   2.60299445e-01,   1.53151751e-01,
          4.00451631e-02,   6.78029664e-03,   1.22648571e-03,
          2.88017146e-04,   8.06983334e-05,   2.42960996e-05,
          7.48556220e-06,   2.32031419e-06,   7.19743365e-07,
          2.23051957e-07,   6.90243465e-08,   2.13222654e-08,
          6.57099636e-09,   2.01620328e-09,   6.11667304e-10,
          1.78586804e-10,   4.58150217e-11]])
    result = SCFsolve(bs.field_equations(parameters),data)

    assert np.allclose(result, data)#, atol=1e-14)

def walk_test():
    sigma = .1
    phi_b = 0
    navgsegments = 95.5
    pdi = 1.2
    chi = 1
    chi_s = .5
    parameters = (chi,chi_s,pdi,sigma,phi_b,navgsegments)

    BasicSystem._cache.clear()
    bs = BasicSystem()
    data = np.array([[  3.07254929e-01,   1.41259529e-01,   1.62795764e-01,
          1.68991420e-01,   1.76513700e-01,   1.83949395e-01,
          1.91169043e-01,   1.98034330e-01,   2.04468664e-01,
          2.10498735e-01,   2.16628713e-01,   2.25451759e-01,
          2.46568079e-01,   2.60299446e-01,   1.53151751e-01,
          4.00451629e-02,   6.78029660e-03,   1.22648570e-03,
          2.88017153e-04,   8.06983412e-05,   2.42961076e-05,
          7.48557041e-06,   2.32032238e-06,   7.19751628e-07,
          2.23060091e-07,   6.90325414e-08,   2.13304685e-08,
          6.57920497e-09,   2.02460826e-09,   6.20312604e-10,
          1.87919083e-10,   5.48014993e-11,   1.40449190e-11]])
    result = bs.walk(parameters)

    assert np.allclose(result, data)

    # check that the cache is holding items
    assert bs._cache

    # check high pdi solutions converge without too many layers
    parameters = (.47,0,1.75,.1,.1,100)
    result = bs.walk(parameters)

    assert result.shape <= (1,150)

    # check vapor swollen too
    vs = VaporSwollenSystem()
    param = (1, -1.5, 2.5, .01, .1, 75, 1)
    result = vs.walk(param)
    data = np.array([[ -1.52118963e+00,  -1.38452635e+00,  -8.13458120e-01,
         -1.90503081e-01,  -2.48189019e-02,  -2.80714314e-03,
         -3.11807894e-04,  -3.46075211e-05,  -3.84694482e-06,
         -4.28561663e-07,  -4.80140880e-08,  -4.74106999e-09,
         -1.19466698e-09,  -3.52537929e-10,  -3.63749514e-10,
          3.85931103e-12,  -1.46389074e-10,  -2.77829538e-10,
         -1.02209555e-06,  -9.42265017e-06,  -8.69152683e-05,
         -8.01458558e-04,  -7.36536166e-03,  -6.56689503e-02,
         -4.69992867e-01],
       [ -9.41579696e-01,  -8.23304003e-01,  -5.89680968e-01,
         -1.45219368e-01,  -1.91983326e-02,  -2.17836231e-03,
         -2.42051213e-04,  -2.68633159e-05,  -2.98565304e-06,
         -3.32590195e-07,  -3.71186147e-08,  -3.86014721e-09,
         -9.06348322e-10,  -1.96828443e-10,  -2.84606057e-10,
          5.87285778e-12,  -3.42501035e-10,  -2.41638372e-10,
         -7.94888799e-07,  -7.32856028e-06,  -6.76006315e-05,
         -6.23348799e-04,  -5.72794300e-03,  -5.10211524e-02,
         -2.78862797e-01],
       [  1.73564354e+00,   1.14044803e+00,   2.18743362e-01,
          2.59693843e-02,   2.88315793e-03,   3.19408804e-04,
          3.54380505e-05,   3.93856522e-06,   4.38475642e-07,
          4.88121511e-08,   5.65685850e-09,   4.47293317e-10,
         -5.37544155e-11,   1.31041211e-10,  -8.60481442e-11,
          4.78910041e-11,  -4.57409539e-10,  -8.37306209e-11,
          1.13483273e-07,   1.04714720e-06,   9.65790220e-06,
          8.90905311e-05,   8.21732197e-04,   7.57004031e-03,
          6.89908215e-02]])

    assert np.allclose(result, data)


def SCFsqueeze_test():

    # squeeze the easy solution substantially
    chi = 0.1
    chi_s = 0.05
    sigma = .1
    phi_b = 0
    navgsegments = 95.5
    pdi = 1.2
    layers = 65
    data = np.array([  3.65558082e-01,   3.97533333e-01,   3.95179978e-01,
         3.88757819e-01,   3.80787284e-01,   3.72130794e-01,
         3.63092959e-01,   3.53800165e-01,   3.44316370e-01,
         3.34681240e-01,   3.24923297e-01,   3.15065003e-01,
         3.05125186e-01,   2.95120440e-01,   2.85066025e-01,
         2.74976440e-01,   2.64865786e-01,   2.54747977e-01,
         2.44636853e-01,   2.34546245e-01,   2.24489996e-01,
         2.14481972e-01,   2.04536066e-01,   1.94666194e-01,
         1.84886295e-01,   1.75210336e-01,   1.65652309e-01,
         1.56226235e-01,   1.46946170e-01,   1.37826200e-01,
         1.28880447e-01,   1.20123068e-01,   1.11568257e-01,
         1.03230243e-01,   9.51233029e-02,   8.72617647e-02,
         7.96600346e-02,   7.23326302e-02,   6.52942345e-02,
         5.85597723e-02,   5.21445036e-02,   4.60641230e-02,
         4.03348257e-02,   3.49732711e-02,   2.99963349e-02,
         2.54205052e-02,   2.12607873e-02,   1.75290516e-02,
         1.42319226e-02,   1.13685232e-02,   8.92858342e-03,
         6.89147965e-03,   5.22661400e-03,   3.89520205e-03,
         2.85314433e-03,   2.05437856e-03,   1.45405351e-03,
         1.01101862e-03,   6.89388676e-04,   4.59200254e-04,
         2.96354450e-04,   1.82124633e-04,   1.02535872e-04,
         4.79564181e-05,   1.33585282e-05])
    result = SCFsqueeze(chi,chi_s,pdi,sigma,phi_b,navgsegments,layers)

    assert np.allclose(result, data)

def SCFprofile_test():

    # basically checking that numpy interp hasn't changed
    data = np.array([ 0.50131233,  0.48795632,  0.47460032,  0.4616026 ,  0.45405516,
        0.44650771,  0.43949663,  0.43629684,  0.43309705,  0.43001495,
        0.42745113,  0.42488731,  0.42235622,  0.41992505,  0.41749388,
        0.41507472,  0.41268249,  0.41029026,  0.4079072 ,  0.40553974,
        0.40317227,  0.40081446,  0.39846933,  0.39612421,  0.39378928,
        0.39146482,  0.38914036,  0.38682618,  0.38452025,  0.38221431,
        0.37991839,  0.3776287 ,  0.375339  ,  0.37305883,  0.37078318,
        0.36850753,  0.36624085,  0.36397732,  0.36171379,  0.35945866,
        0.35720562,  0.35495257,  0.35270742,  0.35046351,  0.34821961,
        0.34598317,  0.34374734,  0.3415115 ,  0.3392828 ,  0.33705419,
        0.3348259 ,  0.33260387,  0.33038184,  0.32816049,  0.32594457,
        0.32372865,  0.32151372,  0.31930359,  0.31709345,  0.31488462,
        0.31268007,  0.31047551,  0.30827259,  0.30607354,  0.30387449,
        0.30167741,  0.29948389,  0.29729036,  0.2950992 ,  0.29291131,
        0.29072343,  0.28853836,  0.28635634,  0.28417431,  0.28199562,
        0.27981976,  0.2776439 ,  0.275472  ,  0.2733027 ,  0.2711334 ,
        0.26896881,  0.26680658,  0.26464435,  0.2624877 ,  0.26033315,
        0.2581786 ,  0.25603068,  0.25388453,  0.25173838,  0.24960011,
        0.24746321,  0.24532632,  0.24319877,  0.24107212,  0.23894547,
        0.23682992,  0.23471466,  0.23259985,  0.23049731,  0.22839477,
        0.22629361,  0.22420529,  0.22211698,  0.2200312 ,  0.21795886,
        0.21588652,  0.21381813,  0.21176374,  0.20970935,  0.20766066,
        0.20562649,  0.20359231,  0.20156597,  0.19955457,  0.19754317,
        0.1955422 ,  0.19355649,  0.19157078,  0.18959861,  0.18764187,
        0.18568512,  0.18374564,  0.18182154,  0.17989743,  0.17799502,
        0.17610764,  0.17422025,  0.17235977,  0.17051362,  0.16866746,
        0.16685426,  0.16505426,  0.16325426,  0.16149415,  0.15974558,
        0.15799702,  0.15629621,  0.15460467,  0.15291313,  0.15127807,
        0.14964936,  0.14802064,  0.1464579 ,  0.14489786,  0.14333949,
        0.14185384,  0.14036819,  0.13888926,  0.1374834 ,  0.13607754,
        0.13468402,  0.13336276,  0.1320415 ,  0.13073863,  0.12950599,
        0.12827335,  0.12706537,  0.12592433,  0.12478329,  0.12367316,
        0.12262551,  0.12157786,  0.12056706,  0.11961325,  0.11865945,
        0.11774787,  0.11688699,  0.11602612,  0.11521202,  0.1144418 ,
        0.11367158,  0.1129517 ,  0.11226863,  0.11158555,  0.11095524,
        0.11035469,  0.10975415,  0.10920762,  0.10868414,  0.10816065,
        0.10769128,  0.10723875,  0.10678621,  0.10638682,  0.10599875,
        0.10561067,  0.10527384,  0.10494358,  0.10461333,  0.10433165,
        0.10405264,  0.10377406,  0.10353996,  0.10330586,  0.10307453,
        0.10287936,  0.1026842 ,  0.10249347,  0.10233174,  0.10217   ,
        0.1020138 ,  0.10188051,  0.10174722,  0.10162008,  0.10151079,
        0.1014015 ,  0.1012986 ,  0.10120942,  0.10112023,  0.10103739,
        0.10096492,  0.10089244,  0.10082607,  0.10076742,  0.10070876,
        0.10065582,  0.10060852,  0.10056122,  0.10051917,  0.10048115,
        0.10044314,  0.10040986,  0.1003794 ,  0.10034894,  0.1003227 ,
        0.10029837,  0.10027403,  0.10025341,  0.10023402,  0.10021464,
        0.10019848,  0.10018307,  0.10016767,  0.10015505,  0.10014283,
        0.10013062,  0.1001208 ,  0.10011114,  0.10010148,  0.10009385,
        0.10008623,  0.10007871,  0.10007271,  0.10006671,  0.10006087,
        0.10005616,  0.10005145,  0.10004692,  0.10004323,  0.10003954,
        0.10003604,  0.10003316,  0.10003028,  0.10002758,  0.10002533,
        0.10002308,  0.10002102,  0.10001927,  0.10001752,  0.10001593,
        0.10001457,  0.10001321,  0.100012  ,  0.10001094,  0.10000989,
        0.10000896,  0.10000814,  0.10000732,  0.10000661,  0.10000598,
        0.10000534,  0.10000479,  0.10000429,  0.10000379,  0.10000337,
        0.10000297,  0.10000258,  0.10000224,  0.10000192,  0.1000016 ,
        0.10000132,  0.10000105,  0.10000078,  0.10000054,  0.1000003 ,
        0.10000006,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ,
        0.1       ,  0.1       ,  0.1       ,  0.1       ,  0.1       ])
    result = SCFprofile(np.linspace(0,120,350), chi=.5, chi_s=.3, h_dry=15,
                        l_lat=1, mn=200, m_lat=1, phi_b=0.1, pdi=1.5, disp=False)

    assert np.allclose(result, data)


def benchmark():
    from time import perf_counter
    BasicSystem._cache.clear()
    start=perf_counter()
    bs = BasicSystem()
    p = (0,0,1,.1,0,160.52)
    bs.walk(p)
    p = (0,0,1.75,.1,0,360.52)
    bs.walk(p)
    print('Benchmark time:', perf_counter()-start, 'seconds.')


def main():
    from time import perf_counter
    start=perf_counter()
    calc_g_zs_ta_test()
    calc_g_zs_free_test()
    calc_g_zs_ngts_u_test()
    calc_g_zs_ngts_test()
    calc_g_zs_ngts_test()
    BasicSystem_test()
    VaporSwollenSystem_test()
    SCFsolve_test()
    SCFeqns_multi_test()
    walk_test()
    SCFsqueeze_test()
    SCFprofile_test()
    stop=perf_counter()
    print('All tests passed in {:.3g} seconds!'.format(stop-start))
    benchmark()


if __name__ == '__main__':
    main()