CbmMuchTest.cxx

Go to the documentation of this file.

/*
 * CbmMuchTest.cxx
 *
 *  Created on: May 2, 2012
 *      Author: kozlov
 */
 
#include "CbmMuchTest.h"
#include "CbmClusteringGeometry.h"
#include "CbmMCTrack.h"
#include "CbmMuchDigi.h"
#include "CbmMuchGeoScheme.h"
#include "CbmMuchLayer.h"
#include "CbmMuchLayerSide.h"
#include "CbmMuchModuleGem.h"
#include "CbmMuchPad.h"
#include "CbmMuchPixelHit.h"
#include "CbmMuchPoint.h"
#include "CbmMuchStation.h"
#include "CbmStsHit.h"
#include "CbmStsPoint.h"
 
#include "FairRootManager.h"
 
#include "TClonesArray.h"
 
#include <cassert>
#include <iostream>
 
using std::cout;
using std::endl;
 
CbmMuchTest::CbmMuchTest()
  : fMeanErrorOnXforSubCenters()
  , fMeanErrorOnYforSubCenters()
  , fErrorsOnXforSubCenters()
  , fErrorsOnYforSubCenters()
  , fEfficiencyForSubCenters()
  , fEfficiency()
  , fMeanErrorOnY()
  , fMeanErrorOnX()
  , fClusters()
  , fErrorsOnX()
  , fErrorsOnY() {
  fNofPoints = 0;
  //fNofHits = 0;
  fSubStep       = 0;
  fNofSubCenters = 0;
  fNofClusters   = 0;
  fRealPoints    = 0;
}
 
CbmMuchTest::CbmMuchTest(Int_t nofPoints, Float_t subStep)
  : fMeanErrorOnXforSubCenters()
  , fMeanErrorOnYforSubCenters()
  , fErrorsOnXforSubCenters()
  , fErrorsOnYforSubCenters()
  , fMeanErrorOnY()
  , fMeanErrorOnX()
  , fErrorsOnX()
  , fErrorsOnY()
  , fEfficiencyForSubCenters()
  , fEfficiency()
  , fClusters() {
  fNofPoints     = nofPoints;
  fSubStep       = subStep;
  fNofSubCenters = 0;
  fRealPoints    = new M_Point[fNofPoints];
  fNofClusters   = 0;
}
 
CbmMuchTest::~CbmMuchTest() {}
 
void CbmMuchTest::RebuildPoints() {
  Float_t pLenght = 0;
  for (Int_t iPoint = 0; iPoint < fNofPoints; iPoint++) {
    pLenght = sqrt((fRealPoints[iPoint].x1 - fRealPoints[iPoint].x2)
                     * (fRealPoints[iPoint].x1 - fRealPoints[iPoint].x2)
                   + (fRealPoints[iPoint].y1 - fRealPoints[iPoint].y2)
                       * (fRealPoints[iPoint].y1 - fRealPoints[iPoint].y2));
    fRealPoints[iPoint].pLenght = pLenght;
    //std::cout<<"pLenght: "<<pLenght<<"; Step: "<<fSubStep<<"\n";
    if (pLenght < (fSubStep * 2)) {
      fRealPoints[iPoint].xc =
        (fRealPoints[iPoint].x1 + fRealPoints[iPoint].x2) / 2;
      fRealPoints[iPoint].yc =
        (fRealPoints[iPoint].y1 + fRealPoints[iPoint].y2) / 2;
      fRealPoints[iPoint].nofSubCenters = 1;
      fRealPoints[iPoint].xSC[0]        = fRealPoints[iPoint].xc;
      fRealPoints[iPoint].ySC[0]        = fRealPoints[iPoint].yc;
      fNofSubCenters++;
    } else {
      Int_t Dstep = pLenght / fSubStep;
      //std::cout<<"---Dstep: "<<Dstep<<"\n";
      for (Int_t iStep = 0; iStep < Dstep; iStep++) {
        fRealPoints[iPoint].xSC[iStep] =
          fRealPoints[iPoint].x1
          + (((fRealPoints[iPoint].x2 - fRealPoints[iPoint].x1) / Dstep)
             * (iStep + 1));
        fRealPoints[iPoint].ySC[iStep] =
          fRealPoints[iPoint].y1
          + (((fRealPoints[iPoint].y2 - fRealPoints[iPoint].y1) / Dstep)
             * (iStep + 1));
        fNofSubCenters++;
        //std::cout<<"------iStep: "<<iStep<<"; xSC: "<<fRealPoints[iPoint].xSC[iStep]<<"; ySC: "<<fRealPoints[iPoint].ySC[iStep]<<"\n";
      }
    }
  }
  //std::cout<<"fNofSubCenters: "<<fNofSubCenters<<"\n";
}
 
