TSegmentCurl.cxx

Go to the documentation of this file.

#include "TrkReco/TSegmentCurl.h"
 
#define inline
 
 
TSegmentCurl::TSegmentCurl(const unsigned superLayerId,
               const unsigned max)
  : m_MaxLocalLayerId(max), m_superLayerId(superLayerId), m_flagOfUpdate(true)
{
  m_list.removeAll();
  for(unsigned i=0;i<4;++i){
    m_seqOfLayer[i] = m_sizeOfLayer[i] = 0;
    m_layer[i].removeAll();
  }
}
 
 
TSegmentCurl::TSegmentCurl(TSegmentCurl &s)
  : m_flagOfUpdate(s.m_flagOfUpdate), m_list(s.m_list), m_MaxLocalLayerId(s.m_MaxLocalLayerId), m_superLayerId(s.m_superLayerId), 
    m_maxSeq(s.m_maxSeq), m_layerIdOfMaxSeq(s.m_layerIdOfMaxSeq), m_numOfSeqOneLayer(s.m_numOfSeqOneLayer),
    m_numOfLargeSeqLayer(s.m_numOfLargeSeqLayer)
{
  for(unsigned i=0;i<4;++i){
    m_seqOfLayer[i] = s.m_seqOfLayer[i];
    m_sizeOfLayer[i] = s.m_sizeOfLayer[i];
    m_layer[i] = s.m_layer[i];
  } 
}
 
 
TSegmentCurl::TSegmentCurl(TSegmentCurl *s)
  : m_flagOfUpdate(s->m_flagOfUpdate), m_list(s->m_list), m_MaxLocalLayerId(s->m_MaxLocalLayerId), m_superLayerId(s->m_superLayerId), 
    m_maxSeq(s->m_maxSeq), m_layerIdOfMaxSeq(s->m_layerIdOfMaxSeq), m_numOfSeqOneLayer(s->m_numOfSeqOneLayer),
    m_numOfLargeSeqLayer(s->m_numOfLargeSeqLayer)
{
  for(unsigned i=0;i<4;++i){
    m_seqOfLayer[i] = s->m_seqOfLayer[i];
    m_sizeOfLayer[i] = s->m_sizeOfLayer[i];
    m_layer[i] = s->m_layer[i];
  } 
}
 
 
TSegmentCurl::~TSegmentCurl(void)
{
  m_list.removeAll();
  for(unsigned i=0;i<4;++i){
    m_layer[i].removeAll();
  }
}
 
 
inline
const unsigned 
TSegmentCurl::maxLocalLayerId(void) const
{
  return m_MaxLocalLayerId;
}
 
 
inline
const unsigned 
TSegmentCurl::superLayerId(void) const
{
  return m_superLayerId;
}
 
 
inline
const unsigned 
TSegmentCurl::seqOfLayer(const unsigned i)
{
  if(m_flagOfUpdate)update();
  return m_seqOfLayer[i];
}
 
 
inline
const unsigned 
TSegmentCurl::sizeOfLayer(const unsigned i)
{
  if(m_flagOfUpdate)update();
  return m_sizeOfLayer[i];
}
 
 
inline
const unsigned 
TSegmentCurl::maxLocalLayerId(const unsigned i)
{
  m_MaxLocalLayerId = i;
  return m_MaxLocalLayerId;
}
 
 
inline
const unsigned 
TSegmentCurl::superLayerId(const unsigned i)
{
  m_superLayerId = i;
  return m_superLayerId;
}
 
 
inline
void 
TSegmentCurl::append(TMLink &e)
{
  m_flagOfUpdate = true;
  m_layer[e.hit()->wire()->localLayerId()].append(e);
  m_list.append(e);
}
 
 
inline
void 
TSegmentCurl::append(TMLink *e)
{
  m_flagOfUpdate = true;
  m_layer[e->hit()->wire()->localLayerId()].append(e);
  m_list.append(e);
}
 
 
inline
void 
TSegmentCurl::append(AList<TMLink> &e)
{
  m_flagOfUpdate = true;
  for(unsigned i = 0; i < e.length(); ++i)
    m_layer[e[i]->hit()->wire()->localLayerId()].append(e[i]);
  m_list.append(e);
}
 
 
inline
void 
TSegmentCurl::remove(TMLink &e)
{
  m_flagOfUpdate = true;
  m_layer[e.hit()->wire()->localLayerId()].remove(e);
  m_list.remove(e);
}
 
 
inline
void 
TSegmentCurl::remove(TMLink *e)
{
  m_flagOfUpdate = true;
  m_layer[e->hit()->wire()->localLayerId()].remove(e);
  m_list.remove(e);
}
 
 
inline
void 
TSegmentCurl::remove(AList<TMLink> &e)
{
  m_flagOfUpdate = true;
  for(unsigned i = 0; i < e.length(); ++i)
    m_layer[e[i]->hit()->wire()->localLayerId()].remove(e[i]);
  m_list.remove(e);
}
 
 
inline
void 
TSegmentCurl::removeAll(void)
{
  m_flagOfUpdate = true;
  m_list.removeAll();
  for(unsigned i=0;i<4;++i){
    m_layer[i].removeAll();
  }
}
 
 
inline
const unsigned 
TSegmentCurl::maxSeq(void) const
{
  // I try to use non-const member.
  // If this method is bad, other methods are necessary.
  TSegmentCurl * const localThis = const_cast<TSegmentCurl * const>(this);
  if(m_flagOfUpdate)localThis->update();
  return m_maxSeq;
}
 
 
inline
const unsigned 
TSegmentCurl::layerIdOfMaxSeq(void)
{
  if(m_flagOfUpdate)update();
  return m_layerIdOfMaxSeq;
}
 
 
inline
const unsigned 
TSegmentCurl::numOfSeqOneLayer(void)
{
  if(m_flagOfUpdate)update();
  return m_numOfSeqOneLayer;
}
 
 
inline
const unsigned
TSegmentCurl::numOfLargeSeqLayer(void)
{
  if(m_flagOfUpdate)update();
  return m_numOfLargeSeqLayer;
}
 
 
void 
TSegmentCurl::update(void)
{
  if(m_list.length() == 0){
    m_flagOfUpdate = false;
    return;
  }
  m_maxSeq = m_layerIdOfMaxSeq = 0;
  m_numOfSeqOneLayer = m_numOfLargeSeqLayer = 0;
  for(unsigned i = 0; i <= m_MaxLocalLayerId; ++i){
    m_sizeOfLayer[i] = m_layer[i].length();
    calcuSeq(i);
    if(m_seqOfLayer[i] >= m_maxSeq){
      m_maxSeq = m_seqOfLayer[i];
      m_layerIdOfMaxSeq = i;
    }
    if(m_seqOfLayer[i] == 1)++m_numOfSeqOneLayer;
    if(m_seqOfLayer[i] >= TCURL_LARGE_SEQUENCE)++m_numOfLargeSeqLayer;
  }
 
  m_flagOfUpdate = false;
}
 
 
TSegmentCurl &
TSegmentCurl::operator=(const TSegmentCurl &s)
{
  if(this == &s)return *this;
 
  m_flagOfUpdate = s.m_flagOfUpdate;
  m_list = s.m_list;
  m_MaxLocalLayerId = s.m_MaxLocalLayerId;
  m_superLayerId = s.m_superLayerId;
 
  m_maxSeq = s.m_maxSeq;
  m_layerIdOfMaxSeq = s.m_layerIdOfMaxSeq;
  m_numOfSeqOneLayer = s.m_numOfSeqOneLayer;
  m_numOfLargeSeqLayer = s.m_numOfLargeSeqLayer;
 
  for(unsigned i=0;i<4;++i){
    m_seqOfLayer[i] = s.m_seqOfLayer[i];
    m_sizeOfLayer[i] = s.m_sizeOfLayer[i];
    m_layer[i] = s.m_layer[i];
  }
  
  return *this;
}
 
