C++ WolframLibraryData::MTensor_new方法代码示例

// Parameter order:
// inits
// params
// duration
EXTERN_C DLLEXPORT int runODE(WolframLibraryData libData, mint argc, MArgument *argv, MArgument aResult)
    {
    MTensor tensorInits  = MArgument_getMTensor(argv[0]);
    MTensor tensorParams = MArgument_getMTensor(argv[1]);
    double  duration     = MArgument_getReal(argv[2]);
    double  dt           = MArgument_getReal(argv[3]);

    mint rankState  = (mint)(sizeof(ODESTATE)      / sizeof(double));
    mint rankParams = (mint)(sizeof(ODEPARAMETERS) / sizeof(double));

    // Trace("state:%d params:%d", rankState, rankParams);

    ODESTATE inits;
    ODEPARAMETERS parameters;

    copyFromTensor(libData, (double*)&inits, rankState, tensorInits);
    copyFromTensor(libData, (double*)&parameters, rankParams, tensorParams);
    
    ODESTATE result = runODECore(inits, parameters, duration, dt);

    MTensor tensorResult;
    libData->MTensor_new(MType_Real, 1, &rankState, &tensorResult);
    copyToTensor(libData, tensorResult, (double*)&result, rankState);

    MArgument_setMTensor(aResult, tensorResult);

    return LIBRARY_NO_ERROR;
    }

/**
 * Constructs a copy of the input tensor with the number of elements,
 * rank, and type appended at the end.
 **/
DLLEXPORT int demo_T_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T_arg, T_res;
	mint i, rank, type, num, len;
	mint const* dims;
	mint* intData;
	mint* intDataNew;
	mreal* realData;
	mreal* realDataNew;
	int err = LIBRARY_NO_ERROR;
	
	T_arg = MArgument_getMTensor(Args[0]);


	rank = libData->MTensor_getRank(T_arg);
	type = libData->MTensor_getType(T_arg);
	dims = libData->MTensor_getDimensions(T_arg);
	num =  libData->MTensor_getFlattenedLength(T_arg);

	/*
	The result is going to have all the elements, also 
	the length of each dimension, number of elems, rank and type.
	*/
	len = num + rank + 3;

	err = libData->MTensor_new(type, 1, &len, &T_res);
	if (err) return err;

	
	if ( type == MType_Integer) {
		intData = libData->MTensor_getIntegerData(T_arg);
		intDataNew = libData->MTensor_getIntegerData(T_res);
		for ( i = 0; i < num; i++) {
			intDataNew[i] = intData[i];
		}
		for ( i = 0; i < rank; i++) {
			intDataNew[i+num] = dims[i];
		}
		intDataNew[num+rank] = num;
		intDataNew[num+rank+1] = rank;
		intDataNew[num+rank+2] = type;
	}
	else if ( type == MType_Real) {
		realData = libData->MTensor_getRealData(T_arg);
		realDataNew = libData->MTensor_getRealData(T_res);
		for ( i = 0; i < num; i++) {
			realDataNew[i] = realData[i];
		}
		for ( i = 0; i < rank; i++) {
			realDataNew[i+num] = dims[i];
		}
		realDataNew[num+rank] = num;
		realDataNew[num+rank+1] = rank;
		realDataNew[num+rank+2] = type;
	}	
	MArgument_setMTensor(Res, T_res);
	return LIBRARY_NO_ERROR;
}

/**
 * Constructs a new rank 1 tensor with dimension I0, and sets the
 * ith element with the value 2*i. The newly constructed tensor is
 * returned.
 **/
DLLEXPORT int demo1_I_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T0, T1;
	mint i, I0, dims[1];
	int err = LIBRARY_NO_ERROR;

	I0 = MArgument_getInteger(Args[0]);
	dims[0] = I0;
	
	err = libData->MTensor_new(MType_Integer, 1, dims, &T1);
	if (err) return err;
	libData->MTensor_free(T1);
	
	err = libData->MTensor_new(MType_Integer, 1, dims, &T0);
	for ( i = 1; i <= I0 && !err; i++) {
		err = libData->MTensor_setInteger( T0, &i, i*2);
	}
	MArgument_setMTensor(Res, T0);
	return LIBRARY_NO_ERROR;
}

