示例#1
0
def getHybridPlan(xstart: list,
                  xend: list,
                  N: int,
                  btrue: list,
                  binit: list,
                  bstart: list,
                  bend: list,
                  c,
                  Ve,
                  jacf,
                  funcf,
                  NSIG=10,
                  implicit=False,
                  lognorm=False,
                  dotlim=500,
                  verbose=False):
    oplan = o_ap.grandApriornPlanning(
        xstart, xend, N, bstart, bend, c, Ve, jacf, func=None,
        Ntries=5)[1]  #сперва строим априорный план
    return getbSeqPlanUltra(
        xstart,
        xend,
        N,
        btrue,
        binit,
        c,
        Ve,
        jacf,
        funcf,
        initplan=oplan,
        dotlim=500)  #теперь последовательный с лимитом на 500 точек лишних
def extraction_Kirch_DiodeV2Mod2DirectBranchmathath():
    """
    [Реестровая]

    :return:
    """
    global FT,XO,XT,XF
    global foldername

    funcf=solver_Kirch_DiodeV2Mod2DirectBranchmathath
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranchmathath
    c=None
    Ve=np.array([ [1e-5] ]  )
    #       0           1       2        3         4       5    6        7
    btrue=[341.4e-6, 2.664, 37.08e-3, 17.26e-27, 5.662, 4.282, 0.5751, 3.65e-3]

    #коридор в 20 процентов в обе стороны
    diap = .1
    bstart = [item-item*diap for item in btrue]
    bend = [item+item*diap for item in btrue]

    binit=btrue

    xstart, xend = [0.001] , [1]

    N=20
    print("performing aprior plan:")

    import os
    filename ='N{0}_'.format(N)+os.path.basename(__file__).replace('.py','_plan')
    oplan = o_ap.makePlanCached (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True, foldername=foldername, cachname=filename, verbosePlan=True)
示例#3
0
def test():
    """
    Тестирует последовательное планирование
    :return:
    """
    xstart=[1, 100]
    xend=[20,200]


    c={"a":1000}
    funcf=lambda x,b,c: np.array ( [ b[0]+b[1]*x[0]+b[2]*x[1]+b[3]*x[0]*x[1]+b[4]*x[0]*x[0]+b[5]*x[1]*x[1],   b[6]+b[7]*x[0]+b[8]*x[1]+b[9]*x[0]*x[1]+b[10]*x[0]*x[0]+b[11]*x[1]*x[1] ] )




    jacf = lambda x,b,c,y: np.matrix([ [1, x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1], 0, 0, 0, 0, 0, 0],
                                      [0,0,0,0,0,0,1,x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1]] ])

    Ve=np.array([ [0.0001, 0],
                  [0, 0.0001]]  )
    btrue=[8,4,2,2,9,3,4,2,2,3,4,5]
    bstart=np.array(btrue)-np.array([2]*len(btrue))
    bend=np.array(btrue)+np.array([2]*len(btrue))
    binit=[1]*len(btrue)
    N=32


    #seqplanb=getbSeqPlanUltra (xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=o_p.makeRandomUniformExpPlan(xstart, xend, 5), dotlim=500)

    print("performing aprior plan:")
    oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, func=None, Ntries=5)[1]
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
    gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)



    print("\n\nperforming sequence plan with uniform as seed:")
    seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=o_p.makeUniformExpPlan(xstart, xend, 4), dotlim=200, NSIG=10)
    measdata = o_p.makeMeasAccToPlan(funcf, seqplanb[3], btrue, c,Ve)
    gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
    o_q.printSeqPlanData(seqplanb)


#И самый огонь - последовательный план с априорным в затравке!
    print("\n\nperforming sequence plan with aprior as seed (hybrid):")

    seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=oplan, dotlim=200, NSIG=10)


    #seqplanb=o_sp.getHybridPlan(xstart, xend, N, btrue, binit, bstart, bend, c, Ve, jacf, funcf)
    measdata = o_p.makeMeasAccToPlan(funcf, seqplanb[3], btrue, c,Ve)
    gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
    o_q.printSeqPlanData(seqplanb)
def makeplan_lambda (plantype, n, bstart, bend, Ve):
    global xstart, xend, btrue,c
    #- делает нужный план в зависимости от параметров plantype и n
    #Надо создать пачку априорных планов - 5 10 15 20 25 30 35 40 значений
    hash= hashlib.md5((n,bstart,bend,Ve).__str__().encode('utf-8')).hexdigest()

    #hashlib.md5("whatever your string is".encode('utf-8')).

    filename = usercomment+'_'+str(hash)
    if plantype: #если априорный
        return o_ap.makePlanCached (xstart, xend, n, bstart, bend, c, Ve, jacf, funcf, Ntries=4, verbose=False, foldername='DependencyPlans', cachname=filename)
    else:
        return o_p.makeUniformExpPlan(xstart,xend,n)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
    """
    [Реестровая]

    :return:
    """
    global FT
    global foldername

    funcf=solver_Kirch_DiodeV2Mod2DirectBranch
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
    c={}
    Ve=np.array([ [1e-5] ]  )
    #       0           1       2     3   4    5    6
    btrue=[1.238e-14, 1.8,  1.123e-14, 1.5, 1.12, 0.5, 123.]
    bstart=np.array(btrue)-np.array(btrue)*0.3
    bend=np.array(btrue)+np.array(btrue)*0.3
    #binit=[1.1e-14, 1.5,  1.1e-14, 1.9, 1.0, 0.8, 100.]
    binit = np.array(btrue)-np.array(btrue)*0.1

    xstart=[0.001]
    xend=[1.5]
    N=40 #число точек в плане (для планов, кроме априорного)
    NArprior=20 #число точек в априорном плане


    #Получаем априорный план
    import os

    filename =foldername+'/'+os.path.basename(__file__).replace('.py','N{0}_plan'.format (NArprior))
    try:
        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

    newxstart=1.4
    oplan = [item for item in oplan if item[0]<newxstart]

    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )


    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=True )
    #gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)

    gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf,  measdata, c, Ve, name='Limited Count Aprior')
    #gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf,  measdata, c, Ve, name='Normal Count Aprior')

    o_q.printQualitatStandart (gknuxlim2)
