CMApatterns Class Reference

#include <CMApatterns.h>

Inheritance diagram for CMApatterns:

Collaboration diagram for CMApatterns:

Public Types
typedef std::pair< float, float >	TRIGdistance
typedef std::list< CMAtrigger >	TRIGlist
typedef std::priority_queue< CMAtrigger >	TrigSigns

Public Member Functions
	CMApatterns (int, const CMAparameters *, unsigned long int)
	CMApatterns (const CMApatterns &)
CMApatterns	operator= (const CMApatterns &)
bool	operator== (const CMApatterns &) const
bool	operator!= (const CMApatterns &) const
bool	operator< (const CMApatterns &) const
void	load_digit (const RPCdigit *)
CMApatterns &	operator<< (const RPCdigit *)
unsigned long int	debug (void) const
int	sector (void) const
const CMAparameters &	cma_parameters (void) const
const bitPATTERN &	pivot0 (void) const
const bitPATTERN &	pivot1 (void) const
const bitPATTERN &	lowPt0 (void) const
const bitPATTERN &	lowPt1 (void) const
const bitPATTERN &	highPt0 (void) const
const bitPATTERN &	highPt1 (void) const
void	coincidence_distance (TRIGdistance &, TRIGdistance &) const
const TRIGdistance	lowest_distance (const bitPATTERN &, const bitPATTERN &) const
const TRIGdistance	distance (const RPCdigit *, const RPCdigit *) const
const CMAtrigger	give_trigger (Lvl1RPCalgo) const
Matrix *	give_low_pt_matrix (uint NOBXS, uint BCZERO)
Matrix *	give_high_pt_matrix (uint NOBXS, uint BCZERO)
void	Print (std::ostream &, bool) const
void	set_number (int)
int	number (void) const
void	PrintElement (std::ostream &, std::string, bool) const
ObjectType	tag () const
const std::string &	name () const

Static Public Attributes
static const TRIGdistance	no_distance

Private Member Functions
bitPATTERN	decluster (const bitPATTERN &) const
bitPATTERN	majority (bitPATTERN &, bitPATTERN &) const
void	update_distance (const TRIGdistance &, TRIGdistance &) const
CMAtrigger	find_trigger (const bitPATTERN &, const bitPATTERN &, const bitPATTERN &) const
CMAtrigger	find_trigger (const bitPATTERN &, const bitPATTERN &, const bitPATTERN &, const bitPATTERN &) const
CMAtrigger	trigger_window (TRIGdistance, TrigType) const
CMAtrigger	trigger_threshold (int, int, TrigType) const
void	search_for_lowPt (Lvl1RPCalgo, TrigSigns &) const
void	search_for_highPt (Lvl1RPCalgo, TrigSigns &) const
void	search_signatures (Lvl1RPCalgo, TrigType, TrigSigns &, const bitPATTERN &, const bitPATTERN &) const
void	search_signatures (Lvl1RPCalgo, TrigType, CMAtrigger &, const bitPATTERN &) const
void	create_hardware (TrigType, uint NOBXS, uint BCZERO)
void	load_data (int, int, const bitPATTERN &, Matrix *)

Private Attributes
unsigned long int	m_debug
int	m_sector
const CMAparameters *	m_cma_parameters
bitPATTERN	m_pivot0
bitPATTERN	m_pivot1
bitPATTERN	m_lowPt0
bitPATTERN	m_lowPt1
bitPATTERN	m_highPt0
bitPATTERN	m_highPt1
std::unique_ptr< Matrix >	m_low_pt_matrix
std::unique_ptr< Matrix >	m_high_pt_matrix
int	m_number
ObjectType	m_tag
std::string	m_name

Detailed Description

Definition at line 20 of file CMApatterns.h.

Member Typedef Documentation

TRIGdistance

typedef std::pair< float, float > CMApatterns::TRIGdistance

Definition at line 23 of file CMApatterns.h.

TRIGlist

typedef std::list< CMAtrigger > CMApatterns::TRIGlist

Definition at line 26 of file CMApatterns.h.

TrigSigns

typedef std::priority_queue< CMAtrigger > CMApatterns::TrigSigns

Definition at line 27 of file CMApatterns.h.

Constructor & Destructor Documentation

CMApatterns() [1/2]

CMApatterns::CMApatterns	(	int	sector,
		const CMAparameters *	cma,
		unsigned long int	debug
	)

Definition at line 19 of file CMApatterns.cxx.

                                                  :
    RPCtrigDataObject(0,"CMA patterns"),
    m_debug(debug),
    m_sector(sector),m_cma_parameters(cma),
m_pivot0("pivot0 ",PATTERNidentity(Pivot,0),CMAparameters::pivot_channels),
m_pivot1("pivot1 ",PATTERNidentity(Pivot,1),CMAparameters::pivot_channels),
m_lowPt0("lowPt0 ",PATTERNidentity(LowPt,0),CMAparameters::confirm_channels),
m_lowPt1("lowPt1 ",PATTERNidentity(LowPt,1),CMAparameters::confirm_channels),
m_highPt0("highPt0",PATTERNidentity(HighPt,0),CMAparameters::confirm_channels),
m_highPt1("highPt1",PATTERNidentity(HighPt,1),CMAparameters::confirm_channels)
{}