EXTERN_C DLLEXPORT int GrabFrame(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	int err = LIBRARY_NO_ERROR;

	// get a pointer to the byte buffer:
	BYTE *pData;
	hr = VR.getReadBuffer(&pData);

	if (hr == MF_E_END_OF_STREAM)
	{
		libData->Message("endofstream");
		return LIBRARY_FUNCTION_ERROR;
	}

	if (FAILED(hr))
	{
		libData->Message("getdatafail");
		return LIBRARY_FUNCTION_ERROR;
	} 

	// create the rank 3 MTensor
	MTensor T0;
	mint dims[3];
	dims[0] = (mint) VR.m_imageheight;
	dims[1] = (mint) VR.m_imagewidth;
	dims[2] = 3;
	err = libData->MTensor_new(MType_Integer, 3, dims, &T0);

	// fill the MTensor from the byte buffer
	mint *mtdata;
    mtdata = libData->MTensor_getIntegerData(T0);
    int npixels = VR.m_imageheight * VR.m_imagewidth;   

    for (int i = 0; i < npixels; i++) {
		// we read B, G, R, (A) bytes and put R, G, B into the pixel buffer
		mtdata[3 * i    ] = (mint) pData[4 * i + 2]; // R
        mtdata[3 * i + 1] = (mint) pData[4 * i + 1]; // G
        mtdata[3 * i + 2] = (mint) pData[4 * i    ]; // B
	}
    
	// unlock the buffer
	hr = VR.releaseBuffer();
	if (FAILED(hr))
	{
		libData->Message("releaseBufferfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// return the MTensor to Mathematica
	MArgument_setMTensor(Res, T0);
	return err; 

} 

DLLEXPORT int brusselator_pde_jacobian_values(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) 
{
	int err;
    mint i, j, k, n, nr;
    mreal dm;
    mreal *u, *v, *jval;
    MTensor Tres, Targ;
    Targ = MArgument_getMTensor(Args[1]);
    if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
    if (libData->MTensor_getRank(Targ) != 1) return LIBRARY_RANK_ERROR;
    nr = libData->MTensor_getFlattenedLength(Targ);
    n = nr/2;
    u = libData->MTensor_getRealData(Targ);
    v = u + n;

	nr = 4 + 8*(n - 2);
    err = libData->MTensor_new(MType_Real, 1, &nr, &Tres);
	if (err) return err;
    jval = libData->MTensor_getRealData(Tres);

    /* Decrement n so loop excludes boundaries */
    n--;
    dm = (mreal) n;
    dm *= alpha*dm;

	k = 0;

	jval[k++] = -1.; /* u[0] bc */
    for (i = 1; i < n; i++) {	
		/* u equations */
		jval[k++] = dm;
		jval[k++] = 2.*u[i]*v[i] - 4. - 2.*dm;
		jval[k++] = dm;
		jval[k++] = u[i]*u[i]; 
	}
	jval[k++] = -1.; /* u[n] bc */
	jval[k++] = -1.; /* v[0] bc */
    for (i = 1; i < n; i++) {	
		/* v equations */
		jval[k++] = 3. - 2.*u[i]*v[i];
		jval[k++] = dm;
		jval[k++] = -u[i]*u[i] - 2.*dm;
		jval[k++] = dm;
	}
	jval[k++] = -1.; /* v[n] bc */

    MArgument_setMTensor(Res, Tres);
    return 0;
}

DLLEXPORT int brusselator_pde_jacobian_positions(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) 
{
	int err;
	mint dims[2];
    mint i, j, k, n, nr;
	mint *jpos;
    MTensor Tres, Targ;
    Targ = MArgument_getMTensor(Args[1]);
    if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
    if (libData->MTensor_getRank(Targ) != 1) return LIBRARY_RANK_ERROR;
    nr = libData->MTensor_getFlattenedLength(Targ);
    n = nr/2;

	dims[0] = 4 + 8*(n - 2);
	dims[1] = 2;
    err = libData->MTensor_new(MType_Integer, 2, dims, &Tres);
	if (err) return err;
    jpos = libData->MTensor_getIntegerData(Tres);

    /* Decrement n so loop excludes boundaries */
    n--;
	k = 0;

	jpos[k++] = 1; jpos[k++] = 1; /* u[0] bc */
    for (i = 1; i < n; i++) {	
		/* u equations */
		mint r = i + 1;
		jpos[k++] = r; jpos[k++] = i;
		jpos[k++] = r; jpos[k++] = i + 1;
		jpos[k++] = r; jpos[k++] = i + 2;
		jpos[k++] = r; jpos[k++] = i + n + 2;
	}
	jpos[k++] = n + 1; jpos[k++] = n + 1; /* u[n] bc */
	jpos[k++] = n + 2; jpos[k++] = n + 2; /* v[0] bc */
    for (i = 1; i < n; i++) {	
		/* v equations */
		mint r = i + n + 2;
		jpos[k++] = r; jpos[k++] = i + 1;
		jpos[k++] = r; jpos[k++] = i + n + 1;
		jpos[k++] = r; jpos[k++] = i + n + 2;
		jpos[k++] = r; jpos[k++] = i + n + 3;
	}
	jpos[k++] = 2*(n + 1); jpos[k++] = 2*(n + 1); /* v[n] bc */

    MArgument_setMTensor(Res, Tres);
    return 0;
}

EXTERN_C DLLEXPORT int InitSourceReader(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	// Get the arguments from MArgument
	char *videofile = MArgument_getUTF8String(Args[0]);

	// convert UTF8 filename to wide chars
	int size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, NULL, 0);
	WCHAR* videofileW = new WCHAR[size];
	size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, videofileW, size);
	
	// Open the file
	hr = VR.initSourceReader(videofileW);

	// finished with the filename now
	delete videofileW;	
	
	if (FAILED(hr))
	{
		libData->Message("initsourcefail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// Return the duration and frame rate
	MTensor T0;
	mint dims[1] = {4};
	mint pos[1];
	
	libData->MTensor_new(MType_Real, 1, dims, &T0);

	pos[0] = 1;
	libData->MTensor_setReal(T0, pos, VR.m_duration);

	pos[0] = 2;
	libData->MTensor_setReal(T0, pos, VR.m_framerate);

	pos[0] = 3;
	libData->MTensor_setReal(T0, pos, VR.m_imagewidth);

	pos[0] = 4;
	libData->MTensor_setReal(T0, pos, VR.m_imageheight);

	MArgument_setMTensor(Res, T0);
	
	return LIBRARY_NO_ERROR;
} 

/**
 * Same as demo_TI_R, but just to avoid copying
 **/
DLLEXPORT int demo_TT_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T0, T1, T2;
	mint I0;
	mreal R0;
	int err = LIBRARY_NO_ERROR;
	T0 = MArgument_getMTensor(Args[0]);
	T1 = MArgument_getMTensor(Args[1]);
	I0 = (libData->MTensor_getIntegerData(T1))[0];	
	err = libData->MTensor_getReal( T0, &I0, &R0);
	if (err) return err;

	err = libData->MTensor_new(MType_Real, 0, NULL, &T2);
	if (err) return err;
	(libData->MTensor_getRealData(T2))[0] = R0;
	
	MArgument_setMTensor(Res, T2);
	return LIBRARY_NO_ERROR;
}

DLLEXPORT int brusselator_pde_rhs(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) 
{
	int err;
    mint i, j, n, nr;
    mreal dm, uuv;
    mreal *u, *v, *up, *vp;
    MTensor Tres, Targ;
    Targ = MArgument_getMTensor(Args[1]);
    if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
    if (libData->MTensor_getRank(Targ) != 1) return LIBRARY_RANK_ERROR;
    nr = libData->MTensor_getFlattenedLength(Targ);
    n = nr/2;
    u = libData->MTensor_getRealData(Targ);
    v = u + n;

    err = libData->MTensor_new(MType_Real, 1, &nr, &Tres);
	if (err) return err;
    up = libData->MTensor_getRealData(Tres);
    vp = up + n;

    /* Decrement n so loop excludes boundaries */
    n--;
    dm = (mreal) n;
    dm *= alpha*dm;

    /* Boundary conditions to converge to correct values */
    up[0] = 1. - u[0];
    up[n] = 1. - u[n];
    vp[0] = 3. - v[0];
    vp[n] = 3. - v[n];

    for (i = 1; i < n; i++) {
        mreal uuv = u[i];
        uuv *= uuv*v[i];
        up[i] = 1. + uuv - 4.*u[i] + dm*(u[i - 1] - 2.*u[i] + u[i + 1]);
        vp[i] = 3.*u[i] - uuv + dm*(v[i - 1] - 2.*v[i] + v[i + 1]);
    }

    MArgument_setMTensor(Res, Tres);
    return 0;
}

/**
 * Intended to demonstrate working with rank 0 tensors.
 *
 * The arguments are three tensors.  
 * The first is a rank > 0 real tensor.
 * The second is a rank 0 integer tensor.
 * The third a rank 0 real tensor.
 *
 * The second argument is used as an index to find
 * an element of the first, which is added to the
 * third argument to form the result.
 *
 * The result is returned as a rank 0 real tensor.
 **/
DLLEXPORT int demo_TTT_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T_arg, T_I_arg, T_R_arg, T_res;
	mint I0;
	mreal R0, R1;
	int err = LIBRARY_NO_ERROR;
	T_arg = MArgument_getMTensor(Args[0]);
	T_I_arg = MArgument_getMTensor(Args[1]);
	T_R_arg = MArgument_getMTensor(Args[2]);
	I0 = (libData->MTensor_getIntegerData(T_I_arg))[0];
	R0 = (libData->MTensor_getRealData(T_R_arg))[0];	
	err = libData->MTensor_getReal( T_arg, &I0, &R1);
	if (err) return err;
	R0 = R0 + R1;

	err = libData->MTensor_new(MType_Integer, 0, NULL, &T_res);
	if (err) return err;
	(libData->MTensor_getIntegerData( T_res))[0] = (mint) R0;
	
	MArgument_setMTensor(Res, T_res);
	return LIBRARY_NO_ERROR;
}

