HarpoRecoEvent.cxx

Go to the documentation of this file.

// 
// File HarpoRecoEvent.cxx
//
#include "HarpoRecoEvent.h"
#include "HarpoDebug.h"

#include "TMath.h"

#include <iostream>

using namespace std;


ClassImp( HarpoRecoEvent)

HarpoRecoClusters::HarpoRecoClusters() :
//TObject(), fType(-1), fQ(-1),fMean(-1),fIndex(-1),fSig(-1),fWidth(-1), fPlane(-1), fRun(-1), fIdClusterTrack(-1)
TObject(), fType(-1), fQ(-1),fQmax(-1),fMean(-1),fIndex(-1),fSig(-1),fWidth(-1),fIfirst(-1),fQuality(0),fNtr(0),fPlane(-1)//, fIdClusterTrack(-1)
{
  fX = -1000;
  fZ = -1000;
  for(Int_t i = 0; i<MAXTRPERCL; i++){
    fIdClusterTrack[i] = -1;
    fXfit[i] = -1000;
    fZfit[i] = -1000;
  }
}

//HarpoRecoClusters::HarpoRecoClusters(Int_t Type, Int_t Q, Double_t Mean, Int_t Index, Double_t Sig,Int_t Width,Int_t IdClusterTrack,Int_t plane, Int_t run):
HarpoRecoClusters::HarpoRecoClusters(Int_t Type, Double_t Q, Double_t Qmax, Double_t Mean, Int_t Index, Double_t Sig, Int_t iFirst, Int_t Width, Int_t IdClusterTrack, Int_t plane, Int_t quality):
    //    TObject(), fType(Type), fQ(Q), fMean(Mean), fIndex(Index), fSig(Sig), fWidth(Width), fPlane(plane), fRun(run), fIdClusterTrack(IdClusterTrack)
  TObject(), fType(Type), fQ(Q), fQmax(Qmax), fMean(Mean), fIndex(Index), fSig(Sig),fWidth(Width),fIfirst(iFirst),fQuality(quality),fPlane(plane)//,fIdClusterTrack(IdClusterTrack)
{
  fX = -1000;
  fZ = -1000;
  for(Int_t i = 0; i<MAXTRPERCL; i++){
    fIdClusterTrack[i] = -1;//clu.fIdClusterTrack[i];
    fXfit[i] = -1000;
    fZfit[i] = -1000;
  }
  fNtr = 0;
  if(IdClusterTrack>=0){
    fNtr = 1;
    fIdClusterTrack[0] = IdClusterTrack;//clu.fIdClusterTrack[i];
  }
}

HarpoRecoClusters::HarpoRecoClusters(const HarpoRecoClusters &clu) :
  //  TObject(), fType(clu.fType), fQ(clu.fQ), fMean(clu.fMean), fIndex(clu.fIndex), fSig(clu.fSig), fWidth(clu.fWidth), fPlane(clu.fPlane), fRun(clu.fRun), fIdClusterTrack(clu.fIdClusterTrack)
  TObject(clu), fType(clu.fType), fQ(clu.fQ), fQmax(clu.fQmax), fMean(clu.fMean), fIndex(clu.fIndex), fSig(clu.fSig), fWidth(clu.fWidth), fIfirst(clu.fIfirst), fQuality(clu.fQuality), fNtr(clu.fNtr), fPlane(clu.fPlane)//, fIdClusterTrack(clu.fIdClusterTrack)
{
  fX = clu.fX;
  fZ = clu.fZ;
  for(Int_t i = 0; i<MAXTRPERCL; i++){
    fIdClusterTrack[i] = clu.fIdClusterTrack[i];
    fXfit[i] = clu.fXfit[i];
    fZfit[i] = clu.fZfit[i];
  }
}


void HarpoRecoClusters::AddIdClusterTrack(Int_t val){
  if(gHarpoDebug>2)
    Info("AddIdClusterTrack","%d (%d)",val,fNtr);
  for(Int_t i = 0; i<fNtr; i++)
    if(fIdClusterTrack[i] == val) return;
  fNtr++;
  if(fNtr>=MAXTRPERCL){
    Info("AddIdClusterTrack","Cannot add track %d on cluster",val);
    return;
  }
  fIdClusterTrack[fNtr-1] = val;
}

void HarpoRecoClusters::RemoveIdClusterTrack(Int_t val)
{
  Int_t i = 0;
  while(i<fNtr){
    if(fIdClusterTrack[i] == val) break;
    i++;
  }
  if(i == fNtr) return;
  for(Int_t j = i; j<9; i++){
    fIdClusterTrack[j] = fIdClusterTrack[j+1];
  }
  fIdClusterTrack[9] = -1;
}


