// Email : alberto.pulvirenti@ct.infn.it
// ---------------------------------------------------------------------------------
-#include <Riostream.h>
-#include <TMath.h>
#include <TString.h>
#include <TObjArray.h>
#include <TVector3.h>
#include "AliITSgeom.h"
#include "AliITStrackSA.h"
-#include "AliITSclusterV2.h"
+#include "AliITSRecPoint.h"
#include "AliITStrackV2.h"
#include "AliITStrackerANN.h"
ClassImp(AliITStrackerANN)
+
+AliITStrackerANN::AliITStrackerANN() : AliITStrackerV2(),
+fVertexX(0.0),
+fVertexY(0.0),
+fVertexZ(0.0),
+fSectorNum(0),
+fSectorWidth(0),
+fPolarInterval(0),
+fCurvNum(0),
+fCurvCut(0),
+fActMinimum(0),
+fEdge1(0),
+fEdge2(0),
+fStabThreshold(0),
+fTemperature(0),
+fGain2CostRatio(0),
+fExponent(0),
+fNLayers(0),
+fFirstModInLayer(0),
+fIndexMap(0),
+fFoundTracks(0),
+fNodes(0),
+fNeurons(0),
+fMsgLevel(0),
+fStructureOK(0),
+fGeom(0){
+ //Default constructor
+}
//__________________________________________________________________________________
AliITStrackerANN::AliITStrackerANN(const AliITSgeom *geom, Int_t msglev)
-: AliITStrackerV2(geom), fMsgLevel(msglev)
+: AliITStrackerV2(0),
+fVertexX(0.0),
+fVertexY(0.0),
+fVertexZ(0.0),
+fSectorNum(0),
+fSectorWidth(0),
+fPolarInterval(0),
+fCurvNum(0),
+fCurvCut(0),
+fActMinimum(0),
+fEdge1(0),
+fEdge2(0),
+fStabThreshold(0),
+fTemperature(0),
+fGain2CostRatio(0),
+fExponent(0),
+fNLayers(0),
+fFirstModInLayer(0),
+fIndexMap(0),
+fFoundTracks(0),
+fNodes(0),
+fNeurons(0),
+fMsgLevel(msglev),
+fStructureOK(0),
+fGeom(0)
{
/**************************************************************************
2) the flag for log-messages writing
The AliITSgeometry is used along the class,
- in order to translate the local AliITSclusterV2 coordinates
+ in order to translate the local AliITSRecPoint coordinates
into the Global reference frame, which is necessary for the
Neural Network algorithm to operate.
In case of serialized use, the log messages should be excluded,
fFoundTracks = 0;
}
+
+AliITStrackerANN::AliITStrackerANN(const AliITStrackerANN &n) : AliITStrackerV2((AliITStrackerV2&)n),
+fVertexX(n.fVertexX),
+fVertexY(n.fVertexY),
+fVertexZ(n.fVertexZ),
+fSectorNum(n.fSectorNum),
+fSectorWidth(n.fSectorWidth),
+fPolarInterval(n.fPolarInterval),
+fCurvNum(n.fCurvNum),
+fCurvCut(n.fCurvCut),
+fActMinimum(n.fActMinimum),
+fEdge1(n.fEdge1),
+fEdge2(n.fEdge2),
+fStabThreshold(n.fStabThreshold),
+fTemperature(n.fTemperature),
+fGain2CostRatio(n.fGain2CostRatio),
+fExponent(n.fExponent),
+fNLayers(n.fNLayers),
+fFirstModInLayer(n.fFirstModInLayer),
+fIndexMap(n.fIndexMap),
+fFoundTracks(n.fFoundTracks),
+fNodes(n.fNodes),
+fNeurons(n.fNeurons),
+fMsgLevel(n.fMsgLevel),
+fStructureOK(n.fStructureOK),
+fGeom(n.fGeom){
+ //Copy constructor
+}
+
+AliITStrackerANN& AliITStrackerANN::operator=(const AliITStrackerANN& arg){
+ //Assignment operator
+ this->~AliITStrackerANN();
+ new(this) AliITStrackerANN(arg);
+ return *this;
+}
+
//__________________________________________________________________________________
void AliITStrackerANN::SetCuts
(Int_t ncurv, Double_t *curv, Double_t *theta2D, Double_t *theta3D, Double_t *helix)
Operations:
essentially, determines the ITS module index from the
- detector index of the AliITSclusterV2 object, and extracts
+ detector index of the AliITSRecPoint object, and extracts
the roto-translation from the ITS geometry, to convert
the local module coordinates into the global ones.
return kFALSE;
}
// checks if the referenced cluster exists and corresponds to the passed reference
- AliITSclusterV2 *refCluster = (AliITSclusterV2*) GetCluster(refIndex);
+ AliITSRecPoint *refCluster = (AliITSRecPoint*) GetCluster(refIndex);
if (!refCluster) {
Error("GetGlobalXYZ", "Cluster not found for index %d", refIndex);
return kFALSE;
neuron-creation phase.
Arguments:
- 1) reference index of the correlated AliITSclusterV2 object
+ 1) reference index of the correlated AliITSRecPoint object
Operations:
- allocates the new AliITSnode objects
If this file must not be created, simply pass a NULL argument
Operations:
- - for each AliITSclusterV2 in each AliITSlayer, a ne AliITSnode
+ - for each AliITSRecPoint in each AliITSlayer, a ne AliITSnode
is created and stored in the correct location.
Return values:
TObjArray *sector = 0;
Int_t ilayer, isector, itheta, nF;
AliITSnode *node1 = 0, *node2 = 0;
- //AliITSclusterV2 *cluster1 = 0, *cluster2 = 0;
+ //AliITSRecPoint *cluster1 = 0, *cluster2 = 0;
for (ilayer = 0; ilayer < 6; ilayer++) {
for (isector = 0; isector < fSectorNum; isector++) {
}
//if (!RiemannFit(fNLayers, node, param)) continue;
// initialization of Kalman Filter Tracking
- AliITSclusterV2 *cluster = (AliITSclusterV2*)GetCluster(node[0]->ClusterRef());
+ AliITSRecPoint *cluster = (AliITSRecPoint*)GetCluster(node[0]->ClusterRef());
Int_t mod = cluster->GetDetectorIndex();
Int_t lay, lad, det;
fGeom->GetModuleId(mod, lay, lad, det);
y0, z0,
param[4], param[7], param[3], 1);
for (l = 0; l < fNLayers; l++) {
- cluster = (AliITSclusterV2*)GetCluster(node[l]->ClusterRef());
+ cluster = (AliITSRecPoint*)GetCluster(node[l]->ClusterRef());
if (cluster) trac->AddClusterV2(l, (node[l]->ClusterRef() & 0x0fffffff)>>0);
}
AliITStrackV2* ot = new AliITStrackV2(*trac);
- ot->ResetCovariance();
+ ot->ResetCovariance(10.);
ot->ResetClusters();
if (RefitAt(49.,ot,trac)) { //fit from layer 1 to layer 6
AliITStrackV2 *otrack2 = new AliITStrackV2(*ot);
- otrack2->ResetCovariance();
+ otrack2->ResetCovariance(10.);
otrack2->ResetClusters();
//fit from layer 6 to layer 1
if (RefitAt(3.7,otrack2,ot)) fFoundTracks->AddLast(otrack2);
//if (!RiemannFit(fNLayers, trackitem, param)) continue;
if (!annTrack.RiemannFit()) continue;
// initialization of Kalman Filter Tracking
- AliITSclusterV2 *cluster = (AliITSclusterV2*)GetCluster(annTrack[0]->ClusterRef());
+ AliITSRecPoint *cluster = (AliITSRecPoint*)GetCluster(annTrack[0]->ClusterRef());
Int_t mod = cluster->GetDetectorIndex();
Int_t lay, lad, det;
fGeom->GetModuleId(mod, lay, lad, det);
annTrack.Curv(), 1);
for (Int_t l = 0; l < fNLayers; l++) {
if (!annTrack[l]) continue;
- cluster = (AliITSclusterV2*)GetCluster(annTrack[l]->ClusterRef());
+ cluster = (AliITSRecPoint*)GetCluster(annTrack[l]->ClusterRef());
if (cluster) trac->AddClusterV2(l, (annTrack[l]->ClusterRef() & 0x0fffffff)>>0);
}
AliITStrackV2* ot = new AliITStrackV2(*trac);
- ot->ResetCovariance();
+ ot->ResetCovariance(10.);
ot->ResetClusters();
if (RefitAt(49.,ot,trac)) { //fit from layer 1 to layer 6
AliITStrackV2 *otrack2 = new AliITStrackV2(*ot);
- otrack2->ResetCovariance();
+ otrack2->ResetCovariance(10.);
otrack2->ResetClusters();
//fit from layer 6 to layer 1
if (RefitAt(3.7,otrack2,ot)) fFoundTracks->AddLast(otrack2);
******************************************/
//__________________________________________________________________________________
-AliITStrackerANN::AliITSnode::AliITSnode()
-: fUsed(kFALSE), fClusterRef(-1),
- fMatches(NULL), fInnerOf(NULL), fOuterOf(NULL),
- fNext(NULL), fPrev(NULL)
+AliITStrackerANN::AliITSnode::AliITSnode():
+fX(0.0),
+fY(0.0),
+fZ(0.0),
+fEX2(0.0),
+fEY2(0.0),
+fEZ2(0.0),
+fUsed(kFALSE),
+fClusterRef(-1),
+fMatches(NULL),
+fInnerOf(NULL),
+fOuterOf(NULL),
+fNext(NULL),
+fPrev(NULL)
{
// Constructor for the embedded 'AliITSnode' class.
// It initializes all pointer-like objects.
- fX = fY = fZ = 0.0;
- fEX2 = fEY2 = fEZ2 = 0.0;
}
+AliITStrackerANN::AliITSnode::AliITSnode(const AliITSnode &n) : TObject((TObject&)n),
+fX(n.fX),
+fY(n.fY),
+fZ(n.fZ),
+fEX2(n.fEX2),
+fEY2(n.fEY2),
+fEZ2(n.fEZ2),
+fUsed(n.fUsed),
+fClusterRef(n.fClusterRef),
+fMatches(n.fMatches),
+fInnerOf(n.fInnerOf),
+fOuterOf(n.fOuterOf),
+fNext(n.fNext),
+fPrev(n.fPrev){
+ //copy constructor
+}
//__________________________________________________________________________________
AliITStrackerANN::AliITSnode::~AliITSnode()
{
//__________________________________________________________________________________
AliITStrackerANN::AliITSneuron::AliITSneuron
-(AliITSnode *inner, AliITSnode *outer, Double_t minAct, Double_t maxAct)
- : fUsed(0), fInner(inner), fOuter(outer)
+(AliITSnode *inner, AliITSnode *outer, Double_t minAct, Double_t maxAct):
+fUsed(0),
+fActivation(0),
+fInner(inner),
+fOuter(outer),
+fGain(0)
{
// Default neuron constructor
fActivation = gRandom->Rndm() * (maxAct-minAct) + minAct;
fGain = new TObjArray;
}
-
+
+AliITStrackerANN::AliITSneuron::AliITSneuron(const AliITSneuron &n) : TObject((TObject&)n),
+fUsed(n.fUsed),
+fActivation(n.fActivation),
+fInner(n.fInner),
+fOuter(n.fOuter),
+fGain(n.fGain){
+ //copy constructor
+}
//__________________________________________________________________________________
Double_t AliITStrackerANN::AliITSneuron::Activate(Double_t temperature)
{
**********************************************/
//__________________________________________________________________________________
-AliITStrackerANN::AliITStrackANN::AliITStrackANN(Int_t dim) : fNPoints(dim)
+AliITStrackerANN::AliITStrackANN::AliITStrackANN(Int_t dim) :
+fNPoints(dim),
+fXCenter(0.0),
+fYCenter(0.0),
+fRadius(0.0),
+fCurv(0.0),
+fDTrans(0.0),
+fDLong(0.0),
+fTanLambda(0.0),
+fPhi(0.0),
+fNode(0)
{
// Default constructor for the AliITStrackANN class
- fXCenter = 0.0;
- fYCenter = 0.0;
- fRadius = 0.0;
- fCurv = 0.0;
- fDTrans = 0.0;
- fDLong = 0.0;
- fTanLambda = 0.0;
-
if (! dim) {
fNode = 0;
}
}
}
+AliITStrackerANN::AliITStrackANN::AliITStrackANN(const AliITStrackANN &n) : TObject((TObject&)n),
+fNPoints(n.fNPoints),
+fXCenter(n.fXCenter),
+fYCenter(n.fYCenter),
+fRadius(n.fRadius),
+fCurv(n.fCurv),
+fDTrans(n.fDTrans),
+fDLong(n.fDLong),
+fTanLambda(n.fTanLambda),
+fPhi(n.fPhi),
+fNode(n.fNode)
+{
+ //copy constructor
+}
//__________________________________________________________________________________
Int_t AliITStrackerANN::AliITStrackANN::CheckOccupation() const
{