DLLEXPORT int refine(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) 
{
	int err;
	mint i, j, k, m, n, nr;
	mint const * dims;
	mint rdims[2];
	mreal dist, distsq;
	mreal x1, x2, dx, y1, y2, dy, d, s, ds;
	mreal *x, *y, *rx, *ry;
	MTensor Targ, Tres;

	dist = MArgument_getReal(Args[0]);
	distsq = dist*dist*(1. + 1.e-8); /* Avoid adding extra points due to roundoff */

	Targ = MArgument_getMTensor(Args[1]);
	if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
	if (libData->MTensor_getRank(Targ) != 2) return LIBRARY_RANK_ERROR;
	dims = (libData->MTensor_getDimensions)(Targ);
	if (dims[0] != 2) return LIBRARY_DIMENSION_ERROR;
	n = dims[1];
	x = libData->MTensor_getRealData(Targ);
	y = x + n;

	/* Do a pass to determine the length of the result */
	x2 = x[0];
	y2 = y[0];
	nr = n;
	for (i = 1; i < n; i++) {
		x1 = x2;
		y1 = y2;
		x2 = x[i];
		y2 = y[i];
		dx = x2 - x1;
		dy = y2 - y1;
		d = dx*dx + dy*dy;
		if (d > distsq) {
			d = sqrt(d);
			k = ((mint) ceil(d/dist)) - 1;
			nr += k;
		}
	}

	rdims[0] = 2;
	rdims[1] = nr;
	err = libData->MTensor_new(MType_Real, 2, rdims, &Tres);
	if (err) return err;
	rx = libData->MTensor_getRealData(Tres);
	ry = rx + nr; 

	x2 = x[0];
	y2 = y[0];
	rx[0] = x2;
	ry[0] = y2;
	for (j = i = 1; i < n; i++, j++) {
		x1 = x2;
		y1 = y2;
		x2 = x[i];
		y2 = y[i];
		dx = x2 - x1;
		dy = y2 - y1;
		d = dx*dx + dy*dy;
		if (d > distsq) {
			d = sqrt(d);
			k = ((mint) ceil(d/dist)) - 1;
			ds = 1./((mreal) (k + 1));
			for (m = 1; m <= k; m++, j++) {
				s = m*ds;
				rx[j] = x1 + s*dx;
				ry[j] = y1 + s*dy;
			}
		}
		rx[j] = x2;
		ry[j] = y2;
	}

	MArgument_setMTensor(Res, Tres);
	return 0;
}

