void MultiFlowComputeCumulativeIncorporationSignal ( struct bead_params *p,struct reg_params *reg_p, float *ivalPtr,
NucStep &cache_step, incorporation_params_block_flows &cur_bead_block,
TimeCompression &time_c, flow_buffer_info &my_flow, PoissonCDFApproxMemo *math_poiss )
{
// only side effect should be new values in ivalPtr
// this is region wide
//This will short-circuit if has been computed
cache_step.CalculateNucRiseCoarseStep ( reg_p,time_c,my_flow );
// pretend I'm making a parallel process
FillIncorporationParamsBlockFlows ( &cur_bead_block, p,reg_p,my_flow.flow_ndx_map,my_flow.buff_flow );
// "In parallel, across flows"
float* nuc_rise_ptr[NUMFB];
float* incorporation_rise[NUMFB];
int my_start[NUMFB];
for ( int fnum=0; fnum<NUMFB; fnum++ )
{
nuc_rise_ptr[fnum] = cache_step.NucCoarseStep ( fnum );
incorporation_rise[fnum]= &ivalPtr[fnum*time_c.npts() ];
my_start[fnum] = cache_step.i_start_coarse_step[fnum];
}
// this is >almost< a parallel operation by flows now
bool use_my_parallel=true;
if ( use_my_parallel )
{
//@TODO handle cases of fewer than 4 flows remaining
for ( int fnum=0; fnum<NUMFB; fnum+=4 )
{
ParallelSimpleComputeCumulativeIncorporationHydrogens ( &incorporation_rise[fnum], time_c.npts(), &time_c.deltaFrameSeconds[0],&nuc_rise_ptr[fnum],
ISIG_SUB_STEPS_MULTI_FLOW, &my_start[fnum], &p->Ampl[fnum],
&cur_bead_block.SP[fnum],&cur_bead_block.kr[fnum], &cur_bead_block.kmax[fnum], &cur_bead_block.d[fnum], &cur_bead_block.molecules_to_micromolar_conversion[fnum], math_poiss );
for ( int q=0; q<4; q++ )
MultiplyVectorByScalar ( incorporation_rise[fnum+q], cur_bead_block.sens[fnum+q],time_c.npts() ); // transform hydrogens to signal
}
}
else
{
for ( int fnum=0;fnum<NUMFB;fnum++ )
{
ComputeCumulativeIncorporationHydrogens ( incorporation_rise[fnum], time_c.npts(),
&time_c.deltaFrameSeconds[0], nuc_rise_ptr[fnum], ISIG_SUB_STEPS_MULTI_FLOW, my_start[fnum],
cur_bead_block.C[fnum], p->Ampl[fnum], cur_bead_block.SP[fnum], cur_bead_block.kr[fnum], cur_bead_block.kmax[fnum], cur_bead_block.d[fnum],cur_bead_block.molecules_to_micromolar_conversion[fnum], math_poiss );
MultiplyVectorByScalar ( incorporation_rise[fnum], cur_bead_block.sens[fnum],time_c.npts() ); // transform hydrogens to signal
}
}
}
//@TODO: Revert local bead correction here
// For refining "time" shifts, we want to use sampled beads, so don't do bkg subtraction on everything and munge the buffers.
void RefineFit::FitAmplitudePerBeadPerFlow (int ibd, NucStep &cache_step, int flow_block_size, int flow_block_start)
{
int fitType[flow_block_size];
BeadParams *p = &bkg.region_data->my_beads.params_nn[ibd];
float block_signal_corrected[bkg.region_data->my_scratch.bead_flow_t];
float block_signal_predicted[bkg.region_data->my_scratch.bead_flow_t];
float washoutThreshold = bkg.getWashoutThreshold();
int washoutFlowDetection = bkg.getWashoutFlowDetection();
SupplyMultiFlowSignal (block_signal_corrected, ibd, flow_block_size, flow_block_start);
if (bkg.global_defaults.signal_process_control.exp_tail_fit)
my_exp_tail_fit.CorrectTraces(block_signal_corrected,bkg.region_data->my_scratch.shifted_bkg,
p,&bkg.region_data->my_regions.rp,
bkg.region_data_extras.my_flow,bkg.region_data->time_c, flow_block_size, flow_block_start);
error_track err_t; // temporary store errors for this bead this flow
for (int fnum=0;fnum < flow_block_size;fnum++)
{
float evect[bkg.region_data->time_c.npts()];
bkg.region_data->emphasis_data.CustomEmphasis (evect, p->Ampl[fnum]);
float *signal_corrected = &block_signal_corrected[fnum*bkg.region_data->time_c.npts()];
float *signal_predicted = &block_signal_predicted[fnum*bkg.region_data->time_c.npts()];
int NucID = bkg.region_data_extras.my_flow->flow_ndx_map[fnum];
fitType[fnum] =
my_single_fit.FitOneFlow (fnum,evect,p,&err_t, signal_corrected,signal_predicted,
NucID,cache_step.NucFineStep (fnum),cache_step.i_start_fine_step[fnum],
flow_block_start,bkg.region_data->time_c,bkg.region_data->emphasis_data,bkg.region_data->my_regions);
}
//int reg = bkg.region_data->region->index;
//printf("RefineFit::FitAmplitudePerBeadPerFlow... (r,b)=(%d,%d) predicted[10]=%f corrected[10]=%f\n",reg,ibd,block_signal_predicted[10],block_signal_corrected[10]);
// note: predicted[0:7]=0 most of the time, my_start=8 or 9
// do things with my error vector for this bead
// now detect corruption & store average error
p->DetectCorruption (err_t, washoutThreshold, washoutFlowDetection, flow_block_size);
// update error here to be passed to later block of flows
// don't keep individual flow errors because we're surprisingly tight on memory
p->UpdateCumulativeAvgError (err_t, flow_block_start + flow_block_size, flow_block_size); // current flow reached, 1-based
// send prediction to hdf5 if necessary
CrazyDumpToHDF5(p,ibd,block_signal_predicted, block_signal_corrected, fitType, err_t, flow_block_start );
}
//@TODO: Revert local bead correction here
// For refining "time" shifts, we want to use sampled beads, so don't do bkg subtraction on everything and munge the buffers.
void RefineFit::FitAmplitudePerBeadPerFlow (int ibd, NucStep &cache_step)
{
bead_params *p = &bkg.region_data->my_beads.params_nn[ibd];
float block_signal_corrected[bkg.region_data->my_scratch.bead_flow_t];
float block_signal_predicted[bkg.region_data->my_scratch.bead_flow_t];
SupplyMultiFlowSignal (block_signal_corrected, ibd);
if (bkg.global_defaults.signal_process_control.exp_tail_fit)
my_exp_tail_fit.CorrectTraces(block_signal_corrected,bkg.region_data->my_scratch.shifted_bkg,p,&bkg.region_data->my_regions.rp,
&bkg.region_data->my_flow,bkg.region_data->time_c);
error_track err_t; // temporary store errors for this bead this flow
for (int fnum=0;fnum < NUMFB;fnum++)
{
float evect[bkg.region_data->time_c.npts()];
//local_emphasis[fnum].CustomEmphasis (evect,p->Ampl[fnum]);
bkg.region_data->emphasis_data.CustomEmphasis (evect, p->Ampl[fnum]);
float *signal_corrected = &block_signal_corrected[fnum*bkg.region_data->time_c.npts()];
float *signal_predicted = &block_signal_predicted[fnum*bkg.region_data->time_c.npts()];
int NucID = bkg.region_data->my_flow.flow_ndx_map[fnum];
my_single_fit.FitOneFlow (fnum,evect,p,&err_t, signal_corrected,signal_predicted, NucID,cache_step.NucFineStep (fnum),cache_step.i_start_fine_step[fnum],bkg.region_data->my_flow,bkg.region_data->time_c,bkg.region_data->emphasis_data,bkg.region_data->my_regions);
}
// do things with my error vector for this bead
// now detect corruption & store average error
DetectCorruption (p,err_t, WASHOUT_THRESHOLD, WASHOUT_FLOW_DETECTION);
// update error here to be passed to later block of flows
// don't keep individual flow errors because we're surprisingly tight on memory
UpdateCumulativeAvgError (p,err_t,bkg.region_data->my_flow.buff_flow[NUMFB-1]+1); // current flow reached, 1-based
// if necessary, send the errors to HDF5
bkg.global_state.SendErrorVectorToHDF5 (p,err_t, bkg.region_data->region,bkg.region_data->my_flow);
// send prediction to hdf5 if necessary
bkg.global_state.SendPredictedToHDF5(ibd, block_signal_predicted, *bkg.region_data);
bkg.global_state.SendCorrectedToHDF5(ibd, block_signal_corrected, *bkg.region_data);
bkg.global_state.SendXtalkToHDF5(ibd, bkg.region_data->my_scratch.cur_xtflux_block, *bkg.region_data);
}
void MathModel::MultiFlowComputeCumulativeIncorporationSignal (
struct BeadParams *p,struct reg_params *reg_p, float *ivalPtr,
NucStep &cache_step, incorporation_params_block_flows &cur_bead_block,
const TimeCompression &time_c, const FlowBufferInfo &my_flow,
PoissonCDFApproxMemo *math_poiss, int flow_block_size,
int flow_block_start )
{
// only side effect should be new values in ivalPtr
// this is region wide
//This will short-circuit if has been computed
cache_step.CalculateNucRiseCoarseStep ( reg_p,time_c,my_flow );
// pretend I'm making a parallel process
FillIncorporationParamsBlockFlows ( &cur_bead_block, p,reg_p,my_flow.flow_ndx_map,
flow_block_start, flow_block_size );
// "In parallel, across flows"
const float** nuc_rise_ptr = new const float *[flow_block_size];
float** incorporation_rise = new float *[flow_block_size];
int* my_start = new int[flow_block_size];
for ( int fnum=0; fnum<flow_block_size; fnum++ )
{
nuc_rise_ptr[fnum] = cache_step.NucCoarseStep ( fnum );
incorporation_rise[fnum] = &ivalPtr[fnum*time_c.npts() ];
my_start[fnum] = cache_step.i_start_coarse_step[fnum];
}
// this is >almost< a parallel operation by flows now
bool use_my_parallel= (flow_block_size%4 == 0);
if ( use_my_parallel )
{
//@TODO handle cases of fewer than 4 flows remaining
for ( int fnum=0; fnum<flow_block_size; fnum+=4 )
{
MathModel::ParallelSimpleComputeCumulativeIncorporationHydrogens (
&incorporation_rise[fnum], time_c.npts(), &time_c.deltaFrameSeconds[0],
&nuc_rise_ptr[fnum],
ISIG_SUB_STEPS_MULTI_FLOW, &my_start[fnum], &p->Ampl[fnum],
&cur_bead_block.SP[fnum],&cur_bead_block.kr[fnum], &cur_bead_block.kmax[fnum],
&cur_bead_block.d[fnum], &cur_bead_block.molecules_to_micromolar_conversion[fnum],
math_poiss, reg_p->hydrogenModelType );
}
}
else
{
for ( int fnum=0;fnum<flow_block_size;fnum++ )
{
MathModel::ComputeCumulativeIncorporationHydrogens ( incorporation_rise[fnum], time_c.npts(),
&time_c.deltaFrameSeconds[0], nuc_rise_ptr[fnum], ISIG_SUB_STEPS_MULTI_FLOW,
my_start[fnum], cur_bead_block.C[fnum], p->Ampl[fnum], cur_bead_block.SP[fnum],
cur_bead_block.kr[fnum], cur_bead_block.kmax[fnum],
cur_bead_block.d[fnum],cur_bead_block.molecules_to_micromolar_conversion[fnum],
math_poiss, reg_p->hydrogenModelType );
}
}
// transform hydrogens to signal
for ( int fnum=0;fnum<flow_block_size;fnum++ )
MultiplyVectorByScalar ( incorporation_rise[fnum], cur_bead_block.sens[fnum],time_c.npts() );
// Cleanup.
delete [] nuc_rise_ptr;
delete [] incorporation_rise;
delete [] my_start;
}