void CbmMuchTest::SetNPoints(Int_t nofPoints) {
  fNofPoints  = nofPoints;
  fRealPoints = new M_Point[fNofPoints];
}
/*void CbmMuchTest::SetNHits(Int_t nofHits)
{
        fNofHits = nofHits;
}*/
 
void CbmMuchTest::SetXIn(Float_t xIn, Int_t iPoint) {
  if (iPoint >= fNofPoints)  //Bad condition!!!
  {
    std::cout << "Error! fRealPoint is not declared!\n";
  } else {
    fRealPoints[iPoint].x1 = xIn;
    //std::cout<<"-> XIn: "<<fRealPoints[iPoint].x1<<" <- "<<iPoint<<"\n";
  }
}
 
void CbmMuchTest::SetYIn(Float_t yIn, Int_t iPoint) {
  if (iPoint >= fNofPoints)  //Bad condition!!!
  {
    std::cout << "Error! fRealPoint is not declared!\n";
  } else {
    fRealPoints[iPoint].y1 = yIn;
  }
}
 
void CbmMuchTest::SetXOut(Float_t xOut, Int_t iPoint) {
  if (iPoint >= fNofPoints)  //Bad condition!!!
  {
    std::cout << "Error! fRealPoint is not declared!\n";
  } else {
    fRealPoints[iPoint].x2 = xOut;
  }
}
 
void CbmMuchTest::SetYOut(Float_t yOut, Int_t iPoint) {
  if (iPoint >= fNofPoints)  //Bad condition!!!
  {
    std::cout << "Error! fRealPoint is not declared!\n";
  } else {
    fRealPoints[iPoint].y2 = yOut;
  }
}
 
void CbmMuchTest::SetSubStep(Int_t iStep) { fSubStep = iStep; }
 
void CbmMuchTest::SetNClusters(Int_t NCl) {
  fNofClusters             = NCl;
  fClusters                = new Cluster[fNofClusters];
  fErrorsOnX               = new Float_t[fNofClusters];
  fErrorsOnY               = new Float_t[fNofClusters];
  fErrorsOnXforSubCenters  = new Float_t[fNofClusters];
  fErrorsOnYforSubCenters  = new Float_t[fNofClusters];
  fEfficiency              = 0;
  fEfficiencyForSubCenters = 0;
}
void CbmMuchTest::SetNCl(Int_t nCl, Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].nofCluster = nCl;
  }
}
void CbmMuchTest::SetXCl(Float_t xCl, Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].xc = xCl;
  }
}
void CbmMuchTest::SetYCl(Float_t yCl, Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].yc = yCl;
  }
}
void CbmMuchTest::SetCharge(UInt_t chCl, Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].sumClCharge = chCl;
  }
}
void CbmMuchTest::SetNPads(Int_t nofPads, Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].nofPads = nofPads;
  }
}
void CbmMuchTest::SetPadInCl(Int_t nPad, Int_t iCl, Int_t iPad) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].padsInCluster[iPad] = nPad;
  }
}
void CbmMuchTest::SetCluster(Int_t nCl,
                             Float_t xCl,
                             Float_t yCl,
                             UInt_t chCl,
                             Int_t nofPads,
                             Int_t iCl) {
  if (fNofClusters == 0) {
    std::cout << "Error! fClusters is not declared!\n";
  } else {
    fClusters[iCl].nofCluster  = nCl;
    fClusters[iCl].xc          = xCl;
    fClusters[iCl].yc          = yCl;
    fClusters[iCl].sumClCharge = chCl;
    fClusters[iCl].nofPads     = nofPads;
  }
}
 