bool MathematicaPeakFinder::convertRawScopeData(WolframLibraryData& libData, const STI::Types::TDataMixedSeq& rawScopeData, MTensor& formatedScopeData)
{
	int vecPos = -1;
	double timebase = 1;
	std::string timeBaseStr = "TimeBase";

	for(unsigned i = 0; i < rawScopeData.length(); i++) {
		if(rawScopeData[i]._d() == STI::Types::DataVector && rawScopeData[i].vector().length() == 2
			&& rawScopeData[i].vector()[0]._d() == STI::Types::DataString
			&& timeBaseStr.compare(rawScopeData[i].vector()[0].stringVal()) == 0
			&& rawScopeData[i].vector()[1]._d() == STI::Types::DataDouble) {
			
			timebase = rawScopeData[i].vector()[1].doubleVal();
		}
		else if(rawScopeData[i]._d() == STI::Types::DataVector && rawScopeData[i].vector().length() > 0
			&& rawScopeData[i].vector()[0]._d() == STI::Types::DataVector) {
			vecPos = i;
		}
	}

	if(vecPos == -1) {	//data not found
		return false;
	}

	//Count all the data points.
	int points = 0;
	const STI::Types::TDataMixedSeq& rawData = rawScopeData[vecPos].vector();

	for(unsigned i = 0; i < rawData.length(); i++) {
		if(rawData[i]._d() == STI::Types::DataVector 
			&& rawData[i].vector().length() == 2 
			&& rawData[i].vector()[0]._d() == STI::Types::DataDouble
			&& rawData[i].vector()[1]._d() == STI::Types::DataVector) {
			
			//Count only those data points that come in a section of a certain length or longer
			if (rawData[i].vector()[1].vector().length() >= minNumPointsPerSection)
				points += rawData[i].vector()[1].vector().length();
		}
		else {
			return false;	//error in format of data vector
		}
	}

	//Allocate space for the MTensor containing the scope data
	mint type = MType_Real;
	mint dims[2];
	mint rank = 2;
	int err;
	dims[0] = points;
	dims[1] = 2;
	err = libData->MTensor_new(type, rank, dims, &formatedScopeData);

	if(err != 0) {
		return false;
	}

	int point = 1;
	mint pos[2];
	double t0 = 0;
	const STI::Types::TDataMixedSeq* rawDataSection;
	for(unsigned i = 0; i < rawData.length(); i++) {
		t0 = rawData[i].vector()[0].doubleVal();
		rawDataSection = &(rawData[i].vector()[1].vector());
		
		//Save only those data points that come in a section of a certain length or longer
		if (rawDataSection->length() < minNumPointsPerSection)
			continue;

		for(unsigned j = 0; j < rawDataSection->length(); j++) {
			if((*rawDataSection)[j]._d() != STI::Types::DataDouble) {
				return false;	//data format error
			}
			pos[0] = point;
			
			//Set X
			pos[1] = 1;
			err = libData->MTensor_setReal(formatedScopeData, pos, t0 + j*timebase);
			
			//Set Y
			pos[1] = 2;
			err = libData->MTensor_setReal(formatedScopeData, pos, (*rawDataSection)[j].doubleVal());

			point++;
		}
	}

	return true;
}

