gar::geo::seg::SegmentationMultiGridStripXYAlg Class Reference

#include <SegmentationMultiGridStripXYAlg.h>

Inheritance diagram for gar::geo::seg::SegmentationMultiGridStripXYAlg:

Public Member Functions
	SegmentationMultiGridStripXYAlg (fhicl::ParameterSet const &pset)
	Default constructor used by derived classes passing the encoding string. More...
	SegmentationMultiGridStripXYAlg (const BitFieldCoder *decoder, fhicl::ParameterSet const &pset)
	Default constructor used by derived classes passing an existing decoder. More...
	~SegmentationMultiGridStripXYAlg ()
void	reconfigure (fhicl::ParameterSet const &pset) override
void	Initialize (const gar::geo::GeometryCore &geo) override
std::array< double, 3 >	GetPosition (const gar::geo::GeometryCore &geo, const gar::raw::CellID_t &cID) const override
gar::raw::CellID_t	GetCellID (const gar::geo::GeometryCore &geo, const unsigned int &det_id, const unsigned int &stave, const unsigned int &module, const unsigned int &layer, const unsigned int &slice, const std::array< double, 3 > &localPosition) const override
	determine the cell ID based on the position More...
bool	isTile (const gar::raw::CellID_t &cID) const override
bool	isBarrel (const gar::raw::CellID_t &cID) const override
double	getStripLength (const gar::geo::GeometryCore &geo, const std::array< double, 3 > &local, const gar::raw::CellID_t &cID) const override
std::pair< TVector3, TVector3 >	getStripEnds (const gar::geo::GeometryCore &geo, const std::array< double, 3 > &local, const gar::raw::CellID_t &cID) const override
std::pair< float, float >	CalculateLightPropagation (const gar::geo::GeometryCore &geo, const std::array< double, 3 > &local, const gar::raw::CellID_t &cID) const override
std::array< double, 3 >	ReconstructStripHitPosition (const gar::geo::GeometryCore &geo, const std::array< double, 3 > &local, const float &xlocal, const gar::raw::CellID_t &cID) const override
const double &	gridSizeX () const override
const double &	gridSizeY () const
const double &	stripSizeX () const override
const double &	stripSizeY () const
const double &	offsetX () const
const double &	offsetY () const
const double &	layerDimX () const
const double &	layerDimY () const
const std::string &	fieldNameX () const
const std::string &	fieldNameY () const
const std::string &	fieldNameLayer () const
const std::string &	fieldNameSlice () const
const unsigned int &	nLayers () const override
void	setGridSizeX (double cellSize)
void	setGridSizeY (double cellSize)
void	setStripSizeX (double stripSize)
void	setStripSizeY (double stripSize)
void	setOffsetX (double offset)
void	setOffsetY (double offset)
void	setFieldNameX (const std::string &fieldName)
void	setFieldNameY (const std::string &fieldName)
void	setFieldNameLayer (const std::string &fieldName)
void	setFieldNameSlice (const std::string &fieldName)
void	setLayerDimXY (const double &dimX, const double &dimY) const override
void	setVariables (const double &innerangle, const double &endcapsidelength) const override
Public Member Functions inherited from gar::geo::seg::SegmentationAlg
virtual	~SegmentationAlg ()
virtual const std::string &	name () const
virtual void	setName (const std::string &value)
virtual const std::string &	type () const
virtual const std::string &	description () const
virtual const BitFieldCoder *	decoder () const
virtual const unsigned int &	nPlanes () const
virtual const std::string &	cellEncoding () const
virtual void	setDecoder (const BitFieldCoder *decoder)

Protected Member Functions
void	PrintParameters () const override
std::array< std::vector< unsigned int >, 2 >	TokenizeLayerVectors (std::vector< std::string > grid) const
Protected Member Functions inherited from gar::geo::seg::SegmentationAlg
	SegmentationAlg (fhicl::ParameterSet const &pset)
	SegmentationAlg (const BitFieldCoder *decoder, fhicl::ParameterSet const &pset)

Protected Attributes
double	_gridSizeX
	the grid size in X More...
double	_offsetX
	the coordinate offset in X More...
double	_gridSizeY
	the grid size in Y More...
double	_offsetY
	the coordinate offset in Y More...
std::string	_xId
	the field name used for X More...
std::string	_yId
	the field name used for Y More...
std::string	_layerId
	the field name used for layer More...
std::string	_sliceId
	the field name used for slice More...
std::string	_encoding
	the encoding string More...
double	_stripSizeX
	the strip size in X More...
double	_stripSizeY
	the strip size in Y More...
double	_frac
	fraction of tiles to remove at the edge More...
