def METHOD_NAME(eps,loss_a,loss_b,n_factor_a,n_factor_b,N):
	"""
	Simulate skr with an SPDC state.
	Parameters
	----------
	eps : float
	    The squeezing factor, sort of analogous to the amount of 
	    pumping power to the spdc source, but not really.
	loss_a : float
	    Efficiency of the quantum channel going to Alice.
	loss_b : float
	    Efficiency of the quantum channel going to Bob. 
	n_factor_a : float
	    Background noise in Alice's detection.
	n_factor_b : float
	    Background noise in Bob's detection.
	N : int
	    Size of the fock space that we allow for the states
	Returns
	-------
	qber : float
	    The Quantum Bit Error Rate
	twofolds : float
	    Probability of Alice and Bob getting a simultaneous detection 
	    of a photon pair (also referred to as coincidences) within a 
	    timing window.
	skr : float
	    Probability of getting a secure key bit within a timing window, 
	    assuming error correction and privacy amplification, in the 
	    limit of many coincidences.
    """
	#make vaccuum state
	vacc = basis(N,0)
	#make squeezing operator for SPDC
	H_sq = 1j*eps*(tensor(create(N),create(N))+tensor(destroy(N),destroy(N)))
	#exponentiate hamiltonian and apply it to vaccuum state to make an SPDC state
	U_sq = H_sq.expm()
	spdc = U_sq*tensor(vacc,vacc)
	psi = tensor(spdc,spdc)
	#since qutip doesn't have a permute function, 
	#we have to do a couple of steps in between
	#1. turn psi from a sparse matrix to a full matrix
	out = psi.full()
	#2. reshape psi into a 4-D matrix
	out = reshape(out, (N,N,N,-1))
	#3. permute the dimensions of our 4-D matrix
	out = transpose(out,(0,3,2,1))
	#4. turn the matrix back into a 1-D array 
	out = reshape(out,(N*N*N*N,-1))
	#5. convert the matrix back into a quantum object
	psi = Qobj(out,dims = [[N, N, N, N], [1, 1, 1, 1]])
	# model detectors
	a_det = BucketDetector_realistic_detector(N,loss_a,n_factor_a)
	b_det = BucketDetector_realistic_detector(N,loss_b,n_factor_b)
	#measure detection probabilities
	probs2f=measure_2folds_4modes_squashing(N,psi,a_det,b_det)
	#Rates returned are 'per pulse', so multiply by source rate
	twofolds=probs2f[0]+probs2f[1]+probs2f[2]+probs2f[3]
	#Determine QBER from returned detection probabilities
	qber = (probs2f[0]+probs2f[3])/twofolds
	#calculate the entropy of the qber  
	if qber>0:
		H2=-qber*log2(qber) - (1-qber)*log2(1-qber)
	else:
		H2 = 0
	# estimate error correction efficiency from the CASCADE algorithm 
	f_e = 1.16904371810274 + qber
	#security analysis - calculate skr in infinite key limit
	#See Chris Erven's PhD thesis or Xiongfeng Ma's paper 
	#to understand where this equation comes from
	skr=real(twofolds*0.5*(1-(1+f_e)*H2))
	return [qber, skr, twofolds]