bool MathematicaPeakFinder::calculateFeedbackSignalsFromFirstAndSecondSideband(const MixedData& peaks, MixedData& feedback)
{
	WolframLibraryData libData = 0;
	WolframRTL_initialize(WolframLibraryVersion);
	libData = WolframLibraryData_new(WolframLibraryVersion);

	//Setup arguments

	//Initialize peak tensor
	MTensor peakTensor;
	int err;
	mint type = MType_Real;
	mint rank = 2;
	mint dims[2];
	dims[0] = 4;
	dims[1] = 2;
	err = libData->MTensor_new(type, rank, dims, &peakTensor);

	if(err != 0)
		return false;

	mint peakPos[2];

	for(int i = 1; i <= dims[0]; i++) {
		peakPos[0] = i;
		for(int j = 1; j <= dims[1]; j++) {
			peakPos[1] = j;
			err = libData->MTensor_setReal(peakTensor, peakPos, 
				peaks.getVector().at(i-1).getVector().at(j-1).getDouble());
		}
	}

	if(err != 0)
		return false;

	//Initialize result tensor
	MTensor feedbackResults;
	type = MType_Real;
	rank = 1;
	mint dimsRes[1];
	dimsRes[0] = 2;
	err = libData->MTensor_new(type, rank, dimsRes, &feedbackResults);

	if(err != 0)
		return false;

	Initialize_getFeedbackSignalsFromFirstAndSecondSidebands(libData);			//Begin call to Mathematica code

	err = getFeedbackSignalsFromFirstAndSecondSidebands(libData, peakTensor, &feedbackResults);

	Uninitialize_getFeedbackSignalsFromFirstAndSecondSidebands(libData);		//End call to Mathematica code

		
	if( err == 0) {
		//Copy results of the feedback function

		double value = 0;
		mint pos[1];
		feedback.clear();
		
		for(int j = 1; j <= 2; j++) {
			pos[0] = j;
			err = libData->MTensor_getReal(feedbackResults, pos, &value);
			feedback.addValue(value);
		}
	}
	
	cout << "Feedback results:" << endl;
	cout << feedback.print() << endl;

	libData->MTensor_free(peakTensor);
	libData->MTensor_free(feedbackResults);

	return (err == 0);
}

