diff --git a/backend/src/b1500/measure/pulsed.rs b/backend/src/b1500/measure/pulsed.rs index f095b94..7f5a69a 100644 --- a/backend/src/b1500/measure/pulsed.rs +++ b/backend/src/b1500/measure/pulsed.rs @@ -41,14 +41,29 @@ fn init_pulsed_voltage_waveform( pub type PulseTrainCollection = Vec; +/// Notes: +/// _____ _____ _____ ------------> v_high +/// | | | | | | +/// | | | | | | +/// | |_____| |_____| |_____ -------> v_low +/// |<------->| cycle_time #[derive(Serialize, Deserialize, Clone, Debug)] #[serde(rename_all = "camelCase")] pub struct PulseTrain { + /// The number of pulses the train has pub n_pulses: usize, + /// The duty cycle of the pulses, that is the proportion of the cycle time + /// that the pulse is active (at v_high). pub duty_cycle: f64, + /// The cycle time, that is the time that it takes to complete a cycle, + /// one v_high, one v_low. (seconds) pub cycle_time: f64, + /// Active voltage of the pulses, see notes above. (Volts) pub v_high: f64, + /// Low voltage of the pulses, see notes above. (Volts) pub v_low: f64, + /// Initial waiting delay, in seconds. (seconds) + pub delay: f64 } fn wgfmu_add_pulse_train( @@ -122,6 +137,26 @@ fn wgfmu_add_pulse_train( pulse_train.duty_cycle, ); + if pulse_train.delay != 0.0 { + let wait_wf: VoltageWaveForm = vec![VoltageWaveFormPoint { voltage: 0.0, dtime: pulse_train.delay * 1.001 }]; + let delay_pattern = format!("{}_delay", pattern); + wgfmu.create_pattern(delay_pattern.as_str(), 0.0)?; + add_waveform(wgfmu, &wait_wf, delay_pattern.as_str())?; + wgfmu.add_sequence(CHANNEL2, delay_pattern.as_str(), 1)?; + // eventEndTime = time + interval * (points - 1) + average + let points = 80.0; + let interval = (pulse_train.delay - *avg_time) / (points - 1.0); + wgfmu.set_measure_event( + delay_pattern.as_str(), + "event_delay", + 0.0, + points as i32, + interval, + *avg_time, + MeasureEventMode::MeasureEventDataAveraged, + )?; + } + if !noise { add_waveform(wgfmu, &waveform, pattern)?; wgfmu.add_sequence(CHANNEL2, pattern, pulse_train.n_pulses)?; @@ -166,10 +201,10 @@ fn wgfmu_add_pulse_train( )?; // Sampling margin - let pattern_margin = format!("{}_margin", pattern); - wgfmu.create_pattern(pattern_margin.as_str(), 0.0)?; - wgfmu.add_vector(pattern_margin.as_str(), pulse_train.cycle_time, 0.0)?; - wgfmu.add_sequence(CHANNEL2, "v1_margin", 1)?; + // let pattern_margin = format!("{}_margin", pattern); + // wgfmu.create_pattern(pattern_margin.as_str(), 0.0)?; + // wgfmu.add_vector(pattern_margin.as_str(), pulse_train.delay, 0.0)?; + // wgfmu.add_sequence(CHANNEL2, pattern_margin.as_str(), 1)?; } else { // let total_measure_time = measure_totaltime_high + measure_totaltime_low; @@ -210,6 +245,26 @@ fn wgfmu_add_pulse_train( { let v2 = format!("{}_v2", pattern); + if pulse_train.delay != 0.0 { + let wait_wf: VoltageWaveForm = vec![VoltageWaveFormPoint { voltage: 0.0, dtime: pulse_train.delay * 1.001 }]; + let delay_pattern = format!("{}_delay", v2); + wgfmu.create_pattern(delay_pattern.as_str(), 0.0)?; + add_waveform(wgfmu, &wait_wf, delay_pattern.as_str())?; + wgfmu.add_sequence(CHANNEL1, delay_pattern.as_str(), 1)?; + // eventEndTime = time + interval * (points - 1) + average + let points = 80.0; + let interval = (pulse_train.delay - *avg_time) / (points - 1.0); + wgfmu.set_measure_event( + delay_pattern.as_str(), + "event_delay_v2", + 0.0, + points as i32, + interval, + *avg_time, + MeasureEventMode::MeasureEventDataAveraged, + )?; + } + if !noise { let total_time = pulse_train.cycle_time + 2e-8; @@ -218,7 +273,7 @@ fn wgfmu_add_pulse_train( // End at 0 wgfmu.set_vector(v2.as_str(), total_time, 0.0)?; - wgfmu.add_sequence(CHANNEL1, "v2", pulse_train.n_pulses)?; + wgfmu.add_sequence(CHANNEL1, v2.as_str(), pulse_train.n_pulses)?; wgfmu.set_measure_event( v2.as_str(), @@ -247,7 +302,7 @@ fn wgfmu_add_pulse_train( // End at 0 wgfmu.set_vector(v2.as_str(), total_time * (pulse_train.n_pulses as f64), 0.0)?; - wgfmu.add_sequence(CHANNEL1, "v2", 1)?; + wgfmu.add_sequence(CHANNEL1, v2.as_str(), 1)?; let total_points = (n_rep * (unique_pulses * (n_points_low as usize + n_points_high as usize))) as i32; diff --git a/backend/src/b1500/utils.rs b/backend/src/b1500/utils.rs index ebb4cc8..26027f7 100644 --- a/backend/src/b1500/utils.rs +++ b/backend/src/b1500/utils.rs @@ -99,7 +99,7 @@ pub fn add_noisy_waveform( n_points ]; - // We llok at two adjacent points and linearly interpolate between them + // We look at two adjacent points and linearly interpolate between them let mut current_index = 0; // Index of the of the first of the two points we are looking at in the provided waveform let mut current_time = 0.0; // Absolute time of the first of the two points we are looking at in the provided waveform for (idx, &time) in final_time_points[..n_points - 1].iter().enumerate() { diff --git a/backend/src/www/measurements/pulse.rs b/backend/src/www/measurements/pulse.rs index 725d123..9e9365e 100644 --- a/backend/src/www/measurements/pulse.rs +++ b/backend/src/www/measurements/pulse.rs @@ -109,6 +109,7 @@ pub async fn pulse_measurement( cycle_time: params.cycle_time, v_high: params.v_high, v_low: params.v_low, + delay: 0.0 }, params.n_points_high, params.n_points_low, diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Stdp/AnimateHeight.tsx b/frontend/src/components/Graph/AnimateHeight.tsx similarity index 100% rename from frontend/src/routes/wgfmu/MeasurementsControls/Stdp/AnimateHeight.tsx rename to frontend/src/components/Graph/AnimateHeight.tsx diff --git a/frontend/src/components/Graph/plots/stdpCollection.ts b/frontend/src/components/Graph/plots/stdpCollection.ts index 3a1659c..995ae00 100644 --- a/frontend/src/components/Graph/plots/stdpCollection.ts +++ b/frontend/src/components/Graph/plots/stdpCollection.ts @@ -36,14 +36,16 @@ export function getParameters(data: StdpCollectionMeasurement, dimensions: Dimen let auxDataConductanceRatio = data.collection.map(meas => (meas.stdpMeasurement.conductance - data.baseConductance) / data.baseConductance) - let auxDataDelay = data.collection.map(w => w.delay) + console.log({auxDataConductanceRatio}) + let finalData: StdpPoint[] = [] auxDataConductanceRatio.forEach((r, i) => finalData.push({delay: auxDataDelay[i], conductanceRatio: r})) let delayScaling = getScaling(auxDataDelay, 's', (d) => d) // let conductanceScaling = getScaling(auxDataConductance, 'S', (d) => d) + console.log({sfactor: delayScaling.scalingFactor}) let xExtentDelay: [number, number] = [0, 0] let aux = d3.extent([...auxDataDelay.map(d => -d), ...auxDataDelay], d => d * delayScaling.scalingFactor) @@ -52,8 +54,9 @@ export function getParameters(data: StdpCollectionMeasurement, dimensions: Dimen let yExtentConductanceRatio: [number, number] = [0, 0] aux = d3.extent([...auxDataConductanceRatio.map(c => -c), ...auxDataConductanceRatio], d => d) + console.log({aux}) aux[0] != undefined && aux[1] != undefined && (yExtentConductanceRatio = aux) - if (yExtentConductanceRatio[0] + yExtentConductanceRatio[1] == 0) { + if (Math.abs(yExtentConductanceRatio[0]) + Math.abs(yExtentConductanceRatio[1]) == 0) { yExtentConductanceRatio = [-1, 1] } diff --git a/frontend/src/components/Modal.tsx b/frontend/src/components/Modal.tsx new file mode 100644 index 0000000..fdadbca --- /dev/null +++ b/frontend/src/components/Modal.tsx @@ -0,0 +1,57 @@ +import { Children } from "react" + +interface Props { + children: React.ReactNode +} + +export default function Modal(props: Props) { + return ( + <> + + + ) +} diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/EpscControls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/EpscControls.tsx new file mode 100644 index 0000000..3a594da --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/EpscControls.tsx @@ -0,0 +1,68 @@ +import { boolean } from "mathjs" +import { useState } from "react" +import { HiLockClosed, HiLockOpen } from "react-icons/hi" +import { Slider, Number } from "../../../../../components/Input" +import { useAppDispatch, useAppSelector } from "../../../../../store/hooks" +import { EpscControls as EpscControlsInterface } from "../../types" +import { + selectEpscParams, + setEpscParamsField, + setMultiPulseParamsField as setParamsField, + updateState, +} from "./collectionControlsSlice" + +type ValidateInterface = { + [k in keyof EpscControlsInterface]: boolean +} + +export default function EpscControls() { + const dispatch = useAppDispatch() + const params = useAppSelector(selectEpscParams) + + const [valid, setValid] = useState({ + frequencies: true, + interTrainsTime: true, + spikeTime: true, + }) // wether or not this settings are valid + + const [samplingPointsTied, setSamplingPointsTied] = useState(true) + + const onValidateCurry = (id: keyof EpscControlsInterface) => { + return (isValid: boolean) => setValid({ ...valid, [id]: isValid }) + } + + return ( + <> +
+ { + dispatch(setEpscParamsField({ val: value, key: "interTrainsTime" })) + }} + value={params.interTrainsTime} + onValidate={onValidateCurry("interTrainsTime")} + type={{ + type: "sci", + unit: "s", + }} + min={0} + /> +
+
+ { + dispatch(setEpscParamsField({ val: value, key: "spikeTime" })) + }} + value={params.spikeTime} + onValidate={onValidateCurry("spikeTime")} + type={{ + type: "sci", + unit: "s", + }} + min={0} + /> +
+ + ) +} diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/MultiPulseControls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/MultiPulseControls.tsx new file mode 100644 index 0000000..e0e6f1b --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/MultiPulseControls.tsx @@ -0,0 +1,151 @@ +import { boolean } from "mathjs" +import { useState } from "react" +import { HiLockClosed, HiLockOpen } from "react-icons/hi" +import { Slider, Number } from "../../../../../components/Input" +import { useAppDispatch, useAppSelector } from "../../../../../store/hooks" +import { MultiPulseControls as MultiPulseControlsInterface } from "../../types" +import { + selectMultiPulseParams, + setMultiPulseParamsField as setParamsField, + updateState, +} from "./collectionControlsSlice" + +type ValidateInterface = { + [k in keyof MultiPulseControlsInterface]: boolean +} + +export default function MultiPulseControls() { + const dispatch = useAppDispatch() + const params = useAppSelector(selectMultiPulseParams) + + const [valid, setValid] = useState({ + cycleTime: true, + dutyCycle: true, + firstCycleType: true, + nPointsHigh: true, + nPointsLow: true, + nPulses: true, + nReps: true, + resetDutyCycle: true, + resetVoltages: true, + setDutyCycle: true, + setVoltages: true, + }) // wether or not this settings are valid + + const [samplingPointsTied, setSamplingPointsTied] = useState(true) + + const onValidateCurry = (id: keyof MultiPulseControlsInterface) => { + return (isValid: boolean) => setValid({ ...valid, [id]: isValid }) + } + + return ( + <> +
+ { + dispatch(setParamsField({ val: value, key: "nReps" })) + }} + value={params.nReps} + onValidate={onValidateCurry("nReps")} + /> +
+
+ { + dispatch(setParamsField({ val: value, key: "cycleTime" })) + }} + value={params.cycleTime} + onValidate={onValidateCurry("cycleTime")} + type={{ + type: "sci", + unit: "s", + }} + min={0} + /> +
+
+ { + dispatch( + setParamsField({ + val: value, + key: "dutyCycle", + }) + ) + }} + step={10} + min={0} + max={100} + value={params.dutyCycle} + format={(dc: string) => dc + "%"} + /> +
+
+
Number of sampling points
+
+
+ { + dispatch(setParamsField({ val: value, key: "nPointsHigh" })) + samplingPointsTied && + dispatch(setParamsField({ val: value, key: "nPointsLow" })) + }} + value={params.nPointsHigh} + onValidate={onValidateCurry("nPointsHigh")} + vertical={true} + min={1} + /> +
High
+
+
+ + {/* This is just to set everything nicely */} +
High
+
+
+ { + dispatch(setParamsField({ val: value, key: "nPointsLow" })) + samplingPointsTied && + dispatch(setParamsField({ val: value, key: "nPointsHigh" })) + }} + value={params.nPointsLow} + onValidate={onValidateCurry("nPointsLow")} + vertical={true} + min={1} + /> +
Low
+
+
+
+ + ) +} diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/PpfControls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/PpfControls.tsx new file mode 100644 index 0000000..4be79b1 --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/PpfControls.tsx @@ -0,0 +1,3 @@ +export default function PpfControls() { + return <> +} \ No newline at end of file diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/collectionControlsSlice.ts b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/collectionControlsSlice.ts new file mode 100644 index 0000000..370709b --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/collectionControlsSlice.ts @@ -0,0 +1,101 @@ +import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit" +import { Root } from "react-dom/client" +import { RootState } from "../../../../../store/store" +import { PulseCollectionControls, MultiPulseControls, EpscControls } from "../../types" + +export const initialState: PulseCollectionControls = { + epscControls: { + frequencies: ["20", "50", "100"], + interTrainsTime: "1 ms", + spikeTime: "100 us", + }, + multipulseControls: { + firstCycleType: "Potenciation", + nPulses: ["50", "50", "50"], + nReps: "3", + resetDutyCycle: ["0.5", "0.5", "0.5"], + setDutyCycle: ["0.5", "0.5", "0.5"], + resetVoltages: ["-1", "-1", "-1"], + setVoltages: ["1", "1", "1"], + cycleTime: "10 us", + dutyCycle: "50", + nPointsHigh: "10", + nPointsLow: "10", + }, + ppfControls: { + spikeVoltage: "0.95 V", + spikeTime: "1 ms", + startInterSpikeTime: "0.05 ms", + stopInterSpikeTime: "1 ms", + nMeas: "5", + }, + collectionType: "MultiPulse", + pulseTrainCollection: [], + nPointsHigh: "100", + nPointsLow: "100", + noise: false, + noiseStd: "0.0", +} + +export const collectionControlsSlice = createSlice({ + name: "pulseCollectionControls", + initialState, + reducers: { + setMultiPulseParamsField: ( + state, + action: PayloadAction<{ + val: MultiPulseControls[keyof MultiPulseControls] + key: keyof MultiPulseControls + }> + ) => { + state.multipulseControls = { + ...state.multipulseControls, + [action.payload.key]: action.payload.val, + } + // return state + }, + setEpscParamsField: ( + state, + action: PayloadAction<{ + val: EpscControls[keyof EpscControls], + key: keyof EpscControls + }> + ) => { + state.epscControls = { + ...state.epscControls, + [action.payload.key]: action.payload.val + } + }, + setParamsField: ( + state, + action: PayloadAction<{ + val: PulseCollectionControls[keyof PulseCollectionControls] + key: keyof PulseCollectionControls + }> + ) => { + // console.log('maldita sea') + state = { + ...state, + [action.payload.key]: action.payload.val, + } + return state + }, + updateState: (state) => { + return state + }, + }, +}) + +export const selectParams = (state: RootState) => + state.waveform.pulse.collectionParams +export const selectControlsType = (state: RootState) => + state.waveform.pulse.collectionParams.collectionType +export const selectMultiPulseParams = (state: RootState) => + state.waveform.pulse.collectionParams.multipulseControls +export const selectEpscParams = (state: RootState) => + state.waveform.pulse.collectionParams.epscControls + +export const { setMultiPulseParamsField, setEpscParamsField, setParamsField, updateState } = + collectionControlsSlice.actions + +export default collectionControlsSlice.reducer diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/index.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/index.tsx new file mode 100644 index 0000000..5725347 --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/CollectionControls/index.tsx @@ -0,0 +1,103 @@ +import { contourDensity } from "d3" +import { LayoutGroup, motion } from "framer-motion" +import AnimateHeight from "../../../../../components/Graph/AnimateHeight" +import { useAppDispatch, useAppSelector } from "../../../../../store/hooks" +import { + selectParams, + selectControlsType, + setParamsField, +} from "./collectionControlsSlice" +import EpscControls from "./EpscControls" +import MultiPulseControls from "./MultiPulseControls" +import PpfControls from "./PpfControls" + +export default function () { + const params = useAppSelector(selectParams) + const controlsType = useAppSelector(selectControlsType) + const dispatch = useAppDispatch() + + return ( + <> +
+ + + + + +
+ + + + + + + + + + + + + + + ) +} diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/Controls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/Controls.tsx new file mode 100644 index 0000000..434a12d --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/Controls.tsx @@ -0,0 +1,164 @@ +import { useEffect, useState } from 'react' +import { Number, Slider } from "../../../../components/Input" +import { number } from 'mathjs'; +import { HiLockOpen, HiLockClosed } from 'react-icons/hi' +import { useAppSelector, useAppDispatch } from '../../../../store/hooks'; +import { setPoints, setPulseParamsField, selectPulseParams, setTimeScale, selectPulseType, setPulseType, selectPulseCollectionParams } from '../measurementControlsSlice'; +import { VoltageWaveform } from '../types' +import math from '../../../../utils/math' +import SciNumberInput from '../../../../components/Input/SciNumberInput'; +import { LayoutGroup, motion } from 'framer-motion'; +import AnimateHeight from '../../../../components/Graph/AnimateHeight'; +import CollectionControls from './CollectionControls'; +import SingleControls from './SingleControls'; + +type ValidateId = + "vHigh" | "vLow" | "nPulses" | "cycleTime" | "dutyCycle" | "nPointsHigh" | "nPointsLow" + +type PulseWaveFormParams = { + vHigh: number, + vLow: number, + nPulses: number, + dutyCycle: number, + cycleTime: number, + nPointsHigh: number, + nPointsLow: number, +} + +async function GenerateWaveform(params: PulseWaveFormParams) { + let cycle: VoltageWaveform = []; + + // First halve + let timeHigh = params.cycleTime * params.dutyCycle / 100 + let samplingTimeHigh = timeHigh / (params.nPointsHigh + 1) + cycle.push({ time: 0, voltage: params.vHigh }) + // for (let i = 0; i < params.nPointsHigh; i++) {{ + // cycle.push({time: (i+1) * samplingTimeHigh, voltage: params.vHigh}) + // }} + cycle.push({ time: timeHigh, voltage: params.vHigh }) + + // Second halve + let timeLow = params.cycleTime * (1 - params.dutyCycle / 100); + let samplingTimeLow = timeLow / (params.nPointsLow + 1) + cycle.push({ time: timeHigh, voltage: params.vLow }) + // for (let i = 0; i < params.nPointsLow; i++) {{ + // cycle.push({time: (i+1) * samplingTimeLow + timeHigh, voltage: params.vLow}) + // }} + cycle.push({ time: params.cycleTime, voltage: params.vLow }) + + + let waveForm: VoltageWaveform = []; + for (let i = 0; i < params.nPulses; i++) { + waveForm.push( + ...cycle.map((point) => ( + { + time: point.time + (params.cycleTime * i), + voltage: point.voltage + } + )) + ) + } + + return waveForm + +} + +export default function PulseControls() { + const dispatch = useAppDispatch() + const params = useAppSelector(selectPulseParams) + const collectionParams = useAppSelector(selectPulseCollectionParams) + const measurementType = useAppSelector(selectPulseType) + + const [samplingPointsTied, setSamplingPointsTied] = useState(true) + + const [valid, setValid] = useState({ + vHigh: true, + vLow: true, + nPulses: true, + cycleTime: true, + dutyCycle: true, + nPointsHigh: true, + nPointsLow: true + }) // wether or not this settings are valid + + useEffect(() => { + if (!Object.values(valid).every(v => v)) + return + try { + let unitCycleTime = math.unit(params.cycleTime) + + //@ts-expect-error + let scaling = Math.ceil(1 / unitCycleTime.units[0].prefix.value) + if (scaling < 1) { + scaling = 1 + } + dispatch(setTimeScale(scaling)) + + let nPulses = parseInt(params.nPulses) > 100 ? 100 : parseInt(params.nPulses); + GenerateWaveform({ + vHigh: math.unit(params.vHigh).value, + vLow: math.unit(params.vLow).value, + nPulses: nPulses, + cycleTime: unitCycleTime.value, + dutyCycle: parseFloat(params.dutyCycle !== "" ? params.dutyCycle : "0"), + nPointsHigh: parseInt(params.nPointsHigh), + nPointsLow: parseInt(params.nPointsLow), + }).then((waveForm) => { + dispatch(setPoints(waveForm)) + }) + } catch { } + + }, [params]) + + const onValidateCurry = (id: ValidateId) => { + return (isValid: boolean) => setValid({ ...valid, [id]: isValid }) + } + + return ( +
+ +
+
+ + + + +
+
+ + + + + + + + + + +
+ ) +} diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/PulseControls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/SingleControls.tsx similarity index 55% rename from frontend/src/routes/wgfmu/MeasurementsControls/PulseControls.tsx rename to frontend/src/routes/wgfmu/MeasurementsControls/Pulse/SingleControls.tsx index 197e10e..5ce5eb2 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/PulseControls.tsx +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/SingleControls.tsx @@ -1,65 +1,12 @@ -import { useEffect, useState } from 'react' -import { Number, Slider } from "../../../components/Input" -import { number } from 'mathjs'; -import { HiLockOpen, HiLockClosed } from 'react-icons/hi' -import { useAppSelector, useAppDispatch } from '../../../store/hooks'; -import { setPoints, setPulseParamsField, selectPulseParams, setTimeScale } from './measurementControlsSlice'; -import { VoltageWaveform } from './types' -import math from '../../../utils/math' -import SciNumberInput from '../../../components/Input/SciNumberInput'; - -type ValidateId = - "vHigh" | "vLow" | "nPulses" | "cycleTime" | "dutyCycle" | "nPointsHigh" | "nPointsLow" - -type PulseWaveFormParams = { - vHigh: number, - vLow: number, - nPulses: number, - dutyCycle: number, - cycleTime: number, - nPointsHigh: number, - nPointsLow: number, -} - -async function GenerateWaveform(params: PulseWaveFormParams) { - let cycle: VoltageWaveform = []; - - // First halve - let timeHigh = params.cycleTime * params.dutyCycle / 100 - let samplingTimeHigh = timeHigh / (params.nPointsHigh + 1) - cycle.push({time: 0, voltage: params.vHigh}) - // for (let i = 0; i < params.nPointsHigh; i++) {{ - // cycle.push({time: (i+1) * samplingTimeHigh, voltage: params.vHigh}) - // }} - cycle.push({time: timeHigh, voltage: params.vHigh}) - - // Second halve - let timeLow = params.cycleTime * (1 - params.dutyCycle / 100); - let samplingTimeLow = timeLow / (params.nPointsLow + 1) - cycle.push({time: timeHigh, voltage: params.vLow}) - // for (let i = 0; i < params.nPointsLow; i++) {{ - // cycle.push({time: (i+1) * samplingTimeLow + timeHigh, voltage: params.vLow}) - // }} - cycle.push({time: params.cycleTime, voltage: params.vLow}) - - - let waveForm: VoltageWaveform = []; - for (let i = 0; i < params.nPulses; i++) { - waveForm.push( - ...cycle.map((point) => ( - { - time: point.time + (params.cycleTime * i), - voltage: point.voltage - } - )) - ) - } - - return waveForm - -} - -export default function PulseControls() { +import { useState } from "react" +import { HiLockClosed, HiLockOpen } from "react-icons/hi" +import { Number, Slider } from "../../../../components/Input" +import SciNumberInput from "../../../../components/Input/SciNumberInput" +import { useAppDispatch, useAppSelector } from "../../../../store/hooks" +import { selectPulseParams, setPulseParamsField } from "../measurementControlsSlice" +import { PulseTrain } from "../types" + +export default function CollectionControls() { const dispatch = useAppDispatch() const params = useAppSelector(selectPulseParams) @@ -75,47 +22,19 @@ export default function PulseControls() { nPointsLow: true }) // wether or not this settings are valid - useEffect(() => { - if (!Object.values(valid).every( v => v )) - return - try { - let unitCycleTime = math.unit(params.cycleTime) - - //@ts-expect-error - let scaling = Math.ceil(1 / unitCycleTime.units[0].prefix.value) - if (scaling < 1) { - scaling = 1 - } - dispatch(setTimeScale(scaling)) - - let nPulses = parseInt(params.nPulses) > 100 ? 100 : parseInt(params.nPulses); - GenerateWaveform({ - vHigh: math.unit(params.vHigh).value, - vLow: math.unit(params.vLow).value, - nPulses: nPulses, - cycleTime: unitCycleTime.value, - dutyCycle: parseFloat(params.dutyCycle !== "" ? params.dutyCycle : "0"), - nPointsHigh: parseInt(params.nPointsHigh), - nPointsLow: parseInt(params.nPointsLow), - }).then((waveForm) => { - dispatch(setPoints(waveForm)) - }) - } catch {} - - }, [params]) - - const onValidateCurry = (id: ValidateId) => { + const onValidateCurry = (id: keyof PulseTrain | "nPointsHigh" | "nPointsLow") => { return (isValid: boolean) => setValid({ ...valid, [id]: isValid }) } - return ( -
+ + + return (<>
{ // setVHigh(value) - dispatch(setPulseParamsField({val: value, key: 'vHigh'})) + dispatch(setPulseParamsField({ val: value, key: 'vHigh' })) }} value={params.vHigh} onValidate={onValidateCurry("vHigh")} @@ -129,7 +48,7 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'vLow'})) + dispatch(setPulseParamsField({ val: value, key: 'vLow' })) }} value={params.vLow} onValidate={onValidateCurry("vLow")} @@ -143,7 +62,7 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'nPulses'})) + dispatch(setPulseParamsField({ val: value, key: 'nPulses' })) }} value={params.nPulses} onValidate={onValidateCurry("nPulses")} @@ -153,7 +72,7 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'cycleTime'})) + dispatch(setPulseParamsField({ val: value, key: 'cycleTime' })) }} value={params.cycleTime} onValidate={onValidateCurry("cycleTime")} @@ -168,7 +87,7 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'dutyCycle'})) + dispatch(setPulseParamsField({ val: value, key: 'dutyCycle' })) }} step={10} min={0} @@ -186,8 +105,8 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'nPointsHigh'})) - samplingPointsTied && dispatch(setPulseParamsField({val: value, key: 'nPointsLow'})) + dispatch(setPulseParamsField({ val: value, key: 'nPointsHigh' })) + samplingPointsTied && dispatch(setPulseParamsField({ val: value, key: 'nPointsLow' })) }} value={params.nPointsHigh} onValidate={onValidateCurry("nPointsHigh")} @@ -207,7 +126,7 @@ export default function PulseControls() { return } - samplingPointsTied && dispatch(setPulseParamsField({val: params.nPointsHigh, key: 'nPointsLow'})) + samplingPointsTied && dispatch(setPulseParamsField({ val: params.nPointsHigh, key: 'nPointsLow' })) setSamplingPointsTied(true) }} > @@ -228,8 +147,8 @@ export default function PulseControls() { { - dispatch(setPulseParamsField({val: value, key: 'nPointsLow'})) - samplingPointsTied && dispatch(setPulseParamsField({val: value, key: 'nPointsHigh'})) + dispatch(setPulseParamsField({ val: value, key: 'nPointsLow' })) + samplingPointsTied && dispatch(setPulseParamsField({ val: value, key: 'nPointsHigh' })) }} value={params.nPointsLow} onValidate={onValidateCurry("nPointsLow")} @@ -244,33 +163,33 @@ export default function PulseControls() {
- - { params.noise && -
-
- Noise STD -
-
- { - dispatch(setPulseParamsField({val: value, key: 'noiseStd'})) - }} - > + + {params.noise && +
+
+ Noise STD +
+
+ { + dispatch(setPulseParamsField({ val: value, key: 'noiseStd' })) + }} + > +
-
}
dispatch(setPulseParamsField({val: !params.noise, key: 'noise'}))} + onClick={() => dispatch(setPulseParamsField({ val: !params.noise, key: 'noise' }))} > - { params.noise ? 'Disable' : 'Enable Noise' } + {params.noise ? 'Disable' : 'Enable Noise'}
-
+ ) -} +} \ No newline at end of file diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/index.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/index.tsx new file mode 100644 index 0000000..8331679 --- /dev/null +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Pulse/index.tsx @@ -0,0 +1 @@ +export { default as PulseControls } from './Controls' \ No newline at end of file diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/Stdp/Controls.tsx b/frontend/src/routes/wgfmu/MeasurementsControls/Stdp/Controls.tsx index 786419b..0fd5f75 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/Stdp/Controls.tsx +++ b/frontend/src/routes/wgfmu/MeasurementsControls/Stdp/Controls.tsx @@ -9,7 +9,7 @@ import { StdpControls as StdpControlsInterface, VoltageWaveform, StdpWaveform, S import { conductanceMeasurement } from '../api' import { ConductanceMeasurement } from '../../../../utils/types' import generateWaveform, { getMaxV, getMinV } from './generateWaveform' -import AnimateHeight from './AnimateHeight' +import AnimateHeight from '../../../../components/Graph/AnimateHeight' import MultiSlider from '../../../../components/MultiSlider' import SciNumberInput from '../../../../components/Input/SciNumberInput' diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/api.ts b/frontend/src/routes/wgfmu/MeasurementsControls/api.ts index ef8e120..acd0e6d 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/api.ts +++ b/frontend/src/routes/wgfmu/MeasurementsControls/api.ts @@ -1,12 +1,13 @@ import { PulseControls, StdpCollectionControls, StdpControls } from './types' import math from '../../../utils/math' import { ConductanceMeasurement } from '../../../utils/types' +import { buildUrl } from '../../../utils' -const MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/" -const PULSE_MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/pulse" -const STDP_MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/stdp" -const STDP_COLLECTION_MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/stdp-collection" -const CONDUCTANCE_MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/conductance" +const MEASUREMENT_ENDPOINT = buildUrl("measurements/") +const PULSE_MEASUREMENT_ENDPOINT = buildUrl("measurements/pulse") +const STDP_MEASUREMENT_ENDPOINT = buildUrl("measurements/stdp") +const STDP_COLLECTION_MEASUREMENT_ENDPOINT = buildUrl("measurements/stdp-collection") +const CONDUCTANCE_MEASUREMENT_ENDPOINT = buildUrl("measurements/conductance") export async function pulseMeasurement(params: PulseControls, avgTime: string) { diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/index.ts b/frontend/src/routes/wgfmu/MeasurementsControls/index.ts index 4483ddb..41370c7 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/index.ts +++ b/frontend/src/routes/wgfmu/MeasurementsControls/index.ts @@ -1,4 +1,4 @@ -export {StdpControls} from './Stdp' -export {default as PulseControls} from './PulseControls' +export { StdpControls } from './Stdp' +export { PulseControls } from './Pulse' diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/measurementControlsSlice.ts b/frontend/src/routes/wgfmu/MeasurementsControls/measurementControlsSlice.ts index 8d2f426..8c4e7f8 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/measurementControlsSlice.ts +++ b/frontend/src/routes/wgfmu/MeasurementsControls/measurementControlsSlice.ts @@ -1,43 +1,69 @@ -import { createAsyncThunk, createSlice, PayloadAction } from '@reduxjs/toolkit'; -import { RootState, AppThunk } from '../../../store/store'; -// import { fetchCount } from './counterApi'; -import { VoltageWaveform, PulseControls, StdpControls, StdpWaveform, StdpCollectionControls } from './types' -import { pulseMeasurement, getMeasurement, stdpMeasurement, stdpCollectionMeasurement } from './api' -import { Measurement, MeasurementData, StdpMeasurement, MeasurementType } from '../../../utils/types'; -import { fetchMeasurements } from '../../../store/globalSlice'; -import math from '../../../utils/math' -import { e } from 'mathjs'; +import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit" +import { RootState, AppThunk } from "../../../store/store" +import pulseCollectionReducer, { + initialState as pulseCollectionParamsInitialState, + updateState as updatePulseCollectionParams, +} from "./Pulse/CollectionControls/collectionControlsSlice" +// import { fetchCount } from './counterApi' +import { + VoltageWaveform, + PulseControls, + StdpControls, + StdpWaveform, + StdpCollectionControls, + PulseCollectionControls, +} from "./types" +import { + pulseMeasurement, + getMeasurement, + stdpMeasurement, + stdpCollectionMeasurement, +} from "./api" +import { + Measurement, + MeasurementData, + StdpMeasurement, + MeasurementType, +} from "../../../utils/types" +import { + collectionControlsSlice, + initialState as collectionControlsInitialState, +} from "./Pulse/CollectionControls/collectionControlsSlice" +import { fetchMeasurements } from "../../../store/globalSlice" +import math from "../../../utils/math" +import { e } from "mathjs" export interface WaveformState { waveform: { // scaling: {} points: VoltageWaveform | StdpWaveform - }, - measurement: null | Measurement, + } + measurement: null | Measurement pulse: { - params: PulseControls, + params: PulseControls + collectionParams: PulseCollectionControls type: MeasurementType - }, + } // Stdp stdp: { params: StdpControls collectionParams: StdpCollectionControls - measuredConductance: null | number, + measuredConductance: null | number type: MeasurementType - }, + } - controlsPage: 0 | 1,// Current controls page, STDP or PULSED + controlsPage: 0 | 1 // Current controls page, STDP or PULSED - avgTime: string, - timeScale: number, + avgTime: string + timeScale: number previewWaveform: boolean } const initialState: WaveformState = { waveform: { - points: [] + points: [], }, measurement: null, // Pulse measurements @@ -51,9 +77,10 @@ const initialState: WaveformState = { nPointsHigh: "10", nPointsLow: "10", noise: false, - noiseStd: "0 mV" + noiseStd: "0 mV", }, - type: "Single" + collectionParams: pulseCollectionParamsInitialState, + type: "Single", }, // Stdp stdp: { @@ -65,7 +92,7 @@ const initialState: WaveformState = { stdpType: "Depression", nPoints: "400", noise: false, - noiseStd: "0 mV" + noiseStd: "0 mV", }, collectionParams: { delayPoints: "5", @@ -75,21 +102,21 @@ const initialState: WaveformState = { waitTime: "1 us", nPoints: "400", noise: false, - noiseStd: "0 mV" + noiseStd: "0 mV", }, measuredConductance: null, - type: "Single" + type: "Single", }, controlsPage: 0, avgTime: "10 ns", timeScale: 1, // scale to apply on the x axis, - previewWaveform: false // wether waveform preview is activated or not -}; + previewWaveform: false, // wether waveform preview is activated or not +} export const waveformSlice = createSlice({ - name: 'waveform', + name: "waveform", initialState, // The `reducers` field lets us define reducers and generate associated actions reducers: { @@ -98,109 +125,146 @@ export const waveformSlice = createSlice({ // // doesn't actually mutate the state because it uses the Immer library, // // which detects changes to a "draft state" and produces a brand new // // immutable state based off those changes - // state.value += 1; + // state.value += 1 // }, // Use the PayloadAction type to declare the contents of `action.payload` - setPoints: (state, action: PayloadAction) => { - state.waveform.points = action.payload; + setPoints: ( + state, + action: PayloadAction + ) => { + state.waveform.points = action.payload }, - setPulseParamsField: (state, action: PayloadAction<{ val: string | boolean, key: keyof PulseControls }>) => { - - if (action.payload.key == 'nPointsHigh' || action.payload.key == 'nPointsLow') { - let totalPoints = parseInt(action.payload.val as string); - if (action.payload.key == 'nPointsHigh') + setPulseParamsField: ( + state, + action: PayloadAction<{ + val: PulseControls[keyof PulseControls] + key: keyof PulseControls + }> + ) => { + if ( + action.payload.key == "nPointsHigh" || + action.payload.key == "nPointsLow" + ) { + let totalPoints = parseInt(action.payload.val as string) + if (action.payload.key == "nPointsHigh") totalPoints = totalPoints + parseInt(state.pulse.params.nPointsLow) - if (action.payload.key == 'nPointsLow') + if (action.payload.key == "nPointsLow") totalPoints = totalPoints + parseInt(state.pulse.params.nPointsHigh) - if (math.unit(state.pulse.params.cycleTime).value / totalPoints < 10e-8) { - - let actualPoints = parseInt(state.pulse.params.nPointsHigh) + parseInt(state.pulse.params.nPointsLow) - - let maxP = Math.floor(math.unit(state.pulse.params.cycleTime).value / 10e-8) + if ( + math.unit(state.pulse.params.cycleTime).value / totalPoints < + 10e-8 + ) { + let actualPoints = + parseInt(state.pulse.params.nPointsHigh) + + parseInt(state.pulse.params.nPointsLow) + + let maxP = Math.floor( + math.unit(state.pulse.params.cycleTime).value / 10e-8 + ) if (actualPoints != maxP) { state.pulse.params = { ...state.pulse.params, nPointsHigh: Math.floor(maxP / 2).toString(), - nPointsLow: Math.floor(maxP / 2).toString() + nPointsLow: Math.floor(maxP / 2).toString(), } } - return } } state.pulse.params = { ...state.pulse.params, - [action.payload.key]: action.payload.val + [action.payload.key]: action.payload.val, } }, + setPulseType: (state, action: PayloadAction) => { + state.pulse.type = action.payload + }, + setStdpParamsField: ( state, - action: PayloadAction< - { val: StdpControls[keyof StdpControls] | StdpCollectionControls[keyof StdpCollectionControls], - key: keyof StdpControls | keyof StdpCollectionControls }>) => { + action: PayloadAction<{ + val: + | StdpControls[keyof StdpControls] + | StdpCollectionControls[keyof StdpCollectionControls] + key: keyof StdpControls | keyof StdpCollectionControls + }> + ) => { switch (state.stdp.type) { case "Single": state.stdp.params = { ...state.stdp.params, - [action.payload.key]: action.payload.val + [action.payload.key]: action.payload.val, } break // Collection default: state.stdp.collectionParams = { ...state.stdp.collectionParams, - [action.payload.key]: action.payload.val + [action.payload.key]: action.payload.val, } } }, - setStdpCollectionParamsField: (state, action: PayloadAction<{ val: string, key: keyof StdpCollectionControls }>) => { + setStdpCollectionParamsField: ( + state, + action: PayloadAction<{ val: string; key: keyof StdpCollectionControls }> + ) => { state.stdp.collectionParams = { ...state.stdp.collectionParams, - [action.payload.key]: action.payload.val + [action.payload.key]: action.payload.val, } }, setAvgTime(state, action: PayloadAction) { state.avgTime = action.payload }, setMeasurement: (state, action: PayloadAction) => { - state.measurement = action.payload; + state.measurement = action.payload }, emptyMeasurement: (state) => { - state.measurement = null; + state.measurement = null }, setTimeScale: (state, action: PayloadAction) => { state.timeScale = action.payload }, - setStdpMeasuredConductance: (state, action: PayloadAction) => { - state.stdp.measuredConductance = action.payload; + setStdpMeasuredConductance: ( + state, + action: PayloadAction + ) => { + state.stdp.measuredConductance = action.payload }, - setStdpType: (state, action: PayloadAction< MeasurementType >) => { - state.stdp.type = action.payload; + setStdpType: (state, action: PayloadAction) => { + state.stdp.type = action.payload }, }, // The `extraReducers` field lets the slice handle actions defined elsewhere, // including actions generated by createAsyncThunk or in other slices. - // extraReducers: (builder) => { - // builder - // .addCase(incrementAsync.pending, (state) => { - // state.status = 'loading'; - // }) - // .addCase(incrementAsync.fulfilled, (state, action) => { - // state.status = 'idle'; - // state.value += action.payload; - // }) - // .addCase(incrementAsync.rejected, (state) => { - // state.status = 'failed'; - // }); - // }, -}); + extraReducers: (builder) => { + // builder.addDefaultCase( (state, action) => { + // console.log('first?') + // state.pulse.collectionParams = pulseCollectionReducer( + // state.pulse.collectionParams, + // action + // ) + // }) + builder.addMatcher( + (action) => action.type.includes("pulseCollectionControls"), // Refer to the name atribute on collectionControlsSlice + (state, action) => { + state.pulse.collectionParams = pulseCollectionReducer( + state.pulse.collectionParams, + action + ) + } + ) + }, + // extraReducers +}) export const { setPoints, setPulseParamsField, + setPulseType, setStdpParamsField, setStdpCollectionParamsField, setStdpMeasuredConductance, @@ -208,86 +272,104 @@ export const { setAvgTime, setMeasurement, emptyMeasurement, - setTimeScale -} = waveformSlice.actions; + setTimeScale, +} = waveformSlice.actions // The function below is called a selector and allows us to select a value from // the state. Selectors can also be defined inline where they're used instead of // in the slice file. For example: `useSelector((state: RootState) => state.counter.value)` -export const selectWaveform = (state: RootState) => state.waveform.waveform.points; -export const selectPulseParams = (state: RootState) => state.waveform.pulse.params; -export const selectStdpParams = (state: RootState) => state.waveform.stdp.params; -export const selectStdpCollectionParams = (state: RootState) => state.waveform.stdp.collectionParams; -export const selectStdpMeasuredConductance = (state: RootState) => state.waveform.stdp.measuredConductance; -export const selectStdpType = (state: RootState) => state.waveform.stdp.type; -export const selectAvgTime = (state: RootState) => state.waveform.avgTime; -export const selectMeasurement = (state: RootState) => state.waveform.measurement; -export const selectTimeScale = (state: RootState) => state.waveform.timeScale; -export const selectControlsPage = (state: RootState) => state.waveform.controlsPage; +export const selectWaveform = (state: RootState) => + state.waveform.waveform.points +export const selectPulseParams = (state: RootState) => + state.waveform.pulse.params +export const selectPulseCollectionParams = (state: RootState) => + state.waveform.pulse.collectionParams +export const selectPulseType = (state: RootState) => state.waveform.pulse.type +export const selectStdpParams = (state: RootState) => state.waveform.stdp.params +export const selectStdpCollectionParams = (state: RootState) => + state.waveform.stdp.collectionParams +export const selectStdpMeasuredConductance = (state: RootState) => + state.waveform.stdp.measuredConductance +export const selectStdpType = (state: RootState) => state.waveform.stdp.type +export const selectAvgTime = (state: RootState) => state.waveform.avgTime +export const selectMeasurement = (state: RootState) => + state.waveform.measurement +export const selectTimeScale = (state: RootState) => state.waveform.timeScale +export const selectControlsPage = (state: RootState) => + state.waveform.controlsPage const DATA_LIMIT = 1_000_000 -export const fetchMeasurement = createAsyncThunk( - 'wgfmu/get-measurement', - async (id: number, thunkAPI) => { - const response = (await getMeasurement(id)) as Measurement - if (response.status != "InProgress") { - - let measurement: Measurement - - // Check for array for retrocompatibility - if (response.category === "Stdp" && !Array.isArray(response.data) && response.data) { - let data = response.data as StdpMeasurement - measurement = { - ...response, - data: { - conductance: data.conductance, - iv: data.iv.length > DATA_LIMIT ? data.iv.slice(0, DATA_LIMIT) : data.iv - } as StdpMeasurement - } as Measurement - - } else { - let data = (response.data ?? []) as MeasurementData - measurement = { - ...response, - data: data.length > DATA_LIMIT ? data.slice(0, DATA_LIMIT) : data - } as Measurement - } - - thunkAPI.dispatch(setMeasurement(measurement)) +export const fetchMeasurement = createAsyncThunk< + void, + number, + { state: RootState } +>("wgfmu/get-measurement", async (id: number, thunkAPI) => { + const response = (await getMeasurement(id)) as Measurement + if (response.status != "InProgress") { + let measurement: Measurement + + // Check for array for retrocompatibility + if ( + response.category === "Stdp" && + !Array.isArray(response.data) && + response.data + ) { + let data = response.data as StdpMeasurement + measurement = { + ...response, + data: { + conductance: data.conductance, + iv: + data.iv.length > DATA_LIMIT + ? data.iv.slice(0, DATA_LIMIT) + : data.iv, + } as StdpMeasurement, + } as Measurement + } else { + let data = (response.data ?? []) as MeasurementData + measurement = { + ...response, + data: data.length > DATA_LIMIT ? data.slice(0, DATA_LIMIT) : data, + } as Measurement } - } -) -export const waitForMeasurement = createAsyncThunk( - 'wgfmu/wait-measurement', - async (id: number, thunkAPI) => { - setTimeout(async () => { - try { - await thunkAPI.dispatch(fetchMeasurement(id)) - let state = thunkAPI.getState() - if (state.waveform.measurement && state.waveform.measurement.id == id && (state.waveform.measurement.status == "Done" || state.waveform.measurement.status == "Error")) { - thunkAPI.dispatch(fetchMeasurements()) - } else { - thunkAPI.dispatch(waitForMeasurement(id)) - } - } catch { } - }, 500) + thunkAPI.dispatch(setMeasurement(measurement)) } -) +}) + +export const waitForMeasurement = createAsyncThunk< + void, + number, + { state: RootState } +>("wgfmu/wait-measurement", async (id: number, thunkAPI) => { + setTimeout(async () => { + try { + await thunkAPI.dispatch(fetchMeasurement(id)) + let state = thunkAPI.getState() + if ( + state.waveform.measurement && + state.waveform.measurement.id == id && + (state.waveform.measurement.status == "Done" || + state.waveform.measurement.status == "Error") + ) { + thunkAPI.dispatch(fetchMeasurements()) + } else { + thunkAPI.dispatch(waitForMeasurement(id)) + } + } catch {} + }, 500) +}) export const measurePulse = createAsyncThunk( - 'wgfmu/measure-pulse', + "wgfmu/measure-pulse", async (arg: void, thunkAPI) => { - - const pulseParams = selectPulseParams(thunkAPI.getState()) const avgTime = selectAvgTime(thunkAPI.getState()) - const response = await pulseMeasurement(pulseParams, avgTime); + const response = await pulseMeasurement(pulseParams, avgTime) - - const id = response.id; + const id = response.id if (id == undefined) { return @@ -302,9 +384,8 @@ export const measurePulse = createAsyncThunk( ) export const measureStdp = createAsyncThunk( - 'wgfmu/measure-stdp', + "wgfmu/measure-stdp", async (arg: void, thunkAPI) => { - const type = selectStdpType(thunkAPI.getState()) const avgTime = selectAvgTime(thunkAPI.getState()) @@ -314,21 +395,20 @@ export const measureStdp = createAsyncThunk( case "Single": getResponse = async () => { const params = selectStdpParams(thunkAPI.getState()) - return await stdpMeasurement(params, avgTime); + return await stdpMeasurement(params, avgTime) } break // Collection default: getResponse = async () => { const params = selectStdpCollectionParams(thunkAPI.getState()) - return await stdpCollectionMeasurement(params, avgTime); + return await stdpCollectionMeasurement(params, avgTime) } } let response = await getResponse() - - const id = response.id; + const id = response.id if (id == undefined) { return @@ -342,5 +422,4 @@ export const measureStdp = createAsyncThunk( } ) - -export default waveformSlice.reducer; +export default waveformSlice.reducer diff --git a/frontend/src/routes/wgfmu/MeasurementsControls/types.ts b/frontend/src/routes/wgfmu/MeasurementsControls/types.ts index a8109b4..1fb1d69 100644 --- a/frontend/src/routes/wgfmu/MeasurementsControls/types.ts +++ b/frontend/src/routes/wgfmu/MeasurementsControls/types.ts @@ -1,72 +1,136 @@ export interface VoltagePoint { - voltage: number, - time: number + voltage: number + time: number } export interface CurrentPoint { - current: number, - time: number + current: number + time: number } export interface IVMeasurementPoint { - current: number, - voltage: number, - time: number + current: number + voltage: number + time: number +} + +export interface PulseTrain { + // The number of pulses the train has + nPulses: string + // The duty cycle of the pulses, that is the proportion of the cycle time + // that the pulse is active (at v_high). + dutyCycle: string + // The cycle time, that is the time that it takes to complete a cycle, + // one v_high, one v_low. (seconds) + cycleTime: string + // Active voltage of the pulses, see notes above. (Volts) + vHigh: string + // Low voltage of the pulses, see notes above. (Volts) + vLow: string + // Initial waiting delay, in seconds. (seconds) + delay: string } export type VoltageWaveform = VoltagePoint[] export interface PulseControls { - vHigh: string, - vLow: string, - nPulses: string, - dutyCycle: string, - cycleTime: string, - nPointsHigh: string, - nPointsLow: string, - noise: boolean, - noiseStd: string + vHigh: string + vLow: string + nPulses: string + dutyCycle: string + cycleTime: string + nPointsHigh: string + nPointsLow: string + noise: boolean + noiseStd: string +} + +export interface PulseCollectionControls { + pulseTrainCollection: PulseTrain[] + collectionType: "MultiPulse" | "EPSC" | "PPF" + multipulseControls: MultiPulseControls + epscControls: EpscControls + ppfControls: PpfControls + nPointsHigh: string + nPointsLow: string + noise: boolean + noiseStd: string +} + +export interface MultiPulseControls { + // Number of potenciation + depression trains + nReps: string + // Controls the order of the pulses Potenciation -> Depression or + // Depression -> Potenciation + firstCycleType: "Potenciation" | "Depression" + + setVoltages: string[] + resetVoltages: string[] + + setDutyCycle: string[] + resetDutyCycle: string[] + + nPulses: string[] + + nPointsHigh: string + nPointsLow: string + dutyCycle: string + cycleTime: string +} + +export interface EpscControls { + frequencies: string[] + spikeTime: string + interTrainsTime: string +} + +export interface PpfControls { + spikeVoltage: string + spikeTime: string + startInterSpikeTime: string + stopInterSpikeTime: string + nMeas: string } export interface StdpControls { - delay: string, - amplitude: string, - pulseDuration: string, - waitTime: string, - stdpType: "Depression" | "Potenciation", - nPoints: string, - noise: boolean, - noiseStd: string + delay: string + amplitude: string + pulseDuration: string + waitTime: string + stdpType: "Depression" | "Potenciation" + nPoints: string + noise: boolean + noiseStd: string } export interface StdpCollectionControls { - delayPoints: string, - amplitude: string, - pulseDuration: string, - waitTime: string, - stdpType: "Depression" | "Potenciation", - nPoints: string, - noise: boolean, - noiseStd: string + delayPoints: string + amplitude: string + pulseDuration: string + waitTime: string + stdpType: "Depression" | "Potenciation" + nPoints: string + noise: boolean + noiseStd: string } export interface StdpWaveform { - waveformA: VoltageWaveform // not delayed - waveformB: VoltageWaveform // delayed - equivalent: VoltageWaveform + waveformA: VoltageWaveform // not delayed + waveformB: VoltageWaveform // delayed + equivalent: VoltageWaveform } export interface Cycle { - type: 'set' | 'reset', - measurements: IVMeasurementPoint[] + type: "set" | "reset" + measurements: IVMeasurementPoint[] } export interface SingleTrainMeasurement { - id: number, - measurements: IVMeasurementPoint[] + id: number + measurements: IVMeasurementPoint[] } export interface CyclingTrainMeasurement { - id: number, - measurements: Cycle[] -} \ No newline at end of file + id: number + measurements: Cycle[] +} diff --git a/frontend/src/settings.json b/frontend/src/settings.json new file mode 100644 index 0000000..f67dae1 --- /dev/null +++ b/frontend/src/settings.json @@ -0,0 +1,3 @@ +{ + "backendBaseUrl": "http://localhost:8000/api/" +} \ No newline at end of file diff --git a/frontend/src/store/api.ts b/frontend/src/store/api.ts index 0ffb360..5c1df2d 100644 --- a/frontend/src/store/api.ts +++ b/frontend/src/store/api.ts @@ -1,6 +1,7 @@ +import { buildUrl } from "../utils" -const MEASUREMENT_ENDPOINT = "http://localhost:8000/api/measurements/" -const CALIBRATE_ENDPOINT = "http://localhost:8000/api/calibrate" +const MEASUREMENT_ENDPOINT = buildUrl("measurements/") +const CALIBRATE_ENDPOINT = buildUrl("calibrate") export async function fetchMeasurements() { const response = await fetch(MEASUREMENT_ENDPOINT, { diff --git a/frontend/src/store/globalSlice.ts b/frontend/src/store/globalSlice.ts index 2e2fdd8..52e33ec 100644 --- a/frontend/src/store/globalSlice.ts +++ b/frontend/src/store/globalSlice.ts @@ -2,7 +2,6 @@ import { createAsyncThunk, createSlice, PayloadAction } from '@reduxjs/toolkit'; import { RootState, AppThunk } from './store'; import { MeasurementList } from '../utils/types' import { fetchMeasurements as fetchMeasurementsFromAPI } from './api'; -import { dispatch } from 'd3'; export interface GlobalState { measurements: MeasurementList diff --git a/frontend/src/utils/index.ts b/frontend/src/utils/index.ts index 20a2091..997d8d2 100644 --- a/frontend/src/utils/index.ts +++ b/frontend/src/utils/index.ts @@ -1,3 +1,5 @@ +import { backendBaseUrl } from '../settings.json' + export function isMobile() { return window.screen.width < 640 // 640 is the default breakpoint for xs } @@ -6,4 +8,8 @@ export function clone(obj:any) { return JSON.parse(JSON.stringify(obj)) } +export function buildUrl(path: string) { + return backendBaseUrl + path +} + export default {} \ No newline at end of file diff --git a/py_xavier/epcs.ipynb b/py_xavier/epcs.ipynb new file mode 100644 index 0000000..1dd2485 --- /dev/null +++ b/py_xavier/epcs.ipynb @@ -0,0 +1,137 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from py_xavier import Xavier\n", + "\n", + "xavier = Xavier('localhost', 8000)\n", + "xavier.api_isalive()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 7\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtime\u001b[39;00m\n\u001b[1;32m 5\u001b[0m pulse_train_collection: List[PulseTrain] \u001b[39m=\u001b[39m []\n\u001b[0;32m----> 7\u001b[0m reset_voltages \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m, \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m, \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m])\u001b[39m*\u001b[39m\u001b[39m0.5\u001b[39m\n\u001b[1;32m 8\u001b[0m set_voltages \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m])\u001b[39m*\u001b[39m\u001b[39m0.5\u001b[39m\n\u001b[1;32m 10\u001b[0m reset_pulse_width \u001b[39m=\u001b[39m \u001b[39m1e-3\u001b[39m\n", + "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" + ] + } + ], + "source": [ + "from typing import List \n", + "from py_xavier.custom_types import PulseTrain\n", + "import time\n", + "import numpy as np\n", + "\n", + "pulse_train_collection: List[PulseTrain] = []\n", + "\n", + "epcs_iter_time = 1e-3\n", + "epcs_freqs = np.array([20, 50, 100])\n", + "spike_time = 100e-6\n", + "\n", + "for i in range(2):\n", + "\n", + " cycle_time = 1 / epcs_freqs[i]\n", + " duty_cycle = spike_time / cycle_time\n", + "\n", + " pulse_train_collection.append({\n", + " 'cycle_time': cycle_time,\n", + " 'duty_cycle': duty_cycle,\n", + " 'n_pulses': 100,\n", + " 'v_high': 0.2,\n", + " 'v_low': 0,\n", + " 'delay': epcs_iter_time if i != 0 else 0\n", + " })\n", + "\n", + "\n", + "args = {\n", + " \"pulse_train_collection\": pulse_train_collection,\n", + " \"n_points_high\": 100,\n", + " \"n_points_low\": 100,\n", + " \"avg_time\": 100e-6,\n", + " \"noise\": False,\n", + " \"noise_std\": 0.0\n", + "}\n", + "\n", + "meas_id = -1\n", + "\n", + "meas_resp = xavier.measure.pulse_collection(**args)\n", + "if 'id' in meas_resp:\n", + " meas_id = meas_resp['id']\n", + " \n", + " \n", + "time.sleep(8)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "data = xavier.measure.retrieve_measurement(3352)['data']\n", + "\n", + "voltage = list(map(lambda el: el['voltage'], data))\n", + "time = list(map(lambda el: el['time'], data))\n", + "current = np.array(list(map(lambda el: el['current'], data)))\n", + "\n", + "plt.figure(figsize=(10,5))\n", + "fig, ax = plt.subplots()\n", + "ax2 = ax.twinx()\n", + "\n", + "voltage_plot = ax.plot(time, voltage, label='Voltage')\n", + "current_plot = ax2.plot(time, current, color='C1', label='Current')\n", + "\n", + "ax.set_ylabel('Voltage (V)')\n", + "ax2.set_ylabel(r'Current (mA)')\n", + "ax.set_xlabel('Time (s)')\n", + "\n", + "plt.grid()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/py_xavier/ppf.ipynb b/py_xavier/ppf.ipynb new file mode 100644 index 0000000..afe8aeb --- /dev/null +++ b/py_xavier/ppf.ipynb @@ -0,0 +1,128 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from py_xavier import Xavier\n", + "\n", + "xavier = Xavier('localhost', 8000)\n", + "xavier.api_isalive()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List \n", + "from py_xavier.custom_types import PulseTrain\n", + "import time\n", + "import numpy as np\n", + "\n", + "pulse_train_collection: List[PulseTrain] = []\n", + "\n", + "spike_time = 1e-3\n", + "spike_voltage = 0.9\n", + "inter_spike = np.array([0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])\n", + "\n", + "measurement_delay = 5e-3\n", + "\n", + "for i in range(inter_spike):\n", + "\n", + " cycle_time = spike_time * 2\n", + " duty_cycle = 0.5\n", + "\n", + " pulse_train_collection.append({\n", + " 'cycle_time': cycle_time,\n", + " 'duty_cycle': duty_cycle,\n", + " 'n_pulses': 1,\n", + " 'v_high': 0,\n", + " 'v_low': spike_voltage,\n", + " 'delay': inter_spike[i]\n", + " })\n", + "\n", + " pulse_train_collection.append({\n", + " 'cycle_time': cycle_time,\n", + " 'duty_cycle': duty_cycle,\n", + " 'n_pulses': 1,\n", + " 'v_high': spike_voltage,\n", + " 'v_low': 0,\n", + " 'delay': measurement_delay\n", + " })\n", + "\n", + "\n", + "args = {\n", + " \"pulse_train_collection\": pulse_train_collection,\n", + " \"n_points_high\": 100,\n", + " \"n_points_low\": 100,\n", + " \"avg_time\": 100e-6,\n", + " \"noise\": False,\n", + " \"noise_std\": 0.0\n", + "}\n", + "\n", + "meas_id = -1\n", + "\n", + "meas_resp = xavier.measure.pulse_collection(**args)\n", + "if 'id' in meas_resp:\n", + " meas_id = meas_resp['id']\n", + " \n", + " \n", + "time.sleep(8)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "data = xavier.measure.retrieve_measurement(3352)['data']\n", + "\n", + "voltage = list(map(lambda el: el['voltage'], data))\n", + "time = list(map(lambda el: el['time'], data))\n", + "current = np.array(list(map(lambda el: el['current'], data)))\n", + "\n", + "plt.figure(figsize=(10,5))\n", + "fig, ax = plt.subplots()\n", + "ax2 = ax.twinx()\n", + "\n", + "voltage_plot = ax.plot(time, voltage, label='Voltage')\n", + "current_plot = ax2.plot(time, current, color='C1', label='Current')\n", + "\n", + "ax.set_ylabel('Voltage (V)')\n", + "ax2.set_ylabel(r'Current (mA)')\n", + "ax.set_xlabel('Time (s)')\n", + "\n", + "plt.grid()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.9 (main, Dec 19 2022, 17:35:49) [GCC 12.2.0]" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/py_xavier/pulsed_measurement.ipynb b/py_xavier/pulsed_measurement.ipynb new file mode 100644 index 0000000..d5f38b6 --- /dev/null +++ b/py_xavier/pulsed_measurement.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from py_xavier import Xavier\n", + "\n", + "xavier = Xavier('localhost', 8000)\n", + "xavier.api_isalive()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"id\":3352}'\n" + ] + }, + { + "data": { + "text/plain": [ + "{'id': 3352}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from typing import List \n", + "from py_xavier.custom_types import PulseTrain\n", + "import time\n", + "\n", + "pulse_train_collection: List[PulseTrain] = []\n", + "\n", + "reset_voltages = np.array([-1, -1, -1])*0.5\n", + "set_voltages = np.array([1, 1, 1])*0.5\n", + "\n", + "reset_pulse_width = 1e-3\n", + "set_pulse_width = 10e-3\n", + "\n", + "down_time = 1e-3\n", + "\n", + "for i in range(2):\n", + " for train_type in ['potenciation', 'depression']:\n", + " if train_type == 'depression':\n", + " v_low = 0\n", + " v_high = reset_voltages[i]\n", + " cycle_time = reset_pulse_width + down_time\n", + " duty_cycle = reset_pulse_width / cycle_time\n", + " else:\n", + " v_low = 0\n", + " v_high = set_voltages[i] \n", + " cycle_time = set_pulse_width + down_time\n", + " duty_cycle = set_pulse_width / cycle_time\n", + "\n", + " pulse_train_collection.append({\n", + " 'cycle_time': cycle_time,\n", + " 'duty_cycle': duty_cycle,\n", + " 'n_pulses': 100,\n", + " 'v_high': v_high,\n", + " 'v_low': v_low\n", + " })\n", + "\n", + "\n", + "args = {\n", + " \"pulse_train_collection\": pulse_train_collection,\n", + " \"n_points_high\": 100,\n", + " \"n_points_low\": 100,\n", + " \"avg_time\": 100e-6,\n", + " \"noise\": False,\n", + " \"noise_std\": 0.0\n", + "}\n", + "\n", + "meas_id = -1\n", + "\n", + "meas_resp = xavier.measure.pulse_collection(**args)\n", + "if 'id' in meas_resp:\n", + " meas_id = meas_resp['id']\n", + " \n", + " \n", + "time.sleep(8)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "data = xavier.measure.retrieve_measurement(3352)['data']\n", + "\n", + "voltage = list(map(lambda el: el['voltage'], data))\n", + "time = list(map(lambda el: el['time'], data))\n", + "current = np.array(list(map(lambda el: el['current'], data)))\n", + "\n", + "plt.figure(figsize=(10,5))\n", + "fig, ax = plt.subplots()\n", + "ax2 = ax.twinx()\n", + "\n", + "voltage_plot = ax.plot(time, voltage, label='Voltage')\n", + "current_plot = ax2.plot(time, current, color='C1', label='Current')\n", + "\n", + "ax.set_ylabel('Voltage (V)')\n", + "ax2.set_ylabel(r'Current (mA)')\n", + "ax.set_xlabel('Time (s)')\n", + "\n", + "plt.grid()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/py_xavier/py_xavier/__init__.py b/py_xavier/py_xavier/__init__.py index b074a8b..d37b9be 100644 --- a/py_xavier/py_xavier/__init__.py +++ b/py_xavier/py_xavier/__init__.py @@ -62,6 +62,7 @@ class Xavier(): ENDPOINT_PING = 'ping' ENDPOINT_CALIBRATE = 'calibrate' + STATUS_ERROR = 'Error' def __init__(self, host, port): self.host = host @@ -339,4 +340,7 @@ def retrieve_measurement(self, meas_id: int): ) ) - return response.json() + response = response.json() + if response['status'] == self.xavier.STATUS_ERROR: + raise Exception("Measurement error, check console logs.") + return response diff --git a/py_xavier/py_xavier/__pycache__/__init__.cpython-310.pyc b/py_xavier/py_xavier/__pycache__/__init__.cpython-310.pyc index 01a71fc..d029b8b 100644 Binary files a/py_xavier/py_xavier/__pycache__/__init__.cpython-310.pyc and b/py_xavier/py_xavier/__pycache__/__init__.cpython-310.pyc differ diff --git a/py_xavier/py_xavier/__pycache__/custom_types.cpython-310.pyc b/py_xavier/py_xavier/__pycache__/custom_types.cpython-310.pyc index 024e306..16b0b94 100644 Binary files a/py_xavier/py_xavier/__pycache__/custom_types.cpython-310.pyc and b/py_xavier/py_xavier/__pycache__/custom_types.cpython-310.pyc differ diff --git a/py_xavier/py_xavier/custom_types.py b/py_xavier/py_xavier/custom_types.py index a9edeb9..81b644b 100644 --- a/py_xavier/py_xavier/custom_types.py +++ b/py_xavier/py_xavier/custom_types.py @@ -3,8 +3,17 @@ StdpType = Literal[ 'Depression', 'Potenciation' ] class PulseTrain(TypedDict): + # The number of pulses the train has n_pulses: int + # The duty cycle of the pulses, that is the proportion of the cycle time + # that the pulse is active (at v_high). duty_cycle: float + # The cycle time, that is the time that it takes to complete a cycle, + # one v_high, one v_low. (seconds) cycle_time: float + # Active voltage of the pulses, see notes above. (Volts) v_high: float + # Low voltage of the pulses, see notes above. (Volts) v_low: float + # Initial waiting delay, in seconds. (seconds) + delay: float \ No newline at end of file diff --git a/py_xavier/test.ipynb b/py_xavier/test.ipynb deleted file mode 100644 index d538af2..0000000 --- a/py_xavier/test.ipynb +++ /dev/null @@ -1,227 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from py_xavier import Xavier\n", - "\n", - "xavier = Xavier('localhost', 8000)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xavier.api_isalive()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'id': 3345}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# args = {\n", - "# \"v_high\": 1,\n", - "# \"v_low\": 0,\n", - "# \"cycle_time\": 1e-3,\n", - "\n", - "# \"duty_cycle\": 0.5,\n", - "# \"n_pulses\": 10,\n", - "\n", - "# \"n_points_high\": 10,\n", - "# \"n_points_low\": 10,\n", - " \n", - "# \"avg_time\": 0.1e-5,\n", - "# \"noise\": False,\n", - "# \"noise_std\": 0.0\n", - "# }\n", - "\n", - "\n", - "# xavier.measure.pulse(**args)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"id\":3354}'\n" - ] - }, - { - "data": { - "text/plain": [ - "{'id': 3354}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "from typing import List\n", - "from py_xavier.custom_types import PulseTrain\n", - "\n", - "pulse_train_collection: List[PulseTrain] = []\n", - "\n", - "low_voltages = [-1.1, -1.2, -1.3]\n", - "for i in range(3):\n", - " for train_type in ['potenciation', 'depression']:\n", - " if train_type == 'depression':\n", - " low_voltage = low_voltages[i]\n", - " else:\n", - " low_voltage = 0.9\n", - "\n", - " pulse_train_collection.append({\n", - " 'cycle_time': 1e-3,\n", - " 'duty_cycle': 0.5,\n", - " 'n_pulses': 5,\n", - " 'v_high': 0,\n", - " 'v_low': low_voltage\n", - " })\n", - "\n", - "\n", - "args = {\n", - " \"pulse_train_collection\": pulse_train_collection,\n", - " \"n_points_high\": 10,\n", - " \"n_points_low\": 10,\n", - " \"avg_time\": 0.1e-3,\n", - " \"noise\": False,\n", - " \"noise_std\": 0.0\n", - "}\n", - "\n", - "\n", - "xavier.measure.pulse_collection(**args)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "data = xavier.measure.retrieve_measurement(3354)['data']\n", - "\n", - "voltage = list(map(lambda el: el['voltage'], data))\n", - "time = list(map(lambda el: el['time'], data))" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(time, voltage)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from typing import TypedDict\n", - "\n", - "class a(TypedDict):\n", - " b: float\n", - "\n", - "c: a = {'b': 1.0}\n", - "\n", - "print(type(c))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}