Пример #1
0
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
    }
  }
}
Пример #2
0
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;
}