CMApatterns() [2/2]

CMApatterns::CMApatterns

(

const CMApatterns &

patterns

)

Definition at line 32 of file CMApatterns.cxx.

                                                    :
    RPCtrigDataObject(0,patterns.name()),
    m_debug(patterns.debug()),
    m_sector(patterns.sector()),
    m_cma_parameters(&patterns.cma_parameters()),
    m_pivot0(patterns.pivot0()),
    m_pivot1(patterns.pivot1()),
    m_lowPt0(patterns.lowPt0()),
    m_lowPt1(patterns.lowPt1()),
    m_highPt0(patterns.highPt0()),
    m_highPt1(patterns.highPt1())
{}

Member Function Documentation

cma_parameters()

const CMAparameters& CMApatterns::cma_parameters ( void  ) const

inline

Definition at line 87 of file CMApatterns.h.

{return *m_cma_parameters;}

coincidence_distance()

void CMApatterns::coincidence_distance	(	TRIGdistance &	lowTr,
		TRIGdistance &	highTr
	)		const

Definition at line 198 of file CMApatterns.cxx.

{
 
    lowTr  = no_distance;
    highTr = no_distance;
 
    bitPATTERN pivot0  = decluster(m_pivot0);
    bitPATTERN pivot1  = decluster(m_pivot1);
    bitPATTERN lowPt0  = decluster(m_lowPt0);
    bitPATTERN lowPt1  = decluster(m_lowPt1);
    bitPATTERN highPt0 = decluster(m_highPt0);
    bitPATTERN highPt1 = decluster(m_highPt1);
 
    bitPATTERN pivot2  = majority(pivot0,pivot1);
    bitPATTERN lowPt2  = majority(lowPt0,lowPt1);
    bitPATTERN highPt2 = majority(highPt0,highPt1);
 
    update_distance( lowest_distance(pivot2,lowPt2) , lowTr );
    update_distance( lowest_distance(pivot2,lowPt0) , lowTr );
    update_distance( lowest_distance(pivot2,lowPt1) , lowTr );
    update_distance( lowest_distance(pivot0,lowPt2) , lowTr );
    update_distance( lowest_distance(pivot1,lowPt2) , lowTr ); 
 
    update_distance( lowest_distance(pivot2,highPt2) , highTr );
    update_distance( lowest_distance(pivot2,highPt0) , highTr );
    update_distance( lowest_distance(pivot2,highPt1) , highTr );
    update_distance( lowest_distance(pivot0,highPt2) , highTr );
    update_distance( lowest_distance(pivot1,highPt2) , highTr ); 
}

create_hardware()

void CMApatterns::create_hardware ( TrigType  type, uint  NOBXS, uint  BCZERO  )

private

Definition at line 722 of file CMApatterns.cxx.