bool MathematicaPeakFinder::findFirstAndSecondOrderSidebandPeaks(const STI::Types::TDataMixedSeq& rawSidebandData, 
														const CalibrationResults_ptr& calibration, 
														double firstOrderSidebandSpacing, 
														double secondOrderSidebandSpacing, 
														double minimumX,
														double targetRange,
														MixedData& peaks,
														double carrierOffset)
{
	WolframLibraryData libData = 0;
	WolframRTL_initialize(WolframLibraryVersion);
	libData = WolframLibraryData_new(WolframLibraryVersion);

	//Setup arguments

	MTensor formatedSidebandData;		//List of {x,y} pairs, with gaps when y is below threshold

	if(!convertRawScopeData(libData, rawSidebandData, formatedSidebandData)) {
		return false;
	}

	//Initialize calibration tensor
	MTensor calTensor;
	int err;
	mint type = MType_Real;
	mint rank = 2;
	mint dims[2];
	dims[0] = 2;
	dims[1] = 2;
	err = libData->MTensor_new(type, rank, dims, &calTensor);

	if(err != 0)
		return false;

	if(!calibration->getPeaks(libData, &calTensor))
		return false;

	//Initialize results tensor
	MTensor peakResults;
	type = MType_Real;
	rank = 2;
	dims[2];
	dims[0] = 4;	//First and second order sidebands: { {+1, -1}, {+2, -2} }
	dims[1] = 2;	//{time, peak height}
	err = libData->MTensor_new(type, rank, dims, &peakResults);

	mreal firstOrderSidebandSpacingArg = firstOrderSidebandSpacing;
	mreal secondOrderSidebandSpacingArg = secondOrderSidebandSpacing;
	mreal minX = minimumX;
	mreal targetRangeArg = targetRange;
	mreal carrierOffsetArg = carrierOffset;

	if(err == 0) {
		Initialize_findFirstAndSecondOrderSidebands(libData);		//Begin call to Mathematica code

		err = findFirstAndSecondOrderSidebands(libData, formatedSidebandData, calTensor, firstOrderSidebandSpacingArg, secondOrderSidebandSpacingArg, minX, targetRangeArg, carrierOffsetArg, &peakResults);

		Uninitialize_findFirstAndSecondOrderSidebands(libData);		//End call to Mathematica code
	}
	
	if( err == 0) {
		//Copy results of peak search

		double value = 0;
		mint pos[2];
		peaks.clear();
		MixedData peak;
		for(int i = 1; i <= 4; i++) {
			pos[0] = i;
			peak.clear();
			for(int j = 1; j <= 2; j++) {
				pos[1] = j;
				err = libData->MTensor_getReal(peakResults, pos, &value);
				peak.addValue(value);
			}
			peaks.addValue(peak);
		}
	}

	cout << "Peak find results:" << endl;
	cout << peaks.print() << endl;
	

	libData->MTensor_free(formatedSidebandData);
	libData->MTensor_free(calTensor);
	libData->MTensor_free(peakResults);

	return (err == 0);

}

