bitview.cxx File Reference

#include "bitview.h"
#include <math.h>
#include "EdbSegment.h"
#include "Riostream.h"
#include "TMath.h"
#include "deriv.h"

Include dependency graph for bitview.cxx:

Functions
	ClassImp (TBinTracking)
	ClassImp (TBitView)
int	CommonClusters (EdbSegment *seg0, EdbSegment *seg1)
float	Distance (float xp, float yp, float zp, float x0, float y0, float z0, float teta, float phi)
float	Distance (float xp, float yp, float zp, track tr)
float	DistanceInNormalizeSpace (float xp, float yp, float zp, track tr, double dx, double dy, double dz)
int	In (float X, float Y, float Xmin, float Xmax, float Ymin, float Ymax)
float	max (TClonesArray *t)
float	min (TClonesArray *t)
int	MY_LFIT (float *X, float *Y, int L, int KEY, float &A, float &B, float &erA, float &erB, float &s)
void	PreciseBasePosition (float zmin, float zmax, TClonesArray *dc, float &zup, float &zdown)
int	SatCondAccept (track *tr, float xc, float yc, float zc, double dx, double dy, double dz, float accept)
TClonesArray *	Smoothing (EdbView *v)
float	sqr (float x)
void	TrackAngle (track tr, float *teta, float *phi)

Function Documentation

ClassImp() [1/2]

ClassImp

(

TBinTracking

)

ClassImp() [2/2]

ClassImp

(

TBitView

)

CommonClusters()

int CommonClusters	(	EdbSegment *	seg0,
		EdbSegment *	seg1
	)

{
    EdbCluster  *c0 = 0,
                *c1 = 0;
    int numCl0 = seg0->GetNelements(),
        numCl1 = seg1->GetNelements();
    for (int cc0=0; cc0<numCl0; cc0++) {
        c0 = (EdbCluster *)(seg0->GetElements()->At(cc0));
        for (int cc1=0; cc1<numCl1; cc1++) {
            c1 = (EdbCluster *)(seg1->GetElements()->At(cc1));
            if (c0==c1) return true;
        }
    }
    return false;
}

Distance() [1/2]

float Distance	(	float	xp,
		float	yp,
		float	zp,
		float	x0,
		float	y0,
		float	z0,
		float	teta,
		float	phi
	)

{
  float r2,cos2,sin2,pr;
  float x = xp-x0;
  float y = yp-y0;
  float z = zp-z0;
 
  r2=x*x+y*y+z*z;
  pr=x*TMath::Sin(teta)*TMath::Cos(phi)+y*TMath::Sin(teta)*TMath::Sin(phi)+z*TMath::Cos(teta);
  if (r2==0.0) {return (0.0);}
  cos2=pr*pr/r2;
  sin2=1-cos2;
 
//    printf("r2=%lf \n",r2*sin2);
 
  return TMath::Sqrt(r2*sin2);
}

Distance() [2/2]

float Distance	(	float	xp,
		float	yp,
		float	zp,
		track	tr
	)

{
    float xt = tr.x;
    float yt = tr.y;
    float zt = tr.z;
    float teta, phi;
 
    TrackAngle(tr,&teta,&phi);
    return Distance(xp,yp,zp,xt,yt,zt,teta,phi);
}

DistanceInNormalizeSpace()

float DistanceInNormalizeSpace	(	float	xp,
		float	yp,
		float	zp,
		track	tr,
		double	dx,
		double	dy,
		double	dz
	)

{
    float xpNorm = xp/dx;
    float ypNorm = yp/dy;
    float zpNorm = zp/dz;
    track trNorm;
    trNorm.x = tr.x/dx;
    trNorm.y = tr.y/dy;
    trNorm.z = tr.z/dz;
    trNorm.tgx = tr.tgx * dz/dx;
    trNorm.tgy = tr.tgy * dz/dy;
    return Distance(xpNorm,ypNorm,zpNorm,trNorm);
}

In()

int In ( float  X, float  Y, float  Xmin, float  Xmax, float  Ymin, float  Ymax  )

inline

{
    if ((X>=Xmin)&&(X<Xmax)&&(Y>=Ymin)&&(Y<Ymax)) return 1;
    else return 0;
}