def extraction_Kirch_DiodeV2Mod2DirectBranchmathath():
    """
    [Реестровая]

    :return:
    """
    global FT, XO, XT, XF
    global foldername

    funcf = solver_Kirch_DiodeV2Mod2DirectBranchmathath
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranchmathath
    c = None
    Ve = np.array([[1e-5]])
    #       0           1       2        3         4       5    6        7
    btrue = [
        341.4e-6, 2.664, 37.08e-3, 17.26e-27, 5.662, 4.282, 0.5751, 3.65e-3
    ]

    #коридор в 20 процентов в обе стороны
    diap = .1
    bstart = [item - item * diap for item in btrue]
    bend = [item + item * diap for item in btrue]

    binit = btrue

    xstart, xend = [0.001], [1]

    N = 20
    print("performing aprior plan:")

    import os
    filename = 'N{0}_'.format(N) + os.path.basename(__file__).replace(
        '.py', '_plan')
    oplan = o_ap.makePlanCached(xstart,
                                xend,
                                N,
                                bstart,
                                bend,
                                c,
                                Ve,
                                jacf,
                                funcf,
                                Ntries=6,
                                verbose=True,
                                foldername=foldername,
                                cachname=filename,
                                verbosePlan=True)
def extraction_DiodeV4_partIn_Decimal(plot=True):
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    #возвращает значение y
    funcf=solver_DiodeV4_partIn_Decimal
    jacf = jac_DiodeV4_partIn_Decimal
    #теперь попробуем сделать эксперимент.
    c={}
    Ve=np.array([ [0.00000001] ]  )
    btrue=[1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart=np.array(btrue)-np.array(btrue)*0.3
    bend=np.array(btrue)+np.array(btrue)*0.3
    binit=[1.0e-14, 1.7, 70]
    #binit=[1.238e-14, 1.8, 100]

    xstart=[0.001]
    #xend=[20,60]
    xend=[1.5]
    N=100 #для неаприорных планов
    NAprior=20 #для априорных планов


     #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename ='cachedPlans/'+os.path.basename(__file__).replace('.py','_plan')
    try:
        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:

        oplan=o_ap.grandApriornPlanning (xstart, xend, NAprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)
    #}

    unifplan =  o_p.makeUniformExpPlan(xstart, xend, N)

    #получаем измерения с планов
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )


    measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c,Ve )

    filename = os.path.basename(__file__).replace('.py','_results')

    #выполняем оценку
    print ("performing aprior plan")
    gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf,  measdata, binit, c, Ve, NSIG=100, implicit=True)
    o_q.analyseDifList(gknu, imagename='Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)


    print ("performing uniform plan")
    gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf,  measdataUnif, binit, c, Ve, NSIG=100, implicit=True)
    o_q.analyseDifList(gknu, imagename='Uniform_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def extraction_func_DiodeV3Approach1_part_In():
    """
    [Реестровая]

    :return:
    """
    funcf=solver_func_DiodeV3Approach1_part_In
    jacf=Jac_func_DiodeV3Approach1_part_In
    c={}
    Ve=np.array([ [0.001] ]  )
    btrue=[1.238e-14, 1.3]
    bstart=np.array(btrue)-np.array(btrue)*0.1
    bend=np.array(btrue)+np.array(btrue)*0.1

    binit=np.array(btrue)+np.array(btrue)*0.05
    xstart=[0.01]
    #xend=[20,60]
    xend=[3]
    N=300 #число точек в плане (для планов, кроме априорного)
    NArprior=20 #число точек в априорном плане

    #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename = os.path.basename(__file__).replace('.py','_plan')
    try:
        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)
    #}


    unifplan =  o_p.makeUniformExpPlan(xstart, xend, N)


    #получаем измерения с планов
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
    measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c,Ve )

    filename = os.path.basename(__file__).replace('.py','_results')



    #выполняем оценку
    print ("performing aprior plan")
    gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf,  measdata, binit, c, Ve, NSIG=100, implicit=True)
    o_q.analyseDifList(gknu, imagename='Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)


    print ("performing uniform plan")
    gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf,  measdataUnif, binit, c, Ve, NSIG=100, implicit=True)
    o_q.analyseDifList(gknu, imagename='Uniform_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)


    print ("performing ExtraStart™ method")
    resarr=list() #Список результатов
    t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])

    for i in range(30):
        measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
        gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf,  measdata, bstart, bend, c, Ve,  NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
        if (gknu):
            resarr.append(gknu)
    if resarr:
        for gknu in resarr:
            if (gknu):
                t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    gknu=o_e.selectBestEstim (resarr)

    t.add_row(['*', '*', '*', '*' ])
    t.add_row([gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    print(t)

    o_q.analyseDifList(gknu, imagename='ExtraStart_et_Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def testDiodeParameterExtractionIMPLICIT(plot=True):
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    #возвращает значение y
    funcf=diodeResistorIMPLICITfunction
    jacf = diodeResistorIMPLICITJac
    #теперь попробуем сделать эксперимент.
    c={}
    Ve=np.array([ [0.00000001] ]  )
    btrue=[1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart=np.array(btrue)-np.array(btrue)*0.3
    bend=np.array(btrue)+np.array(btrue)*0.3
    binit=[1.0e-14, 1.7, 70]
    #binit=[1.238e-14, 1.8, 100]

    xstart=[0.001]
    #xend=[20,60]
    xend=[2 ]
    N=20


    print("performing aprior plan:")

#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
    try:
        oplan=o_p.readPlanFromFile() #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
        o_p.writePlanToFile(oplan)

    #получаем измеренные данные
#     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
#     #чертим эти данные
#     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
#     #оценка
#     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
#
#     #вывод данных оценки - данные, квалитат, дроп
#     o_q.printGKNUNeat(gknu)
#     o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
#     if plot:
#         o_pl.plotSkGraph(gknu, 'Aprior Research Sk drop')
#
#
    terminationOptDict={'VdShelfPow':-7}
#
#
#     N=30
#
#     print("\n\nperforming sequence plan with random as seed:")
#     seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf,  dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
#     #выводим данные последовательного планирования
#     o_q.printSeqPlanData(seqplanb)
#     #получаем данные измерения по этому последовательному плану
#     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
#     #чертим эти  данные
#     if plot:
#         o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
#     print("GKNU for plan")
#     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
#     o_q.printGKNUNeat(gknu)
#     o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
#     if plot:
#         o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#
#
#     print("\n\nperforming sequence plan with uniform as seed:")
#     unifplan=o_p.makeUniformExpPlan(xstart, xend, N)
#     seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=unifplan, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
#     #выводим данные последовательного планирования
#     o_q.printSeqPlanData(seqplanb)
#     #получаем данные измерения по этому последовательному плану
#     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
#     #чертим эти  данные
#     if plot:
#         o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
#     print("GKNU for plan")
#     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
#     o_q.printGKNUNeat(gknu)
#     o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
#     if plot:
#         o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#




    # print("\n\nperforming sequence plan with aprior as seed (hybrid):")
    # seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf,  dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
    # # #выводим данные последовательного планирования


    # o_q.printSeqPlanData(seqplanb)
    #получаем данные измерения по этому последовательному плану


    # #пробуем несколько измерений произвести
    # resarr=list()
    # #несколько раз измерения
    # t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
    # for i in range(20):
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
    #     gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf,  measdata, bstart, bend, c, Ve,  NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
    #     if (gknu):
    #         resarr.append(gknu)
    # if resarr:
    #     for gknu in resarr:
    #         if (gknu):
    #             t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    # be=o_e.selectBestEstim (resarr)
    # t.add_row(['*', '*', '*', '*' ])
    # t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
    # print(t)
    # o_q.analyseDifList(be)




    #Априорный план просто


    startplan =  o_p.makeUniformExpPlan(xstart, xend, 150)

    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c,Ve)
    gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_Diode_Irev_Limited():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    global FT
    global foldername

    #возвращает значение y
    funcf = solver_Diode_Irev_Limited
    jacf = jac_Diode_Irev_Limited
    #теперь попробуем сделать эксперимент.
    c = {}

    Ve = np.array([[1.34e-7]
                   ])  #согласно погрешности на мультиметре CHROMA 12061
    #btrue=[5.31656e-8,2 ,.0392384] #номинальные значения диода D1N4001
    btrue = [
        5e-8, 400, .0422
    ]  #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя

    # V=x[0] #напряжение на диоде, в данном случае обратное
    # IBV=b[0]
    # BV=b[1]
    # R=b[2]

    bstart = np.array(btrue) - np.array(btrue) * 0.1
    bend = np.array(btrue) + np.array(btrue) * 0.1

    print('conditions:')
    print(bstart)
    print(bend)

    binit = [
        5e-8, 400, .0422
    ]  #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя

    xstart = [399]
    xend = [401]
    N = 30

    print("performing uniform plan:")
    plan = o_p.makeUniformExpPlan(xstart, xend, N)
    measdata = o_p.makeMeasAccToPlan(funcf, plan, btrue, c, None)
    print(measdata)
    plotPlanAndMeas2D(measdata)

    exit(0)

    print("performing aprior plan:")

    #примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров

    import os
    filename = foldername + '/' + 'RD_11N4004_' + os.path.basename(
        __file__).replace('.py', '_plan')
    try:
        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          N,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)


#    получаем измеренные данные
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
    #     #чертим эти данные
    #     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
    #
    #     #оценка

    #grandCountGN_UltraX1_Limited_wrapper (funcf, jacf,  measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
                                                         jacf,
                                                         measdata,
                                                         binit,
                                                         bstart,
                                                         bend,
                                                         c,
                                                         implicit=True,
                                                         verbose=False,
                                                         verbose_wrapper=False)
    gknux = o_e.grandCountGN_UltraX1(funcf,
                                     jacf,
                                     measdata,
                                     binit,
                                     c,
                                     implicit=True)

    gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
                                              funcf,
                                              jacf,
                                              measdata,
                                              c,
                                              Ve,
                                              name='Limited Count Aprior')
    gknux2 = o_q.convertToQualitatStandart(gknux,
                                           funcf,
                                           jacf,
                                           measdata,
                                           c,
                                           Ve,
                                           name='Normal Count Aprior')

    o_q.printQualitatStandart(gknuxlim2)
    o_q.printQualitatStandart(gknux2)