HarpoRecoClusters::~HarpoRecoClusters()
{
}






HarpoRecoTracks::HarpoRecoTracks() :
  TObject(), fNtrack(-1),fQtTrack(-1),fAngleTrack(-1),fX0(-1),fTypeTrack(-1) ,fPlane(-1),fIdTrackMatching(-1),fNclusterTrack(-1),fXstart(-1),fZstart(-1),fXend(-1),fZend(-1)
{
}

HarpoRecoTracks::HarpoRecoTracks(Int_t Ntrack, Int_t QtTrack,Double_t AngleTrack, Double_t x0, Int_t TypeTrack, Int_t IdTrackMatching,Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart,  Double_t xEnd, Double_t zEnd):
  TObject(), fNtrack(Ntrack), fQtTrack(QtTrack),fAngleTrack(AngleTrack),fX0(x0),fTypeTrack(TypeTrack) ,fPlane(plane),fIdTrackMatching(IdTrackMatching),fNclusterTrack(NclusterTrack),fXstart(xStart),fZstart(zStart),fXend(xEnd),fZend(zEnd)
{
}

HarpoRecoTracks::HarpoRecoTracks(const HarpoRecoTracks &tra) :
  TObject(), fNtrack(tra.fNtrack), fQtTrack(tra.fQtTrack), fAngleTrack(tra.fAngleTrack),fX0(tra.fX0),fTypeTrack(tra.fTypeTrack),fPlane(tra.fPlane),fIdTrackMatching(tra.fIdTrackMatching),fNclusterTrack(tra.fNclusterTrack),fXstart(tra.fXstart),fZstart(tra.fZstart),fXend(tra.fXend),fZend(tra.fZend)
{
}

HarpoRecoTracks::~HarpoRecoTracks()
{
}



HarpoRecoHoughTracks::HarpoRecoHoughTracks() :
  HarpoRecoTracks(), fMtheta(-1),fMrho(-1),fSigtheta(-1),fSigrho(-1)
{
}

HarpoRecoHoughTracks::HarpoRecoHoughTracks(Int_t Ntrack, Double_t Mtheta, Double_t Mrho, Double_t Sigtheta, Double_t Sigrho,Int_t QtTrack,Double_t AngleTrack, Double_t x0, Int_t TypeTrack, Int_t IdTrackMatching,Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart, Double_t xEnd, Double_t zEnd):
  HarpoRecoTracks(Ntrack, QtTrack,AngleTrack,x0, TypeTrack, IdTrackMatching,NclusterTrack,plane, xStart, zStart, xEnd, zEnd), fMtheta(Mtheta),fMrho(Mrho),fSigtheta(Sigtheta),fSigrho(Sigrho)
{
}

HarpoRecoHoughTracks::HarpoRecoHoughTracks(const HarpoRecoHoughTracks &tra) :
  HarpoRecoTracks(tra), fMtheta(tra.fMtheta), fMrho(tra.fMrho), fSigtheta(tra.fSigtheta), fSigrho(tra.fSigrho)
{
}

HarpoRecoHoughTracks::~HarpoRecoHoughTracks()
{
}



HarpoRecoKalmanTracks::HarpoRecoKalmanTracks() :
  HarpoRecoTracks(), fPxStart(-1), fPzStart(-1),fPxEnd(-1),fPzEnd(-1)
{
  //  fGraph = 0;
}

HarpoRecoKalmanTracks::HarpoRecoKalmanTracks(Int_t Ntrack, Int_t QtTrack,Double_t AngleTrack, Double_t x0, Double_t chi2,Int_t TypeTrack, Int_t IdTrackMatching,Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart, Double_t pxStart, Double_t pzStart, Double_t xEnd, Double_t zEnd, Double_t pxEnd, Double_t pzEnd):
  HarpoRecoTracks(Ntrack, QtTrack,AngleTrack,x0, TypeTrack, IdTrackMatching,NclusterTrack,plane, xStart, zStart, xEnd, zEnd), fPxStart(pxStart),fPzStart(pzStart),fPxEnd(pxEnd),fPzEnd(pzEnd),fChi2(chi2)
{
  //  fGraph = 0;
}

HarpoRecoKalmanTracks::HarpoRecoKalmanTracks(const HarpoRecoKalmanTracks &tra) :
  HarpoRecoTracks(tra), fPxStart(tra.fPxStart),fPzStart(tra.fPzStart),fPxEnd(tra.fPxEnd),fPzEnd(tra.fPzEnd),fChi2(tra.fChi2)
{
  //  fGraph = 0;
}