unsigned int	_nLayers
	number of layers More...
unsigned int	_active_slice
	active slice number More...
std::vector< std::string >	_gridBarrelLayers
	the layers (start::end) for grid in Barrel More...
std::vector< std::string >	_stripBarrelLayers
	the layers (start::end) for strips in Barrel More...
std::vector< std::string >	_gridEndcapLayers
	the layers (start::end) for grid in Endcap More...
std::vector< std::string >	_stripEndcapLayers
	the layers (start::end) for strips in Endcap More...
double	_layer_dim_X
	layer dimension in X More...
double	_layer_dim_Y
	layer dimension in Y More...
double	_InnerAngle
	Inner Angle. More...
double	_EndcapSideLength
	Endcap Side Length. More...
bool	_OnSameLayer
	are the strips on the same layer? More...
Protected Attributes inherited from gar::geo::seg::SegmentationAlg
std::string	_name
std::string	_type
std::string	_description
std::string	_encoding
double	_gridSizeX
double	_stripSizeX
unsigned int	_nLayers
unsigned int	_nPlanes
const BitFieldCoder *	_decoder = 0

Additional Inherited Members
Static Protected Member Functions inherited from gar::geo::seg::SegmentationAlg
static double	binToPosition (gar::raw::CellID_t bin, double cellSize, double offset=0)
static int	positionToBin (double position, double cellSize, double offset=0)

Detailed Description

Definition at line 18 of file SegmentationMultiGridStripXYAlg.h.

Constructor & Destructor Documentation

gar::geo::seg::SegmentationMultiGridStripXYAlg::SegmentationMultiGridStripXYAlg

(

fhicl::ParameterSet const &

pset

)

Default constructor used by derived classes passing the encoding string.

Definition at line 20 of file SegmentationMultiGridStripXYAlg.cxx.

            : SegmentationAlg(pset)
            {
                _type = "MultiGridStripXY";
                _description = "Cartesian segmentation in the local XY-plane, containing integer number of tiles/strips/cells";

                std::cout << "######### gar::geo::seg::SegmentationMultiGridStripXYAlg() " << std::endl ;

                this->reconfigure(pset);
            }

gar::geo::seg::SegmentationMultiGridStripXYAlg::SegmentationMultiGridStripXYAlg	(	const BitFieldCoder *	decoder,
		fhicl::ParameterSet const &	pset
	)

Default constructor used by derived classes passing an existing decoder.

Definition at line 33 of file SegmentationMultiGridStripXYAlg.cxx.

            : SegmentationAlg(decode, pset)
            {
                _type = "MultiGridStripXY";
                _description = "Cartesian segmentation in the local XY-plane, containing integer number of tiles/strips/cells";

                std::cout << "######### gar::geo::seg::SegmentationMultiGridStripXYAlg() " << std::endl ;

                this->reconfigure(pset);
            }

gar::geo::seg::SegmentationMultiGridStripXYAlg::~SegmentationMultiGridStripXYAlg

(

)

Definition at line 45 of file SegmentationMultiGridStripXYAlg.cxx.

            {
            }

Member Function Documentation

std::pair< float, float > gar::geo::seg::SegmentationMultiGridStripXYAlg::CalculateLightPropagation ( const gar::geo::GeometryCore &  geo, const std::array< double, 3 > &  local, const gar::raw::CellID_t &  cID  ) const

overridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 459 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                //Propagate the light to the SiPM on the side
                //convert c to mm/ns
                // c   = 29.9792458 cm/ns
                float c = (CLHEP::c_light * CLHEP::mm / CLHEP::ns) / CLHEP::cm; // in cm/ns
                //time1 is left SiPM
                float time1 = 0.;
                //time2 is right SiPM
                float time2 = 0.;
                //check if it is barrel or not
                bool isBarrel = this->isBarrel(cID);

                //Strip along X (local)
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 == 0) )
                {
                    if(isBarrel) {
                        time1 = ( _layer_dim_X / 2 + local[0] ) / c;
                        time2 = ( _layer_dim_X / 2 - local[0] ) / c;
                    } else {
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[0] - ( _EndcapSideLength / 2. )) / _stripSizeY );
                        if ( n < 0 ) n = 0;
                        float strip_dim = _layer_dim_X - ( n * ( _stripSizeY / std::tan(angle) ) );
                        time1 = ( strip_dim / 2. + local[0] ) / c;
                        time2 = ( strip_dim / 2. - local[0] ) / c;
                    }
                }

                //Strip along Y (local)
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice+1) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 != 0) )
                {
                    if(isBarrel) {
                        time1 = ( _layer_dim_Y / 2 + local[1] ) / c;
                        time2 = ( _layer_dim_Y / 2 - local[1] ) / c;
                    } else {
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[1] - ( _EndcapSideLength / 2. )) / _stripSizeX );
                        if ( n < 0 ) n = 0;
                        float strip_dim = _layer_dim_Y - ( n * ( _stripSizeX / std::tan(angle) ) );
                        time1 = ( strip_dim / 2. + local[1] ) / c;
                        time2 = ( strip_dim / 2. - local[1] ) / c;
                    }
                }

                return std::make_pair(time1, time2);
            }