def extraction_Diode_Irev_Limited():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    global FT
    global foldername

    #возвращает значение y
    funcf=solver_Diode_Irev_Limited
    jacf = jac_Diode_Irev_Limited
    #теперь попробуем сделать эксперимент.
    c={}

    Ve=np.array([ [1.34e-7] ]  ) #согласно погрешности на мультиметре CHROMA 12061
    #btrue=[5.31656e-8,2 ,.0392384] #номинальные значения диода D1N4001
    btrue=[5e-8, 400 ,.0422] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя


    # V=x[0] #напряжение на диоде, в данном случае обратное
    # IBV=b[0]
    # BV=b[1]
    # R=b[2]

    bstart=np.array(btrue)-np.array(btrue)*0.1
    bend=np.array(btrue)+np.array(btrue)*0.1


    print('conditions:')
    print(bstart)
    print(bend)


    binit=[5e-8, 400 ,.0422] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя



    xstart=[399]
    xend=[401]
    N=30


    print("performing uniform plan:")
    plan = o_p.makeUniformExpPlan(xstart,xend, N)
    measdata = o_p.makeMeasAccToPlan(funcf, plan, btrue, c,None )
    print (measdata)
    plotPlanAndMeas2D(measdata)

    exit(0)







    print("performing aprior plan:")