bool MathematicaPeakFinder::findCalibrationPeaks(const STI::Types::TDataMixedSeq& rawCalData, double FSR_s, double minimumX,
												 const CalibrationResults_ptr& calResults)
{
	WolframLibraryData libData = 0;
	WolframRTL_initialize(WolframLibraryVersion);
	libData = WolframLibraryData_new(WolframLibraryVersion);

	//Setup arguments

	MTensor formatedScopeCalibrationData;		//List of {x,y} pairs, with gaps when y is below threshold

	if(!convertRawScopeData(libData, rawCalData, formatedScopeCalibrationData)) {
		return false;
	}

	////test
	//mint lens[2];
	//int err2;
	//double value;
	//
	//lens[0] = 4;
	//for(unsigned j = 1; j < 50; j++) {
	//	lens[0] = j;

	//	lens[1] = 1;
	//	err2 = libData->MTensor_getReal(formatedScopeCalibrationData, lens, &value);
	//	cout << "(" << value <<", ";
	//	lens[1] = 2;
	//	err2 = libData->MTensor_getReal(formatedScopeCalibrationData, lens, &value);
	//	cout << value << ")" << endl;
	//}


	MTensor calibration;
	int err;
	mint type = MType_Real;
	mint rank = 2;
	mint dims[2];
	dims[0] = 2;
	dims[1] = 2;
	err = libData->MTensor_new(type, rank, dims, &calibration);
	MTensor* result = &calibration;
	
	cout << "In Peak Finder: error = " << err << endl;

	if(err == 0) {
		Initialize_findCalibration(libData);		//Begin call to Mathematica code

		mreal fsrTime = FSR_s;
		mreal minX = minimumX;

		err = findCalibration(libData, formatedScopeCalibrationData, fsrTime, minX, &calibration);

		cout << "Calibration Result:" << endl;
		mint lens[2];
		int err2;
		double value = 0;
		for(unsigned j = 1; j <= 2; j++) {
			lens[0] = j;

			lens[1] = 1;
			err2 = libData->MTensor_getReal(calibration, lens, &value);
			cout << "(" << value <<", ";
			lens[1] = 2;
			err2 = libData->MTensor_getReal(calibration, lens, &value);
			cout << value << ")" << endl;
		}


		if(err == 0) {
			calResults->savePeaks(libData, &calibration);
		}

		Uninitialize_findCalibration(libData);		//End call to Mathematica code
	}
	

	libData->MTensor_free(formatedScopeCalibrationData);
	libData->MTensor_free(calibration);
	result = 0;

	return (err == 0);
}