#if defined(__GNUG__)
int
sortByWireSerialNumber( const TMLink **a, const TMLink **b )
{
  if( (*a)->hit()->wire()->id() < (*b)->hit()->wire()->id() ){
    return 1;
  }else if( (*a)->hit()->wire()->id() == (*b)->hit()->wire()->id() ){
    return 0;
  }else{
    return -1;
  }
}
#else
extern "C" int
sortByWireSerialNumber( const void *av, const void *bv )
{
  const TMLink **a((const TMLink **)av);
  const TMLink **b((const TMLink **)bv);
  if( (*a)->hit()->wire()->id() < (*b)->hit()->wire()->id() ){
    return 1;
  }else if( (*a)->hit()->wire()->id() == (*b)->hit()->wire()->id() ){
    return 0;
  }else{
    return -1;
  }
}
#endif
 
void
TSegmentCurl::calcuSeq(unsigned i)
{
  //...exception
  if(i > m_MaxLocalLayerId){
    m_seqOfLayer[i] = 0;
    return;
  }
  unsigned size = m_layer[i].length();
  if(size < 1){
    m_seqOfLayer[i] = 0;
    return;
  }
  if(size == 1){
    m_seqOfLayer[i] = 1;
    return;
  }
 
  //...initialize
  m_layer[i].sort(sortByWireSerialNumber);
  unsigned seq = 1;
  unsigned maxSeq = 0;
  unsigned layerIdForWires = m_layer[i][0]->hit()->wire()->layerId();
  
  //...calculation
//  if(m_layer[i][0]->hit()->wire()->localId() == static_cast<unsigned>(wires(m_superLayerId)-1) && 
  if(m_layer[i][0]->hit()->wire()->localId() == static_cast<unsigned>(wires(layerIdForWires)-1) &&
     m_layer[i][size-1]->hit()->wire()->localId() == 0){
    for(unsigned j=0;j<size-1;++j){
      if(m_layer[i][j]->hit()->wire()->localIdForMinus()-1 == 
     m_layer[i][j+1]->hit()->wire()->localId()){
    ++seq;
      }else{
    break;
      }
      if(j == size-2)goto loop;
    }
    ++seq;
    for(unsigned j=size-1;j>0;--j){
      if(m_layer[i][j]->hit()->wire()->localIdForPlus()+1 == 
     m_layer[i][j-1]->hit()->wire()->localId()){
    ++seq;
      }else{
    break;
      }
    }
     loop:
    if(seq > maxSeq)maxSeq = seq;
  }
  seq = 1;
  for(unsigned j=0;j<size-1;++j){
    if(m_layer[i][j]->hit()->wire()->localIdForMinus()-1 == 
       m_layer[i][j+1]->hit()->wire()->localId()){
      ++seq;
    }else{
      if(seq > maxSeq)maxSeq = seq;
      seq = 1;
    }
  }
  if(seq > maxSeq)maxSeq = seq;
 
  //...set and return
  m_seqOfLayer[i] = maxSeq;
  return;
}
 
 
/*unsigned
TSegmentCurl::wires(const unsigned superLayerId) const
{
  // input   - super layer id#(0-10)
  // output  - # of its super layer
  if(superLayerId ==  0)return  64;
  if(superLayerId ==  1)return  80;
  if(superLayerId ==  2)return  96;
  if(superLayerId ==  3)return 128;
  if(superLayerId ==  4)return 144;
  if(superLayerId ==  5)return 160;
  if(superLayerId ==  6)return 192;
  if(superLayerId ==  7)return 208;
  if(superLayerId ==  8)return 240;
  if(superLayerId ==  9)return 256;
  if(superLayerId == 10)return 288;
 
  std::cerr << "Error in the SegmentCurl(wires)." << std::endl;
  return 0;
}*/
unsigned
TSegmentCurl::wires(const unsigned LayerId) const
{
  // input   - layer id#(0-422)
  // output  - # of its layer
  if(LayerId ==  0)return  40;
  if(LayerId ==  1)return  44;
  if(LayerId ==  2)return  48;
  if(LayerId ==  3)return  56;
  if(LayerId ==  4)return  64;
  if(LayerId ==  5)return  72;
  if(LayerId ==  6 || LayerId ==  7) return  80;
  if(LayerId ==  8 || LayerId ==  9) return  76;
  if(LayerId ==  10|| LayerId ==  11)return  88;
  if(LayerId ==  12|| LayerId ==  13)return 100;
  if(LayerId ==  14|| LayerId ==  15)return 112;
  if(LayerId ==  16|| LayerId ==  17)return 128;
  if(LayerId ==  18|| LayerId ==  19)return 140;
  if(LayerId < 24)return 160;
  if(LayerId < 28)return 176;
  if(LayerId < 32)return 208;
  if(LayerId < 36)return 240;
  if(LayerId < 40)return 256;
  if(LayerId < 43)return 288;
                                                                                                                             
  std::cerr << "Error in the SegmentCurl(wires)." << std::endl;
  return 0;
}
 
