noe Namespace Reference

Classes
class	noe

Functions
	__attribute__ ((unused)) static void add_test_fd_event()
static cppoint	get_int_plane_and_cell (const double x, const double y, const double z, const geo::View_t view)
static void	build_cell_lookup_table (art::ServiceHandle< geo::Geometry > &geo)
static std::pair< cppoint, cppoint >	cart_to_cp (art::ServiceHandle< geo::Geometry > &geo, const TVector3 &tp)

Variables
static vector< vector< float > >	xcell_z
static vector< vector< float > >	ycell_z
static vector< float >	xplane_z
static vector< float >	yplane_z
static vector< vector< float > >	xcell_x
static vector< vector< float > >	ycell_y

Function Documentation

noe::__attribute__

(

(unused)

)

Definition at line 90 of file noe_module.cc.

References hit::adc, noeevent::addhit(), plot_validation_datamc::c, hit::cell, noeevent::nevent, noeevent::nrun, noeevent::nsubrun, hit::plane, hit::tdc, and theevents.

{
  noeevent ev;
  ev.nevent = 0;
  ev.nrun = 0;
  ev.nsubrun = 0;

  for(unsigned int c = 0; c < 12 * 32; c++){
    for(unsigned int p = 0; p < 32 * 28; p++){
      hit thehit;
      thehit.cell = c;
      thehit.plane = p;
      thehit.adc =  (c*p)%124;
      thehit.tdc = ((c*p)%432)*4;
      ev.addhit(thehit);
    }
  }
  theevents.push_back(ev);
}

static void noe::build_cell_lookup_table ( art::ServiceHandle< geo::Geometry > &  geo )

static

Definition at line 201 of file noe_module.cc.

References geo::GeometryBase::CellInfo(), geo::kX, geo::PlaneGeo::Ncells(), geo::GeometryBase::NPlanes(), std_candles::pl, geo::GeometryBase::Plane(), NDAPDHVSetting::plane, push_back(), POTSpillRate::view, ycell_y, ycell_z, and yplane_z.

Referenced by cart_to_cp().

{
  for(unsigned int pl = 0; pl < geo->NPlanes(); pl++){
    const geo::PlaneGeo * const plane = geo->Plane(pl);
    geo::View_t view;
    vector<float> cell_z, cell_t;
    for(unsigned int ce = 0; ce < plane->Ncells(); ce++){
      double cellcenter[3], dum[3];
      geo->CellInfo(pl, ce, &view, cellcenter, dum);
      cell_z.push_back(cellcenter[2]);
      cell_t.push_back(geo::kX?cellcenter[0]:cellcenter[1]);
    }

    (view == geo::kX?xcell_z:ycell_z).push_back(cell_z);
    (view == geo::kX?xcell_x:ycell_y).push_back(cell_t);

    vector<float> & pz = (view == geo::kX?xplane_z:yplane_z);
    pz.push_back(cell_z[cell_z.size()/2]);
  }
}

static std::pair<cppoint, cppoint> noe::cart_to_cp ( art::ServiceHandle< geo::Geometry > &  geo, const TVector3 &  tp  )

static

Definition at line 225 of file noe_module.cc.

References build_cell_lookup_table(), geo::GeometryBase::CellInfo(), get_int_plane_and_cell(), geo::kX, and geo::kY.

Referenced by noe::noe::produce().

