3705.sagews

from sage.numerical.optimize import find_fit
Capacitance = 1.080 # En Farad
Resistance = 50 # En Ohm
EMF = 10 # In Volt
MaxCurrent = EMF/Resistance
TimeConstant = Resistance*Capacitance
def GraphicalAnalysis(data, current=False):
    LinearData = [(i, ln(abs(y))) for i, y in data]
    mean = sum([i for i, y in LinearData])/(len(LinearData)-1)
    k = (0.001/mean + 0.4/Resistance)*mean/Resistance if current else 0.001 # Uncertainty on measurement
    Modif = lambda x: -k*x/150 + k
    var('x, a, b')
    model(x) = a*x+b
    BestFit = find_fit(LinearData, model, solution_dict=True)
    BestFunc = lambda x: BestFit[a]*x+BestFit[b]
    MaxSlope = find_fit([(i, y+Modif(i)) for i, y in LinearData], model, solution_dict=True)[a]
    MinSlope = find_fit([(i, y-Modif(i)) for i, y in LinearData], model, solution_dict=True)[a]
    SlopeUncertainty = abs((MinSlope-MaxSlope)/2)
    MaxOffset = find_fit([(i, y+k) for i, y in LinearData], model, solution_dict=True)[b]
    MinOffset = find_fit([(i, y-k) for i, y in LinearData], model, solution_dict=True)[b]
    OffsetUncertainty = abs((MinOffset-MaxOffset)/2)
    MaxFunc = lambda x: MaxSlope*x+MaxOffset
    MinFunc = lambda x: MinSlope*x+MinOffset
    Plot = list_plot(LinearData) + plot(BestFunc, 0, 300, color='red') + plot(MaxFunc, 0, 300, color='red') + plot(MinFunc, 0, 300, color='red')
    Uncertainties = {a: SlopeUncertainty, b: OffsetUncertainty}
    return Plot, BestFit, Uncertainties

def GetData(file, current=False):
    data = open(DATA+file)
    data = data.read()
    data = data.strip()
    data = data.split('\n')
    data = data[3:]
    data = [i.split('\t') for i in data]
    data = [(float(i[0]), float(i[1])) for i in data]
    if current:
        data = [(float(i[0]), float(i[1])/Resistance) for i in data]
    return data


ExpectedPotentialChargeFunc = lambda x: EMF*(1-exp(-x/TimeConstant))
ExpectedCurrentChargeFunc = lambda x: MaxCurrent*exp(-x/TimeConstant)
ExpectedPotentialDischargeFunc = lambda x: EMF*exp(-x/TimeConstant)
ExpectedCurrentDischargeFunc = lambda x: -MaxCurrent*exp(-x/TimeConstant)

ResistorChargeCapacitorData = GetData('resistor_charge_capacitor', True)
CurrentAcrossResistorAsCapacitorCharges = list_plot(ResistorChargeCapacitorData)
var('x, a, b')
model(x) = a*exp(-x/b)
CurrentAcrossResistorAsCapacitorChargesFit = find_fit(ResistorChargeCapacitorData, model, solution_dict=True)
ParamA = CurrentAcrossResistorAsCapacitorChargesFit[a]
ParamB = CurrentAcrossResistorAsCapacitorChargesFit[b]
func = lambda x: ParamA*exp(-x/ParamB)
func2 = lambda x: ExpectedCurrentChargeFunc(x+50)
plot(func, 0, 300, color='red') + CurrentAcrossResistorAsCapacitorCharges + plot(ExpectedCurrentChargeFunc, 0, 300, color='green') + plot(func2, 0, 300, color='green'), MaxCurrent, TimeConstant

(, 1/5, 54.0000000000000)

CurrentChargingGraph, CurrentChargingFit, CurrentChargingUncertainties = GraphicalAnalysis(ResistorChargeCapacitorData, True)
MaxCurrent1 = exp(CurrentChargingFit[b])
TimeConstant1 = -1/CurrentChargingFit[a]
MaxCurrentUncertainty = abs(exp(CurrentChargingFit[b] - CurrentChargingUncertainties[b]) - exp(CurrentChargingFit[b] + CurrentChargingUncertainties[b])) / 2
TimeConstantUncertainty = abs(1/(CurrentChargingFit[a] - CurrentChargingUncertainties[a]) - 1/(CurrentChargingFit[a] + CurrentChargingUncertainties[a])) / 2
CurrentChargingGraph, (MaxCurrent1, MaxCurrentUncertainty), (TimeConstant1, TimeConstantUncertainty)

(, (0.068506483258886558, 0.0016462321318375453), (68.575145134278841, 0.75337686561705652))