#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров

    import os
    filename =foldername+'/'+'RD_11N4004_'+os.path.basename(__file__).replace('.py','_plan')
    try:
        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)





#    получаем измеренные данные
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
#     #чертим эти данные
#     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
#     #оценка


    #grandCountGN_UltraX1_Limited_wrapper (funcf, jacf,  measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=False )
    gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)

    gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf,  measdata, c, Ve, name='Limited Count Aprior')
    gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf,  measdata, c, Ve, name='Normal Count Aprior')

    o_q.printQualitatStandart (gknuxlim2)
    o_q.printQualitatStandart (gknux2)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
    """
    [Реестровая]

    :return:
    """
    global FT
    global foldername

    funcf = solver_Kirch_DiodeV2Mod2DirectBranch
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
    c = {}
    Ve = np.array([[1e-5]])
    #       0           1       2     3   4    5    6
    btrue = [1.238e-14, 1.8, 1.123e-14, 1.5, 1.12, 0.5, 123.]
    bstart = np.array(btrue) - np.array(btrue) * 0.3
    bend = np.array(btrue) + np.array(btrue) * 0.3
    #binit=[1.1e-14, 1.5,  1.1e-14, 1.9, 1.0, 0.8, 100.]
    binit = np.array(btrue) - np.array(btrue) * 0.1

    xstart = [0.001]
    xend = [1.5]
    N = 40  #число точек в плане (для планов, кроме априорного)
    NArprior = 20  #число точек в априорном плане

    #Получаем априорный план
    import os

    filename = foldername + '/' + os.path.basename(__file__).replace(
        '.py', 'N{0}_plan'.format(NArprior))
    try:
        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          NArprior,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

    newxstart = 1.4
    oplan = [item for item in oplan if item[0] < newxstart]

    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
                                                         jacf,
                                                         measdata,
                                                         binit,
                                                         bstart,
                                                         bend,
                                                         c,
                                                         implicit=True,
                                                         verbose=False,
                                                         verbose_wrapper=True)
    #gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)

    gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
                                              funcf,
                                              jacf,
                                              measdata,
                                              c,
                                              Ve,
                                              name='Limited Count Aprior')
    #gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf,  measdata, c, Ve, name='Normal Count Aprior')

    o_q.printQualitatStandart(gknuxlim2)
示例#13
0
def testDiodeParameterExtractionIMPLICIT(plot=True):
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    #возвращает значение y
    funcf = diodeResistorIMPLICITfunction
    jacf = diodeResistorIMPLICITJac
    #теперь попробуем сделать эксперимент.
    c = {}
    Ve = np.array([[0.00000001]])
    btrue = [1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart = np.array(btrue) - np.array(btrue) * 0.3
    bend = np.array(btrue) + np.array(btrue) * 0.3
    binit = [1.0e-14, 1.7, 70]
    #binit=[1.238e-14, 1.8, 100]

    xstart = [0.001]
    #xend=[20,60]
    xend = [2]
    N = 20

    print("performing aprior plan:")

    #примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
    try:
        oplan = o_p.readPlanFromFile(
        )  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          N,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbosePlan=True,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan)

    #получаем измеренные данные