max()

float max

(

TClonesArray *

t

)

                           {
 
int num = t->GetEntries();
float d,z;
float dmax = ((Deriv *)(t->At(0)))->GetD();
float zmax = ((Deriv *)(t->At(0)))->GetZ();
for (int i=1; i<num; i++) {
    d=((Deriv *)(t->At(i)))->GetD();
    z=((Deriv *)(t->At(i)))->GetZ();
    if (d>dmax) {
    zmax=z;
    dmax=d;
    }
}
return zmax;
}

min()

float min

(

TClonesArray *

t

)

                           {
 
int num = t->GetEntries();
//cout<<num<<endl;
float d,z;
float dmin = ((Deriv *)(t->At(0)))->GetD();
float zmin = ((Deriv *)(t->At(0)))->GetZ();
//cout<<" "<<zmin<<" "<<dmin<<endl;
for (int i=1; i<num; i++) {
    d=((Deriv *)(t->At(i)))->GetD();
    z=((Deriv *)(t->At(i)))->GetZ();
//    cout<<" "<<z<<" "<<d<<" "<<endl;
    if (d<dmin) {
    zmin=z;
    dmin=d;
    }
}
//cout<<endl;
return zmin;
}

MY_LFIT()

int MY_LFIT	(	float *	X,
		float *	Y,
		int	L,
		int	KEY,
		float &	A,
		float &	B,
		float &	erA,
		float &	erB,
		float &	s
	)

{
 
  A=0; B=0; erA=0; erB=0; s=0;
 
  //     CALCULTE SUMS
  if(L<2)  return false;
 
  double Ex=0.;
  double Ey=0.;
  double Sxx=0.;
  double Syy=0.;
  double Syx=0.;
  int    ICNT=0;
  double SSE;
  int j;
 
  for(j=0; j<L; j++ ){
    if( Y[j]==0. && KEY==0 )  continue;
    Ex+=X[j];
    Ey+=Y[j];
    ICNT++;
  }
 
  if(ICNT<3)     return false;
 
  Ex=Ex/(double)ICNT;
  Ey=Ey/(double)ICNT;
 
  for(j=0; j<L; j++ ){
    if( Y[j]==0. && KEY==0 )  continue;
    Syx+=(Y[j]-Ey)*(X[j]-Ex);
    Sxx+=(X[j]-Ex)*(X[j]-Ex);
    Syy+=(Y[j]-Ey)*(Y[j]-Ey);
 }
 
  if(Sxx==0.) return false;
 
 
  A=Syx/Sxx;
  B=Ey-A*Ex;
 
  SSE=Syy-A*Syx;
 
  s=sqrt(SSE/(double)(ICNT-2));
  
  erA=s/sqrt(Sxx);
  erB=s*sqrt(1./(double)ICNT+Ex*Ex/Sxx);
 
  //  printf("MYTEST!!!!!!!!!!! A= %lf , erA= %lf , B= %lf , erB= %lf \n",A,erA,B,erB);
 
 
  return true;
}

PreciseBasePosition()

void PreciseBasePosition	(	float	zmin,
		float	zmax,
		TClonesArray *	dc,
		float &	zup,
		float &	zdown
	)

{
    TH1F *h1min = new TH1F("h1min","h1min",20,zmin-5.,zmin+5.);
    TH1F *h1max = new TH1F("h1max","h1max",20,zmax-5.,zmax+5.);
    float z,d;
    Deriv *D=0;
    int N=dc->GetEntries();
    for (int i=0; i<N; i++) {
        D=(Deriv *)(dc->At(i));
        z=D->GetZ();
        d=D->GetD();
        if (TMath::Abs(z-zmin)<5.) h1min->Fill(z,d);
        if (TMath::Abs(z-zmax)<5.) h1max->Fill(z,d);
    }
//  h1min->Fit("gaus","Q0");
//  h1max->Fit("gaus","Q0");
//  TF1 *fmin = h1min->GetFunction("gaus");
//  TF1 *fmax = h1max->GetFunction("gaus");
//  error->Fill(fmin->GetParameter(2));
//  error->Fill(fmax->GetParameter(2));
//  zdown = fmax->GetParameter(1);
//  zup = fmin->GetParameter(1);
    zdown = h1max->GetMean();
    zup = h1min->GetMean();
//  error->Fill(h1max->GetRMS());
//  error->Fill(h1min->GetRMS());
    delete h1min;
    delete h1max;
}