{   
 
    if(type == None) return;
 
    int run                 = 0;
    int event               = 0;
    unsigned int long debug = m_debug;
    int subsystem           = (m_sector<32)? 0 : 1;
    int proj                = cma_parameters().id().type();
    int sector              = m_sector%32;
    int PADadd              = cma_parameters().id().PAD_index();
    int lohi                = (type == Low) ? 0 : 1;
    int address[2]          = { cma_parameters().id().eta_index(),
                                cma_parameters().id().phi_index()  };
    int localAdd            = cma_parameters().id().Ixx_index();
     
 
    // Instanciate the Matrix
 
    auto matrix = std::make_unique<Matrix>(run,event,debug,subsystem,proj,sector,PADadd,lohi,
                                           address,localAdd, NOBXS, BCZERO);
 
    // ****************** START PROGRAMMING THE MATRIX ****************** //
 
 
    // Loading pivot data into Matrix
    // load_data(0,0,m_pivot0,matrix);
    // load_data(0,1,m_pivot1,matrix);
 
 
    // Specify the readout threshold to be transmitted into the readout
    matrix->setKReadOut(0);
 
    // Specify the AND/OR logic for a matrix input (0=pivot, 1=coincidence)
    matrix->setLocalDirection(0,7);
    matrix->setLocalDirection(1,7);
 
    // Specify the width of the pulse signal in Matrix clock thick (320 Mhz)
    matrix->setPulseWidth(4);
 
    if(type == Low) 
    {
      // Loading pivot data into Matrix
      load_data(0,0,m_pivot0,matrix.get());
      load_data(0,1,m_pivot1,matrix.get());
      
      // Load the theshold registers into Matrix hardware simulation
      const CMAprogram* program = cma_parameters().lowPt_program();
      const int pivot_ch = CMAparameters::pivot_channels;
      
      CMAword ovl1 = 0x0;
      CMAword ovl2 = 0x0;
      CMAword maj_th0 = 0x2;
      CMAword maj_th1 = 0x2;
      CMAword maj_th2 = 0x2;
 
 
      if(program)
    {
      if(cma_parameters().id().type() == Phi)
        {
          const uint32_t* bytes = program->bytes();
 
          for(int th=0;th<3;++th)                 // loop over thresholds
        for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
          for (int by=0;by<2;++by)        // loop over bytes
            {
                     // G.Bruni, M.Corradi 1/3/2010 set phi roads for new cabling
                     if (cma_parameters().conf_type() != CMAparameters::Atlas){
                         matrix->setRoad(th,ch,by,0xffffffff); // old cabling, keep the phi roads all open
                     } else {
                         int pos = th*pivot_ch*2 + ch*2 + by;
                         matrix->setRoad(th,ch,by,bytes[pos]);
             }
            }
        }
      else
        {
 
          const uint32_t* bytes = program->bytes();
          
          for(int th=0;th<3;++th)                 // loop over thresholds
        for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
          for (int by=0;by<2;++by)        // loop over bytes
            {
              int pos = th*pivot_ch*2 + ch*2 + by;
              matrix->setRoad(th,ch,by,bytes[pos]);
            }
        }
      
      ovl1 = program->overlap1();
      ovl2 = program->overlap2();
          maj_th0 = program->trig_thr0_maj_reg();
          maj_th1 = program->trig_thr1_maj_reg();
          maj_th2 = program->trig_thr2_maj_reg();   
 
      
        }
      else if (!program && cma_parameters().id().type() == Phi)
    {
      // open only the Phi matrix if no program is found
      
      for(int th=0;th<3;++th)                 // loop over thresholds
        for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
          for (int by=0;by<2;++by)        // loop over bytes
        {
          matrix->setRoad(th,ch,by,0xffffffff);
        }
    }
      
      // Load the Majority logic setup
      matrix->setMajority(0,maj_th0);
      matrix->setMajority(1,maj_th1);
      matrix->setMajority(2,maj_th2);
      
      //matrix->setMask1(0,1);
      
      // Load the Overlap flag
      matrix->setMatOverlap(0, ovl1);
      matrix->setMatOverlap(1, ovl2);
      
      // Load Low Pt plane data into Matrix
      load_data(1,0,m_lowPt0,matrix.get());
      load_data(1,1,m_lowPt1,matrix.get());
      
      // Execute the matrix simulation
      matrix->execute(); 
      m_low_pt_matrix = std::move(matrix);
    }
    else 
      {
    // Load the theshold registers into Matrix hardware simulation
        const CMAprogram* program = cma_parameters().highPt_program();
        const int pivot_ch = CMAparameters::pivot_channels;
    
        CMAword ovl1 = 0x0;
    CMAword ovl2 = 0x0;
        CMAword maj_th0 = 0x1;
        CMAword maj_th1 = 0x1;
        CMAword maj_th2 = 0x1;
 
        if(program)
      {
 
        if(cma_parameters().id().type() == Phi)
          {
                 const uint32_t* bytes = program->bytes();
 
                 for(int th=0;th<3;++th)                 // loop over thresholds
          for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
            for (int by=0;by<2;++by)        // loop over bytes
                    {
                        // G.Bruni, M.Corradi 1/3/2010 set phi roads for new cabling
                       if (cma_parameters().conf_type()!= CMAparameters::Atlas){
                           matrix->setRoad(th,ch,by,0xffffffff); // old cabling, keep the phi roads all open
                       } else {
                           int pos = th*pivot_ch*2 + ch*2 + by;
                           matrix->setRoad(th,ch,by,bytes[pos]);
                       }
              }
          }
        else
          {
            const uint32_t* bytes = program->bytes();
                for(int th=0;th<3;++th)                 // loop over thresholds
          for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
            for (int by=0;by<2;++by)        // loop over bytes
              {
            int pos = th*pivot_ch*2 + ch*2 + by;
            matrix->setRoad(th,ch,by,bytes[pos]);
              }
          }
        
            ovl1 = program->overlap1();
        ovl2 = program->overlap2();
            maj_th0 = program->trig_thr0_maj_reg();
            maj_th1 = program->trig_thr1_maj_reg();
            maj_th2 = program->trig_thr2_maj_reg();
 
      }
        else if (!program && cma_parameters().id().type() == Phi)
      {
 
            // open only the Phi matrix if no program is found
        
            for(int th=0;th<3;++th)                 // loop over thresholds
          for (int ch=0; ch<pivot_ch; ++ch)   // loop over channels
        for (int by=0;by<2;++by)        // loop over bytes
          {
            matrix->setRoad(th,ch,by,0xffffffff);
          }
      }
        // Load the Majority logic setup
        matrix->setMajority(0,maj_th0);
        matrix->setMajority(1,maj_th1);
        matrix->setMajority(2,maj_th2);
    
    // Load the Overlap flag
    matrix->setMatOverlap(0, ovl1);
    matrix->setMatOverlap(1, ovl2);
 
        // Load High Pt plane data into Matrix
        load_data(1,0,m_highPt0,matrix.get());
        load_data(1,1,m_highPt1,matrix.get());
 
        if(!m_low_pt_matrix) create_hardware(Low, NOBXS, BCZERO);
 
        // Put the Low Pt patterns into the High Pt Matrix input
        matrix->putPatt(m_low_pt_matrix.get());
 
        // Execute the matrix simulation
        matrix->execute();
        m_high_pt_matrix = std::move(matrix);
    }
}

debug()

unsigned long int CMApatterns::debug ( void  ) const

inline

Definition at line 84 of file CMApatterns.h.

{return m_debug;}

decluster()

bitPATTERN CMApatterns::decluster ( const bitPATTERN &  data ) const

private