HarpoRecoKalmanTracks::~HarpoRecoKalmanTracks()
{
  // fGraph->Delete();
}


HarpoRecoVertex::HarpoRecoVertex():
  TObject(), fNvertex(-1), fPlane(-1), fTr1Vertex(-1), fTr2Vertex(-1), fXvertex(-1), fZvertex(-1), fPxVertex(-1), fPzVertex(-1), fThetaVertex(-1), fChi2Vertex(-1)
{
}

HarpoRecoVertex::HarpoRecoVertex(Int_t plane, Double_t z, Double_t x, Double_t pz, Double_t px, Double_t theta, Double_t chi2, Int_t tr1, Int_t tr2):
  TObject(), fNvertex(-1), fPlane(plane), fTr1Vertex(tr1), fTr2Vertex(tr2), fXvertex(x), fZvertex(z), fPxVertex(px), fPzVertex(pz), fThetaVertex(theta), fChi2Vertex(chi2)
{
}

HarpoRecoVertex::HarpoRecoVertex(const HarpoRecoVertex &vec):
  TObject(vec), fNvertex(vec.fNvertex), fPlane(vec.fPlane), fTr1Vertex(vec.fTr1Vertex), fTr2Vertex(vec.fTr2Vertex), fXvertex(vec.fXvertex), fZvertex(vec.fZvertex), fPxVertex(vec.fPxVertex), fPzVertex(vec.fPzVertex), fThetaVertex(vec.fThetaVertex), fChi2Vertex(vec.fChi2Vertex)
{
}

HarpoRecoVertex::~HarpoRecoVertex()
{
}

HarpoRecoVertex3D::HarpoRecoVertex3D():
  TObject(), fIdVertex3D(-1), fVertexX(-1), fVertexY(-1), fXvertex3D(-1), fYvertex3D(-1), fZvertex3D(-1), fPx1Vertex3D(-1), fPy1Vertex3D(-1), fPz1Vertex3D(-1), fPx2Vertex3D(-1), fPy2Vertex3D(-1), fPz2Vertex3D(-1), fChi2Vertex3D(-1)
{
}

HarpoRecoVertex3D::HarpoRecoVertex3D(Double_t x, Double_t y, Double_t z, Double_t px1, Double_t py1, Double_t pz1, Double_t px2, Double_t py2, Double_t pz2, Int_t vX, Int_t vY, Double_t chi2):
  TObject(), fIdVertex3D(-1), fVertexX(vX), fVertexY(vY), fXvertex3D(x), fYvertex3D(y), fZvertex3D(z), fPx1Vertex3D(px1), fPy1Vertex3D(py1), fPz1Vertex3D(pz1), fPx2Vertex3D(px2), fPy2Vertex3D(py2), fPz2Vertex3D(pz2), fChi2Vertex3D(chi2)
{
}

HarpoRecoVertex3D::HarpoRecoVertex3D(const HarpoRecoVertex3D &vec):
  TObject(vec), fIdVertex3D(vec.fIdVertex3D), fVertexX(vec.fVertexX), fVertexY(vec.fVertexY), fXvertex3D(vec.fXvertex3D), fYvertex3D(vec.fYvertex3D), fZvertex3D(vec.fZvertex3D), fPx1Vertex3D(vec.fPx1Vertex3D), fPy1Vertex3D(vec.fPy1Vertex3D), fPz1Vertex3D(vec.fPz1Vertex3D), fPx2Vertex3D(vec.fPx2Vertex3D), fPy2Vertex3D(vec.fPy2Vertex3D), fPz2Vertex3D(vec.fPz2Vertex3D), fChi2Vertex3D(vec.fChi2Vertex3D)
{
}

HarpoRecoVertex3D::~HarpoRecoVertex3D()
{
}


Double_t HarpoRecoVertex3D::GetOmega()
{

  Double_t omega = TMath::ATan2(fPz2Vertex3D*fPx1Vertex3D-fPz1Vertex3D*fPx2Vertex3D,
                                fPz2Vertex3D*fPy2Vertex3D-fPz1Vertex3D*fPx1Vertex3D);
  return omega;

}

Double_t HarpoRecoVertex3D::GetOpenAngle()
{

  Double_t cos = fPx1Vertex3D*fPx2Vertex3D + 
                 fPy1Vertex3D*fPy2Vertex3D +
                 fPz1Vertex3D*fPz2Vertex3D;

  return TMath::ACos(cos);
}

