Cluster.cxx

Go to the documentation of this file.

// $Id: Cluster.cxx,v 1.7 2009/08/25 00:52:55 messier Exp $
//
// Definition of reco Cluster of CellHits
//
// \author $Author: messier $
// \date   $Date: 2009/08/25 00:52:55 $
//

#include "RecoBase/Cluster.h"
#include "JobControl/Exception.h"
#include "Geometry/PlaneGeo.h"

#include <algorithm>

using namespace std;
using namespace recobase;

ClassImp(Cluster);

//------------------------------------------------------------
// Default constructor
//------------------------------------------------------------
Cluster::Cluster() : 
  fXPlane(0), fYPlane(0), fPlane(0), fStatus(0), 
  fQ(0), fdQ(0)
{
  Clear();
} 

//------------------------------------------------------------
void Cluster::Clear()
{
  fXPlane.clear();
  fYPlane.clear();
  fPlane.clear();
  fStatus=0;
  fQ=0;
  fdQ=0;  


  for (int i=0; i<4; ++i) {
    f4Vec[i] = -1.e9;
    fd4Vec[i] = 0.;
  }

  for (unsigned int i=0; i<fXCell.size(); ++i)
    delete fXCell[i];

  for (unsigned int i=0; i<fYCell.size(); ++i)
    delete fYCell[i];

  fXCell.clear();
  fYCell.clear();

}

//------------------------------------------------------------
// Construct a cluster from a vector of cell hits.
//------------------------------------------------------------

Cluster::Cluster(vector<const CellHit*>& cell) : 
  fXPlane(0), 
  fYPlane(0),
  fPlane(0),
  fStatus(0), 
  fQ(0),
  fdQ(0)
{
  for (int i=0; i<4; ++i) {
    f4Vec[i] = -1.e9;
    fd4Vec[i] = 0.;
  }

  for (unsigned int i=0; i<cell.size(); ++i) {
    if (cell[i]->View() == geo::kX) { // cell is in a x-plane
      fXCell.push_back(cell[i]);
      if (find(fXPlane.begin(),fXPlane.end(),cell[i]->Plane()) ==
          fXPlane.end()) fXPlane.push_back(cell[i]->Plane());
    }
    else { // cell is in a y-plane
      fYCell.push_back(cell[i]);
      if (find(fYPlane.begin(),fYPlane.end(),cell[i]->Plane()) ==
          fYPlane.end()) fYPlane.push_back(cell[i]->Plane());      
    }

    if (find(fPlane.begin(),fPlane.end(),cell[i]->Plane()) ==
        fPlane.end()) fPlane.push_back(cell[i]->Plane());
  }

  // sort planes
  sort(fXPlane.begin(),fXPlane.end());
  sort(fYPlane.begin(),fYPlane.end());
  sort(fPlane.begin(),fPlane.end());

} 

//------------------------------------------------------------
// Default destructor
//------------------------------------------------------------
Cluster::~Cluster()
{

}

//------------------------------------------------------------

int Cluster::XPlane(int i) const
{
  unsigned int j = i;
  assert_jobc((i >= 0 && j < fXPlane.size()),
              "Cluster::XPlane(): out of bounds exception!");
  return fXPlane[j];
}

//------------------------------------------------------------

int Cluster::YPlane(int i) const
{
  unsigned int j = i;
  assert_jobc((i >= 0 && j < fYPlane.size()),
              "Cluster::YPlane(): out of bounds exception!");
  return fYPlane[j];
}

//------------------------------------------------------------

int Cluster::Plane(int i) const
{
  unsigned int j = i;
  
  if(!(i >= 0 && j < (fPlane.size()))) {
    
    cout << "error.. out of bound request " << i << " has " 
         << fYPlane.size() << ", " << fXPlane.size() << endl;
  
}

  assert_jobc((i >= 0 && j < (fPlane.size())),
              "Cluster::Plane(): out of bounds exception!");
  
  if (fYPlane.empty()) return this->XPlane(i);
  if (fXPlane.empty()) return this->YPlane(i);
  
  return fPlane[j];
}

//------------------------------------------------------------

int Cluster::NXCell() const
{
  return fXCell.size();
}

//------------------------------------------------------------

int Cluster::NYCell() const
{
  return fYCell.size();
}

//------------------------------------------------------------

int Cluster::NCell() const
{
  return this->NXCell() + this->NYCell();
}

//------------------------------------------------------------

int Cluster::NCell(geo::View_t view) const
{
  if(view==geo::kX){
    return this->NXCell();
  }
  else if(view==geo::kY){
    return this->NYCell();
  }
  return this->NCell();
}

//------------------------------------------------------------

const CellHit* Cluster::XCell(int i) const
{
  assert_jobc((i >= 0) && (i < this->NXCell()),
              "Cluster::XCell(): out of bounds exception!");

  unsigned int j = i;
  return fXCell[j];
}

//------------------------------------------------------------

const CellHit* Cluster::XCell(int icell, int iplane) const
{
  for (int i=0; i<this->NXCell(); ++i) {
    const CellHit* c2 = this->XCell(i);
    if (c2->Plane() == iplane &&
        c2->Cell() == icell)
      return c2;
  }

  return 0;
}

//------------------------------------------------------------

const CellHit* Cluster::YCell(int i) const
{
  assert_jobc((i >= 0) && (i < this->NYCell()),
              "Cluster::YCell(): out of bounds exception!");
  
  unsigned int j = i;
  return fYCell[j];
}

//------------------------------------------------------------

const CellHit* Cluster::YCell(int icell, int iplane) const
{
  for (int i=0; i<this->NYCell(); ++i) {
    const CellHit* c2 = this->YCell(i);
    if (c2->Plane() == iplane &&
        c2->Cell() == icell)
      return c2;
  }
  
  return 0;
}

//------------------------------------------------------------

const CellHit* Cluster::Cell(geo::View_t view, int i) const
{
  if(view==geo::kX){
    return this->XCell(i);
  }
  else if(view==geo::kY){
    return this->YCell(i);
  }

  return 0;
}


//------------------------------------------------------------


const CellHit* Cluster::Cell(geo::View_t view, int icell, int iplane) const
{

  if(view==geo::kX){
    return this->XCell(icell,iplane);
  }
  else if(view==geo::kY){
    return this->YCell(icell,iplane);
  }

  return 0;

}
//------------------------------------------------------------

bool Cluster::Add(const CellHit* cell)
{
  bool foundDup = false;

  if (cell->View() == geo::kX) {
    for (int i=0; i<this->NXCell(); ++i) {
      const CellHit* c2 = this->XCell(i);
      if (c2->Plane() == cell->Plane() && c2->Cell() == cell->Cell()) {
        foundDup = true;
        break;
      }
    }
    if (!foundDup){
      fXCell.push_back(cell);
      fXPlane.push_back(cell->Plane());
      fPlane.push_back(cell->Plane()); 
      sort(fXPlane.begin(),fXPlane.end());
    }
  }
  else {
    for (int i=0; i<this->NYCell(); ++i) {
      const CellHit* c2 = this->YCell(i);
      if (c2->Plane() == cell->Plane() && c2->Cell() == cell->Cell()) {
        foundDup = true;
        break;
      }
    }
    if (!foundDup){ 
      fYCell.push_back(cell);
      fYPlane.push_back(cell->Plane());
      fPlane.push_back(cell->Plane());
      sort(fYPlane.begin(),fYPlane.end());
    }

  }

  if (!foundDup){
    sort(fPlane.begin(),fPlane.end());
  }

  return !foundDup;
}

---