cnn::RegPixelMap Class Reference

RegPixelMap, basic input to CNN neural net. More...

#include <RegPixelMap.h>

Public Member Functions
	RegPixelMap (unsigned int nWire, unsigned int nWRes, unsigned int nTdc, unsigned int nTRes, const RegCNNBoundary &bound, const bool &prongOnly)
	RegPixelMap ()
unsigned int	NWire () const
	Length in wires. More...
unsigned int	NWRes () const
	Number of Merged wires. More...
unsigned int	NTdc () const
	Width in tdcs. More...
unsigned int	NTRes () const
	Number of Merged tdcs. More...
unsigned int	NPixel () const
	Total number of pixels in map. More...
RegCNNBoundary	Bound () const
	Map boundary. More...
unsigned int	NInput () const
	Number of inputs for the neural net. More...
void	FillInputVector (float *input) const
void	Add (const int &wire, const int &tdc, const unsigned int &view, const double &pe, const unsigned int &tpc, int hit_prong_tag)
void	GetTPC (const int &wire, const int &tdc, const unsigned int &view, const unsigned int &tpc)
unsigned int	GlobalToIndex (const int &wire, const int &tdc, const unsigned int &view)
	Take global wire, tdc (detector) and return index in fPE vector. More...
unsigned int	LocalToIndex (const unsigned int &wire, const unsigned int &tdc) const
	Take local wire, tdc (within map) and return index in fPE vector. More...
unsigned int	GlobalToIndexSingle (const int &wire, const int &tdc, const unsigned int &view)
	Take global wire, tdc (detector) and return index in fPE vector. More...
void	Print ()
TH2F *	ToTH2 () const
	Return the pixel map as a 2D histogram for visualization. More...
TH2F *	ToLabTH2 () const
TH2F *	SingleViewToTH2 (const unsigned int &view) const
void	Finish ()

Public Attributes
unsigned int	fNWire
	Number of wires, length of pixel map. More...
unsigned int	fNWRes
unsigned int	fNTdc
	Number of tdcs, width of pixel map. More...
unsigned int	fNTRes
unsigned int	fInPM
unsigned int	fTPC
double	fdist
std::vector< float >	fPE
	Vector of PE measurements for pixels. More...
std::vector< float >	fPEX
	Vector of X PE measurements for pixels. More...
std::vector< float >	fPEY
	Vector of Y PE measurements for pixels. More...
std::vector< float >	fPEZ
	Vector of Y PE measurements for pixels. More...
std::vector< double >	fPur
	Vector of purity for pixels. More...
std::vector< double >	fPurX
	Vector of X purity for pixels. More...
std::vector< double >	fPurY
	Vector of Y purity for pixels. More...
std::vector< double >	fPurZ
	Vector of Y purity for pixels. More...
std::vector< HitType >	fLab
	Vector of Truth labels for pixels. More...
std::vector< HitType >	fLabX
	Vector of X Truth labels for pixels. More...
std::vector< HitType >	fLabY
	Vector of Y Truth labels for pixels. More...
std::vector< HitType >	fLabZ
	Vector of Y Truth labels for pixels. More...
RegCNNBoundary	fBound
bool	fProngOnly
std::vector< int >	fProngTagX
std::vector< int >	fProngTagY
std::vector< int >	fProngTagZ

Detailed Description

RegPixelMap, basic input to CNN neural net.

Definition at line 22 of file RegPixelMap.h.

Constructor & Destructor Documentation

cnn::RegPixelMap::RegPixelMap	(	unsigned int	nWire,
		unsigned int	nWRes,
		unsigned int	nTdc,
		unsigned int	nTRes,
		const RegCNNBoundary &	bound,
		const bool &	prongOnly
	)

Definition at line 18 of file RegPixelMap.cxx.

                                                                                                    :
  fNWire(nWire),
  fNWRes(nWRes),
  fNTdc(nTdc),
  fNTRes(nTRes),
  fInPM(0),
  fTPC(0),
  fdist(100000),
  fPE(nWire*nTdc),
  fPEX(nWire*nTdc),
  fPEY(nWire*nTdc),
  fPEZ(nWire*nTdc),
  fPur(nWire*nTdc),
  fPurX(nWire*nTdc),
  fPurY(nWire*nTdc),
  fPurZ(nWire*nTdc),
  fLab(nWire*nTdc),
  fLabX(nWire*nTdc),
  fLabY(nWire*nTdc),
  fLabZ(nWire*nTdc),
  fBound(bound),
  fProngOnly(prongOnly),
  fProngTagX(nWire*nTdc),
  fProngTagY(nWire*nTdc),
  fProngTagZ(nWire*nTdc)
  {
      std::cout<<"here :"<<fNWire<<", "<<fNTdc<<", "<<fNWRes<<", "<<fNTRes<<std::endl;
  }

