speaker-calibration 2.2.245 → 2.2.247

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speaker-calibration",
-  "version": "2.2.245",
+  "version": "2.2.247",
   "description": "Speaker calibration library for auditory testing",
   "main": "dist/main.js",
   "directories": {

package/src/peer-connection/speaker.js

@@ -141,6 +141,80 @@ class Speaker extends AudioPeer {
     return params;
   }
 
+  //no need to connect to the listener, just simulate the calibration
+  static simulateCalibration = async (
+    params,
+    CalibratorInstance,
+    connectionManager,
+    timeOut = 180000
+  ) => {
+    window.speaker = new Speaker(params, CalibratorInstance, connectionManager);
+    const {speaker} = window;
+    speaker.ac = CalibratorInstance;
+    //set sampling rates
+    speaker.ac.setSamplingRates(speaker.calibrateSoundHz);
+    speaker.ac.setSampleSize(speaker.calibrateSoundSamplingDesiredBits);
+    speaker.result = await speaker.ac.startCalibration(
+      null,
+      params.gainValues,
+      params.ICalib,
+      params.knownIR,
+      params.microphoneName,
+      params.calibrateSoundCheck,
+      params.isSmartPhone,
+      params.calibrateSoundBurstDb,
+      params.calibrateSoundBurstFilteredExtraDb,
+      params.calibrateSoundBurstLevelReTBool,
+      params.calibrateSoundBurstUses1000HzGainBool,
+      params.calibrateSoundBurstRepeats,
+      params.calibrateSoundBurstSec,
+      params._calibrateSoundBurstPreSec,
+      params._calibrateSoundBurstPostSec,
+      params.calibrateSoundHz,
+      params.calibrateSoundIRSec,
+      params.calibrateSoundIIRSec,
+      params.calibrateSoundIIRPhase,
+      params.calibrateSound1000HzPreSec,
+      params.calibrateSound1000HzSec,
+      params.calibrateSound1000HzPostSec,
+      params.calibrateSoundBackgroundSecs,
+      params.calibrateSoundSmoothOctaves,
+      params.calibrateSoundSmoothMinBandwidthHz,
+      params.calibrateSoundPowerBinDesiredSec,
+      params.calibrateSoundPowerDbSDToleratedDb,
+      params.calibrateSoundTaperSec,
+      params.micManufacturer,
+      params.micSerialNumber,
+      params.micModelNumber,
+      params.micModelName,
+      params.calibrateMicrophonesBool,
+      params.authorEmails,
+      params.webAudioDeviceNames,
+      params.IDsToSaveInSoundProfileLibrary,
+      params.restartButton,
+      params.reminder,
+      params.calibrateSoundLimit,
+      params.calibrateSoundBurstNormalizeBy1000HzGainBool,
+      params.calibrateSoundBurstScalarDB,
+      params.calibrateSound1000HzMaxSD_dB,
+      params.calibrateSound1000HzMaxTries,
+      params._calibrateSoundBurstMaxSD_dB,
+      params.calibrateSoundSamplingDesiredBits,
+      params.language,
+      params.loudspeakerModelName,
+      params.phrases,
+      params.soundSubtitleId,
+      params.calibrateSoundBurstDownsample,
+      params.calibrateSoundSimulateMicrophone,
+      params.calibrateSoundSimulateMicrophoneTime,
+      params.calibrateSoundSimulateLoudspeaker,
+      params.calibrateSoundSimulateLoudspeakerTime,
+      params.isLoudspeakerCalibration
+    );
+    speaker.#removeUIElems();
+    return speaker.result;
+  };
+
   /**
    * Async factory method that creates the Speaker object, and returns a promise that resolves to the result of the calibration.
    *
@@ -270,7 +344,10 @@ class Speaker extends AudioPeer {
             params.soundSubtitleId,
             params.calibrateSoundBurstDownsample,
             params.calibrateSoundSimulateMicrophone,
-            params.calibrateSoundSimulateLoudspeaker
+            params.calibrateSoundSimulateMicrophoneTime,
+            params.calibrateSoundSimulateLoudspeaker,
+            params.calibrateSoundSimulateLoudspeakerTime,
+            params.isLoudspeakerCalibration
           );
           speaker.#removeUIElems();
           //remove the call
@@ -859,7 +936,10 @@ class Speaker extends AudioPeer {
             params.soundSubtitleId,
             params.calibrateSoundBurstDownsample,
             params.calibrateSoundSimulateMicrophone,
-            params.calibrateSoundSimulateLoudspeaker
+            params.calibrateSoundSimulateMicrophoneTime,
+            params.calibrateSoundSimulateLoudspeaker,
+            params.calibrateSoundSimulateLoudspeakerTime,
+            params.isLoudspeakerCalibration
           );
           clearInterval(permissionCheckInterval);
           window.speaker.#removeUIElems();

package/src/powerCheck.js

@@ -1,99 +1,110 @@
-export const volumePowerCheck = (rec, fs, preSec, Sec, _calibrateSoundPowerBinDesiredSec) => {
-    const coarseHz = 1 / _calibrateSoundPowerBinDesiredSec;
-    const power = rec.map(x => Math.pow(x, 2)); // Squared values of the signal
-    
-    // Adjust coarseHz so that fs is an integer multiple of coarseHz.
-    let n = Math.round(fs / coarseHz);
-    
-    // Sampling times for plotting
-    const t = Array.from({ length: power.length }, (_, i) => i / fs);
-    
-    const coarseSamples = Math.ceil(power.length / n);
-    const coarsePowerDb = new Array(coarseSamples).fill(0);
-    const coarseT = new Array(coarseSamples).fill(0);
-
-    for (let i = 0; i < coarseSamples; i++) {
-        const indices = Array.from({ length: Math.min(n, power.length - i * n) }, (_, idx) => i * n + idx);
-        const extremeIndices = [indices[0], indices[indices.length - 1]];
-        
-        const avgPower = indices.reduce((sum, idx) => sum + power[idx], 0) / indices.length;
-        coarsePowerDb[i] = 10 * Math.log10(avgPower);
-        
-        const avgTime = (t[extremeIndices[0]] + t[extremeIndices[1]]) / 2;
-        coarseT[i] = avgTime;
-    }
-
-    const prepSamples = Math.round(coarseHz * preSec);
-    const postSamples = Math.round(coarseHz * (preSec + Sec));
-    const sd = Math.round(standardDeviation(coarsePowerDb.slice(prepSamples)) * 10) / 10;
-    
-    const coarseTRounded = coarseT.map(t => Math.round(t * 1000) / 1000); // Round to 3 decimal places
-    const coarsePowerDbRounded = coarsePowerDb.map(db => Math.round(db * 1000) / 1000); // Round to 3 decimal places
-
-    const start = interpolate(coarseT, coarsePowerDb, preSec);
-    const end = interpolate(coarseT, coarsePowerDb, preSec + Sec);
-    
-    let preT = coarseTRounded.slice(0, prepSamples);
-    let preDb = coarsePowerDbRounded.slice(0, prepSamples);
-    
-    // Adjust starting point of preT and preDb
-    if (preT[preT.length - 1] < preSec) {
-        preT.push(preSec);
-        preDb.push(start);
-    }
-
-    let recT = coarseTRounded.slice(prepSamples, postSamples);
-    let recDb = coarsePowerDbRounded.slice(prepSamples, postSamples);
-    
-    if (recT[0] > preSec) {
-        recT.unshift(preSec);
-        recDb.unshift(start);
-    }
-    
-    if (recT[recT.length - 1] < preSec + Sec) {
-        recT.push(preSec + Sec);
-        recDb.push(end);
-    }
-
-    let postT = coarseTRounded.slice(postSamples);
-    let postDb = coarsePowerDbRounded.slice(postSamples);
-
-    if (postT[0] > preSec + Sec) {
-        postT.unshift(preSec + Sec);
-        postDb.unshift(end);
-    }
-
-    return { preT, preDb, recT, recDb, postT, postDb, sd };
-}
+export const volumePowerCheck = (
+  rec,
+  fs,
+  preSec,
+  Sec,
+  _calibrateSoundPowerBinDesiredSec,
+  postSec
+) => {
+  const coarseHz = 1 / _calibrateSoundPowerBinDesiredSec;
+  const power = rec.map(x => Math.pow(x, 2)); // Squared values of the signal
+
+  // Adjust coarseHz so that fs is an integer multiple of coarseHz.
+  let n = Math.round(fs / coarseHz);
+
+  // Sampling times for plotting
+  const t = Array.from({length: power.length}, (_, i) => i / fs);
+
+  const coarseSamples = Math.ceil(power.length / n);
+  const coarsePowerDb = new Array(coarseSamples).fill(0);
+  const coarseT = new Array(coarseSamples).fill(0);
+
+  for (let i = 0; i < coarseSamples; i++) {
+    const indices = Array.from(
+      {length: Math.min(n, power.length - i * n)},
+      (_, idx) => i * n + idx
+    );
+    const extremeIndices = [indices[0], indices[indices.length - 1]];
+
+    const avgPower = indices.reduce((sum, idx) => sum + power[idx], 0) / indices.length;
+    coarsePowerDb[i] = 10 * Math.log10(avgPower);
+
+    const avgTime = (t[extremeIndices[0]] + t[extremeIndices[1]]) / 2;
+    coarseT[i] = avgTime;
+  }
+
+  const prepSamples = Math.round(coarseHz * preSec);
+  const postSamples = Math.round(coarseHz * (preSec + Sec));
+  const postSamplesEnd = Math.round(coarseHz * (preSec + Sec + postSec));
+  const sd = Math.round(standardDeviation(coarsePowerDb.slice(prepSamples)) * 10) / 10;
+
+  const coarseTRounded = coarseT.map(t => Math.round(t * 1000) / 1000); // Round to 3 decimal places
+  const coarsePowerDbRounded = coarsePowerDb.map(db => Math.round(db * 1000) / 1000); // Round to 3 decimal places
+
+  const start = interpolate(coarseT, coarsePowerDb, preSec);
+  const end = interpolate(coarseT, coarsePowerDb, preSec + Sec);
+
+  let preT = coarseTRounded.slice(0, prepSamples);
+  let preDb = coarsePowerDbRounded.slice(0, prepSamples);
+
+  // Adjust starting point of preT and preDb
+  if (preT[preT.length - 1] < preSec) {
+    preT.push(preSec);
+    preDb.push(start);
+  }
+
+  let recT = coarseTRounded.slice(prepSamples, postSamples);
+  let recDb = coarsePowerDbRounded.slice(prepSamples, postSamples);
+
+  if (recT[0] > preSec) {
+    recT.unshift(preSec);
+    recDb.unshift(start);
+  }
+
+  if (recT[recT.length - 1] < preSec + Sec) {
+    recT.push(preSec + Sec);
+    recDb.push(end);
+  }
+
+  let postT = coarseTRounded.slice(postSamples, postSamplesEnd);
+  let postDb = coarsePowerDbRounded.slice(postSamples, postSamplesEnd);
+
+  if (postT[0] > preSec + Sec) {
+    postT.unshift(preSec + Sec);
+    postDb.unshift(end);
+  }
+
+  return {preT, preDb, recT, recDb, postT, postDb, sd};
+};
 
 // Helper function for interpolation
 export const interpolate = (x, y, target) => {
-    let lowIdx = 0;
-    while (lowIdx < x.length - 1 && x[lowIdx] < target) {
-        lowIdx++;
-    }
+  let lowIdx = 0;
+  while (lowIdx < x.length - 1 && x[lowIdx] < target) {
+    lowIdx++;
+  }
 
-    const x0 = x[lowIdx - 1];
-    const y0 = y[lowIdx - 1];
-    const x1 = x[lowIdx];
-    const y1 = y[lowIdx];
+  const x0 = x[lowIdx - 1];
+  const y0 = y[lowIdx - 1];
+  const x1 = x[lowIdx];
+  const y1 = y[lowIdx];
 
-    // Linear interpolation
-    return y0 + ((target - x0) * (y1 - y0)) / (x1 - x0);
-}
+  // Linear interpolation
+  return y0 + ((target - x0) * (y1 - y0)) / (x1 - x0);
+};
 
 // Helper function to calculate standard deviation
-export const standardDeviation = (arr) => {
-    const mean = arr.reduce((sum, val) => sum + val, 0) / arr.length;
-    const variance = arr.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / arr.length;
-    return Math.sqrt(variance);
-}
-
-export const getPower = (dataArray) => {
-    const squaredValues = dataArray.map(value => value * value);
-      const sum_of_squares = squaredValues.reduce((total, value) => total + value, 0);
-      const squared_mean = sum_of_squares / dataArray.length;
-      const dbLevel = 20 * Math.log10(Math.sqrt(squared_mean));
-      const roundedDbLevel = Math.round(dbLevel * 10) / 10;
-      return roundedDbLevel;
-}
+export const standardDeviation = arr => {
+  const mean = arr.reduce((sum, val) => sum + val, 0) / arr.length;
+  const variance = arr.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / arr.length;
+  return Math.sqrt(variance);
+};
+
+export const getPower = dataArray => {
+  const squaredValues = dataArray.map(value => value * value);
+  const sum_of_squares = squaredValues.reduce((total, value) => total + value, 0);
+  const squared_mean = sum_of_squares / dataArray.length;
+  const dbLevel = 20 * Math.log10(Math.sqrt(squared_mean));
+  const roundedDbLevel = Math.round(dbLevel * 10) / 10;
+  return roundedDbLevel;
+};

package/src/server/PythonServerAPI.js

@@ -126,6 +126,45 @@ class PythonServerAPI {
     return res.data[task];
   };
 
+  getFrequencyResponseFromImpulseResponse = async ({
+    impulseResponseMicrophone,
+    impulseResponseLoudspeaker,
+    sampleRate,
+    timeArray,
+    totalDuration,
+    totalDuration1000Hz,
+  }) => {
+    const task = 'frequency-response';
+    let res = null;
+
+    const data = JSON.stringify({
+      task,
+      impulse_response_microphone: impulseResponseMicrophone,
+      impulse_response_loudspeaker: impulseResponseLoudspeaker,
+      sample_rate: sampleRate,
+      time_array: timeArray,
+      total_duration: totalDuration,
+      total_duration_1000hz: totalDuration1000Hz,
+    });
+
+    await axios({
+      method: 'post',
+      baseURL: PythonServerAPI.PYTHON_SERVER_URL,
+      url: `/task/${task}`,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      data,
+    })
+      .then(response => {
+        res = response;
+      })
+      .catch(error => {
+        throw error;
+      });
+    return res.data[task];
+  };
+
   getMLS = async ({
     length,
     amplitude,
@@ -843,7 +882,12 @@ class PythonServerAPI {
     })
       .then(response => {
         res = response;
-        console.log(res.data[task]);
+        if (typeof res.data === 'string') {
+          //if there is NaN in the string, replace it with 0
+          res.data = res.data.replace('NaN', '0');
+          res.data = JSON.parse(res.data);
+        }
+        console.log('res', res);
       })
       .catch(error => {
         throw error;

package/src/tasks/combination/combination.js

@@ -834,14 +834,18 @@ class Combination extends AudioCalibrator {
               payload_skipped_warmUp,
               this._calibrateSoundBurstDownsample
             );
+            // console.log('usedPeriodStart', usedPeriodStart);
+            // console.log('payload', payload);
+            // console.log('payload_skipped_warmUp', payload_skipped_warmUp);
+            // console.log('payload_skipped_warmUp_downsampled', payload_skipped_warmUp_downsampled);
+            const factor = 1;
+            //simulationEnabled ? this._calibrateSoundBurstDownsample : 1;
             await this.pyServerAPI
               .getAutocorrelation({
                 mls: mls,
                 payload: payload_skipped_warmUp_downsampled,
                 sampleRate: fMLS,
-                numPeriods:
-                  (this.numMLSPerCapture - this.num_mls_to_skip) /
-                  (2 * this._calibrateSoundBurstDownsample),
+                numPeriods: (this.numMLSPerCapture - this.num_mls_to_skip) / factor,
                 downsample: this._calibrateSoundBurstDownsample,
               })
               .then(async res => {
@@ -854,9 +858,7 @@ class Combination extends AudioCalibrator {
                     .getImpulseResponse({
                       mls,
                       sampleRate: fMLS,
-                      numPeriods:
-                        (this.numMLSPerCapture - this.num_mls_to_skip) /
-                        (2 * this._calibrateSoundBurstDownsample),
+                      numPeriods: (this.numMLSPerCapture - this.num_mls_to_skip) / factor,
                       sig: payload_skipped_warmUp_downsampled,
                       fs2: this.fs2,
                       L_new_n: this.L_new_n,
@@ -2759,7 +2761,8 @@ class Combination extends AudioCalibrator {
       this.sourceSamplingRate || 96000,
       this.calibrateSound1000HzPreSec,
       this.calibrateSound1000HzSec,
-      this._calibrateSoundPowerBinDesiredSec
+      this._calibrateSoundPowerBinDesiredSec,
+      this.calibrateSound1000HzPostSec
     );
     console.log(res);
     this.recordingChecks['volume'][this.inDB] = res;
@@ -2821,8 +2824,8 @@ class Combination extends AudioCalibrator {
       // Run the simulation for initial calibration
       await this.simulatedVolumeCalibrationSteps(
         calibrationToneSignal,
-        this.calibrateSoundSimulateLoudspeaker,
-        this.calibrateSoundSimulateMicrophone,
+        this.calibrateSoundSimulateLoudspeaker1000Hz,
+        this.calibrateSoundSimulateMicrophone1000Hz,
         this.#sendToServerForProcessing,
         lCalib,
         checkRec
@@ -2883,8 +2886,8 @@ class Combination extends AudioCalibrator {
         // Run the simulation for this gain value
         await this.simulatedVolumeCalibrationSteps(
           calibrationToneSignal,
-          this.calibrateSoundSimulateLoudspeaker,
-          this.calibrateSoundSimulateMicrophone,
+          this.calibrateSoundSimulateLoudspeaker1000Hz,
+          this.calibrateSoundSimulateMicrophone1000Hz,
           this.#sendToServerForProcessing,
           lCalib,
           checkRec
@@ -3315,7 +3318,10 @@ class Combination extends AudioCalibrator {
     soundSubtitleId,
     calibrateSoundBurstDownsample = 1,
     calibrateSoundSimulateMicrophone = null,
-    calibrateSoundSimulateLoudspeaker = null
+    calibrateSoundSimulateMicrophoneTime = null,
+    calibrateSoundSimulateLoudspeaker = null,
+    calibrateSoundSimulateLoudspeakerTime = null,
+    isLoudspeakerCalibration = true
   ) => {
     this._calibrateSoundBurstDownsample = calibrateSoundBurstDownsample;
     this._calibrateSoundBurstPreSec = _calibrateSoundBurstPreSec;
@@ -3361,7 +3367,15 @@ class Combination extends AudioCalibrator {
     this.calibrateSoundSamplingDesiredBits = calibrateSoundSamplingDesiredBits;
     this.phrases = phrases;
     this.soundSubtitleId = soundSubtitleId;
-    if (isSmartPhone) {
+    const simulationEnabled =
+      this.calibrateSoundSimulateMicrophone !== null &&
+      this.calibrateSoundSimulateLoudspeaker !== null;
+    //pre + repeats * sec + post
+    const allHzDuation =
+      this._calibrateSoundBurstPreSec +
+      this._calibrateSoundBurstRepeats * this._calibrateSoundBurstSec +
+      this._calibrateSoundBurstPostSec;
+    if (isSmartPhone && !simulationEnabled) {
       const leftQuote = '\u201C'; // "
       const rightQuote = '\u201D'; // "
       this.webAudioDeviceNames.microphone = this.deviceInfo.microphoneFromAPI;
@@ -3412,8 +3426,8 @@ class Combination extends AudioCalibrator {
       DeviceType: isSmartPhone ? this.deviceInfo.devicetype : 'N/A',
       ID_from_51Degrees: isSmartPhone ? this.deviceInfo.DeviceId : 'N/A',
       calibrateMicrophonesBool: calibrateMicrophonesBool,
-      screenHeight: this.deviceInfo.screenHeight,
-      screenWidth: this.deviceInfo.screenWidth,
+      screenHeight: this.deviceInfo?.screenHeight,
+      screenWidth: this.deviceInfo?.screenWidth,
       webAudioDeviceNames: {
         loudspeaker: this.webAudioDeviceNames.loudspeaker,
         microphone: this.webAudioDeviceNames.microphone,
@@ -3433,40 +3447,76 @@ class Combination extends AudioCalibrator {
 
     // this.writeMicrophoneInfoToFirestore(ID, micInfo, OEM, 'default');
     // this.addMicrophoneInfo(ID, OEM, micInfo);
-    if (componentIR == null) {
-      //mode 'ir'
-      //global variable this.componentIR must be set
-      await this.readFrqGainFromFirestore(ID, OEM, true).then(data => {
-        if (data !== null) {
-          this.componentIR = data.ir;
-          micInfo['parentTimestamp'] = data.createDate ? data.createDate : new Date();
-          micInfo['parentFilenameJSON'] = data.jsonFileName ? data.jsonFileName : '';
-        }
-      });
+    if (!simulationEnabled) {
+      if (componentIR == null) {
+        //mode 'ir'
+        //global variable this.componentIR must be set
+        await this.readFrqGainFromFirestore(ID, OEM, true).then(data => {
+          if (data !== null) {
+            this.componentIR = data.ir;
+            micInfo['parentTimestamp'] = data.createDate ? data.createDate : new Date();
+            micInfo['parentFilenameJSON'] = data.jsonFileName ? data.jsonFileName : '';
+          }
+        });
 
-      // await this.readFrqGain(ID, OEM).then(data => {
-      //   return data;
-      // });
-
-      // lCalib = await this.readGainat1000Hz(ID, OEM);
-      lCalib = await this.readGainat1000HzFromFirestore(ID, OEM, true);
-      micInfo['gainDBSPL'] = lCalib;
-      // this.componentGainDBSPL = this.convertToDB(lCalib);
-      this.componentGainDBSPL = lCalib;
-      //TODO: if this call to database is unknown, cannot perform experiment => return false
-      if (this.componentIR == null) {
-        this.status =
-          `Microphone (${OEM},${ID}) is not found in the database. Please add it to the database.`.toString();
-        this.emit('update', {message: this.status});
-        return false;
+        // await this.readFrqGain(ID, OEM).then(data => {
+        //   return data;
+        // });
+
+        // lCalib = await this.readGainat1000Hz(ID, OEM);
+        lCalib = await this.readGainat1000HzFromFirestore(ID, OEM, true);
+        micInfo['gainDBSPL'] = lCalib;
+        // this.componentGainDBSPL = this.convertToDB(lCalib);
+        this.componentGainDBSPL = lCalib;
+        //TODO: if this call to database is unknown, cannot perform experiment => return false
+        if (this.componentIR == null) {
+          this.status =
+            `Microphone (${OEM},${ID}) is not found in the database. Please add it to the database.`.toString();
+          this.emit('update', {message: this.status});
+          return false;
+        }
+      } else {
+        this.transducerType = 'Microphone';
+        this.componentIR = componentIR;
+        lCalib = this.findGainatFrequency(this.componentIR.Freq, this.componentIR.Gain, 1000);
+        // this.componentGainDBSPL = this.convertToDB(lCalib);
+        this.componentGainDBSPL = lCalib;
+        // await this.writeIsSmartPhone(ID, isSmartPhone, OEM);
       }
     } else {
-      this.transducerType = 'Microphone';
-      this.componentIR = componentIR;
-      lCalib = this.findGainatFrequency(this.componentIR.Freq, this.componentIR.Gain, 1000);
-      // this.componentGainDBSPL = this.convertToDB(lCalib);
-      this.componentGainDBSPL = lCalib;
-      // await this.writeIsSmartPhone(ID, isSmartPhone, OEM);
+      //simulation.
+      const frequencyResponse = await this.pyServerAPI.getFrequencyResponseFromImpulseResponse({
+        impulseResponseMicrophone: this.calibrateSoundSimulateMicrophone,
+        impulseResponseLoudspeaker: this.calibrateSoundSimulateLoudspeaker,
+        sampleRate: this.sourceSamplingRate,
+        timeArray: calibrateSoundSimulateMicrophoneTime,
+        totalDuration: allHzDuation,
+        totalDuration1000Hz: this.CALIBRATION_TONE_DURATION,
+      });
+      this.calibrateSoundSimulateMicrophone = frequencyResponse.impulse_response_microphone;
+      this.calibrateSoundSimulateLoudspeaker = frequencyResponse.impulse_response_loudspeaker;
+      this.calibrateSoundSimulateMicrophone1000Hz =
+        frequencyResponse.impulse_response_1000hz_microphone;
+      this.calibrateSoundSimulateLoudspeaker1000Hz =
+        frequencyResponse.impulse_response_1000hz_loudspeaker;
+
+      if (isLoudspeakerCalibration) {
+        //define this.componentIR, this.componentGainDBSPL
+        this.componentIR = {
+          Freq: frequencyResponse.frequencies_microphone,
+          Gain: frequencyResponse.gains_microphone,
+        };
+        this.componentGainDBSPL = frequencyResponse.gain_at_1000hz_microphone;
+        lCalib = this.componentGainDBSPL;
+      } else {
+        //define this.componentIR, this.componentGainDBSPL
+        this.componentIR = {
+          Freq: frequencyResponse.frequencies_loudspeaker,
+          Gain: frequencyResponse.gains_loudspeaker,
+        };
+        this.componentGainDBSPL = frequencyResponse.gain_at_1000hz_loudspeaker;
+        lCalib = this.componentGainDBSPL;
+      }
     }
 
     this.oldComponentIR = JSON.parse(JSON.stringify(this.componentIR));