Definition at line 120 of file CMApatterns.cxx.

{
 
    bitPATTERN pattern(data);
 
    for(int i=0;i<pattern.size();++i)
    {
    if(pattern.test(i))
    {
        int cluster_size = 0;
            do { ++cluster_size; } while( pattern.test(i+cluster_size) );
 
            int decl_lower = 1;
            int decl_upper = cluster_size;
 
            switch (cluster_size%2)
        {
            case 0:
        for( ;decl_lower+1 < decl_upper && decl_lower<=3; ++decl_lower)
                {
            pattern.unset(i - 1 + decl_lower);
                    pattern.unset(i - 1 + decl_upper);
                    --decl_upper;
        }
        break;
            case 1:
                for( ;decl_lower+1 < decl_upper && decl_lower<=3; ++decl_lower)
                { 
                    pattern.unset(i - 1 + decl_lower);
                    pattern.unset(i - 1 + decl_upper);
                    --decl_upper;
        }
        }
        i += (cluster_size - 1);
    }
    }
    return pattern;
}

distance()

const CMApatterns::TRIGdistance CMApatterns::distance	(	const RPCdigit *	pivot,
		const RPCdigit *	confirm
	)		const

Definition at line 255 of file CMApatterns.cxx.

{
 
 
    TRIGdistance value = no_distance;
    float pivrad = 0;
    float conrad = 0;
    if( pivot->station_radius(pivrad) && confirm->station_radius(conrad) )
    {
        if(pivot->decoding().view() == Eta)
        {
        if(pivot->station_eta(value.second))
        {
                float Zprime = pivot->z()*(conrad/pivrad);
                value.first  = confirm->z() - Zprime;
        }
        }
        else if (pivot->decoding().view() == Phi)
        {
            float pivphi = 0;
            float conphi = 0;
            float staphi = 0;
            if( pivot->phi(pivphi)         && 
                confirm->phi(conphi)       && 
                pivot->station_phi(staphi) &&
                pivot->station_eta(value.second) )
            {
                float Sprime = std::tan(pivphi-staphi)*conrad;
                value.first  = std::tan(conphi-staphi)*conrad - Sprime;
            } 
        }
    }
    return value;
}

find_trigger() [1/2]

CMAtrigger CMApatterns::find_trigger ( const bitPATTERN &  pivot, const bitPATTERN &  lowPt, const bitPATTERN &  highPt  ) const

private

Definition at line 468 of file CMApatterns.cxx.

{
 
 
   CMAtrigger trigger_result(GeometricAlgo,this);
 
    if ( !pivot.any() || !lowPt.any() ) return trigger_result;
 
    for(int i=0;i<pivot.size();++i)
    {
        if(const RPCdigit* pivot_digit = pivot[i])
    {
        // Start searching for Low Pt trigger signature
        for(int j=0;j<lowPt.size();++j)
        {
        if(const RPCdigit* confirm_digit = lowPt[j])
        {
            TRIGdistance d = distance(pivot_digit,confirm_digit);
            CMAtrigger signature = trigger_window(d,Low);
                    signature.set_pivot(pivot_digit);
            signature.set_lowPt(confirm_digit);
                    trigger_result += signature;
        }
 
                // if Low Pt Third threshold has fired
                if ( trigger_result.trigger().searchForHigh() )
        {            
                    // Start searching for High Pt trigger signature
                    for(int k=0;k<highPt.size();++k)
                {
                if(const RPCdigit* confirm_digit = highPt[k])
                {
                    TRIGdistance d=distance(pivot_digit,confirm_digit);
                    CMAtrigger signature = trigger_window(d,High);
                    signature.set_highPt(confirm_digit);
                            trigger_result += signature;
                }
                        if( trigger_result.trigger().highest(High) ) break;
            }
            }
                if ( trigger_result.trigger().highest(High) ) break;  
        }
    }
        if ( trigger_result.trigger().highest(High) ) break;
    }
 
    return trigger_result;
}

find_trigger() [2/2]

CMAtrigger CMApatterns::find_trigger ( const bitPATTERN &  pivot, const bitPATTERN &  lowPt, const bitPATTERN &  highPt0, const bitPATTERN &  highPt1  ) const

private

Definition at line 520 of file CMApatterns.cxx.