cnn::RegPixelMap::RegPixelMap ( )

inline

Definition at line 26 of file RegPixelMap.h.

{};

Member Function Documentation

void cnn::RegPixelMap::Add	(	const int &	wire,
		const int &	tdc,
		const unsigned int &	view,
		const double &	pe,
		const unsigned int &	tpc,
		int	hit_prong_tag
	)

Add a hit to the map if it is contained within the wire, tdc rcnne Could be expanded later to add to overflow accordingly.

Definition at line 60 of file RegPixelMap.cxx.

  {
    // keep these for now although we only use fPE
    const HitType label = kEmptyHit;
    const double purity=0.0;
    if(fBound.IsWithin(wire, tdc, view)){
      fInPM = 1; // any hit within the boundary
      GetTPC(wire, tdc, view, tpc);
      fPE[GlobalToIndex(wire, tdc, view)] += (float)pe;
      fLab[GlobalToIndex(wire,tdc, view)] = label;
      fPur[GlobalToIndex(wire,tdc, view)] = purity;
      if(view==0){
            fPEX[GlobalToIndexSingle(wire,tdc, view)] += (float)pe;
        fProngTagX[GlobalToIndexSingle(wire, tdc, view)] = hit_prong_tag;
            fLabX[GlobalToIndexSingle(wire,tdc, view)] = label;
            fPurX[GlobalToIndexSingle(wire,tdc, view)] = purity;
        // FIXIT
        //if (pe!=0) {
        //    std::cout<<view<<" | ";
        //    std::cout<<wire<<", "<<tdc<<", "<<GlobalToIndexSingle(wire,tdc,view)<<", "<<pe<<std::endl;
        //}
      }
      if(view==1){
            fPEY[GlobalToIndexSingle(wire,tdc, view)] += (float)pe;
        fProngTagY[GlobalToIndexSingle(wire, tdc, view)] = hit_prong_tag;
            fLabY[GlobalToIndexSingle(wire,tdc, view)] = label;
            fPurY[GlobalToIndexSingle(wire,tdc, view)] = purity;
      }
     if(view==2){
            fPEZ[GlobalToIndexSingle(wire,tdc, view)] += (float)pe;
        fProngTagZ[GlobalToIndexSingle(wire, tdc, view)] = hit_prong_tag;
            fLabZ[GlobalToIndexSingle(wire,tdc, view)] = label;
            fPurZ[GlobalToIndexSingle(wire,tdc, view)] = purity;
        //std::cout << "Q = " << pe << " " << fPEZ[GlobalToIndexSingle(wire,tdc, view)] << std::endl;
      }
   }
  }

RegCNNBoundary cnn::RegPixelMap::Bound ( ) const

inline

Map boundary.

Definition at line 44 of file RegPixelMap.h.

{return fBound;};

void cnn::RegPixelMap::FillInputVector

(

float *

input

)

const

Definition at line 48 of file RegPixelMap.cxx.

  {
    unsigned int i = 0;

    for(const auto& pe:fPE){
      input[i] = pe;
      ++i;
    }

  }

void cnn::RegPixelMap::Finish

(

)

Definition at line 98 of file RegPixelMap.cxx.

                           {
      // fProngOnly=True means only the primary prong is selected to creat pixel maps 
      //            and that prong needs to be either a muon or antimuon (FIXIT)?
      // Caveat 1: the prong tag of that pixel is determined by the track id of the track 
      //         associlated with the last hit that associated with that pixel. It means
      //         if this pixel-associated hits belong to different prongs, we could 
      //         either add deposited energy from other prongs (if other prongs' hit is
      //         in the front), or throw the energy from primary prong away (if there is
      //         one or more hits from other prongs in the last). A better way could be 
      //         determining the prong tag by looping the hits, instead of the pixels. 
      //         That means we should create a new pixel map only with the spacepoints 
      //         associated with the primary prong, instead of using the prong tag
      //         (little effect on the results, ignored for now)
      if (fProngOnly) {
          std::cout<<"Do Prong Only selection ......"<<std::endl;
          for (unsigned int i_p= 0; i_p< fPE.size(); ++i_p) {
              if (fProngTagX[i_p] != 0)
                  fPEX[i_p] = 0;
              if (fProngTagY[i_p] != 0)
                  fPEY[i_p] = 0;
              if (fProngTagZ[i_p] != 0)
                  fPEZ[i_p] = 0;
          } // end of i_p
      } // end of fProngOnly
  }