#     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
#     #чертим эти данные
#     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
#     #оценка
#     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
#
#     #вывод данных оценки - данные, квалитат, дроп
#     o_q.printGKNUNeat(gknu)
#     o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
#     if plot:
#         o_pl.plotSkGraph(gknu, 'Aprior Research Sk drop')
#
#
    terminationOptDict = {'VdShelfPow': -7}
    #
    #
    #     N=30
    #
    #     print("\n\nperforming sequence plan with random as seed:")
    #     seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf,  dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
    #     #выводим данные последовательного планирования
    #     o_q.printSeqPlanData(seqplanb)
    #     #получаем данные измерения по этому последовательному плану
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
    #     #чертим эти  данные
    #     if plot:
    #         o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
    #     print("GKNU for plan")
    #     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
    #     o_q.printGKNUNeat(gknu)
    #     o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
    #     if plot:
    #         o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
    #
    #
    #
    #     print("\n\nperforming sequence plan with uniform as seed:")
    #     unifplan=o_p.makeUniformExpPlan(xstart, xend, N)
    #     seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=unifplan, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
    #     #выводим данные последовательного планирования
    #     o_q.printSeqPlanData(seqplanb)
    #     #получаем данные измерения по этому последовательному плану
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
    #     #чертим эти  данные
    #     if plot:
    #         o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
    #     print("GKNU for plan")
    #     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=True)
    #     o_q.printGKNUNeat(gknu)
    #     o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
    #     if plot:
    #         o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
    #
    #

    # print("\n\nperforming sequence plan with aprior as seed (hybrid):")
    # seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf,  dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
    # # #выводим данные последовательного планирования

    # o_q.printSeqPlanData(seqplanb)
    #получаем данные измерения по этому последовательному плану

    # #пробуем несколько измерений произвести
    # resarr=list()
    # #несколько раз измерения
    # t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
    # for i in range(20):
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
    #     gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf,  measdata, bstart, bend, c, Ve,  NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
    #     if (gknu):
    #         resarr.append(gknu)
    # if resarr:
    #     for gknu in resarr:
    #         if (gknu):
    #             t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    # be=o_e.selectBestEstim (resarr)
    # t.add_row(['*', '*', '*', '*' ])
    # t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
    # print(t)
    # o_q.analyseDifList(be)

    #Априорный план просто

    startplan = o_p.makeUniformExpPlan(xstart, xend, 150)

    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve)
    gknu = o_e.grandCountGN_UltraX1(funcf,
                                    jacf,
                                    measdata,
                                    binit,
                                    c,
                                    NSIG=100,
                                    implicit=True)
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
    """
    [Реестровая]

    :return:
    """
    funcf = func_Kirch_DiodeV2Mod2DirectBranch
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
    c = {}
    Ve = np.array([[0.0000000000001]])
    btrue = [1.238e-14, 1.8, 1.5e-15, 1.9, 1.2, 0.5]

    bstart = np.array(btrue) - np.array(btrue) * 0.1
    bend = np.array(btrue) + np.array(btrue) * 0.1
    binit = [1.238e-14, 1.7, 1.1e-20, 1.9, 1.1, 0.5]

    xstart = [0.01]
    #xend=[20,60]
    xend = [1.5]
    N = 200  #число точек в плане (для планов, кроме априорного)
    NArprior = 30  #число точек в априорном плане

    #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename = os.path.basename(__file__).replace('.py', '_plan1')
    try:

        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          NArprior,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbosePlan=True,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

    #Задание опций для последовательного плана
    terminationOptDict = {'VdShelfPow': -7}

    #Оценивание параметров с использованием  ряда начальных значений
    # resarr=list() #Список результатов
    # t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
    # for i in range(30):
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
    #     gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf,  measdata, bstart, bend, c, Ve,  NSIG=100, implicit=False, verbose=False, Ntries=10, name='aprior plan plus several measurements')
    #     if (gknu):
    #         resarr.append(gknu)
    # if resarr:
    #     for gknu in resarr:
    #         if (gknu):
    #             t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    # be=o_e.selectBestEstim (resarr)
    #
    # t.add_row(['*', '*', '*', '*' ])
    # t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
    # print(t)
    # #o_q.analyseDifList(be)
    # o_q.printGKNUNeat(be)
    # o_q.printQualitatNeat(measdata, be[0], Ve, funcf, c)

    #Оценивание с использованием binit

    #    По априорному плану
    #     print('Aprior Plan Binit')
    #     #данные по новому формату
    #
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
    #     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=False)
    #     #o_q.analyseDifList(gknu)
    #     o_q.printGKNUNeat(gknu)
    #     o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)

    #
    # #По нормальному плану

    print("performing normal research:")
    startplan = o_p.makeUniformExpPlan(xstart, xend, 150)
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve)
    gknu = o_e.grandCountGN_UltraX1(funcf,
                                    jacf,
                                    measdata,
                                    binit,
                                    c,
                                    NSIG=100,
                                    implicit=False)
    if (gknu):
        #o_q.analyseDifList(gknu)
        o_q.printGKNUNeat(gknu)
        o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
    """
    [Реестровая]

    :return:
    """
    funcf=func_Kirch_DiodeV2Mod2DirectBranch
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
    c={}
    Ve=np.array([ [0.0000000000001] ]  )
    btrue=[1.238e-14, 1.8, 1.5e-15, 1.9, 1.2, 0.5]

    bstart=np.array(btrue)-np.array(btrue)*0.1
    bend=np.array(btrue)+np.array(btrue)*0.1
    binit=[1.238e-14, 1.7,  1.1e-20, 1.9, 1.1, 0.5]


    xstart=[0.01]
    #xend=[20,60]
    xend=[1.5]
    N=200 #число точек в плане (для планов, кроме априорного)
    NArprior=30 #число точек в априорном плане




    #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename = os.path.basename(__file__).replace('.py','_plan1')
    try:

        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

    #Задание опций для последовательного плана
    terminationOptDict={'VdShelfPow':-7}



    #Оценивание параметров с использованием  ряда начальных значений
    # resarr=list() #Список результатов
    # t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
    # for i in range(30):
    #     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
    #     gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf,  measdata, bstart, bend, c, Ve,  NSIG=100, implicit=False, verbose=False, Ntries=10, name='aprior plan plus several measurements')
    #     if (gknu):
    #         resarr.append(gknu)
    # if resarr:
    #     for gknu in resarr:
    #         if (gknu):
    #             t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
    # be=o_e.selectBestEstim (resarr)
    #
    # t.add_row(['*', '*', '*', '*' ])
    # t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
    # print(t)
    # #o_q.analyseDifList(be)
    # o_q.printGKNUNeat(be)
    # o_q.printQualitatNeat(measdata, be[0], Ve, funcf, c)





    #Оценивание с использованием binit