{
 
    CMAtrigger trigger_result(GeometricAlgo,this);
 
    if ( !pivot.any() || !lowPt.any() ) return trigger_result;
 
    for(int i=0;i<pivot.size();++i)
    {
        if(const RPCdigit* pivot_digit = pivot[i])
    {
        // Start searching for Low Pt trigger signature
        for(int j=0;j<lowPt.size();++j)
        {
        if(const RPCdigit* confirm_digit = lowPt[j])
        {
            TRIGdistance d = distance(pivot_digit,confirm_digit);
            CMAtrigger signature =  trigger_window(d,Low);
                    signature.set_pivot(pivot_digit);
            signature.set_lowPt(confirm_digit);
                    trigger_result += signature;
        }
 
                // if Low Pt Third threshold has fired
                if ( trigger_result.trigger().searchForHigh() )
        {            
                    // Start searching for High Pt trigger signature in plane 0
                    for(int k=0;k<highPt0.size();++k)
                {
                if(const RPCdigit* confirm_digit = highPt0[k])
                {
                    TRIGdistance d=distance(pivot_digit,confirm_digit);
                    CMAtrigger signature =  trigger_window(d,High);
                    signature.set_highPt(confirm_digit);
                            trigger_result += signature;
                }
                        if( trigger_result.trigger().highest(High) ) break;
            }
            }
 
                // if Low Pt Third threshold has fired
                if ( trigger_result.trigger().searchForHigh() )
        {            
                    // Start searching for High Pt trigger signature in plane 1
                    for(int k=0;k<highPt1.size();++k)
                {
                if(const RPCdigit* confirm_digit = highPt1[k])
                {
                    TRIGdistance d=distance(pivot_digit,confirm_digit);
                    CMAtrigger signature =  trigger_window(d,High);
                    signature.set_highPt(confirm_digit);
                            trigger_result += signature;
                }
                        if( trigger_result.trigger().highest(High) ) break;
            }
            }
                if ( trigger_result.trigger().highest(High) ) break;  
         }
    }
        if ( trigger_result.trigger().highest(High) ) break;  
    }
 
    return trigger_result;
}

give_high_pt_matrix()

Matrix * CMApatterns::give_high_pt_matrix	(	uint	NOBXS,
		uint	BCZERO
	)

Definition at line 965 of file CMApatterns.cxx.

{
  
  if(!m_high_pt_matrix) create_hardware(High, NOBXS, BCZERO);
  return m_high_pt_matrix.get();
}

give_low_pt_matrix()

Matrix * CMApatterns::give_low_pt_matrix	(	uint	NOBXS,
		uint	BCZERO
	)

Definition at line 956 of file CMApatterns.cxx.

{
  
  if(!m_low_pt_matrix) create_hardware(Low, NOBXS, BCZERO);
  return m_low_pt_matrix.get();
}

give_trigger()

const CMAtrigger CMApatterns::give_trigger

(

Lvl1RPCalgo

type

)

const

Definition at line 291 of file CMApatterns.cxx.

{
 
 
 
    if(type == HardwareEmulation)
    {
        return CMAtrigger(type,this);
    }
    else
    {
        TrigSigns signatures;
    search_for_lowPt(type,signatures);
    if(!signatures.empty())
    {
        if(signatures.top().trigger().searchForHigh()) 
                                       search_for_highPt(type,signatures);
        return signatures.top();
    }
        else return CMAtrigger(type,this);
    }
}

highPt0()

const bitPATTERN& CMApatterns::highPt0 ( void  ) const

inline

Definition at line 93 of file CMApatterns.h.

{return m_highPt0;}

highPt1()

const bitPATTERN& CMApatterns::highPt1 ( void  ) const

inline

Definition at line 94 of file CMApatterns.h.

{return m_highPt1;}

load_data()

void CMApatterns::load_data ( int  side, int  layer, const bitPATTERN &  pattern, Matrix *  mat  )

private

Definition at line 942 of file CMApatterns.cxx.

{
  
  if(pattern.any())
    {
      for (int i=0;i<pattern.size();++i)
    {
      if(pattern.test(i)) mat->putData(side,layer,i,pattern[i]->time());
    }
    }
}

load_digit()

void CMApatterns::load_digit

(

const RPCdigit *

digit

)

Definition at line 90 of file CMApatterns.cxx.

{
    int station = digit->decoding().lvl1_station();
    int cabling = digit->decoding().cabling_code();
 
    CMAinput IO = NoInput;
    int channel = 0;
    int layer   = 0;
 
    if(m_cma_parameters->give_connection(station,cabling,IO,layer,channel))
    {
        if(IO == Pivot)
        {
            if(layer) m_pivot1.set(digit,channel);
            else      m_pivot0.set(digit,channel);
        }
        else if (IO == LowPt)
        {
            if(layer) m_lowPt1.set(digit,channel);
            else      m_lowPt0.set(digit,channel);
        }
        else if (IO == HighPt)
        {
            if(layer) m_highPt1.set(digit,channel);
            else      m_highPt0.set(digit,channel);
        }
    }
}

lowest_distance()

const CMApatterns::TRIGdistance CMApatterns::lowest_distance	(	const bitPATTERN &	pivot,
		const bitPATTERN &	confirm
	)		const

Definition at line 230 of file CMApatterns.cxx.

{
    if ( !pivot.any() || !confirm.any() ) return no_distance;
 
    TRIGdistance value = no_distance;
 
    for(int i=0;i<pivot.size();++i)
    {
        if(const RPCdigit* pivot_digit = pivot[i])
    {
        for(int j=0;j<confirm.size();++j)
        {
        if(const RPCdigit* confirm_digit = confirm[j])
        {
            update_distance(distance(pivot_digit,confirm_digit),value);
        }
        }
    }
    }
 
    return value;
}

lowPt0()

const bitPATTERN& CMApatterns::lowPt0 ( void  ) const

inline

Definition at line 91 of file CMApatterns.h.

{return m_lowPt0;}

lowPt1()

const bitPATTERN& CMApatterns::lowPt1 ( void  ) const

inline

Definition at line 92 of file CMApatterns.h.

{return m_lowPt1;}

majority()

bitPATTERN CMApatterns::majority ( bitPATTERN &  layer0, bitPATTERN &  layer1  ) const

