vec SingleSampleCCE::cluster_evolution(int cce_order, int index)
{/*{{{*/
vector<cSPIN> spin_list = _my_clusters.getCluster(cce_order, index);
cClusterIndex clstIndex = _my_clusters.getClusterIndex(cce_order, index);
Hamiltonian hami0 = create_spin_hamiltonian(_center_spin, _state_pair.first, spin_list, clstIndex);
Hamiltonian hami1 = create_spin_hamiltonian(_center_spin, _state_pair.second, spin_list, clstIndex);
vector<QuantumOperator> hm_list1 = riffle((QuantumOperator) hami0, (QuantumOperator) hami1, _pulse_num);
vector<QuantumOperator> hm_list2 = riffle((QuantumOperator) hami1, (QuantumOperator) hami0, _pulse_num);
vector<double> time_segment = Pulse_Interval(_pulse_name, _pulse_num);
PureState psi = create_cluster_state(clstIndex);
PiecewiseFullMatrixVectorEvolution kernel1(hm_list1, time_segment, psi);
PiecewiseFullMatrixVectorEvolution kernel2(hm_list2, time_segment, psi);
kernel1.setTimeSequence( _t0, _t1, _nTime);
kernel2.setTimeSequence( _t0, _t1, _nTime);
ClusterCoherenceEvolution dynamics1(&kernel1);
ClusterCoherenceEvolution dynamics2(&kernel2);
dynamics1.run();
dynamics2.run();
return calc_observables(&kernel1, &kernel2);
}/*}}}*/
vec EnsembleCCE::cluster_evolution(int cce_order, int index)
{
vector<cSPIN> spin_list = _my_clusters.getCluster(cce_order, index);
Hamiltonian hami0 = create_spin_hamiltonian(_center_spin, _state_pair.first, spin_list);
Hamiltonian hami1 = create_spin_hamiltonian(_center_spin, _state_pair.second, spin_list);
vector<QuantumOperator> left_hm_list = riffle((QuantumOperator) hami0, (QuantumOperator) hami1, _pulse_num);
vector<QuantumOperator> right_hm_list;
if (_pulse_num % 2 == 0)
right_hm_list= riffle((QuantumOperator) hami1, (QuantumOperator) hami0, _pulse_num);
else
right_hm_list = riffle((QuantumOperator) hami0, (QuantumOperator) hami1, _pulse_num);
vector<double> time_segment = Pulse_Interval(_pulse_name, _pulse_num);
DensityOperator ds = create_spin_density_state(spin_list);
PiecewiseFullMatrixMatrixEvolution kernel(left_hm_list, right_hm_list, time_segment, ds);
kernel.setTimeSequence( _t0, _t1, _nTime);
ClusterCoherenceEvolution dynamics(&kernel);
dynamics.run();
return calc_observables(&kernel);
}
/* Calculate species derivates */
int
calc_species_deriv ( realtype time, N_Vector species, N_Vector Dspecies, void * f_data )
{
int return_val;
N_Vector * temp_data;
N_Vector expressions;
N_Vector observables;
N_Vector ratelaws;
/* cast temp_data */
temp_data = (N_Vector*)f_data;
/* sget ratelaws Vector */
expressions = temp_data[0];
observables = temp_data[1];
ratelaws = temp_data[2];
/* calculate observables */
calc_observables( observables, species, expressions );
/* calculate ratelaws */
calc_ratelaws( ratelaws, species, expressions, observables );
/* calculate derivates */
NV_Ith_S(Dspecies,0) = NV_Ith_S(ratelaws,5) -NV_Ith_S(ratelaws,1);
NV_Ith_S(Dspecies,1) = -NV_Ith_S(ratelaws,7) +NV_Ith_S(ratelaws,5) +NV_Ith_S(ratelaws,10) +NV_Ith_S(ratelaws,8) -NV_Ith_S(ratelaws,1) -NV_Ith_S(ratelaws,4);
NV_Ith_S(Dspecies,2) = NV_Ith_S(ratelaws,3) +NV_Ith_S(ratelaws,0) -NV_Ith_S(ratelaws,2) +NV_Ith_S(ratelaws,6) +NV_Ith_S(ratelaws,9);
NV_Ith_S(Dspecies,3) = 0;
NV_Ith_S(Dspecies,4) = -NV_Ith_S(ratelaws,5) +NV_Ith_S(ratelaws,8) +NV_Ith_S(ratelaws,1) -NV_Ith_S(ratelaws,4);
NV_Ith_S(Dspecies,5) = -NV_Ith_S(ratelaws,7) +NV_Ith_S(ratelaws,10) -NV_Ith_S(ratelaws,8) +NV_Ith_S(ratelaws,4);
NV_Ith_S(Dspecies,6) = NV_Ith_S(ratelaws,7) -NV_Ith_S(ratelaws,10);
return(0);
}
/*
** ========
** main MEX
** ========
*/
void mexFunction( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
/* variables */
double * return_status;
double * species_out;
double * observables_out;
double * parameters;
double * species_init;
double * timepoints;
size_t n_timepoints;
size_t i;
size_t j;
/* intermediate data vectors */
N_Vector expressions;
N_Vector observables;
N_Vector ratelaws;
/* array to hold pointers to data vectors */
N_Vector temp_data[3];
/* CVODE specific variables */
realtype reltol;
realtype abstol;
realtype time;
N_Vector species;
void * cvode_mem;
int flag;
/* check number of input/output arguments */
if (nlhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
if (nrhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
/* make sure timepoints has correct dimensions */
if ( (mxGetM(prhs[0]) < 2) || (mxGetN(prhs[0]) != 1) )
{ mexErrMsgTxt("TIMEPOINTS must be a column vector with 2 or more elements."); }
/* make sure species_init has correct dimensions */
if ( (mxGetM(prhs[1]) != 1) || (mxGetN(prhs[1]) != __N_SPECIES__) )
{ mexErrMsgTxt("SPECIES_INIT must be a row vector with 7 elements."); }
/* make sure params has correct dimensions */
if ( (mxGetM(prhs[2]) != 1) || (mxGetN(prhs[2]) != __N_PARAMETERS__) )
{ mexErrMsgTxt("PARAMS must be a column vector with 4 elements."); }
/* get pointers to input arrays */
timepoints = mxGetPr(prhs[0]);
species_init = mxGetPr(prhs[1]);
parameters = mxGetPr(prhs[2]);
/* get number of timepoints */
n_timepoints = mxGetM(prhs[0]);
/* Create an mxArray for output trajectories */
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL );
plhs[1] = mxCreateDoubleMatrix(n_timepoints, __N_SPECIES__, mxREAL);
plhs[2] = mxCreateDoubleMatrix(n_timepoints, __N_OBSERVABLES__, mxREAL);
/* get pointers to output arrays */
return_status = mxGetPr(plhs[0]);
species_out = mxGetPr(plhs[1]);
observables_out = mxGetPr(plhs[2]);
/* initialize intermediate data vectors */
expressions = NULL;
expressions = N_VNew_Serial(__N_EXPRESSIONS__);
if (check_flag((void *)expressions, "N_VNew_Serial", 0))
{
return_status[0] = 1;
return;
}
observables = NULL;
observables = N_VNew_Serial(__N_OBSERVABLES__);
if (check_flag((void *)observables, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
return_status[0] = 1;
return;
}
ratelaws = NULL;
ratelaws = N_VNew_Serial(__N_RATELAWS__);
if (check_flag((void *)ratelaws, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
return_status[0] = 1;
return;
}
/* set up pointers to intermediate data vectors */
temp_data[0] = expressions;
temp_data[1] = observables;
temp_data[2] = ratelaws;
/* calculate expressions (expressions are constant, so only do this once!) */
calc_expressions( expressions, parameters );
/* SOLVE model equations! */
species = NULL;
cvode_mem = NULL;
/* Set the scalar relative tolerance */
reltol = 1e-06;
abstol = 1e-06;
/* Create serial vector for Species */
species = N_VNew_Serial(__N_SPECIES__);
if (check_flag((void *)species, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
return_status[0] = 1;
return;
}
for ( i = 0; i < __N_SPECIES__; i++ )
{ NV_Ith_S(species,i) = species_init[i]; }
/* write initial species populations into species_out */
for ( i = 0; i < __N_SPECIES__; i++ )
{ species_out[i*n_timepoints] = species_init[i]; }
/* write initial observables populations into species_out */
calc_observables( observables, species, expressions );
for ( i = 0; i < __N_OBSERVABLES__; i++ )
{ observables_out[i*n_timepoints] = NV_Ith_S(observables,i); }
/* Call CVodeCreate to create the solver memory:
* CV_ADAMS or CV_BDF is the linear multistep method
* CV_FUNCTIONAL or CV_NEWTON is the nonlinear solver iteration
* A pointer to the integrator problem memory is returned and stored in cvode_mem.
*/
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Call CVodeInit to initialize the integrator memory:
* cvode_mem is the pointer to the integrator memory returned by CVodeCreate
* rhs_func is the user's right hand side function in y'=f(t,y)
* T0 is the initial time
* y is the initial dependent variable vector
*/
flag = CVodeInit(cvode_mem, calc_species_deriv, timepoints[0], species);
if (check_flag(&flag, "CVodeInit", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Set scalar relative and absolute tolerances */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* pass params to rhs_func */
flag = CVodeSetUserData(cvode_mem, &temp_data);
if (check_flag(&flag, "CVodeSetFdata", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* select linear solver */
flag = CVDense(cvode_mem, __N_SPECIES__);
if (check_flag(&flag, "CVDense", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxNumSteps(cvode_mem, 2000);
if (check_flag(&flag, "CVodeSetMaxNumSteps", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxErrTestFails(cvode_mem, 7);
if (check_flag(&flag, "CVodeSetMaxErrTestFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxConvFails(cvode_mem, 10);
if (check_flag(&flag, "CVodeSetMaxConvFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxStep(cvode_mem, 0.0);
if (check_flag(&flag, "CVodeSetMaxStep", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* integrate to each timepoint */
for ( i=1; i < n_timepoints; i++ )
{
flag = CVode(cvode_mem, timepoints[i], species, &time, CV_NORMAL);
if (check_flag(&flag, "CVode", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* copy species output from nvector to matlab array */
for ( j = 0; j < __N_SPECIES__; j++ )
{ species_out[j*n_timepoints + i] = NV_Ith_S(species,j); }
/* copy observables output from nvector to matlab array */
calc_observables( observables, species, expressions );
for ( j = 0; j < __N_OBSERVABLES__; j++ )
{ observables_out[j*n_timepoints + i] = NV_Ith_S(observables,j); }
}
/* Free vectors */
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
/* Free integrator memory */
CVodeFree(&cvode_mem);
return;
}