#    По априорному плану
#     print('Aprior Plan Binit')
#     #данные по новому формату
#
#     measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
#     gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=False)
#     #o_q.analyseDifList(gknu)
#     o_q.printGKNUNeat(gknu)
#     o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)


    #
    # #По нормальному плану

    print("performing normal research:")
    startplan =  o_p.makeUniformExpPlan(xstart, xend, 150)
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c,Ve)
    gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=100, implicit=False)
    if (gknu):
        #o_q.analyseDifList(gknu)
        o_q.printGKNUNeat(gknu)
        o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
示例#16
0
def testDiodeParameterExtraction():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    jacf=jacdiode
    funcf=diode

    #теперь попробуем сделать эксперимент.
    c={}
    Ve=np.asmatrix( [0.1]   )

    btrue=[1.238e-14, 1.8]
    bstart=np.array(btrue)-np.array(btrue)*0.2
    bend=np.array(btrue)+np.array(btrue)*0.2
    binit=[1e-10,1.1]


    xstart=[0.01]
    xend=[2]

    N=30
    print("performing normal research:")
    startplan =  o_p.makeUniformExpPlan(xstart, xend, N)
    print(len(startplan))

    measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
    planplot1=[x[0] for x in startplan]
    measplot1=[x['y'][0] for x in measdata]
    plt.plot(planplot1, measplot1,  'bo')
    plt.show()


    gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=6, sign=1)
    #как мы помним, в случае неявных функций должно ставить sign=0
    print (gknu[0])
    print (o_q.getQualitat(measdata, gknu[0], Ve,  funcf, c))

      #plotting Sk graph
    #TODO better organize: this code to estimation or somewhere
    rng=np.arange(0,len(gknu[3]))
    plt.plot(rng , gknu[3], label='Sk drop')
    plt.legend(loc='upper left')
    plt.ylabel('Sk')
    plt.xlabel('Interation')
    plt.grid()
    plt.show()


    N=20
    print("performing aprior plan:")
    oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6)[1]
    o_p.writePlanToFile(oplan)
    measdata = o_p.makeMeasAccToPlan(funcf, oplan, btrue, c,Ve )



    planplot1=[x[0] for x in oplan]
    measplot1=[x['y'][0] for x in measdata]
    plt.plot(planplot1, measplot1,  'bo')
    plt.show()





    gknu=o_e.grandCountGN_UltraX1 (funcf, jacf,  measdata, binit, c, NSIG=6, sign=1)
    print (gknu[0])
    print (o_q.getQualitat(measdata, gknu[0], Ve,  funcf, c))

         #plotting Sk graph
    #TODO better organize: this code to estimation or somewhere
    rng=np.arange(0,len(gknu[3]))
    plt.plot(rng , gknu[3], label='Sk drop')
    plt.legend(loc='upper left')
    plt.ylabel('Sk')
    plt.xlabel('Interation')
    plt.grid()
    plt.show()