private

Definition at line 161 of file CMApatterns.cxx.

{
 
    int left  = 1;
    int right = 1;
 
    bitPATTERN result(layer0.name(),layer0.id(),layer0.size());
    bitPATTERN tmp1(layer1);
    bitPATTERN tmp2(layer1);
 
    result |= layer0 & layer1;
    for(int i=0;i<left;++i)  result |= layer0 & (tmp1<<1);
    for(int i=0;i<right;++i) result |= layer0 & (tmp2>>1);
 
    for (int i=0;i<result.size();++i)
    {
    if(result.test(i))
    {
        layer0.unset(i);
        layer0.unset(i-1);
        layer0.unset(i+1);
        layer1.unset(i);
        layer1.unset(i-1);
        layer1.unset(i+1);
    }
    }
 
    return result;
}

name()

const std::string& BaseObject::name ( ) const

inlineinherited

Definition at line 23 of file BaseObject.h.

{ return m_name; }

number()

int RPCtrigDataObject::number ( void  ) const

inlineinherited

Definition at line 29 of file RPCtrigDataObject.h.

{return m_number;}

operator!=()

bool CMApatterns::operator!=

(

const CMApatterns &

patterns

)

const

Definition at line 73 of file CMApatterns.cxx.

{
    return !(*this == patterns);
}

operator<()

bool CMApatterns::operator<

(

const CMApatterns &

patterns

)

const

Definition at line 79 of file CMApatterns.cxx.

{
    if(m_sector < patterns.sector())
    {
     if (m_cma_parameters->id() < patterns.cma_parameters().id()) return true;
    }
    return false;
}

operator<<()

CMApatterns & CMApatterns::operator<<

(

const RPCdigit *

digit

)

Definition at line 679 of file CMApatterns.cxx.

{
    load_digit(digit);
    return *this;
}

operator=()

CMApatterns CMApatterns::operator=

(

const CMApatterns &

patterns

)

Definition at line 46 of file CMApatterns.cxx.

{
    static_cast<RPCtrigDataObject&>(*this) = 
        static_cast<const RPCtrigDataObject&>(patterns);
    m_debug = patterns.debug();
    m_sector = patterns.sector();
    m_cma_parameters = &patterns.cma_parameters();
    m_pivot0 = patterns.pivot0();
    m_pivot1 = patterns.pivot1();
    m_lowPt0 = patterns.lowPt0();
    m_lowPt1 = patterns.lowPt1();
    m_highPt0 = patterns.highPt0();
    m_highPt1 = patterns.highPt1();
    return *this;
}

operator==()

bool CMApatterns::operator==

(

const CMApatterns &

patterns

)

const

Definition at line 63 of file CMApatterns.cxx.

{
    if(m_sector == patterns.sector())
    {
     if (m_cma_parameters->id()==patterns.cma_parameters().id()) return true;
    }
    return false;
}

pivot0()

const bitPATTERN& CMApatterns::pivot0 ( void  ) const

inline

Definition at line 89 of file CMApatterns.h.

{return m_pivot0;}

pivot1()

const bitPATTERN& CMApatterns::pivot1 ( void  ) const

inline

Definition at line 90 of file CMApatterns.h.

{return m_pivot1;}

Print()

void CMApatterns::Print ( std::ostream &  stream, bool  detail  ) const

virtual

Reimplemented from BaseObject.

Definition at line 686 of file CMApatterns.cxx.

{    
    //unsigned int upper = 19;
    //unsigned int lower = 17;
 
    unsigned int upper = 95;
    unsigned int lower = 45;
    
    for(int i=0;i<80;++i) stream << (char) upper;
    stream << std::endl;
 
    stream << name() << " giving input to: logic sector = " << m_sector
       << ", sector type = " << cma_parameters().sector_type() << std::endl;
    stream << cma_parameters() << std::endl;
 
    //bitPATTERN layer0 = decluster(pivot0());
    //bitPATTERN layer1 (pivot1()); 
 
    pivot1().Print(stream,detail);
    pivot0().Print(stream,detail);
 
    //layer0.Print(stream,detail);       // test for declustering
    //stream << majority(layer0,layer1); // test for majority logic
    //layer1.Print(stream,detail);       // test for majority logic
    //layer0.Print(stream,detail);       // test for majority logic
 
    lowPt1().Print(stream,detail);
    lowPt0().Print(stream,detail);
    highPt1().Print(stream,detail);
    highPt0().Print(stream,detail);   
    
    for(int i=0;i<80;++i) stream << (char) lower;
    stream << std::endl;
}

PrintElement()

void RPCtrigDataObject::PrintElement ( std::ostream &  , std::string  , bool    ) const

inlineinherited

Definition at line 31 of file RPCtrigDataObject.h.

{}

search_for_highPt()

void CMApatterns::search_for_highPt ( Lvl1RPCalgo  type, TrigSigns &  signatures  ) const

private

Definition at line 335 of file CMApatterns.cxx.