{
  // With this lookup table (which isn't really a lookup table), finding
  // track point uses ~15% of the time spent loading events.  Probably
  // could go faster, although that's not too bad.
  {
    static int first = true;
    if(first) build_cell_lookup_table(geo);
    first = false;
  }

  // For each view, first find a plane and cell which is probably the closest
  // one, or maybe one of the several closest. Then ask the geometry where that
  // cell is and store the difference in the fractional part of the cppoint.
  // This is right up to the difference between the mean plane and cell
  // spacings and the actual spacing near the requested point.  For purposes of
  // the event display, it's fine.

  // Exact values are not very important
  const double meanplanesep = 6.6681604;
  const double meancellsep  = 3.9674375;

  std::pair<cppoint, cppoint> answer;
  answer.first = get_int_plane_and_cell(tp.X(), tp.Y(), tp.Z(), geo::kX);

  double cellcenter[3], dum[3];
  geo::View_t dumv;

  geo->CellInfo(answer.first.plane, answer.first.cell, &dumv, cellcenter, dum);
  answer.first.fcell  = (tp.X() - cellcenter[0])/meancellsep;
  answer.first.fplane = (tp.Z() - cellcenter[2])/meanplanesep;

  // Could optimize this by only checking the nearest two planes to the one
  // found above, but I bet that geo::CellInfo is the hot spot, not
  // std::upper_bound.
  answer.second = get_int_plane_and_cell(tp.X(), tp.Y(), tp.Z(), geo::kY);

  geo->CellInfo(answer.second.plane, answer.second.cell, &dumv, cellcenter, dum);
  answer.second.fcell =  (tp.Y() - cellcenter[1])/meancellsep;
  answer.second.fplane = (tp.Z() - cellcenter[2])/meanplanesep;

  return answer;
}

static cppoint noe::get_int_plane_and_cell ( const double  x, const double  y, const double  z, const geo::View_t  view  )

static

Definition at line 141 of file noe_module.cc.

References add(), cppoint::cell, stan::math::fabs(), geo::kX, python.hepunit::pi, cppoint::plane, confusionMatrixTree::t, ycell_y, yplane_z, and test::z.

Referenced by cart_to_cp().

{
  cppoint ans;

  // (1) First the plane
  {
    vector<float> & tplane_z = view == geo::kX?xplane_z:yplane_z;

    const vector<float>::iterator pi
      = std::upper_bound(tplane_z.begin(), tplane_z.end(), z);

    const int add = (view == geo::kX);

    if(pi == tplane_z.end()){
      // No plane had as big a 'z' as this, so use the last plane.
      ans.plane = (tplane_z.size()-1) * 2 + add;
    }
    else if(pi == tplane_z.begin()){
      // 'z' was smaller than the first plane, so that's the closest.
      ans.plane = add;
    }
    else{
      // Check which is closer, the first plane bigger than 'z', or the
      // previous one.
      const float thisone  = fabs( *pi - z);
      const float previous = fabs( *(pi - 1) - z);
      if(thisone < previous) ans.plane = (pi - tplane_z.begin())*2 + add;
      else                   ans.plane = (pi - tplane_z.begin())*2 + add - 2;
    }
  }

  // (2) Now find the cell
  {
    vector<float> & cells = (view == geo::kX? xcell_x:ycell_y)[ans.plane/2];

    const float t = (view == geo::kX? x: y);
    const vector<float>::iterator ci
      = std::upper_bound(cells.begin(), cells.end(), t);

    if(ci == cells.end()){
      // No cell had as big a 't' as this, so use the last cell.
      ans.cell = cells.size()-1;
    }
    else if(ci == cells.begin()){
      // 't' was smaller than the first cell, so that's the closest.
      ans.cell = 0;
    }
    else{
      // Check which is closer
      const float thisone  = fabs( *ci - t);
      const float previous = fabs( *(ci - 1) - t);
      if(thisone < previous) ans.cell = (ci - cells.begin());
      else                   ans.cell = (ci - cells.begin()) - 1;
    }
  }

  return ans;
}

Variable Documentation

vector< vector<float> > noe::xcell_x

static

Definition at line 136 of file noe_module.cc.

vector< vector<float> > noe::xcell_z

static

Definition at line 132 of file noe_module.cc.

vector<float> noe::xplane_z

static

Definition at line 134 of file noe_module.cc.

vector< vector<float> > noe::ycell_y

static

Definition at line 137 of file noe_module.cc.

Referenced by build_cell_lookup_table(), and get_int_plane_and_cell().

vector< vector<float> > noe::ycell_z

static

Definition at line 133 of file noe_module.cc.

Referenced by build_cell_lookup_table().

vector<float> noe::yplane_z

static

Definition at line 135 of file noe_module.cc.

Referenced by build_cell_lookup_table(), and get_int_plane_and_cell().