code: def test_calc_noise():
      # Inputs for functions
      onsets = [10, 30, 50, 70, 90]
      event_durations = [6]
      tr_duration = 2
      duration = 200
      temporal_res = 100
      tr_number = int(np.floor(duration / tr_duration))
      dimensions_tr = np.array([10, 10, 10, tr_number])
  
      # Preset the noise dict
      nd_orig = sim._noise_dict_update({})
  
      # Create the time course for the signal to be generated
      stimfunction = sim.generate_stimfunction(
          onsets=onsets,
          event_durations=event_durations,
          total_time=duration,
          temporal_resolution=temporal_res,
      )
  
      # Mask the volume to be the same shape as a brain
      mask, template = sim.mask_brain(dimensions_tr, mask_self=None)
      stimfunction_tr = stimfunction[:: int(tr_duration * temporal_res)]
  
      nd_orig["matched"] = 0
      noise = sim.generate_noise(
          dimensions=dimensions_tr[0:3],
          stimfunction_tr=stimfunction_tr,
          tr_duration=tr_duration,
          template=template,
          mask=mask,
          noise_dict=nd_orig,
      )
  
      # Check the spatial noise match
      nd_orig["matched"] = 1
      noise_matched = sim.generate_noise(
          dimensions=dimensions_tr[0:3],
          stimfunction_tr=stimfunction_tr,
          tr_duration=tr_duration,
          template=template,
          mask=mask,
          noise_dict=nd_orig,
          iterations=[50, 0],
      )
  
      # Calculate the noise parameters from this newly generated volume
      nd_new = sim.calc_noise(noise, mask, template)
      nd_matched = sim.calc_noise(noise_matched, mask, template)
  
      # Check the values are reasonable"
      assert nd_new["snr"] > 0, "snr out of range"
      assert nd_new["sfnr"] > 0, "sfnr out of range"
      assert nd_new["auto_reg_rho"][0] > 0, "ar out of range"
  
      # Check that the dilation increases SNR
      no_dilation_snr = sim._calc_snr(
          noise_matched,
          mask,
          dilation=0,
          reference_tr=tr_duration,
      )
  
      assert (
          nd_new["snr"] > no_dilation_snr
      ), "Dilation did not increase SNR"
  
      # Check that template size is in bounds
      with pytest.raises(ValueError):
          sim.calc_noise(noise, mask, template * 2)
  
      # Check that Mask is set is checked
      with pytest.raises(ValueError):
          sim.calc_noise(noise, None, template)
  
      # Check that it can deal with missing noise parameters
      temp_nd = sim.calc_noise(noise, mask, template, noise_dict={})
      assert temp_nd["voxel_size"][0] == 1, "Default voxel size not set"
  
      temp_nd = sim.calc_noise(noise, mask, template, noise_dict=None)
      assert temp_nd["voxel_size"][0] == 1, "Default voxel size not set"
  
      # Check that the fitting worked
      snr_diff = abs(nd_orig["snr"] - nd_new["snr"])
      snr_diff_match = abs(nd_orig["snr"] - nd_matched["snr"])
      assert snr_diff > snr_diff_match, "snr fit incorrectly"
  
      # Test that you can generate rician and exponential noise
      sim._generate_noise_system(
          dimensions_tr,
          1,
          1,
          spatial_noise_type="exponential",
          temporal_noise_type="rician",
      )
  
      # Check the temporal noise match
      nd_orig["matched"] = 1
      noise_matched = sim.generate_noise(
          dimensions=dimensions_tr[0:3],
          stimfunction_tr=stimfunction_tr,
          tr_duration=tr_duration,
          template=template,
          mask=mask,
          noise_dict=nd_orig,
          iterations=[0, 50],
      )
  
      nd_matched = sim.calc_noise(noise_matched, mask, template)
  
      sfnr_diff = abs(nd_orig["sfnr"] - nd_new["sfnr"])
      sfnr_diff_match = abs(nd_orig["sfnr"] - nd_matched["sfnr"])
      assert sfnr_diff > sfnr_diff_match, "sfnr fit incorrectly"
  
      ar1_diff = abs(
          nd_orig["auto_reg_rho"][0] - nd_new["auto_reg_rho"][0]
      )
      ar1_diff_match = abs(
          nd_orig["auto_reg_rho"][0] - nd_matched["auto_reg_rho"][0]
      )
      assert ar1_diff > ar1_diff_match, "AR1 fit incorrectly"
  
      # Check that you can calculate ARMA for a single voxel
      vox = noise[5, 5, 5, :]
      arma = sim._calc_ARMA_noise(
          vox,
          None,
          sample_num=2,
      )
      assert len(arma) == 2, "Two outputs not given by ARMA"
  
file_path: brainiak/tests/utils/test_fmrisim.py
imports: import numpy
  import math
  from brainiak.utils import fmrisim
  import pytest
  from itertools import product
label_desc: Use image node_id 7 for calling a global function with example usage: test_calc_noise() without return types