def extraction_func_DiodeV3Approach1_part_In():
    """
    [Реестровая]

    :return:
    """
    funcf = solver_func_DiodeV3Approach1_part_In
    jacf = Jac_func_DiodeV3Approach1_part_In
    c = {}
    Ve = np.array([[0.001]])
    btrue = [1.238e-14, 1.3]
    bstart = np.array(btrue) - np.array(btrue) * 0.1
    bend = np.array(btrue) + np.array(btrue) * 0.1

    binit = np.array(btrue) + np.array(btrue) * 0.05
    xstart = [0.01]
    #xend=[20,60]
    xend = [3]
    N = 300  #число точек в плане (для планов, кроме априорного)
    NArprior = 20  #число точек в априорном плане

    #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename = os.path.basename(__file__).replace('.py', '_plan')
    try:
        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          NArprior,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbosePlan=True,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)
    #}

    unifplan = o_p.makeUniformExpPlan(xstart, xend, N)

    #получаем измерения с планов
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
    measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c, Ve)

    filename = os.path.basename(__file__).replace('.py', '_results')

    #выполняем оценку
    print("performing aprior plan")
    gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
                                            jacf,
                                            measdata,
                                            binit,
                                            c,
                                            Ve,
                                            NSIG=100,
                                            implicit=True)
    o_q.analyseDifList(gknu, imagename='Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)

    print("performing uniform plan")
    gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
                                            jacf,
                                            measdataUnif,
                                            binit,
                                            c,
                                            Ve,
                                            NSIG=100,
                                            implicit=True)
    o_q.analyseDifList(gknu, imagename='Uniform_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)

    print("performing ExtraStart™ method")
    resarr = list()  #Список результатов
    t = PrettyTable([
        'Среднее логарифма правдоподобия', 'Сигма логарифма правдоподобия',
        'b', 'Среднее остатков по модулю'
    ])

    for i in range(30):
        measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
        gknu = o_e.grandCountGN_UltraX_ExtraStart(
            funcf,
            jacf,
            measdata,
            bstart,
            bend,
            c,
            Ve,
            NSIG=100,
            implicit=True,
            verbose=False,
            Ntries=10,
            name='aprior plan plus several measurements')
        if (gknu):
            resarr.append(gknu)
    if resarr:
        for gknu in resarr:
            if (gknu):
                t.add_row([
                    gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'],
                    gknu['AvDif']
                ])
    gknu = o_e.selectBestEstim(resarr)

    t.add_row(['*', '*', '*', '*'])
    t.add_row([gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'], gknu['AvDif']])
    print(t)

    o_q.analyseDifList(gknu, imagename='ExtraStart_et_Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def extraction_Diode_In_Limited():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    global FT
    global foldername

    #возвращает значение y
    funcf=solver_Diode_In_Limited
    jacf = jac_Diode_In_Limited
    #теперь попробуем сделать эксперимент.
    c={}
    Ve=np.array([ [0.00000001] ]  )
    btrue=[1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart=np.array(btrue)-np.array(btrue)*0.3
    bend=np.array(btrue)+np.array(btrue)*0.3002
    #binit=np.array(btrue)-np.array(btrue)*0.1

    print('conditions:')
    print(bstart)
    print(bend)


    binit=[1.1e-14, 1.5, 90]
    xstart=[0.001]
    xend=[2]
    N=20
    print("performing aprior plan:")

#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров

    import os
    filename =foldername+'/'+os.path.basename(__file__).replace('.py','_plan')
    try:
        oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
        print ("Read file successful")
    except BaseException as e:
        oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

#    получаем измеренные данные
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
#     #чертим эти данные
#     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
#     #оценка


    #grandCountGN_UltraX1_Limited_wrapper (funcf, jacf,  measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=False )
    gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)

    gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf,  measdata, c, Ve, name='Limited Count Aprior')
    gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf,  measdata, c, Ve, name='Normal Count Aprior')

    o_q.printQualitatStandart (gknuxlim2)
    o_q.printQualitatStandart (gknux2)






#extraction_Diode_Irev_Limited()
示例#19
0
def extraction_DiodeV4_partIn_Decimal(plot=True):
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    #возвращает значение y
    funcf = solver_DiodeV4_partIn_Decimal
    jacf = jac_DiodeV4_partIn_Decimal
    #теперь попробуем сделать эксперимент.
    c = {}
    Ve = np.array([[0.00000001]])
    btrue = [1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart = np.array(btrue) - np.array(btrue) * 0.3
    bend = np.array(btrue) + np.array(btrue) * 0.3
    binit = [1.0e-14, 1.7, 70]
    #binit=[1.238e-14, 1.8, 100]

    xstart = [0.001]
    #xend=[20,60]
    xend = [1.5]
    N = 100  #для неаприорных планов
    NAprior = 20  #для априорных планов

    #Получаем априорный план
    print("performing aprior plan:")
    #блок кеширования априорного плана в файл
    filename = 'cachedPlans/' + os.path.basename(__file__).replace(
        '.py', '_plan')
    try:
        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:

        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          NAprior,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbosePlan=True,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)
    #}

    unifplan = o_p.makeUniformExpPlan(xstart, xend, N)

    #получаем измерения с планов
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)

    measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c, Ve)

    filename = os.path.basename(__file__).replace('.py', '_results')

    #выполняем оценку
    print("performing aprior plan")
    gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
                                            jacf,
                                            measdata,
                                            binit,
                                            c,
                                            Ve,
                                            NSIG=100,
                                            implicit=True)
    o_q.analyseDifList(gknu, imagename='Aprior_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)

    print("performing uniform plan")
    gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
                                            jacf,
                                            measdataUnif,
                                            binit,
                                            c,
                                            Ve,
                                            NSIG=100,
                                            implicit=True)
    o_q.analyseDifList(gknu, imagename='Uniform_Plan')
    o_q.printGKNUNeat(gknu)
    o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def getHybridPlan (xstart:list, xend:list, N:int, btrue:list, binit:list, bstart:list, bend:list, c, Ve, jacf, funcf, NSIG=10, implicit=False, lognorm=False, dotlim=500, verbose=False):
    oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, func=None, Ntries=5)[1] #сперва строим априорный план
    return getbSeqPlanUltra (xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=oplan, dotlim=500) #теперь последовательный с лимитом на 500 точек лишних