const std::string& gar::geo::seg::SegmentationMultiGridStripXYAlg::fieldNameLayer ( ) const

inline

Definition at line 67 of file SegmentationMultiGridStripXYAlg.h.

{ return _layerId; }

const std::string& gar::geo::seg::SegmentationMultiGridStripXYAlg::fieldNameSlice ( ) const

inline

Definition at line 69 of file SegmentationMultiGridStripXYAlg.h.

{ return _sliceId; }

const std::string& gar::geo::seg::SegmentationMultiGridStripXYAlg::fieldNameX ( ) const

inline

Definition at line 63 of file SegmentationMultiGridStripXYAlg.h.

{ return _xId; }

const std::string& gar::geo::seg::SegmentationMultiGridStripXYAlg::fieldNameY ( ) const

inline

Definition at line 65 of file SegmentationMultiGridStripXYAlg.h.

{ return _yId; }

gar::raw::CellID_t gar::geo::seg::SegmentationMultiGridStripXYAlg::GetCellID ( const gar::geo::GeometryCore &  geo, const unsigned int &  det_id, const unsigned int &  stave, const unsigned int &  module, const unsigned int &  layer, const unsigned int &  slice, const std::array< double, 3 > &  localPosition  ) const

overridevirtual

determine the cell ID based on the position

Implements gar::geo::seg::SegmentationAlg.

Definition at line 210 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                gar::raw::CellID_t cID = 0;

                _decoder->set(cID, "system", det_id);
                _decoder->set(cID, "module", module);
                _decoder->set(cID, "stave", stave);
                _decoder->set(cID, "layer", layer);
                _decoder->set(cID, "slice", slice);

                //Need to differentiate case tile and strips based on layer and slice
                bool isTile = this->isTile(cID);

                double localX = localPosition[0];
                double localY = localPosition[1];

                if(isTile)
                {
                    _decoder->set(cID, _xId, positionToBin(localX, _gridSizeX, _offsetX));
                    _decoder->set(cID, _yId, positionToBin(localY, _gridSizeY, _offsetY));
                }
                else
                {
                    if( (_OnSameLayer && slice == _active_slice) || (not _OnSameLayer && layer%2 == 0) )
                    {
                        //Segmentation in Y
                        int nCellsX = 1;
                        int nCellsY = int(_layer_dim_Y / _stripSizeY);

                        int _cellIndexX = int ( localX / ( _layer_dim_X / nCellsX ) );
                        int _cellIndexY = int ( localY / ( _layer_dim_Y / nCellsY ) );

                        _decoder->set(cID, _xId, _cellIndexX);
                        _decoder->set(cID, _yId, _cellIndexY);
                    }

                    if( (_OnSameLayer && slice == _active_slice+1) || (not _OnSameLayer && layer%2 != 0) )
                    {
                        //Segmentation in X
                        int nCellsX = int(_layer_dim_X / _stripSizeX);
                        int nCellsY = 1;

                        int _cellIndexX = int ( localX / ( _layer_dim_X / nCellsX ) );
                        int _cellIndexY = int ( localY / ( _layer_dim_Y / nCellsY ) );

                        _decoder->set(cID, _xId, _cellIndexX);
                        _decoder->set(cID, _yId, _cellIndexY);
                    }
                }

                return cID;
            }

std::array< double, 3 > gar::geo::seg::SegmentationMultiGridStripXYAlg::GetPosition ( const gar::geo::GeometryCore &  geo, const gar::raw::CellID_t &  cID  ) const

overridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 92 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                //Local origin for the Barrel in the middle of the layer
                //Local origin for the Endcal at the corner of the full stave
                std::array<double, 3> cellPosition;

                //Need to differentiate case tile and strips based on layer and slice
                bool isTile = this->isTile(cID);
                bool isBarrel = this->isBarrel(cID);

                if(isTile) {
                    //Need to check if the tile is at the edge of the layer!
                    cellPosition[0] = binToPosition(_decoder->get(cID, _xId), _gridSizeX, _offsetX);
                    cellPosition[1] = binToPosition(_decoder->get(cID, _yId), _gridSizeY, _offsetY);
                    cellPosition[2] = 0.;

                    if( isBarrel ) {

                        //Check if the position is outside of the layer size
                        if( std::fabs(cellPosition[0]) > _layer_dim_X/2. ) {

                            cellPosition[0] = cellPosition[0] / std::fabs(cellPosition[0]) * ( _layer_dim_X - _frac ) / 2.;
                        }

                        if(std::fabs(cellPosition[1]) > _layer_dim_Y/2. ) {

                            cellPosition[1] = cellPosition[1] / std::fabs(cellPosition[1]) * ( _layer_dim_Y - _frac ) / 2.;
                        }
                    }

                    //TODO
                    //Problem here is that the full layer is the endcap stave, no "layer shape"
                    //the problem will occur for hits that are at the limit
                    //checking if x or y are over the layer dim does not work (as the stave is not a square/rectangle)
                    if( not isBarrel ) {

                        float r_point = std::sqrt( cellPosition[0]*cellPosition[0] + cellPosition[1]*cellPosition[1] );

                        //Check if the point is outside.... layer_dim_x = layer_dim_y = apothem
                        if(r_point > _layer_dim_Y) {

                            if( std::fabs(cellPosition[0]) < _EndcapSideLength / 2. || std::fabs(cellPosition[1]) < _EndcapSideLength / 2. ) {

                                if( std::fabs(cellPosition[0]) < _EndcapSideLength / 2. && std::fabs(cellPosition[1]) > _layer_dim_Y ) {

                                    cellPosition[1] = cellPosition[1] / std::fabs(cellPosition[1]) * ( _layer_dim_Y - _frac ) ;
                                }

                                if( std::fabs(cellPosition[1]) < _EndcapSideLength / 2. && std::fabs(cellPosition[0]) > _layer_dim_X ) {

                                    cellPosition[0] = cellPosition[0] / std::fabs(cellPosition[0]) * ( _layer_dim_X - _frac ) ;
                                }

                            } else if ( std::fabs(cellPosition[0]) > _EndcapSideLength / 2. && std::fabs(cellPosition[1]) > _EndcapSideLength / 2. ) {
                                //Complicated part //do NOTHING the hit will be dropped
                            }
                        }
                    }
                }
                else
                {
                    int cellIndexX = _decoder->get(cID,_xId);
                    int cellIndexY = _decoder->get(cID,_yId);

                    if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 == 0) )
                    {
                        //Segmentation in Y
                        int nCellsX = 1;
                        // int nCellsY = int(_layer_dim_Y / _stripSizeY);

                        if(isBarrel) {
                            cellPosition[0] = ( cellIndexX + 0.5 ) * (_layer_dim_X / nCellsX ) - (_layer_dim_X / 2.);
                            cellPosition[1] = ( cellIndexY + 0.5 ) * _stripSizeY;
                            cellPosition[2] = 0.;
                        }
                        else {
                            cellPosition[1] = ( cellIndexY + 0.5 ) * _stripSizeY;
                            cellPosition[0] = ( cellIndexX + 0.5 ) * ( _layer_dim_X / nCellsX );
                            if( cellPosition[1] > _EndcapSideLength / 2.) {
                                //Correct for the endcap
                                float angle = _InnerAngle - M_PI/2;
                                int n = std::round( ( cellPosition[1] - ( _EndcapSideLength / 2. ) ) / _stripSizeX );
                                cellPosition[0] -= n * ( _stripSizeX / std::tan(angle) ) / 2.;
                            }
                            cellPosition[2] = 0.;
                        }
                    }

                    if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice+1) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 != 0) )
                    {
                        //Segmentation in X
                        // int nCellsX = int(_layer_dim_X / _stripSizeX);
                        int nCellsY = 1;

                        if(isBarrel) {
                            cellPosition[0] = ( cellIndexX + 0.5 ) * _stripSizeX;
                            cellPosition[1] = ( cellIndexY + 0.5 ) * (_layer_dim_Y / nCellsY ) - (_layer_dim_Y / 2.);
                            cellPosition[2] = 0.;
                        }
                        else {
                            cellPosition[0] = ( cellIndexX + 0.5 ) * _stripSizeX;
                            cellPosition[1] = ( cellIndexY + 0.5 ) * ( _layer_dim_Y / nCellsY );
                            if( cellPosition[0] > _EndcapSideLength / 2.) {
                                //Correct for the endcap
                                float angle = _InnerAngle - M_PI/2;
                                int n = std::round( ( cellPosition[0] - ( _EndcapSideLength / 2. ) ) / _stripSizeY );
                                cellPosition[1] -= n * ( _stripSizeY / std::tan(angle) ) / 2.;
                            }
                            cellPosition[2] = 0.;
                        }
                    }
                }

                return cellPosition;
            }