{
 
 
    bitPATTERN highPt0 = decluster(m_highPt0);
    bitPATTERN highPt1 = decluster(m_highPt1);
    
    bitPATTERN highPt2 = majority(highPt0,highPt1);   
    
    TrigSigns tmp;
    
    while(!signatures.empty())
    {
        CMAtrigger signature = signatures.top();
    signatures.pop();
    if(signature.trigger().searchForHigh())
    {
        search_signatures(type,High,signature,highPt2);
        search_signatures(type,High,signature,highPt0);
        search_signatures(type,High,signature,highPt1);
        tmp.push(signature);
    }
    }
    
    signatures = std::move(tmp);
}

search_for_lowPt()

void CMApatterns::search_for_lowPt ( Lvl1RPCalgo  type, TrigSigns &  signatures  ) const

private

Definition at line 315 of file CMApatterns.cxx.

{        
 
 
    bitPATTERN pivot0  = decluster(m_pivot0);
    bitPATTERN pivot1  = decluster(m_pivot1);
    bitPATTERN lowPt0  = decluster(m_lowPt0);
    bitPATTERN lowPt1  = decluster(m_lowPt1);
    
    bitPATTERN pivot2  = majority(pivot0,pivot1);
    bitPATTERN lowPt2  = majority(lowPt0,lowPt1);    
    
    search_signatures(type,Low,signatures,pivot2,lowPt2);
    search_signatures(type,Low,signatures,pivot2,lowPt0);
    search_signatures(type,Low,signatures,pivot2,lowPt1);
    search_signatures(type,Low,signatures,pivot0,lowPt2);
    search_signatures(type,Low,signatures,pivot1,lowPt2);
}

search_signatures() [1/2]

void CMApatterns::search_signatures ( Lvl1RPCalgo  algoType, TrigType  trigType, CMAtrigger &  trigger_result, const bitPATTERN &  confirm  ) const

private

Definition at line 419 of file CMApatterns.cxx.

{    
 
    if ( !confirm.any() ) return;
 
 
    const RPCdigit* pivot_digit = trigger_result.pivot_hit();
    const int Kpatt = trigger_result.Kpatt();
    
    // Start searching for trigger signature
    CMAtrigger signature(algoType,this);
 
    for(int j=0;j<confirm.size();++j)
    {
        if(const RPCdigit* confirm_digit = confirm[j])
        {
            TRIGdistance d = distance(pivot_digit,confirm_digit);
        
        if(algoType == GeometricAlgo)
        {
                signature = trigger_window(d,trigType);
        }
        else if (algoType == LogicEmulation)
        {
            signature = trigger_threshold(Kpatt,j,trigType);
        }
        
            if(trigType == Low)
            {
                signature.set_pivot(pivot_digit);
        signature.set_lowPt(confirm_digit);
        }
            else if(trigType == High)
            {
                signature.set_highPt(confirm_digit);
            }
            signature.set_width(d.first);
        signature.set_Kpatt(Kpatt);
            trigger_result += signature;
        }
 
        //if ( trigger_result.trigger().highest(trigType) ) break;  
    }
}

search_signatures() [2/2]

void CMApatterns::search_signatures ( Lvl1RPCalgo  algoType, TrigType  trigType, TrigSigns &  signatures, const bitPATTERN &  pivot, const bitPATTERN &  confirm  ) const

private

Definition at line 364 of file CMApatterns.cxx.

{    
 
    if ( !pivot.any() || !confirm.any() ) return;
     
    for(int i=0;i<pivot.size();++i)
    {
        if(const RPCdigit* pivot_digit = pivot[i])
    {
        // Start searching for trigger signature
        CMAtrigger trigger_result(algoType,this);
 
        for(int j=0;j<confirm.size();++j)
        {
        if(const RPCdigit* confirm_digit = confirm[j])
        {           
            TRIGdistance d = distance(pivot_digit,confirm_digit);
            CMAtrigger signature(algoType,this);
            
            if(algoType == GeometricAlgo)
                {
                        signature = trigger_window(d,trigType);
                }
                else if (algoType == LogicEmulation)
                {
                    signature = trigger_threshold(i,j,trigType);
                }
            
            if(trigType == Low)
            {
                        signature.set_pivot(pivot_digit);
                signature.set_lowPt(confirm_digit);
                }
            else if(trigType == High)
            {
                signature.set_highPt(confirm_digit);
            }
            signature.set_width(d.first);
            signature.set_Kpatt(i);
                    trigger_result += signature;
        }
 
                //if ( trigger_result.trigger().highest(trigType) ) break;  
        }
        if(trigger_result.trigger().type()!=None) 
                                          signatures.push(trigger_result);
    }
    }
}

sector()

int CMApatterns::sector ( void  ) const

inline

Definition at line 86 of file CMApatterns.h.

{return m_sector;}

set_number()

void RPCtrigDataObject::set_number ( int  number )

inherited

Definition at line 42 of file RPCtrigDataObject.cxx.

{
    m_number = number;
}

tag()

ObjectType BaseObject::tag ( ) const

inlineinherited

Definition at line 22 of file BaseObject.h.

{ return m_tag; }

trigger_threshold()

CMAtrigger CMApatterns::trigger_threshold ( int  pivot, int  confirm, TrigType  type  ) const

private

Definition at line 631 of file CMApatterns.cxx.

