Example #1
0
def run_single(P,
               T,
               rs,
               ns,
               mats,
               ncycles,
               delay=1.0,
               T0=0,
               Tdot=1.0,
               nhalf=15):
    def Pfn(t):
        if t < delay:
            return P / delay * t
        else:
            return P

    Tfn = axisym.generate_thickness_gradient(rs[0],
                                             rs[-1],
                                             T0,
                                             T,
                                             Tdot,
                                             0.0,
                                             delay=delay)

    times = axisym.generate_standard_timesteps(T0,
                                               T,
                                               Tdot,
                                               0.0,
                                               nhalf,
                                               0,
                                               ncycles,
                                               delay=delay,
                                               ndelay=nhalf)
    dts = np.diff(times)

    problem = axisym.BreeProblem(rs, mats, ns, Tfn, Pfn)

    for t in times[1:]:
        problem.step(t)

    return problem, 2 * nhalf
Example #2
0
    msize = 1.0

    Ri = Ro - t

    T1 = 0.0
    T2 = 90.0

    Tdot_hot = (T2 - T1) / theat
    Tdot_cold = (T2 - T1) / tcool
    ntotal = nheat + nhold + ncool

    gradient = axisym.generate_thickness_gradient(Ro,
                                                  Ri,
                                                  T1,
                                                  T2,
                                                  Tdot_hot,
                                                  thold,
                                                  Tdot_cold=Tdot_cold,
                                                  delay=tramp)

    def pressure(t):
        if t < tramp:
            return p / tramp * t
        else:
            return p

    amodel = axisym.AxisymmetricProblem(
        [Ri, Ri + tclad, Ro], [clad, base],
        [int(tclad / msize), int((t - tclad) / msize)], gradient, pressure)

    ts_period = np.concatenate(