std::pair< TVector3, TVector3 > gar::geo::seg::SegmentationMultiGridStripXYAlg::getStripEnds ( const gar::geo::GeometryCore &  geo, const std::array< double, 3 > &  local, const gar::raw::CellID_t &  cID  ) const

overridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 407 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                //Local origin for the Barrel in the middle of the layer
                //Local origin for the Endcal at the corner of the full stave
                TVector3 stripEnd1(0., 0., 0.);
                TVector3 stripEnd2(0., 0., 0.);
                bool isBarrel = this->isBarrel(cID);

                //Strip along X (local)
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 == 0) ) {

                    if(isBarrel) {
                        stripEnd1.SetX(-_layer_dim_X/2.);
                        stripEnd2.SetX(_layer_dim_X/2.);
                    } else {
                        stripEnd1.SetX(0.);
                        //not perfect at the edges...
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[1] - ( _EndcapSideLength / 2. )) / _stripSizeX );
                        if ( n < 0 ) n = 0;
                        stripEnd2.SetX( _layer_dim_X - ( n * ( _stripSizeX / std::tan(angle) ) ) );
                    }

                    stripEnd1.SetY(local[1]);
                    stripEnd2.SetY(local[1]);
                    stripEnd1.SetZ(local[2]);
                    stripEnd2.SetZ(local[2]);
                }
                //Strip along Y (local)
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice+1) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 != 0) ) {

                    if(isBarrel) {
                        stripEnd1.SetY(-_layer_dim_Y/2.);
                        stripEnd2.SetY(_layer_dim_Y/2.);
                    } else {
                        stripEnd1.SetY(0.);
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[0] - (_EndcapSideLength / 2.) ) / _stripSizeY );
                        if ( n < 0 ) n = 0;
                        stripEnd2.SetY( _layer_dim_Y - ( n * ( _stripSizeY / std::tan(angle) ) ) );//not perfect at the edges...
                    }

                    stripEnd1.SetX(local[0]);
                    stripEnd2.SetX(local[0]);
                    stripEnd1.SetZ(local[2]);
                    stripEnd2.SetZ(local[2]);
                }

                return std::make_pair(stripEnd1, stripEnd2);
            }

double gar::geo::seg::SegmentationMultiGridStripXYAlg::getStripLength ( const gar::geo::GeometryCore &  geo, const std::array< double, 3 > &  local, const gar::raw::CellID_t &  cID  ) const

overridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 375 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                double stripLength = 0.;
                bool isBarrel = this->isBarrel(cID);

                //Strip along X
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 == 0) ) {
                    if(isBarrel) {
                        stripLength = _layer_dim_X;
                    } else {
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[1] - ( _EndcapSideLength / 2. )) / _stripSizeX );
                        if ( n < 0 ) n = 0;
                        stripLength = _layer_dim_X - ( n * ( _stripSizeX / std::tan(angle) ) );
                    }
                }
                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice+1) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 != 0) ) {
                    //Strip along Y
                    if(isBarrel) {
                        stripLength = _layer_dim_Y;
                    } else {
                        float angle = _InnerAngle - M_PI/2;
                        int n = std::round( (local[1] - ( _EndcapSideLength / 2. )) / _stripSizeY );
                        if ( n < 0 ) n = 0;
                        stripLength = _layer_dim_Y - ( n * ( _stripSizeY / std::tan(angle) ) );
                    }
                }

                return stripLength;
            }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::gridSizeX ( ) const

inlineoverridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 47 of file SegmentationMultiGridStripXYAlg.h.

{ return _gridSizeX; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::gridSizeY ( ) const

inline

Definition at line 49 of file SegmentationMultiGridStripXYAlg.h.

{ return _gridSizeY; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::Initialize ( const gar::geo::GeometryCore &  geo )

overridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 86 of file SegmentationMultiGridStripXYAlg.cxx.

            {

            }

bool gar::geo::seg::SegmentationMultiGridStripXYAlg::isBarrel ( const gar::raw::CellID_t &  cID ) const

overridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 363 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                bool isBarrel = true;

                int det_id = _decoder->get(cID, "system");
                int module = _decoder->get(cID, "module");
                if( det_id == 2 && (module == 0 || module == 6) ) isBarrel = false;

                return isBarrel;
            }

bool gar::geo::seg::SegmentationMultiGridStripXYAlg::isTile ( const gar::raw::CellID_t &  cID ) const

overridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 331 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                bool isTile = false;

                unsigned int det_id = _decoder->get(cID, "system");
                unsigned int layer = _decoder->get(cID, _layerId);

                std::array<std::vector<unsigned int>, 2> _list;

                if(det_id == 1)
                    _list = TokenizeLayerVectors(_gridBarrelLayers);
                if(det_id == 2)
                    _list =  TokenizeLayerVectors(_gridEndcapLayers);

                //Check if it is tile configuration
                for(unsigned int i = 0; i < _list.at(0).size(); i++)
                {
                    if( layer >= _list.at(0).at(i) && layer <= _list.at(1).at(i) )
                    {
                        // std::cout << layer << " " << _list.at(0).at(i) << " " << _list.at(1).at(i) << std::endl;
                        isTile = true;
                        break;
                    }
                    else{
                        continue;
                    }
                }

                return isTile;
            }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::layerDimX ( ) const