void cnn::RegPixelMap::GetTPC	(	const int &	wire,
		const int &	tdc,
		const unsigned int &	view,
		const unsigned int &	tpc
	)

Definition at line 182 of file RegPixelMap.cxx.

  {

    //int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view))/2;
    int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view)+(int)fNWRes)/2;
    int meanTDC  = (fBound.LastTDC(view)+fBound.FirstTDC(view)+(int)fNTRes/2)/2;
    double dist = pow((wire-meanWire)*0.5,2)+pow((tdc-meanTDC)*0.08,2);
    dist = sqrt(dist);
    if (dist < fdist){
        fdist = dist;
        fTPC = tpc;
    }
  }

unsigned int cnn::RegPixelMap::GlobalToIndex	(	const int &	wire,
		const int &	tdc,
		const unsigned int &	view
	)

Take global wire, tdc (detector) and return index in fPE vector.

Definition at line 124 of file RegPixelMap.cxx.

  {

    //int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view))/2;
    int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view)+(int)fNWRes)/2;
    int meanTDC  = (fBound.LastTDC(view)+fBound.FirstTDC(view)+(int)fNTRes/2)/2;

    //unsigned int internalWire = (unsigned int)( (wire-meanWire) + fNWire/2 );
    unsigned int internalWire = (unsigned int)(round((float)((unsigned int)(wire-meanWire)+fNWire*fNWRes/2)/(float)fNWRes) );
    //unsigned int internalTdc  = (unsigned int)( round((float)(tdc-meanTDC)/(float)fNTRes + fNTdc/2) );
    unsigned int internalTdc  = (unsigned int)( round((float)((unsigned int)(tdc-meanTDC)+fNTdc*fNTRes/2)/(float)fNTRes) );

    unsigned int index = internalWire * fNTdc + internalTdc % fNTdc;
   
    //if (internalTdc <1.1){
    //std::cout << "====> " << meanWire <<" " << meanTDC << " " << internalWire << " " << internalTdc << " " << index << std::endl;
    //std::cout << "    => " << wire << " " << tdc << " " << wire-meanWire << " " << round((float)(tdc-meanTDC)/(float)fNTRes) << std::endl;
    //}
    assert(index < fPE.size());
    return index;
  }

unsigned int cnn::RegPixelMap::GlobalToIndexSingle	(	const int &	wire,
		const int &	tdc,
		const unsigned int &	view
	)

Take global wire, tdc (detector) and return index in fPE vector.

Definition at line 157 of file RegPixelMap.cxx.

  {

    //int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view))/2;
    int meanWire = (fBound.LastWire(view)+fBound.FirstWire(view)+(int)fNWRes/2)/2;
    int meanTDC  = (fBound.LastTDC(view)+fBound.FirstTDC(view)+(int)fNTRes/2)/2;

    //unsigned int internalWire = (unsigned int)( (wire-meanWire) + fNWire/2 );
    //unsigned int internalWire = (unsigned int)( round((float)((unsigned int)(wire-meanWire)+fNWire*fNWRes/2)/(float)fNWRes) );
    unsigned int internalWire = (unsigned int)(round((float)(wire - meanWire + fNWire*fNWRes/2)/(float)fNWRes));

    //unsigned int internalTdc  = (unsigned int)( round( (float)(tdc-meanTDC)/(float)fNTRes + fNTdc/2) );
    //unsigned int internalTdc  = (unsigned int)( round((float)((unsigned int)(tdc-meanTDC)+fNTdc*fNTRes/2)/(float)fNTRes) );
    unsigned int internalTdc  = (unsigned int)(round((float)(tdc - meanTDC + fNTdc*fNTRes/2)/(float)fNTRes));

    unsigned int index = internalWire * fNTdc + internalTdc % fNTdc;

    assert(index < fPEX.size());

    return index;
  }

