---

AlConcreteVertices.cpp

Go to the documentation of this file.

//
// Implementation of classes AlVertex and AlUsrVertex
//
// Author : C. Delaere
//

#include <vector>
#include <stdlib.h>
#include <math.h>
#include "AlConcreteVertices.h"

//
// AlVertex
//

// constructor
AlVertex::AlVertex():QvrtBase()
{
        qvrt=NULL;
}

// copy constructor
AlVertex::AlVertex(const AlVertex& origin):QvrtBase(origin)
{
        qvrt = origin.qvrt;
}

// destructor
AlVertex::~AlVertex() {}

// set the pointer to QVRT
void AlVertex::SetPointer(QVRT* pointer)
{
        qvrt=pointer;
        setA4V(qvrt->VX,qvrt->VY,qvrt->VZ,0);
}

// ALPHA wrapping
int AlVertex::KVN() const {if(qvrt != NULL) return qvrt->VN; else return -1;}
int AlVertex::KVTYPE() const {if(qvrt != NULL) return qvrt->TY; else return -1;}
double AlVertex::QVCHIF() const {if(qvrt != NULL) return qvrt->CF; else return -1;}
HepDouble min1(HepDouble a, int b, int c) { return -1;}
HepSymMatrix AlVertex::QVEM() const
{
        HepSymMatrix tmpobj(3,0);
        if(qvrt != NULL)
        {                               
                int cnt=0;
                for(unsigned int i=1;i<=3;i++)
                        for(unsigned int j=1;j<=i;j++)
                                tmpobj(i,j)=qvrt->EM[cnt++];
        }
        else
        {
                tmpobj.apply(&min1);
        }
        return tmpobj;
}
float AlVertex::QVEM(int i,int j) const
{
        if(qvrt == NULL) return -1;
        if(i*j==1) return qvrt->EM[1];
        if(i*j==2) return qvrt->EM[2];
        if(i*j==4) return qvrt->EM[3];
        if(i*j==3) return qvrt->EM[4];
        if(i*j==6) return qvrt->EM[5];
        if(i*j==9) return qvrt->EM[6];
        return -1;
}
float AlVertex::PKINK() const {if(qvrt != NULL) return qvrt->PK; else return -1;}
float AlVertex::PTOUT() const {if(qvrt != NULL) return qvrt->PT; else return -1;}
float AlVertex::PLOUT() const {if(qvrt != NULL) return qvrt->PL; else return -1;}
int   AlVertex::IHYPK() const {if(qvrt != NULL) return qvrt->HY; else return -1;}
float AlVertex::TOF()   const {if((qvrt != NULL)&&(qvrt->AF != NULL)) return qvrt->AF->TO; else return -1;}
char* AlVertex::VertexVolumeName() const 
{
        if((qvrt != NULL)&&(qvrt->AF != NULL))  
                return qvrt->AF->VN; 
        else 
                return "none";
}
char* AlVertex::VertexMechanisme() const
{
        if((qvrt != NULL)&&(qvrt->AF != NULL))
                return qvrt->AF->VM; 
        else 
                return "none";
}


//
// AlUsrVertex
//

// constructor
AlUsrVertex::AlUsrVertex():QvrtBase() 
{
        HepSymMatrix _tmp(3,0); 
        _EM.assign(_tmp);
        _EM.apply(&min1);
        _CHI2 = -1;
}

// copy constructor
AlUsrVertex::AlUsrVertex(const AlUsrVertex& origin):QvrtBase(origin)
{
        _EM = origin._EM;
        _CHI2 = origin._CHI2;
}

// conversion constructor
AlUsrVertex::AlUsrVertex(const AlVertex& origin):QvrtBase(origin)
{
        _EM = origin.QVEM();
        _CHI2 = origin.QVCHIF();
}

//destructor
AlUsrVertex::~AlUsrVertex() {}

// set private members
void AlUsrVertex::setEM(const HepSymMatrix& matrix)
{
        _EM = matrix;
}
void AlUsrVertex::setCHIF(const double chi2)
{
        _CHI2 = chi2;
}

// alpha wrapping
int AlUsrVertex::KVNTYPE() const {return 6;}
double AlUsrVertex::QVCHIF() const {return _CHI2;}
HepSymMatrix AlUsrVertex::QVEM() const {return _EM;}
float AlUsrVertex::QVEM(int i,int j) const {return _EM(i,j);}

---