inline

Definition at line 59 of file SegmentationMultiGridStripXYAlg.h.

{ return _layer_dim_X; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::layerDimY ( ) const

inline

Definition at line 61 of file SegmentationMultiGridStripXYAlg.h.

{ return _layer_dim_Y; }

const unsigned int& gar::geo::seg::SegmentationMultiGridStripXYAlg::nLayers ( ) const

inlineoverridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 71 of file SegmentationMultiGridStripXYAlg.h.

{ return _nLayers; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::offsetX ( ) const

inline

Definition at line 55 of file SegmentationMultiGridStripXYAlg.h.

{ return _offsetX; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::offsetY ( ) const

inline

Definition at line 57 of file SegmentationMultiGridStripXYAlg.h.

{ return _offsetY; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::PrintParameters ( ) const

overrideprotectedvirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 264 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                std::cout << "cell encoding: " << _encoding << std::endl;
                std::cout << "identifier_x: " << _xId << std::endl;
                std::cout << "identifier_y: " << _yId << std::endl;
                std::cout << "grid_size_x: " << _gridSizeX << " cm" << std::endl;
                std::cout << "grid_size_y: " << _gridSizeY << " cm" << std::endl;
                std::cout << "strip_size_x: " << _stripSizeX << " cm" << std::endl;
                std::cout << "strip_size_y: " << _stripSizeY << " cm" << std::endl;
                std::cout << "offset_x: " << _offsetX << " cm" << std::endl;
                std::cout << "offset_y: " << _offsetY << " cm" << std::endl;

                std::cout << "identifier_layer: " << _layerId << std::endl;
                std::cout << "identifier_slice: " << _sliceId << std::endl;
                std::cout << "active slice: " << _active_slice << std::endl;
                std::cout << "nlayers: " << _nLayers << std::endl;

                std::cout << "grid_barrel_layers: ";
                for(unsigned int i = 0; i < _gridBarrelLayers.size(); i++)
                    std::cout << _gridBarrelLayers.at(i) << " ";
                std::cout << std::endl;

                std::cout << "strip_barrel_layers: ";
                for(unsigned int i = 0; i < _stripBarrelLayers.size(); i++)
                    std::cout << _stripBarrelLayers.at(i) << " ";
                std::cout << std::endl;

                std::cout << "grid_endcap_layers: ";
                for(unsigned int i = 0; i < _gridEndcapLayers.size(); i++)
                    std::cout << _gridEndcapLayers.at(i) << " ";
                std::cout << std::endl;

                std::cout << "strip_endcap_layers: ";
                for(unsigned int i = 0; i < _stripEndcapLayers.size(); i++)
                    std::cout << _stripEndcapLayers.at(i) << " ";
                std::cout << std::endl;

                std::cout << "strip_on_same_layer: " << _OnSameLayer << std::endl;
            }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::reconfigure ( fhicl::ParameterSet const &  pset )

overridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 50 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                _gridSizeX = pset.get<double>("grid_size_x");
                _gridSizeY = pset.get<double>("grid_size_y");

                _stripSizeX = pset.get<double>("strip_size_x");
                _stripSizeY = pset.get<double>("strip_size_y");
                _encoding = pset.get<std::string>("cellEncoding");

                _offsetX = pset.get<double>("offset_x");
                _offsetY = pset.get<double>("offset_y");

                _xId = pset.get<std::string>("identifier_x");
                _yId = pset.get<std::string>("identifier_y");
                _layerId = pset.get<std::string>("identifier_layer");
                _sliceId = pset.get<std::string>("identifier_slice");

                _gridBarrelLayers = pset.get< std::vector<std::string> >("grid_barrel_layers");
                _stripBarrelLayers = pset.get< std::vector<std::string> >("strip_barrel_layers");

                _gridEndcapLayers = pset.get< std::vector<std::string> >("grid_endcap_layers");
                _stripEndcapLayers = pset.get< std::vector<std::string> >("strip_endcap_layers");

                _nLayers = pset.get<unsigned int>("nlayers");
                _active_slice = pset.get<unsigned int>("active_slice");

                _frac = 1./3.;

                _OnSameLayer = pset.get<bool>("strip_on_same_layer");

                this->PrintParameters();

                return;
            }

std::array< double, 3 > gar::geo::seg::SegmentationMultiGridStripXYAlg::ReconstructStripHitPosition ( const gar::geo::GeometryCore &  geo, const std::array< double, 3 > &  local, const float &  xlocal, const gar::raw::CellID_t &  cID  ) const

overridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 508 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                float pos = xlocal;
                //Need to check if the local position is bigger than the strip length!
                bool isBarrel = this->isBarrel(cID);
                float stripLength = this->getStripLength(geo, local, cID);

                if(isBarrel) {
                    if( std::abs(pos) > stripLength / 2. ) pos = (pos > 0) ? stripLength / 2. : -stripLength / 2.;
                } else {
                    if( std::abs(pos) > stripLength ) pos = (pos > 0) ? stripLength : 0.;
                }

                std::array<double, 3> newlocal;

                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 == 0) )
                    newlocal = {pos, local[1], local[2]};

                if( (_OnSameLayer && _decoder->get(cID, _sliceId) == _active_slice+1) || (not _OnSameLayer && _decoder->get(cID, _layerId)%2 != 0) ) //Strip along Y
                    newlocal = {local[0], pos, local[2]};

                return newlocal;
            }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setFieldNameLayer ( const std::string &  fieldName )