void
TSegmentCurl::dump(void)
{
  //std::cout.form(" Hep  idhep mother mcPX  mcPY  mcPZ  mcE   mcMass\n");
  //std::cout.form(" %3d   % 4d   % 4d % 2.2f % 2.2f % 2.2f % 2.2f % 2.3f\n", 
  //hepID, partID, mothID, mcpx, mcpy, mcpz, mce, mcmass);
 
  std::cout << "=====Segment for Curling Track Finder=====" << std::endl;
  std::cout << "List Size = " << m_list.length() << std::endl;
  std::cout << "Flag of Update = " << m_flagOfUpdate 
       << ", Max Local Layer ID = " << m_MaxLocalLayerId
       << ", Super Layer ID = " << m_superLayerId << std::endl;
  std::cout << "Max Seq. = " << m_maxSeq << ", Its Layer ID = " << m_layerIdOfMaxSeq << std::endl;
  std::cout << "# of Seq = 1 Layer = " << m_numOfSeqOneLayer 
       << ", # of Large Seq. Layer = " << m_numOfLargeSeqLayer << std::endl;
  //std::cout.form(" ID | Seq. of Layer | Size of Layer | Local ID List\n");
  std::cout << "ID | Seq. of Layer | Size of Layer | Local ID List" << std::endl;
  for(unsigned i=0;i<4;++i){
    //std::cout.form("  %1d |  %2d           | %2d            |", i, m_seqOfLayer[i], m_sizeOfLayer[i]);
    std::cout << i << " | " << m_seqOfLayer[i] << "   | " << m_sizeOfLayer[i] << "   | ";
    for(unsigned j = 0, size = m_layer[i].length(); j < size; ++j)
      std::cout << m_layer[i][j]->hit()->wire()->localId() << ", ";
    std::cout << std::endl;
  }
}