Double_t HarpoRecoVertex3D::GetPxVertex3D()
{
  Double_t norm = 1 + 
    fPx1Vertex3D*fPx2Vertex3D + 
    fPy1Vertex3D*fPy2Vertex3D +
    fPz1Vertex3D*fPz2Vertex3D;
  norm *= 2;
  return (fPx1Vertex3D+fPx2Vertex3D)/TMath::Sqrt(norm);

}

Double_t HarpoRecoVertex3D::GetPyVertex3D()
{
  Double_t norm = 1 + 
    fPx1Vertex3D*fPx2Vertex3D + 
    fPy1Vertex3D*fPy2Vertex3D +
    fPz1Vertex3D*fPz2Vertex3D;
  norm *= 2;
  return (fPy1Vertex3D+fPy2Vertex3D)/TMath::Sqrt(norm);

}

Double_t HarpoRecoVertex3D::GetPzVertex3D()
{
  Double_t norm = 1 + 
    fPx1Vertex3D*fPx2Vertex3D + 
    fPy1Vertex3D*fPy2Vertex3D +
    fPz1Vertex3D*fPz2Vertex3D;
  norm *= 2;
  return (fPz1Vertex3D+fPz2Vertex3D)/TMath::Sqrt(norm);

}



HarpoRecoMatching::HarpoRecoMatching() :
  //TObject(), fngoodmatch(-1), fiMatchTrX(-1),fiMatchTrY(-1)
  TObject(), fngoodmatch(-1), fiMatchTrX(-1),fiMatchTrX2(-1), fiMatchTrY(-1),fiMatchTrY2(-1),fChi2Matching(-1)
{
}

HarpoRecoMatching::HarpoRecoMatching(Int_t ngoodmatch, Int_t iMatchTrX,Int_t iMatchTrX2, Int_t iMatchTrY,Int_t iMatchTrY2,Double_t chi2):
  TObject(), fngoodmatch(ngoodmatch), fiMatchTrX(iMatchTrX),fiMatchTrX2(iMatchTrX2), fiMatchTrY(iMatchTrY),fiMatchTrY2(iMatchTrY2),fChi2Matching(chi2)
{
}

HarpoRecoMatching::HarpoRecoMatching(const HarpoRecoMatching &mat) :
  //  TObject(), fngoodmatch(mat.fngoodmatch), fiMatchTrX(mat.fiMatchTrX), fiMatchTrY(mat.fiMatchTrY),fRun(mat.fRun)
  TObject(), fngoodmatch(mat.fngoodmatch), fiMatchTrX(mat.fiMatchTrX), fiMatchTrX2(mat.fiMatchTrX2), fiMatchTrY(mat.fiMatchTrY), fiMatchTrY2(mat.fiMatchTrY2),fChi2Matching(mat.fChi2Matching)
{
}

HarpoRecoMatching::~HarpoRecoMatching()
{
}



HarpoRecoReco3D::HarpoRecoReco3D() :
  TObject(), fntrack_3d(-1),fDoca(-1),fPoca_x(1000),fPoca_y(1000),fPoca_z(1000),fPx(-10),fPy(-10),fPz(-10),fAopen(-10),fAazimutal(-10)
{
  for(Int_t i=0;i<7;i++) ftypetrack3d[i] = -1;
}

// HarpoRecoReco3D::HarpoRecoReco3D(Int_t ntrack_3d,Double_t doca, Double_t poca_x, Double_t poca_y, Double_t poca_z, Double_t px,Double_t py, Double_t pz,Double_t aopen,Double_t aazimutal, Int_t run):
//   TObject(), fntrack_3d(ntrack_3d),fRun(run),fDoca(doca),fPoca_x(poca_x),fPoca_y(poca_y),fPoca_z(poca_z),fPx(px),fPy(py),fPz(pz),fAopen(aopen),fAazimutal(aazimutal)
HarpoRecoReco3D::HarpoRecoReco3D(Int_t ntrack_3d,Double_t doca, Double_t poca_x, Double_t poca_y, Double_t poca_z, Double_t px,Double_t py, Double_t pz,Double_t aopen,Double_t aazimutal):
  TObject(), fntrack_3d(ntrack_3d),fDoca(doca),fPoca_x(poca_x),fPoca_y(poca_y),fPoca_z(poca_z),fPx(px),fPy(py),fPz(pz),fAopen(aopen),fAazimutal(aazimutal)
{
  for(Int_t i=0;i<7;i++) ftypetrack3d[i] = -1;
}