unsigned int cnn::RegPixelMap::LocalToIndex	(	const unsigned int &	wire,
		const unsigned int &	tdc
	)		const

Take local wire, tdc (within map) and return index in fPE vector.

Definition at line 148 of file RegPixelMap.cxx.

  {
    unsigned int index = wire * fNTdc + tdc % fNTdc;

    assert(index < fPE.size());
    return index;
  }

unsigned int cnn::RegPixelMap::NInput ( ) const

inline

Number of inputs for the neural net.

Definition at line 47 of file RegPixelMap.h.

{return NPixel();};

unsigned int cnn::RegPixelMap::NPixel ( ) const

inline

Total number of pixels in map.

Definition at line 41 of file RegPixelMap.h.

{return fPE.size();};

unsigned int cnn::RegPixelMap::NTdc ( ) const

inline

Width in tdcs.

Definition at line 35 of file RegPixelMap.h.

{return fNTdc;};

unsigned int cnn::RegPixelMap::NTRes ( ) const

inline

Number of Merged tdcs.

Definition at line 38 of file RegPixelMap.h.

{return fNTRes;};

unsigned int cnn::RegPixelMap::NWire ( ) const

inline

Length in wires.

Definition at line 29 of file RegPixelMap.h.

{return fNWire;};

unsigned int cnn::RegPixelMap::NWRes ( ) const

inline

Number of Merged wires.

Definition at line 32 of file RegPixelMap.h.

{return fNWRes;};

void cnn::RegPixelMap::Print

(

)

Draw pixel map to the screen. This is pretty hokey and the aspect ratio is totally unrealistic.

Definition at line 201 of file RegPixelMap.cxx.

  {

    // Start by doing even wires
    for(unsigned int iTdc = 0; iTdc < fNTdc; ++iTdc)
    {
      for(unsigned int iWire = 0; iWire < fNWire; iWire += 2)
      {
        unsigned int index = LocalToIndex(iWire, iTdc);
        if( fPE[index] > 0)
        {
          std::cout << "*";
        }
        else
        {
          std::cout << " ";
        }

      }
      std::cout << std::endl;
    }
    // Then do odd wires
    for(unsigned int iTdc = 0; iTdc < fNTdc; ++iTdc)
    {
      for(unsigned int iWire = 1; iWire < fNWire; iWire += 2)
      {
        unsigned int index = LocalToIndex(iWire, iTdc);
        if( fPE[index] > 0)
        {
          std::cout << "*";
        }
        else
        {
          std::cout << " ";
        }

      }
      std::cout << std::endl;
    }

  }

TH2F * cnn::RegPixelMap::SingleViewToTH2

(

const unsigned int &

view

)

const

Definition at line 283 of file RegPixelMap.cxx.

  {

    // Create a histogram
    TH2F* hist = new TH2F("RegPixelMap", ";Wire;Tdc", fNWire, 0, fNWire,
                                                      fNTdc, 0, fNTdc);

    for(unsigned int iWire = 0; iWire < fNWire; ++iWire)
    {
      for(unsigned int iTdc = 0; iTdc < fNTdc; ++iTdc)
      {
        // Add 1 to in each bin to skip underflow
        if(view==0){
        hist->SetBinContent(iWire+1, iTdc + 1,
                            fPEX[LocalToIndex(iWire, iTdc)]);
        // FIXIT
        //if(fPEX[LocalToIndex(iWire, iTdc)]!=0) {
        //    std::cout<<iWire<<", "<<iTdc<<", "<<fPEX[LocalToIndex(iWire, iTdc)]/500<<std::endl;
        //}
        }
        if(view==1){
        hist->SetBinContent(iWire+1, iTdc + 1,
                            fPEY[LocalToIndex(iWire, iTdc)]);
        }
        if(view==2){
          hist->SetBinContent(iWire+1, iTdc + 1,
                              fPEZ[LocalToIndex(iWire, iTdc)]);
        }
      }
    }
    return hist;
  }

TH2F * cnn::RegPixelMap::ToLabTH2

(

)

const