CapacitorChargeCapacitorData = GetData('capacitor_charge_capacitor')
DifferenceData = [abs(y-ExpectedPotentialChargeFunc(i)) for i, y in CapacitorChargeCapacitorData]
mean = sum(DifferenceData)/len(DifferenceData)
minValue = lambda x: (EMF+0.08)*(1-exp(-x/(TimeConstant+0.5)))
maxValue = lambda x: (EMF-0.08)*(1-exp(-x/(TimeConstant+0.5)))
Uncertainty = lambda x: abs(minValue(x)-maxValue(x))/2
meanUncertainty = sum([Uncertainty(y) for i, y in CapacitorChargeCapacitorData])/len(DifferenceData)
list_plot(CapacitorChargeCapacitorData) + plot(ExpectedPotentialChargeFunc, 0, 300, color='green'), mean, meanUncertainty

(, 0.225824049833359, 0.0108368805510286)

ResistorDischargeCapacitorData = GetData('resistor_discharging_capacitor', True)
CurrentAcrossResistorAsCapacitorDischarges = list_plot(ResistorDischargeCapacitorData)
var('x, a, b')
model(x) = a*exp(-x/b)
CurrentAcrossResistorAsCapacitorDischargesFit = find_fit(ResistorDischargeCapacitorData, model, solution_dict=True)
ParamA = CurrentAcrossResistorAsCapacitorDischargesFit[a]
ParamB = CurrentAcrossResistorAsCapacitorDischargesFit[b]
func = lambda x: ParamA*exp(-x/ParamB)
CurrentAcrossResistorAsCapacitorDischarges + plot(func, 0, 300, color='red') + plot(ExpectedCurrentDischargeFunc, 0, 300, color='green'), CurrentAcrossResistorAsCapacitorDischargesFit

(, {b: 57.804301806778575, a: -0.19746709589338871})

CurrentDischargingGraph, CurrentDischargingFit, CurrentDischargingUncertainties = GraphicalAnalysis(ResistorDischargeCapacitorData, True)
MaxCurrent2 = exp(CurrentDischargingFit[b])
TimeConstant2 = -1/CurrentDischargingFit[a]
MaxCurrentUncertainty = abs(exp(CurrentDischargingFit[b] - CurrentDischargingUncertainties[b]) - exp(CurrentDischargingFit[b] + CurrentDischargingUncertainties[b])) / 2
TimeConstantUncertainty = abs(1/(CurrentDischargingFit[a] - CurrentDischargingUncertainties[a]) - 1/(CurrentDischargingFit[a] + CurrentDischargingUncertainties[a])) / 2
CurrentDischargingGraph, (MaxCurrent2, MaxCurrentUncertainty), (TimeConstant2, TimeConstantUncertainty)

(, (0.18280355832968673, 0.0043928265851305714), (61.415686477514946, 0.60426441695255662))

CapacitorDischargeCapacitorData = GetData('capacitor_discharging_capacitor')
PotentialAcrossCapacitorAsCapacitorDischarges = list_plot(CapacitorDischargeCapacitorData)
var('x, a, b')
model(x) = a*exp(-x/b)
PotentialAcrossCapacitorAsCapacitorDischargesFit = find_fit(CapacitorDischargeCapacitorData, model, solution_dict=True)
ParamA = PotentialAcrossCapacitorAsCapacitorDischargesFit[a]
ParamB = PotentialAcrossCapacitorAsCapacitorDischargesFit[b]
func = lambda x: ParamA*exp(-x/ParamB)
PotentialAcrossCapacitorAsCapacitorDischarges + plot(func, 0, 300, color='red') + plot(ExpectedPotentialDischargeFunc, 0, 300, color='green')

PotentialDischargingGraph, PotentialDischargingFit, PotentialDischargingUncertainties = GraphicalAnalysis(CapacitorDischargeCapacitorData)
InitialPotential1 = exp(PotentialDischargingFit[b])
TimeConstant3 = -1/PotentialDischargingFit[a]
InitialPotentialUncertainty = abs(exp(PotentialDischargingFit[b] - PotentialDischargingUncertainties[b]) - exp(PotentialDischargingFit[b] + PotentialDischargingUncertainties[b])) / 2
TimeConstantUncertainty = abs(1/(PotentialDischargingFit[a] - PotentialDischargingUncertainties[a]) - 1/(PotentialDischargingFit[a] + PotentialDischargingUncertainties[a])) / 2
PotentialDischargingGraph, (InitialPotential1, InitialPotentialUncertainty), (TimeConstant3, TimeConstantUncertainty), PotentialAcrossCapacitorAsCapacitorDischargesFit

(, (9.0378053459048058, 0.009037806874295562), (60.869874801157408, 0.024700948381870091), {b: 57.72346916289888, a: 9.6662189098407545})

(10-9.038)/10, (60.87-54)/54

(0.0962000000000000, 0.127222222222222)