HarpoRecoReco3D::HarpoRecoReco3D(const HarpoRecoReco3D &rec) :
  //  TObject(), fntrack_3d(rec.fntrack_3d),fRun(rec.fRun),fDoca(rec.fDoca),fPoca_x(rec.fPoca_x),fPoca_y(rec.fPoca_y),fPoca_z(rec.fPoca_z),fPx(rec.fPx),fPy(rec.fPy),fPz(rec.fPz),fAopen(rec.fAopen),fAazimutal(rec.fAazimutal)
  TObject(), fntrack_3d(rec.fntrack_3d),fDoca(rec.fDoca),fPoca_x(rec.fPoca_x),fPoca_y(rec.fPoca_y),fPoca_z(rec.fPoca_z),fPx(rec.fPx),fPy(rec.fPy),fPz(rec.fPz),fAopen(rec.fAopen),fAazimutal(rec.fAazimutal)
{
for(Int_t i=0;i<7;i++) ftypetrack3d[i] = rec.ftypetrack3d[i];
}

HarpoRecoReco3D::~HarpoRecoReco3D()
{
}


HarpoRecoEvent::HarpoRecoEvent()
{
  if(gHarpoDebug>1) Info("HarpoRecoEvent()","0x%p",this);
  fClustersArray = new TClonesArray("HarpoRecoClusters",kMaxNclusters);
  fHoughTracksArray = new TClonesArray("HarpoRecoHoughTracks",2*kMaxNtracks);
  fKalmanTracksArray = new TClonesArray("HarpoRecoKalmanTracks",2*kMaxNtracks);
  fVertex3DArray = new TClonesArray("HarpoRecoVertex3D",kMaxNvertex3D);
  fVertexArray = new TClonesArray("HarpoRecoVertex",kMaxNvertex);
  fMatchingArray = new TClonesArray("HarpoRecoMatching",kMaxNtracks);
  fReco3DArray = new TClonesArray("HarpoRecoReco3D",kMaxNtracks);

  fNtracksXEvt  = -1;
  fNtracksYEvt  = -1;
  fNvertexXEvt = 0;
  fNvertexYEvt = 0;
  // fNtracksXEvt_tvs  = -1;
  // fNtracksYEvt_tvs  = -1;
  // fNtracksXEvt_ntvs  = -1;
  // fNtracksYEvt_ntvs  = -1;
  // fNtracksXEvt_depot  = -1;
  // fNtracksYEvt_depot  = -1;
  // fNtracksXEvt_gerbe  = -1;
  // fNtracksYEvt_gerbe  = -1;

  fNtracks3DEvt = -1;
  fNclXEvt      = -1;
  fNclYEvt      = -1;
  fNCclXEvt      = -1;
  fNCclYEvt      = -1;
  fNTclXEvt      = -1;
  fNTclYEvt      = -1;
  fQtotXEvt     = -1;
  fQtotYEvt     = -1;
  fNclTrackEvt  = -1;

  fTrackType = 1;

  fEventType = -1;
  // fEventTTZ = -1;
  // fNEventEmpty = -1;
  // fNEventDeposit = -1;
  // fNEventTTZ = -1;
  // fNEventTT = -1;
  // fNEventTCR = -1;
  // fNEventTCN = -1;
  // fNEventGamma = -1;
  // fNEventDelta = -1;
  // fNEvent2TOther = -1;
  // fNEventShower = -1;
  // fNEventOther = -1;
  fQmaxX = -1;
  fQrestX = -1;
  fQmaxY = -1;
  fQrestY = -1;
  fAngleOmega =-10;


  fXmin = -1000;
  fYmin = -1000;
  fTmin = -1000;
  fXmax = -1000;
  fYmax = -1000;
  fTmax = -1000;
  fXstart = -1000;
  fYstart = -1000;
  fTstart = -1000;
}

HarpoRecoEvent::~HarpoRecoEvent()
{
  if(gHarpoDebug>1) Info("~HarpoRecoEvent()","0x%p",this);

  fClustersArray->Delete();
  fHoughTracksArray->Delete();
  fKalmanTracksArray->Delete();
  fVertexArray->Delete();
  fVertex3DArray->Delete();
  fMatchingArray->Delete();
  fReco3DArray->Delete();
}


void HarpoRecoEvent::Summary()
{
  Info("Summary","Ncl = %d, NtrHough = %d, NtrKalman = %d, Nmatch = %d, N3D = %d",
       fClustersArray->GetEntries(),     
       fHoughTracksArray->GetEntries(), 
       fKalmanTracksArray->GetEntries(), 
       fMatchingArray->GetEntries(),
       fReco3DArray->GetEntries());
  
}