inline

Definition at line 89 of file SegmentationMultiGridStripXYAlg.h.

{ _layerId = fieldName; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setFieldNameSlice ( const std::string &  fieldName )

inline

Definition at line 91 of file SegmentationMultiGridStripXYAlg.h.

{ _sliceId = fieldName; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setFieldNameX ( const std::string &  fieldName )

inline

Definition at line 85 of file SegmentationMultiGridStripXYAlg.h.

{ _xId = fieldName; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setFieldNameY ( const std::string &  fieldName )

inline

Definition at line 87 of file SegmentationMultiGridStripXYAlg.h.

{ _yId = fieldName; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setGridSizeX ( double  cellSize )

inline

Definition at line 73 of file SegmentationMultiGridStripXYAlg.h.

{ _gridSizeX = cellSize; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setGridSizeY ( double  cellSize )

inline

Definition at line 75 of file SegmentationMultiGridStripXYAlg.h.

{ _gridSizeY = cellSize; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setLayerDimXY ( const double &  dimX, const double &  dimY  ) const

inlineoverridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 93 of file SegmentationMultiGridStripXYAlg.h.

{ _layer_dim_X = dimX; _layer_dim_Y = dimY; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setOffsetX ( double  offset )

inline

Definition at line 81 of file SegmentationMultiGridStripXYAlg.h.

{ _offsetX = offset; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setOffsetY ( double  offset )

inline

Definition at line 83 of file SegmentationMultiGridStripXYAlg.h.

{ _offsetY = offset; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setStripSizeX ( double  stripSize )

inline

Definition at line 77 of file SegmentationMultiGridStripXYAlg.h.

{ _stripSizeX = stripSize; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setStripSizeY ( double  stripSize )

inline

Definition at line 79 of file SegmentationMultiGridStripXYAlg.h.

{ _stripSizeY = stripSize; }

void gar::geo::seg::SegmentationMultiGridStripXYAlg::setVariables ( const double &  innerangle, const double &  endcapsidelength  ) const

inlineoverridevirtual

Implements gar::geo::seg::SegmentationAlg.

Definition at line 95 of file SegmentationMultiGridStripXYAlg.h.

{ _InnerAngle = innerangle; _EndcapSideLength = endcapsidelength; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::stripSizeX ( ) const

inlineoverridevirtual

Reimplemented from gar::geo::seg::SegmentationAlg.

Definition at line 51 of file SegmentationMultiGridStripXYAlg.h.

{ return _stripSizeX; }

const double& gar::geo::seg::SegmentationMultiGridStripXYAlg::stripSizeY ( ) const

inline

Definition at line 53 of file SegmentationMultiGridStripXYAlg.h.

{ return _stripSizeY; }

std::array< std::vector< unsigned int >, 2 > gar::geo::seg::SegmentationMultiGridStripXYAlg::TokenizeLayerVectors ( std::vector< std::string >  grid ) const

protected

Definition at line 305 of file SegmentationMultiGridStripXYAlg.cxx.

            {
                std::vector<unsigned int> _gridFirst;
                std::vector<unsigned int> _gridLast;

                for(unsigned int i = 0; i < grid.size(); i++)
                {
                    std::vector<std::string> descriptors ;
                    Tokenizer t( descriptors ,':') ;

                    std::string value = grid.at(i);
                    std::for_each( value.begin(), value.end(), t ) ;

                    // std::cout << descriptors.size() << std::endl;
                    // for(unsigned int ii = 0; ii < descriptors.size(); ii++)
                    // std::cout << descriptors.at(ii) << std::endl;

                    _gridFirst.push_back(std::atoi(descriptors.at(0).c_str()));
                    _gridLast.push_back(std::atoi(descriptors.at(1).c_str()));
                }

                std::array<std::vector<unsigned int>, 2> _list = {{_gridFirst, _gridLast}};
                return _list;
            }

Member Data Documentation

unsigned int gar::geo::seg::SegmentationMultiGridStripXYAlg::_active_slice

protected

active slice number

Definition at line 130 of file SegmentationMultiGridStripXYAlg.h.

std::string gar::geo::seg::SegmentationMultiGridStripXYAlg::_encoding

protected

the encoding string

Definition at line 120 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_EndcapSideLength

mutableprotected

Endcap Side Length.

Definition at line 146 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_frac

protected

fraction of tiles to remove at the edge

Definition at line 126 of file SegmentationMultiGridStripXYAlg.h.

std::vector<std::string> gar::geo::seg::SegmentationMultiGridStripXYAlg::_gridBarrelLayers

protected

the layers (start::end) for grid in Barrel

Definition at line 132 of file SegmentationMultiGridStripXYAlg.h.

std::vector<std::string> gar::geo::seg::SegmentationMultiGridStripXYAlg::_gridEndcapLayers

protected

the layers (start::end) for grid in Endcap

Definition at line 136 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_gridSizeX

protected

the grid size in X

Definition at line 104 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_gridSizeY

protected

the grid size in Y

Definition at line 108 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_InnerAngle

mutableprotected

Inner Angle.

Definition at line 144 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_layer_dim_X

mutableprotected

layer dimension in X

Definition at line 140 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_layer_dim_Y

mutableprotected

layer dimension in Y

Definition at line 142 of file SegmentationMultiGridStripXYAlg.h.

std::string gar::geo::seg::SegmentationMultiGridStripXYAlg::_layerId

protected

the field name used for layer

Definition at line 116 of file SegmentationMultiGridStripXYAlg.h.

unsigned int gar::geo::seg::SegmentationMultiGridStripXYAlg::_nLayers

protected

number of layers

Definition at line 128 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_offsetX

protected

the coordinate offset in X

Definition at line 106 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_offsetY

protected

the coordinate offset in Y

Definition at line 110 of file SegmentationMultiGridStripXYAlg.h.

bool gar::geo::seg::SegmentationMultiGridStripXYAlg::_OnSameLayer

protected

are the strips on the same layer?

Definition at line 148 of file SegmentationMultiGridStripXYAlg.h.

std::string gar::geo::seg::SegmentationMultiGridStripXYAlg::_sliceId

protected

the field name used for slice

Definition at line 118 of file SegmentationMultiGridStripXYAlg.h.

std::vector<std::string> gar::geo::seg::SegmentationMultiGridStripXYAlg::_stripBarrelLayers

protected

the layers (start::end) for strips in Barrel

Definition at line 134 of file SegmentationMultiGridStripXYAlg.h.

std::vector<std::string> gar::geo::seg::SegmentationMultiGridStripXYAlg::_stripEndcapLayers

protected

the layers (start::end) for strips in Endcap

Definition at line 138 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_stripSizeX

protected

the strip size in X

Definition at line 122 of file SegmentationMultiGridStripXYAlg.h.

double gar::geo::seg::SegmentationMultiGridStripXYAlg::_stripSizeY

protected

the strip size in Y

Definition at line 124 of file SegmentationMultiGridStripXYAlg.h.

std::string gar::geo::seg::SegmentationMultiGridStripXYAlg::_xId

protected

the field name used for X

Definition at line 112 of file SegmentationMultiGridStripXYAlg.h.

std::string gar::geo::seg::SegmentationMultiGridStripXYAlg::_yId

protected

the field name used for Y

Definition at line 114 of file SegmentationMultiGridStripXYAlg.h.

---

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

• garsoft/Geometry/ChannelMapAlgs/SegmentationMultiGridStripXYAlg.h
• garsoft/Geometry/ChannelMapAlgs/SegmentationMultiGridStripXYAlg.cxx