def extraction_Diode_In_Limited():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """

    global FT
    global foldername

    #возвращает значение y
    funcf = solver_Diode_In_Limited
    jacf = jac_Diode_In_Limited
    #теперь попробуем сделать эксперимент.
    c = {}
    Ve = np.array([[0.00000001]])
    btrue = [1.238e-14, 1.8, 100]
    #btrue=[1.5e-14, 1.75, 150]

    bstart = np.array(btrue) - np.array(btrue) * 0.3
    bend = np.array(btrue) + np.array(btrue) * 0.3002
    #binit=np.array(btrue)-np.array(btrue)*0.1

    print('conditions:')
    print(bstart)
    print(bend)

    binit = [1.1e-14, 1.5, 90]
    xstart = [0.001]
    xend = [2]
    N = 20
    print("performing aprior plan:")

    #примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров

    import os
    filename = foldername + '/' + os.path.basename(__file__).replace(
        '.py', '_plan')
    try:
        oplan = o_p.readPlanFromFile(
            filename)  #переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart,
                                          xend,
                                          N,
                                          bstart,
                                          bend,
                                          c,
                                          Ve,
                                          jacf,
                                          funcf,
                                          Ntries=6,
                                          verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

#    получаем измеренные данные
    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
    #     #чертим эти данные
    #     #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
    #
    #     #оценка

    #grandCountGN_UltraX1_Limited_wrapper (funcf, jacf,  measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
                                                         jacf,
                                                         measdata,
                                                         binit,
                                                         bstart,
                                                         bend,
                                                         c,
                                                         implicit=True,
                                                         verbose=False,
                                                         verbose_wrapper=False)
    gknux = o_e.grandCountGN_UltraX1(funcf,
                                     jacf,
                                     measdata,
                                     binit,
                                     c,
                                     implicit=True)

    gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
                                              funcf,
                                              jacf,
                                              measdata,
                                              c,
                                              Ve,
                                              name='Limited Count Aprior')
    gknux2 = o_q.convertToQualitatStandart(gknux,
                                           funcf,
                                           jacf,
                                           measdata,
                                           c,
                                           Ve,
                                           name='Normal Count Aprior')

    o_q.printQualitatStandart(gknuxlim2)
    o_q.printQualitatStandart(gknux2)


#extraction_Diode_Irev_Limited()
def extraction_Kirch_DiodeV2Mod2DirectBranch():
    """
    [Реестровая]

    :return:
    """

    global FT
    global foldername

    funcf = solver_Kirch_DiodeV2Mod2DirectBranch
    jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
    c = {}
    Ve = np.array([[1.9e-5]])

    btrue = [341.4e-6, 2.664, 37.08e-3, 17.26e-27, 5.662, 4.282, 0.5751, 3.65e-3]

    bstart = np.array(btrue) - np.array(btrue) * 0.05
    bend = np.array(btrue) + np.array(btrue) * 0.05

    binit = [
        341.4e-6,
        2.664,
        37.08e-3,
        17.26e-27,
        5.662,
        4.282,
        0.5751,
        3.65e-3,
    ]  # binit=btrue так как взято из спайс-модели

    xstart = [0.7]
    # xend=[20,60]
    xend = [0.77]

    N = 20  # число точек в априорном плане

    # Получаем априорный план
    print("performing aprior plan:")

    # блок кеширования априорного плана в файл
    import os

    filename = (
        foldername + "/" + "RD_10BQ100_N{0}_Dev-62012P_".format(N) + os.path.basename(__file__).replace(".py", "_plan")
    )

    try:

        oplan = o_p.readPlanFromFile(filename)  # переключение на чтение априорного плана из файла
        print("Read file successful")
    except BaseException as e:
        oplan = o_ap.grandApriornPlanning(xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
        o_p.writePlanToFile(oplan, filename)

    # #Задание опций для последовательного плана
    # terminationOptDict={'VdShelfPow':-7}

    measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
    plotPlanAndMeas2D(measdata)

    gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(
        funcf, jacf, measdata, binit, bstart, bend, c, implicit=True, verbose=False, verbose_wrapper=False
    )
    gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim, funcf, jacf, measdata, c, Ve, name="Limited Count Aprior")
    o_q.printQualitatStandart(gknuxlim2)