SatCondAccept()

int SatCondAccept	(	track *	tr,
		float	xc,
		float	yc,
		float	zc,
		double	dx,
		double	dy,
		double	dz,
		float	accept
	)

{
/*  float xt = tr->x;
    float yt = tr->y;
    float zt = tr->z;
    float tgx = tr->tgx;
    float tgy = tr->tgy;
 
    float x = xt + (zc-zt)*tgx;
    float y = yt + (zc-zt)*tgy;
    
    float teta, phi;
    TrackAngle(*tr,&teta,&phi);
*/
/*  if (Distance(xc,yc,zc,xt,yt,zt,teta,phi)<=accept) return true;
    else return false;
*/
    if (DistanceInNormalizeSpace(xc,yc,zc,*tr,dx,dy,dz)<=accept) return true;
    else return false;
 
/*  if (sqrt((x-xc)*(x-xc)+(y-yc)*(y-yc))<=accept) return true;
    else return false;
    */
}

Smoothing()

TClonesArray* Smoothing

(

EdbView *

v

)

{
    TClonesArray *t = new TClonesArray("EdbFrame");
    EdbFrame *fpp=0,*fpred=0,*f=0,*fsucc=0,*fss=0;
    int nFrame = v->GetNframes();
    for (int i=0; i<nFrame; i++) {
        int Nclpp,Nclp,Ncl,Ncls,Nclss;
        if (i>1) {
            fpp = (EdbFrame *)(v->GetFrames()->At(i-2));
            Nclpp = fpp->GetNcl();
        }
        else Nclpp = 0;
        if (i>0) {
            fpred = (EdbFrame *)(v->GetFrames()->At(i-1));
            Nclp = fpred->GetNcl();
        }
        else Nclp = 0;
        f = (EdbFrame *)(v->GetFrames()->At(i));
        Ncl = f->GetNcl();
        if (i<nFrame-1) {
            fsucc = (EdbFrame *)(v->GetFrames()->At(i+1));
            Ncls = fsucc->GetNcl();
        }
        else Ncls = 0;
        if (i<nFrame-2) {
            fss = (EdbFrame *)(v->GetFrames()->At(i+2));
            Nclss = fss->GetNcl();
        }
        else Nclss = 0;
        int ncl = (Nclpp+2*Nclp+3*Ncl+2*Ncls+Nclss)/9;
        new((*t)[i]) EdbFrame(f->GetID(),f->GetZ(),ncl,f->GetNpix());
//      h2->Fill(f->GetZ(),ncl);
//      t->Add(new EdbFrame(f->GetID(),f->GetZ(),ncl,f->GetNpix()));
    }
    return t;
}

sqr()

float sqr ( float  x )

inline

{return x*x;}

TrackAngle()

void TrackAngle	(	track	tr,
		float *	teta,
		float *	phi
	)

{
    float tgx = tr.tgx;
    float tgy = tr.tgy;
 
    float tgteta = TMath::Sqrt(tgx*tgx+tgy*tgy);
    *teta = TMath::ATan(tgteta);
    float tgphi;
 
    if (tgx!=0.0) {
        tgphi=(tgy)/(tgx);
  //  printf("tgphi=%lf, \n ",tgphi);
        if (tgphi>=0) {
            if (tgx>0) {
                *phi=TMath::ATan(tgphi);
            }
            else {
                *phi=TMath::ATan(tgphi)+TMath::Pi();
            }
        }
        else {
            if (tgx>0) {
                *phi=2*TMath::Pi()-TMath::ATan(-tgphi);
            }
            else {
                *phi=TMath::Pi()-TMath::ATan(-tgphi);
            }
        }
    }
    else {
        if (tgy>0) {
            *phi=TMath::Pi()/2.0;
        }
        else if (tgy<0) {
            *phi=3.0*TMath::Pi()/2.0;
        }
        else {
            *phi=0.0;
        }
    //   printf("phi=%lf ,a=%lf, c=%lf\n", phi,a,c);
  }
}