{
 
    if (type == None) return CMAtrigger(LogicEmulation,this);
    
    const int pivch = CMAparameters::pivot_channels;
    const int conch = CMAparameters::confirm_channels;
    
    const bool* program = 0;
        
    if(type == Low) 
    {
        if(const CMAprogram* prog = cma_parameters().lowPt_program() )
    {
        // avoid to use the Phi program for the time being ///////////
        if(cma_parameters().id().type() == Phi)                     //
            return CMAtrigger(LogicEmulation,type,ThirdTh,this);    //
        program = prog->registers();
    }
    else return CMAtrigger(LogicEmulation,type,ThirdTh,this);
    }
    else
    {
        if(const CMAprogram* prog = cma_parameters().highPt_program() )
    {
        // avoid to use the Phi program for the time being ///////////
        if(cma_parameters().id().type() == Phi)                     //
            return CMAtrigger(LogicEmulation,type,ThirdTh,this);    //
        program = prog->registers();
    }
    else return CMAtrigger(LogicEmulation,type,ThirdTh,this);
    }
    
    
    for(int th=2;th>=0;--th)
    {
    int pos = th*pivch*conch + pivot*conch + confirm;
    if(*(program+pos))
    {
        Threshold threshold = static_cast<Threshold>(th);
        return CMAtrigger(LogicEmulation,type,threshold,this);
    }
    }
    return CMAtrigger(LogicEmulation,this);
}

trigger_window()

CMAtrigger CMApatterns::trigger_window ( TRIGdistance  dist, TrigType  type  ) const

private

Definition at line 587 of file CMApatterns.cxx.

{
 
    if (type == None) return CMAtrigger(GeometricAlgo,this);
 
    if(m_cma_parameters->id().type() == Eta)
    {
        //implement the geometric coincidence for the eta projection
        int upper_threshold = (type == Low)? 2 : 4;
        int lower_threshold = (type == Low)? 0 : 3;
 
        for(int i=upper_threshold; i >= lower_threshold;--i)
        {
        if (windows(dist.first,dist.second,i,m_sector%32))
        {
            Threshold threshold = FirstTh;
                if      ( (i%3) == 0 ) threshold = FirstTh;
                else if ( (i%3) == 1 ) threshold = SecondTh;
                else if ( (i%3) == 2 ) threshold = ThirdTh;
            return CMAtrigger(GeometricAlgo,type,threshold,this);
        }
        }
    }
    else if (m_cma_parameters->id().type() == Phi)
    {
        //implement the geometric coincidence for the phi projection
    if(type == Low)
    {
        // set the trigger window width equal to 10 centimeters
        if(fabsf(dist.first)<10.0) 
                return CMAtrigger(GeometricAlgo,type,ThirdTh,this);
    }
    else if (type == High)
    {
        // set the trigger window width equal to 10 centimeters
        if(fabsf(dist.first)<10.0) 
                return CMAtrigger(GeometricAlgo,type,SecondTh,this); 
    }
    }
    
    return CMAtrigger(GeometricAlgo,this);
}

update_distance()

void CMApatterns::update_distance ( const TRIGdistance &  NEW, TRIGdistance &  OLD  ) const

private

Definition at line 192 of file CMApatterns.cxx.

{
    if(std::fabs(NEW.first) < std::fabs(OLD.first)) OLD = NEW;
} 

Member Data Documentation

m_cma_parameters

const CMAparameters* CMApatterns::m_cma_parameters

private

Definition at line 33 of file CMApatterns.h.

m_debug

unsigned long int CMApatterns::m_debug

private

Definition at line 30 of file CMApatterns.h.

m_high_pt_matrix

std::unique_ptr<Matrix> CMApatterns::m_high_pt_matrix

private

Definition at line 43 of file CMApatterns.h.

m_highPt0

bitPATTERN CMApatterns::m_highPt0

private

Definition at line 39 of file CMApatterns.h.

m_highPt1

bitPATTERN CMApatterns::m_highPt1

private

Definition at line 40 of file CMApatterns.h.

m_low_pt_matrix

std::unique_ptr<Matrix> CMApatterns::m_low_pt_matrix

private

Definition at line 42 of file CMApatterns.h.

m_lowPt0

bitPATTERN CMApatterns::m_lowPt0

private

Definition at line 37 of file CMApatterns.h.

m_lowPt1

bitPATTERN CMApatterns::m_lowPt1

private

Definition at line 38 of file CMApatterns.h.

m_name

std::string BaseObject::m_name

privateinherited

Definition at line 16 of file BaseObject.h.

m_number

int RPCtrigDataObject::m_number

privateinherited

Definition at line 17 of file RPCtrigDataObject.h.

m_pivot0

bitPATTERN CMApatterns::m_pivot0

private

Definition at line 35 of file CMApatterns.h.

m_pivot1

bitPATTERN CMApatterns::m_pivot1

private

Definition at line 36 of file CMApatterns.h.

m_sector

int CMApatterns::m_sector

private

Definition at line 32 of file CMApatterns.h.

m_tag

ObjectType BaseObject::m_tag

privateinherited

Definition at line 15 of file BaseObject.h.

no_distance

const CMApatterns::TRIGdistance CMApatterns::no_distance

static

Initial value:

=
  TRIGdistance(99999.,99999.)

Definition at line 24 of file CMApatterns.h.

---

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

• CMApatterns.h
• CMApatterns.cxx