void CbmMuchTest::CalculateEfficiency() {
  /*std::cout<<"Start\n";
        std::cout<<"fNofClusters: "<<fNofClusters<<"\n";
        std::cout<<"fNofPoints: "<<fNofPoints<<"\n";*/
  fEfficiency = 100.0 * (Float_t) fNofClusters / (Float_t) fNofPoints;
  fEfficiencyForSubCenters =
    100.0 * (Float_t) fNofClusters / (Float_t) fNofSubCenters;
}
void CbmMuchTest::CalculateAccuracy() {
  fMeanErrorOnX = 0;
  fMeanErrorOnY = 0;
  for (Int_t iCl = 0; iCl < fNofClusters; iCl++) {
    fErrorsOnX[iCl]              = 100000;
    fErrorsOnY[iCl]              = 100000;
    fErrorsOnXforSubCenters[iCl] = 100000;
    fErrorsOnYforSubCenters[iCl] = 100000;
    //std::cout<<"-1----- "<<fMeanErrorOnX<<"   ---   "<<fMeanErrorOnY<<"\n";
    Float_t r1 = 100000;
    for (Int_t jCl = 0; jCl < fNofPoints; jCl++) {
      Float_t r2 = sqrt((fClusters[iCl].xc - fRealPoints[jCl].xc)
                          * (fClusters[iCl].xc - fRealPoints[jCl].xc)
                        + (fClusters[iCl].yc - fRealPoints[jCl].yc)
                            * (fClusters[iCl].yc - fRealPoints[jCl].yc));
      if (r2 < r1) {
        r1              = r2;
        fErrorsOnX[iCl] = fabs(fClusters[iCl].xc - fRealPoints[jCl].xc);
        fErrorsOnY[iCl] = fabs(fClusters[iCl].yc - fRealPoints[jCl].yc);
      }
      /*Subcentral efficiency does not work 
                         * The problem is in modules with different cell size.
                         * SV while calculating fErrorsOnYforSubCenters[iCl].
                         * The problem is with fRealPoints[jCl].ySC[kCl].
                         */
      /*if(fRealPoints[jCl].nofSubCenters > 1)
                        {
                                for(Int_t kCl = 0; kCl < fRealPoints[jCl].nofSubCenters; kCl++)
                                {
                                        r2 = sqrt((fClusters[iCl].xc - fRealPoints[jCl].xSC[kCl]) *
                                                        (fClusters[iCl].xc - fRealPoints[jCl].xSC[kCl]) +
                                                        (fClusters[iCl].yc - fRealPoints[jCl].ySC[kCl]) *
                                                        (fClusters[iCl].yc - fRealPoints[jCl].ySC[kCl]));
                                        if(r2 < r1)
                                        {
                                                fErrorsOnXforSubCenters[iCl] = fabs(fClusters[iCl].xc - fRealPoints[jCl].xSC[kCl]);
                                                fErrorsOnYforSubCenters[iCl] = fabs(fClusters[iCl].yc - fRealPoints[jCl].ySC[kCl]);
                                        }
                                }
                        }
                        else
                        {*/
      fErrorsOnXforSubCenters[iCl] = fErrorsOnX[iCl];
      fErrorsOnYforSubCenters[iCl] = fErrorsOnY[iCl];
      //}
    }
    fMeanErrorOnX += fErrorsOnX[iCl];
    fMeanErrorOnY += fErrorsOnY[iCl];
    fMeanErrorOnXforSubCenters += fErrorsOnXforSubCenters[iCl];
    fMeanErrorOnYforSubCenters += fErrorsOnYforSubCenters[iCl];
    //std::cout<<"-2----- "<<fMeanErrorOnX<<"   ---   "<<fMeanErrorOnY<<"\n";
  }
  fMeanErrorOnX              = fMeanErrorOnX / fNofClusters;
  fMeanErrorOnY              = fMeanErrorOnY / fNofClusters;
  fMeanErrorOnXforSubCenters = fMeanErrorOnXforSubCenters / fNofClusters;
  fMeanErrorOnYforSubCenters = fMeanErrorOnYforSubCenters / fNofClusters;
}
void CbmMuchTest::MainTesting() {
  CalculateEfficiency();
  CalculateAccuracy();
}