Definition at line 263 of file RegPixelMap.cxx.

  {

    // Create a histogram, use twice as many tdcs to distinguish views
    TH2F* hist = new TH2F("RegPixelMap", ";Wire;Tdc", fNWire, 0, fNWire,
                                                      fNTdc*3, 0, fNTdc*3);

    for(unsigned int iWire = 0; iWire < fNWire; ++iWire)
    {
      for(unsigned int iTdc = 0; iTdc < fNTdc; ++iTdc)
      {
        // Add 1 to in each bin to skip underflow
        hist->SetBinContent(iWire+1, iTdc + fNTdc*(iWire%3) + 1,
                            (double)fLab[LocalToIndex(iWire, iTdc)]);

      }
    }
    return hist;
  }

TH2F * cnn::RegPixelMap::ToTH2

(

)

const

Return the pixel map as a 2D histogram for visualization.

Definition at line 243 of file RegPixelMap.cxx.

  {

    // Create a histogram, use twice as many tdcs to distinguish views
    TH2F* hist = new TH2F("RegPixelMap", ";Wire;Tdc", fNWire, 0, fNWire,
                                                      fNTdc*3, 0, fNTdc*3);

    for(unsigned int iWire = 0; iWire < fNWire; ++iWire)
    {
      for(unsigned int iTdc = 0; iTdc < fNTdc; ++iTdc)
      {
        // Add 1 to in each bin to skip underflow
        hist->SetBinContent(iWire+1, iTdc + fNTdc*(iWire%3) + 1,
                            fPE[LocalToIndex(iWire, iTdc)]);

      }
    }
    return hist;
  }

Member Data Documentation

RegCNNBoundary cnn::RegPixelMap::fBound

Definition at line 104 of file RegPixelMap.h.

double cnn::RegPixelMap::fdist

Definition at line 90 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fInPM

Definition at line 88 of file RegPixelMap.h.

std::vector<HitType> cnn::RegPixelMap::fLab

Vector of Truth labels for pixels.

Definition at line 99 of file RegPixelMap.h.

std::vector<HitType> cnn::RegPixelMap::fLabX

Vector of X Truth labels for pixels.

Definition at line 100 of file RegPixelMap.h.

std::vector<HitType> cnn::RegPixelMap::fLabY

Vector of Y Truth labels for pixels.

Definition at line 101 of file RegPixelMap.h.

std::vector<HitType> cnn::RegPixelMap::fLabZ

Vector of Y Truth labels for pixels.

Definition at line 102 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fNTdc

Number of tdcs, width of pixel map.

Definition at line 86 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fNTRes

Definition at line 87 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fNWire

Number of wires, length of pixel map.

Definition at line 84 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fNWRes

Definition at line 85 of file RegPixelMap.h.

std::vector<float> cnn::RegPixelMap::fPE

Vector of PE measurements for pixels.

Definition at line 91 of file RegPixelMap.h.

std::vector<float> cnn::RegPixelMap::fPEX

Vector of X PE measurements for pixels.

Definition at line 92 of file RegPixelMap.h.

std::vector<float> cnn::RegPixelMap::fPEY

Vector of Y PE measurements for pixels.

Definition at line 93 of file RegPixelMap.h.

std::vector<float> cnn::RegPixelMap::fPEZ

Vector of Y PE measurements for pixels.

Definition at line 94 of file RegPixelMap.h.

bool cnn::RegPixelMap::fProngOnly

Definition at line 105 of file RegPixelMap.h.

std::vector<int> cnn::RegPixelMap::fProngTagX

Definition at line 106 of file RegPixelMap.h.

std::vector<int> cnn::RegPixelMap::fProngTagY

Definition at line 107 of file RegPixelMap.h.

std::vector<int> cnn::RegPixelMap::fProngTagZ

Definition at line 108 of file RegPixelMap.h.

std::vector<double> cnn::RegPixelMap::fPur

Vector of purity for pixels.

Definition at line 95 of file RegPixelMap.h.

std::vector<double> cnn::RegPixelMap::fPurX

Vector of X purity for pixels.

Definition at line 96 of file RegPixelMap.h.

std::vector<double> cnn::RegPixelMap::fPurY

Vector of Y purity for pixels.

Definition at line 97 of file RegPixelMap.h.

std::vector<double> cnn::RegPixelMap::fPurZ

Vector of Y purity for pixels.

Definition at line 98 of file RegPixelMap.h.

unsigned int cnn::RegPixelMap::fTPC

Definition at line 89 of file RegPixelMap.h.

---

The documentation for this class was generated from the following files:

• dunereco/dunereco/RegCNN/func/RegPixelMap.h
• dunereco/dunereco/RegCNN/func/RegPixelMap.cxx