[u/mrichter/AliRoot.git] / PWG3 / muondep / AliCheckMuonDetEltResponse.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//Class to check the response of the detection elements of the  MUON tracking chambers 
//in function of the position in the detection element.
//Author:  Nicolas LE BRIS - SUBATECH Nantes
//Modified by Matthieu LENHARDT - SUBATECH Nantes

//PWG3/muondep:
#include "AliCheckMuonDetEltResponse.h"

//include STEER:
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"

//include MUON:
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONTrackExtrap.h"
#include "AliMUONVCluster.h"
#include "AliMUONConstants.h"
#include "AliMUONESDInterface.h"
#include "AliMUONGeometryTransformer.h"

//include MUON/mapping:
#include "mapping/AliMpDEManager.h"
#include "mapping/AliMpSegmentation.h"
#include "mapping/AliMpSlatSegmentation.h"
#include "mapping/AliMpSectorSegmentation.h"
#include "mapping/AliMpPad.h"

//include ROOT:
#include <TH2F.h>
#include <TList.h>
#include <TClonesArray.h>

/// \cond CLASSIMP
ClassImp(AliCheckMuonDetEltResponse)
/// \endcond

const Int_t AliCheckMuonDetEltResponse::fgkNCh                   = AliMUONConstants::NTrackingCh();
const Int_t AliCheckMuonDetEltResponse::fgkNSt                   = AliMUONConstants::NTrackingSt();
const Int_t AliCheckMuonDetEltResponse::fgkNDE                   = 156;
const Int_t AliCheckMuonDetEltResponse::fgkNbrOfDetectionElt[10] = {4, 4, 4, 4, 18, 18, 26, 26, 26, 26};
const Int_t AliCheckMuonDetEltResponse::fgkFirstDetectionElt[10] = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
const Int_t AliCheckMuonDetEltResponse::fgkOffset                = 100;

//_____________________________________________________________________________
AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse() 
: TObject(),
  fkTransformer(0x0),
  fESD(0x0),
  fTracksTotalNbr(0x0),
  fNbrUsableTracks(0),
  fTrackParams(0x0),
  fTrackParam(0x0),
  fCluster(0x0),
  fDetEltTDHistList(0),
  fDetEltTTHistList(0),
  fChamberTDHistList(0),
  fChamberTTHistList(0)
{
/// Default constructor

    fNbrUsableTracks = 0;

    for (Int_t iCluster = 0; iCluster<fgkNCh; ++iCluster)
      fNbrClustersCh[iCluster] = 0;

    for (Int_t i=0; i<fgkNCh; ++i)
      fTrackFilter[i] = 0;
}

//_____________________________________________________________________________
AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse(const AliCheckMuonDetEltResponse& src) 
: TObject(src),
  fkTransformer(0x0),
  fESD(0x0),
  fTracksTotalNbr(0x0),
  fNbrUsableTracks(0),
  fTrackParams(0x0),
  fTrackParam(0x0),
  fCluster(0x0),
  fDetEltTDHistList(0),
  fDetEltTTHistList(0),
  fChamberTDHistList(0),
  fChamberTTHistList(0)
{
 src.Copy(*this);
}
//_____________________________________________________________________________
AliCheckMuonDetEltResponse& AliCheckMuonDetEltResponse::operator=(const AliCheckMuonDetEltResponse& src) 
{
  /// assignement operator
  if ( this != &src ) 
  {
    src.Copy(*this);
  }
  return *this;
}

//_____________________________________________________________________________
AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse(const AliMUONGeometryTransformer* transformer,
						       AliESDEvent* esd,
						       TList* detEltTDHistList,
						       TList* detEltTTHistList,
						       TList* chamberTDHistList,
						       TList* chamberTTHistList) 
: TObject(),
  fkTransformer(transformer),
  fESD(esd),
  fTracksTotalNbr(0),
  fNbrUsableTracks(0),
  fTrackParams(0x0),
  fTrackParam(0),
  fCluster(0),
  fDetEltTDHistList(detEltTDHistList),
  fDetEltTTHistList(detEltTTHistList),
  fChamberTDHistList(chamberTDHistList),
  fChamberTTHistList(chamberTTHistList)
{
/// Constructor

    fNbrUsableTracks = 0;

    for (Int_t iCluster = 0; iCluster<fgkNCh; ++iCluster)
      fNbrClustersCh[iCluster] = 0;
    
    for (Int_t i=0; i<fgkNCh; ++i)
      fTrackFilter[i] = 0;
}


//_____________________________________________________________________________
AliCheckMuonDetEltResponse::~AliCheckMuonDetEltResponse()

{
/// Destructor
    delete fTrackParams;
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::CheckDetEltResponse()
{
//
//Cataloging positions (X,Y) of the clusters detected in the detection elements
//(fDetEltTDHistList), and positions of crossing points between all the
//tracks and the detection elements (fDetEltTTHistList).
//Efficiency = 100 * fDetEltTDHistList / fDetEltTTHistList.

//Loop on tracks
//--------------
  TrackLoop();
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::TrackLoop()
{
// Check if the track is kept
  AliESDMuonTrack* esdTrack;
  AliMUONTrack track;
  Int_t nTracks, iTrack;

  nTracks = (Int_t)fESD -> GetNumberOfMuonTracks();
  fTrackParams = new TClonesArray();
  ///Begininig of the loop:
  //if (fESD->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL"))
  {
    for (iTrack = 0; iTrack < nTracks; iTrack++)
      {
	esdTrack   = fESD -> GetMuonTrack(iTrack);
	
	if(esdTrack->ContainTrackerData() && esdTrack->GetMatchTrigger() > 0)
	  {
	    AliMUONESDInterface::ESDToMUON(*esdTrack, track);
	    fTrackParams = track.GetTrackParamAtCluster();
	    TrackParamLoop(); //!<Loop on trackParam.
	    fNbrUsableTracks += 1;
	  }
      }
  }
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::TrackParamLoop()
{
// Loop on all the track params and fill the histos
  Int_t nTrackParams = (Int_t) fTrackParams->GetEntriesFast();  //!<Number of trackParams in the track.
  Int_t iTrackParam = 0;                                        //!<Number of the trackParam of the track.
  Int_t oldChamber = -1, newChamber = 0; //!<To check if there is 0, 1 or 2 (overlap cases) clusters in the same chamber for a track.                                      
  Int_t detElt;                          //!<Detection element Id.
  
  for (Int_t ch = 0; ch < fgkNCh; ++ch)
    fTrackFilter[ch] = 0;

  Double_t posXL, posYL, posZL;          //!<Local positions.
  Double_t posXG, posYG, posZG;          //!<Global. positions.
  Int_t chamberResponse [10] = {0};      //!<1 if the chamber has responded; 0 if not
  
  for (iTrackParam = 0; iTrackParam < nTrackParams; ++iTrackParam)
    { 
      fTrackParam = (AliMUONTrackParam*) fTrackParams->At(iTrackParam);
      fCluster    = (AliMUONVCluster*  ) fTrackParam ->GetClusterPtr();    
      fTrackFilter   [fCluster->GetChamberId()] = 1;
      chamberResponse[fCluster->GetChamberId()] = 1;
    }

  for (Int_t station = 0; station < fgkNSt-1; ++station)
    {
      Int_t filter;                                                       //<!
      Int_t ch1, ch2, ch3, ch4;                                           //<!
      ch1 = 2*station;                                                    //<!
      ch2 = 2*station + 1;                                                //<!
      ch3 = 2*station + 2;                                                //<!
      ch4 = 2*station + 3;                                                //<!
                                                                          //<!For the efficiency calculation the tracks
      if (station < 3 )                                                   //<!reconstructed must have responded to the
	{                                                                 //<!criteria of the tracking. 
	  filter            = fTrackFilter[ch1];                          //<!And that's why the tracks usable for the 
	  fTrackFilter[ch1] = fTrackFilter[ch2];                          //<!intrinsic efficiency calculation are
	  fTrackFilter[ch2] = filter;                                     //<!the tracks which have one or two clusters
	}                                                                 //<!in each station. So the case where a track
                                                                          //<!hasn't a cluster in a station is not
      else                                                                //<!taking into account.
	{                                                                 //<!This part solves the problem. See the ALICE 
	  if (chamberResponse[ch3]*chamberResponse[ch4] != 0)             //<!note of Diego STOCCO on the trigger efficiency
	    {                                                             //<!
	      filter            = fTrackFilter[ch1];                      //<!
	      fTrackFilter[ch1] = fTrackFilter[ch2];                      //<!
	      fTrackFilter[ch2] = filter;                                 //<!
	    }                                                             //<!
	  else                                                            //<!
	    {                                                             //<!
	      fTrackFilter[ch1] = 0;                                      //<!
	      fTrackFilter[ch2] = 0;                                      //<!
	    }                                                             //<!

	  if (chamberResponse[ch1]*chamberResponse[ch2] != 0)
	    {
	      filter            = fTrackFilter[ch3];
	      fTrackFilter[ch3] = fTrackFilter[ch4];
	      fTrackFilter[ch4] = filter;
	    }
	  else
	    {
	      fTrackFilter[ch3] = 0;
	      fTrackFilter[ch4] = 0;
	    }
	}
    }
  

  ///Begining of the loop:
  for (iTrackParam = 0; iTrackParam < nTrackParams; ++iTrackParam)
    {
      fTrackParam = (AliMUONTrackParam*) fTrackParams->At(iTrackParam);
      fCluster    = (AliMUONVCluster*  ) fTrackParam ->GetClusterPtr(); 
      
      newChamber  = fCluster->GetChamberId();
      detElt      = fCluster->GetDetElemId();

      ///Global and local positions calculation:
      posXG = fTrackParam->GetNonBendingCoor(); 
      posYG = fTrackParam->GetBendingCoor(); 
      posZG = fTrackParam->GetZ(); 
      
      fkTransformer->Global2Local(detElt, posXG, posYG, posZG, posXL, posYL, posZL);  //!<Transfomation from global to local positions.
      
      ///Filling histograms of the cluster positions on the detection element of the TRACKS DETECTED (TD):
      FillTDHistos(newChamber, detElt, posXL, posYL);
    
      ///Filling histograms of the cluster positions on the detection element of ALL THE TRACKS (TT):
      FillTTHistos(newChamber, detElt, posXL, posYL);

      if (newChamber != oldChamber) 
	{
	  if (newChamber > oldChamber + 1)                                 //!<Check if it doesn't miss a chamber.
	    {
	      Int_t nbrMissChamber = newChamber - (oldChamber + 1);
	      FindAndFillMissedDetElt(fTrackParam, oldChamber+1, nbrMissChamber); //!<Calculation of the parameters of the missing cluster(s).
	    }
	    
	  if ( iTrackParam == nTrackParams - 1 && newChamber != fgkNCh-1)           //!<Check if the last chamber, chamber 9 (from 0 to 9) has responded.
	    FindAndFillMissedDetElt(fTrackParam, fgkNCh-1, 1);                      //!<Calculation of the parameters of the missing cluster(s) in the last chamber.
	    
	}
      oldChamber = newChamber; 
    } 
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::FillTDHistos(Int_t chamber,
					      Int_t detElt,
					      Double_t posXL,
					      Double_t posYL)
{
// Fill the histo for tracks detected
  if(fTrackFilter[chamber]== 1)
    {
      Int_t iDet = 0; //!<Position of the detection element in the histograms' list.
      iDet = FromDetElt2iDet(chamber, detElt);
      ((TH2F*) fDetEltTDHistList->At(iDet))->Fill(posXL, posYL);

      Int_t detEltLocalId = 0;  //!<Id of the detection element in the station
      detEltLocalId =  FromDetElt2LocalId(chamber, detElt);
      ((TH1F*) fChamberTDHistList->At(chamber))->Fill(detEltLocalId);
      ((TH1F*) fChamberTDHistList->At(fgkNCh))->Fill(chamber + 1);
   }
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::FillTTHistos(Int_t chamber,
					      Int_t detElt,
					      Double_t posXL,
					      Double_t posYL)
{
// Fill the histo for total number of tracks
  if(fTrackFilter[chamber] == 1)
    {
      Int_t iDet = 0; //!<Position of the detection element in the histograms' list.
      iDet = FromDetElt2iDet(chamber, detElt);
      ((TH2F*) fDetEltTTHistList->At(iDet)) -> Fill(posXL, posYL);
     
      Int_t detEltLocalId = 0;  //!<Id of the detection element in the station
      detEltLocalId =  FromDetElt2LocalId(chamber, detElt);
      ((TH1F*) fChamberTTHistList->At(chamber))->Fill(detEltLocalId);
      ((TH1F*) fChamberTTHistList->At(fgkNCh))->Fill(chamber + 1);
    }
}


//_____________________________________________________________________________
Int_t AliCheckMuonDetEltResponse::FromDetElt2iDet(Int_t chamber, 
						  Int_t detElt) const
{
///
///Connexion between the detection element X and its position in the list of histograms iX.
///

    Int_t iDet = 0; //!<Position of the detection element (detElt) in the histograms' list.

    if (chamber<4)             iDet = detElt-fgkOffset*(chamber+1)+ 4* chamber      ; 
    if (chamber>3 && chamber<6) iDet = detElt-fgkOffset*(chamber+1)+18*(chamber-4)+16;
    if (chamber>5)             iDet = detElt-fgkOffset*(chamber+1)+26*(chamber-6)+52;

    return iDet;    
}


//_____________________________________________________________________________
Int_t AliCheckMuonDetEltResponse::FromDetElt2LocalId(Int_t chamber, 
						     Int_t detElt) const
{
///
///Connexion between the detection element X and its number in the station.
///

    Int_t localId = 0; //!<Position of the detection element (detElt) in the histograms' list.
    localId = detElt - (chamber+1) * 100;

    return localId;    
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::FindAndFillMissedDetElt(AliMUONTrackParam* extrapTrackParam, 
							 Int_t firstMissCh,
							 Int_t nbrMissCh)
{
///
///Find which detection elements should have been hit but were missed, 
///and fill the TT histos appropriately
///
  for (Int_t iCh = 0; iCh < nbrMissCh; ++iCh)
    {
      Int_t chamber = firstMissCh + iCh;
      Int_t nbrOfDetElt =  AliMpDEManager::GetNofDEInChamber(chamber, kTRUE); //!<Number of detection elements in the chamber.
      
      Double_t pos1[6] = {0, 0, 0, 0, 0, 0};        //!<First point used to compute the extrapolated point (first 3 for global coordinates, last 3 for local).
      Double_t pos2[6] = {0, 0, 0, 0, 0, 0};        //!<Second point used to compute the extrapolated point (first 3 for global coordinates, last 3 for local).
      Double_t posMiss[2] = {0, 0};                 //!<(X, Y) local coordinates of the missing cluster.
            
      pos1[2] = AliMUONConstants::DefaultChamberZ(chamber);           //!<Z of point 1, defined by being the Z of the chamber in "perfect" position.
      AliMUONTrackExtrap::ExtrapToZ(extrapTrackParam, pos1[2]);
      pos1[0] = extrapTrackParam->GetNonBendingCoor();                //!<X of point 1, extrapolated by following the Track.
      pos1[1] = extrapTrackParam->GetBendingCoor();                   //!<Y of point 1, extrapolated by following the Track.
      
      pos2[2] = AliMUONConstants::DefaultChamberZ(chamber) + AliMUONConstants::DzCh();   //!<Z of point 2, defined by being the Z of the chamber in "perfect" position 
      AliMUONTrackExtrap::ExtrapToZ(extrapTrackParam, pos2[2]);                           //!< + plus a small shift (the distance between two stations in a same chamber).
      pos2[0] = extrapTrackParam->GetNonBendingCoor();                                   //!<X of point 2, extrapolated by following the Track.                        
      pos2[1] = extrapTrackParam->GetBendingCoor();                                      //!<Y of point 2, extrapolated by following the Track.                          
      
      
	for (Int_t iDE = 0; iDE < nbrOfDetElt; iDE++)                    //!<Loop on all the detection element of the chamber
	  {
	    Int_t deId = (chamber + 1)*fgkOffset + iDE;                        //!<detection element Id 
	    
	    fkTransformer->Global2Local(deId, pos1[0], pos1[1], pos1[2], pos1[3], pos1[4], pos1[5]);      //!<convesrion of point 1 and 2 in the local coordinates
	    fkTransformer->Global2Local(deId, pos2[0], pos2[1], pos2[2], pos2[3], pos2[4], pos2[5]);
	    
	    CoordinatesOfMissingCluster(pos1[3], pos1[4], pos1[5], pos2[3], pos2[4], pos2[5], posMiss[0], posMiss[1]);

	    Bool_t isMissed = kFALSE;
	    if (chamber < 4)
	      isMissed = CoordinatesInDetEltSt12(deId, posMiss[0], posMiss[1]);
	    else
	      isMissed = CoordinatesInDetEltSt345(deId, posMiss[0], posMiss[1]);

	    if (isMissed)
	      FillTTHistos(chamber, deId, posMiss[0], posMiss[1]);
	  }
    }
}


//_____________________________________________________________________________
void AliCheckMuonDetEltResponse::CoordinatesOfMissingCluster(Double_t x1, Double_t y1, Double_t z1,
							     Double_t x2, Double_t y2, Double_t z2,
							     Double_t& x, Double_t& y) const
{
  //
  //Compute the coordinates of the missing cluster.
  //There are defined by the intersection between the straigth line joining two extrapolated points (1 and 2) and the detection element plane.
  //In the local coordinates, this means Z=0 in the parametric equation of the line.
  //

  Double_t t = 0;
  t = - z1 / (z2 - z1);
  
  x = t * (x2 - x1) + x1;
  y = t * (y2 - y1) + y1;
}


//_____________________________________________________________________________
Bool_t AliCheckMuonDetEltResponse::CoordinatesInDetEltSt345(Int_t DeId, Double_t x, Double_t y)
{
  //
  //Return kTRUE if the coordinates are in the Detection Element, for station 3, 4 and 5.
  //This is done by checking if a pad correspond to the (x, y) position.
  //  

  AliMpPad pad1;
  AliMpPad pad2;

  AliMpSlatSegmentation *segm1 = new AliMpSlatSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSlat(DeId, AliMp::kCath0));
  AliMpSlatSegmentation *segm2 = new AliMpSlatSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSlat(DeId, AliMp::kCath1));
  pad1 = segm1->PadByPosition(x, y, kFALSE);
  pad2 = segm2->PadByPosition(x, y, kFALSE);
 
  if (pad1.IsValid() && pad2.IsValid())
    return kTRUE;
  else
    return kFALSE;
}


//_____________________________________________________________________________
Bool_t AliCheckMuonDetEltResponse::CoordinatesInDetEltSt12(Int_t DeId, Double_t x, Double_t y)
{
  //Return kTRUE if the coordinates are in the Detection Element, for station 1 and 2.
  //This is done by checking if a pad correspond to the (x, y) position.
  
  AliMpPad pad1;
  AliMpPad pad2;

  AliMpSectorSegmentation *segm1 = new AliMpSectorSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSector(DeId, AliMp::kCath0));
  AliMpSectorSegmentation *segm2 = new AliMpSectorSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSector(DeId, AliMp::kCath1));
  pad1 = segm1->PadByPosition(x, y, kFALSE);
  pad2 = segm2->PadByPosition(x, y, kFALSE);
 
  if (pad1.IsValid() && pad2.IsValid())
    return kTRUE;
  else
    return kFALSE;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//Class to check the response of the detection elements of the MUON tracking chambers
	17	//in function of the position in the detection element.
	18	//Author: Nicolas LE BRIS - SUBATECH Nantes
	19	//Modified by Matthieu LENHARDT - SUBATECH Nantes
	20
	21	//PWG3/muondep:
	22	#include "AliCheckMuonDetEltResponse.h"
	23
	24	//include STEER:
	25	#include "AliESDEvent.h"
	26	#include "AliESDMuonTrack.h"
	27
	28	//include MUON:
	29	#include "AliMUONTrack.h"
	30	#include "AliMUONTrackParam.h"
	31	#include "AliMUONTrackExtrap.h"
	32	#include "AliMUONVCluster.h"
	33	#include "AliMUONConstants.h"
	34	#include "AliMUONESDInterface.h"
	35	#include "AliMUONGeometryTransformer.h"
	36
	37	//include MUON/mapping:
	38	#include "mapping/AliMpDEManager.h"
	39	#include "mapping/AliMpSegmentation.h"
	40	#include "mapping/AliMpSlatSegmentation.h"
	41	#include "mapping/AliMpSectorSegmentation.h"
	42	#include "mapping/AliMpPad.h"
	43
	44	//include ROOT:
	45	#include <TH2F.h>
	46	#include <TList.h>
	47	#include <TClonesArray.h>
	48
	49	/// \cond CLASSIMP
	50	ClassImp(AliCheckMuonDetEltResponse)
	51	/// \endcond
	52
	53	const Int_t AliCheckMuonDetEltResponse::fgkNCh = AliMUONConstants::NTrackingCh();
	54	const Int_t AliCheckMuonDetEltResponse::fgkNSt = AliMUONConstants::NTrackingSt();
	55	const Int_t AliCheckMuonDetEltResponse::fgkNDE = 156;
	56	const Int_t AliCheckMuonDetEltResponse::fgkNbrOfDetectionElt[10] = {4, 4, 4, 4, 18, 18, 26, 26, 26, 26};
	57	const Int_t AliCheckMuonDetEltResponse::fgkFirstDetectionElt[10] = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
	58	const Int_t AliCheckMuonDetEltResponse::fgkOffset = 100;
	59
	60	//_____________________________________________________________________________
	61	AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse()
	62	: TObject(),
	63	fkTransformer(0x0),
	64	fESD(0x0),
	65	fTracksTotalNbr(0x0),
	66	fNbrUsableTracks(0),
	67	fTrackParams(0x0),
	68	fTrackParam(0x0),
	69	fCluster(0x0),
	70	fDetEltTDHistList(0),
	71	fDetEltTTHistList(0),
	72	fChamberTDHistList(0),
	73	fChamberTTHistList(0)
	74	{
	75	/// Default constructor
	76
	77	fNbrUsableTracks = 0;
	78
	79	for (Int_t iCluster = 0; iCluster<fgkNCh; ++iCluster)
	80	fNbrClustersCh[iCluster] = 0;
	81
	82	for (Int_t i=0; i<fgkNCh; ++i)
	83	fTrackFilter[i] = 0;
	84	}
	85
	86	//_____________________________________________________________________________
	87	AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse(const AliCheckMuonDetEltResponse& src)
	88	: TObject(src),
	89	fkTransformer(0x0),
	90	fESD(0x0),
	91	fTracksTotalNbr(0x0),
	92	fNbrUsableTracks(0),
	93	fTrackParams(0x0),
	94	fTrackParam(0x0),
	95	fCluster(0x0),
	96	fDetEltTDHistList(0),
	97	fDetEltTTHistList(0),
	98	fChamberTDHistList(0),
	99	fChamberTTHistList(0)
	100	{
	101	src.Copy(*this);
	102	}
	103	//_____________________________________________________________________________
	104	AliCheckMuonDetEltResponse& AliCheckMuonDetEltResponse::operator=(const AliCheckMuonDetEltResponse& src)
	105	{
	106	/// assignement operator
	107	if ( this != &src )
	108	{
	109	src.Copy(*this);
	110	}
	111	return *this;
	112	}
	113
	114	//_____________________________________________________________________________
	115	AliCheckMuonDetEltResponse::AliCheckMuonDetEltResponse(const AliMUONGeometryTransformer* transformer,
	116	AliESDEvent* esd,
	117	TList* detEltTDHistList,
	118	TList* detEltTTHistList,
	119	TList* chamberTDHistList,
	120	TList* chamberTTHistList)
	121	: TObject(),
	122	fkTransformer(transformer),
	123	fESD(esd),
	124	fTracksTotalNbr(0),
	125	fNbrUsableTracks(0),
	126	fTrackParams(0x0),
	127	fTrackParam(0),
	128	fCluster(0),
	129	fDetEltTDHistList(detEltTDHistList),
	130	fDetEltTTHistList(detEltTTHistList),
	131	fChamberTDHistList(chamberTDHistList),
	132	fChamberTTHistList(chamberTTHistList)
	133	{
	134	/// Constructor
	135
	136	fNbrUsableTracks = 0;
	137
	138	for (Int_t iCluster = 0; iCluster<fgkNCh; ++iCluster)
	139	fNbrClustersCh[iCluster] = 0;
	140
	141	for (Int_t i=0; i<fgkNCh; ++i)
	142	fTrackFilter[i] = 0;
	143	}
	144
	145
	146	//_____________________________________________________________________________
	147	AliCheckMuonDetEltResponse::~AliCheckMuonDetEltResponse()
	148
	149	{
	150	/// Destructor
	151	delete fTrackParams;
	152	}
	153
	154
	155
	156	//_____________________________________________________________________________
	157	void AliCheckMuonDetEltResponse::CheckDetEltResponse()
	158	{
	159	//
	160	//Cataloging positions (X,Y) of the clusters detected in the detection elements
	161	//(fDetEltTDHistList), and positions of crossing points between all the
	162	//tracks and the detection elements (fDetEltTTHistList).
	163	//Efficiency = 100 * fDetEltTDHistList / fDetEltTTHistList.
	164
	165	//Loop on tracks
	166	//--------------
	167	TrackLoop();
	168	}
	169
	170
	171
	172	//_____________________________________________________________________________
	173	void AliCheckMuonDetEltResponse::TrackLoop()
	174	{
	175	// Check if the track is kept
	176	AliESDMuonTrack* esdTrack;
	177	AliMUONTrack track;
	178	Int_t nTracks, iTrack;
	179
	180	nTracks = (Int_t)fESD -> GetNumberOfMuonTracks();
	181	fTrackParams = new TClonesArray();
	182	///Begininig of the loop:
	183	//if (fESD->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL"))
	184	{
	185	for (iTrack = 0; iTrack < nTracks; iTrack++)
	186	{
	187	esdTrack = fESD -> GetMuonTrack(iTrack);
	188
	189	if(esdTrack->ContainTrackerData() && esdTrack->GetMatchTrigger() > 0)
	190	{
	191	AliMUONESDInterface::ESDToMUON(*esdTrack, track);
	192	fTrackParams = track.GetTrackParamAtCluster();
	193	TrackParamLoop(); //!<Loop on trackParam.
	194	fNbrUsableTracks += 1;
	195	}
	196	}
	197	}
	198	}
	199
	200
	201
	202	//_____________________________________________________________________________
	203	void AliCheckMuonDetEltResponse::TrackParamLoop()
	204	{
	205	// Loop on all the track params and fill the histos
	206	Int_t nTrackParams = (Int_t) fTrackParams->GetEntriesFast(); //!<Number of trackParams in the track.
	207	Int_t iTrackParam = 0; //!<Number of the trackParam of the track.
	208	Int_t oldChamber = -1, newChamber = 0; //!<To check if there is 0, 1 or 2 (overlap cases) clusters in the same chamber for a track.
	209	Int_t detElt; //!<Detection element Id.
	210
	211	for (Int_t ch = 0; ch < fgkNCh; ++ch)
	212	fTrackFilter[ch] = 0;
	213
	214	Double_t posXL, posYL, posZL; //!<Local positions.
	215	Double_t posXG, posYG, posZG; //!<Global. positions.
	216	Int_t chamberResponse [10] = {0}; //!<1 if the chamber has responded; 0 if not
	217
	218	for (iTrackParam = 0; iTrackParam < nTrackParams; ++iTrackParam)
	219	{
	220	fTrackParam = (AliMUONTrackParam*) fTrackParams->At(iTrackParam);
	221	fCluster = (AliMUONVCluster* ) fTrackParam ->GetClusterPtr();
	222	fTrackFilter [fCluster->GetChamberId()] = 1;
	223	chamberResponse[fCluster->GetChamberId()] = 1;
	224	}
	225
	226	for (Int_t station = 0; station < fgkNSt-1; ++station)
	227	{
	228	Int_t filter; //<!
	229	Int_t ch1, ch2, ch3, ch4; //<!
	230	ch1 = 2*station; //<!
	231	ch2 = 2*station + 1; //<!
	232	ch3 = 2*station + 2; //<!
	233	ch4 = 2*station + 3; //<!
	234	//<!For the efficiency calculation the tracks
	235	if (station < 3 ) //<!reconstructed must have responded to the
	236	{ //<!criteria of the tracking.
	237	filter = fTrackFilter[ch1]; //<!And that's why the tracks usable for the
	238	fTrackFilter[ch1] = fTrackFilter[ch2]; //<!intrinsic efficiency calculation are
	239	fTrackFilter[ch2] = filter; //<!the tracks which have one or two clusters
	240	} //<!in each station. So the case where a track
	241	//<!hasn't a cluster in a station is not
	242	else //<!taking into account.
	243	{ //<!This part solves the problem. See the ALICE
	244	if (chamberResponse[ch3]*chamberResponse[ch4] != 0) //<!note of Diego STOCCO on the trigger efficiency
	245	{ //<!
	246	filter = fTrackFilter[ch1]; //<!
	247	fTrackFilter[ch1] = fTrackFilter[ch2]; //<!
	248	fTrackFilter[ch2] = filter; //<!
	249	} //<!
	250	else //<!
	251	{ //<!
	252	fTrackFilter[ch1] = 0; //<!
	253	fTrackFilter[ch2] = 0; //<!
	254	} //<!
	255
	256	if (chamberResponse[ch1]*chamberResponse[ch2] != 0)
	257	{
	258	filter = fTrackFilter[ch3];
	259	fTrackFilter[ch3] = fTrackFilter[ch4];
	260	fTrackFilter[ch4] = filter;
	261	}
	262	else
	263	{
	264	fTrackFilter[ch3] = 0;
	265	fTrackFilter[ch4] = 0;
	266	}
	267	}
	268	}
	269
	270
	271	///Begining of the loop:
	272	for (iTrackParam = 0; iTrackParam < nTrackParams; ++iTrackParam)
	273	{
	274	fTrackParam = (AliMUONTrackParam*) fTrackParams->At(iTrackParam);
	275	fCluster = (AliMUONVCluster* ) fTrackParam ->GetClusterPtr();
	276
	277	newChamber = fCluster->GetChamberId();
	278	detElt = fCluster->GetDetElemId();
	279
	280	///Global and local positions calculation:
	281	posXG = fTrackParam->GetNonBendingCoor();
	282	posYG = fTrackParam->GetBendingCoor();
	283	posZG = fTrackParam->GetZ();
	284
	285	fkTransformer->Global2Local(detElt, posXG, posYG, posZG, posXL, posYL, posZL); //!<Transfomation from global to local positions.
	286
	287	///Filling histograms of the cluster positions on the detection element of the TRACKS DETECTED (TD):
	288	FillTDHistos(newChamber, detElt, posXL, posYL);
	289
	290	///Filling histograms of the cluster positions on the detection element of ALL THE TRACKS (TT):
	291	FillTTHistos(newChamber, detElt, posXL, posYL);
	292
	293	if (newChamber != oldChamber)
	294	{
	295	if (newChamber > oldChamber + 1) //!<Check if it doesn't miss a chamber.
	296	{
	297	Int_t nbrMissChamber = newChamber - (oldChamber + 1);
	298	FindAndFillMissedDetElt(fTrackParam, oldChamber+1, nbrMissChamber); //!<Calculation of the parameters of the missing cluster(s).
	299	}
	300
	301	if ( iTrackParam == nTrackParams - 1 && newChamber != fgkNCh-1) //!<Check if the last chamber, chamber 9 (from 0 to 9) has responded.
	302	FindAndFillMissedDetElt(fTrackParam, fgkNCh-1, 1); //!<Calculation of the parameters of the missing cluster(s) in the last chamber.
	303
	304	}
	305	oldChamber = newChamber;
	306	}
	307	}
	308
	309
	310
	311	//_____________________________________________________________________________
	312	void AliCheckMuonDetEltResponse::FillTDHistos(Int_t chamber,
	313	Int_t detElt,
	314	Double_t posXL,
	315	Double_t posYL)
	316	{
	317	// Fill the histo for tracks detected
	318	if(fTrackFilter[chamber]== 1)
	319	{
	320	Int_t iDet = 0; //!<Position of the detection element in the histograms' list.
	321	iDet = FromDetElt2iDet(chamber, detElt);
	322	((TH2F*) fDetEltTDHistList->At(iDet))->Fill(posXL, posYL);
	323
	324	Int_t detEltLocalId = 0; //!<Id of the detection element in the station
	325	detEltLocalId = FromDetElt2LocalId(chamber, detElt);
	326	((TH1F*) fChamberTDHistList->At(chamber))->Fill(detEltLocalId);
	327	((TH1F*) fChamberTDHistList->At(fgkNCh))->Fill(chamber + 1);
	328	}
	329	}
	330
	331
	332
	333
	334	//_____________________________________________________________________________
	335	void AliCheckMuonDetEltResponse::FillTTHistos(Int_t chamber,
	336	Int_t detElt,
	337	Double_t posXL,
	338	Double_t posYL)
	339	{
	340	// Fill the histo for total number of tracks
	341	if(fTrackFilter[chamber] == 1)
	342	{
	343	Int_t iDet = 0; //!<Position of the detection element in the histograms' list.
	344	iDet = FromDetElt2iDet(chamber, detElt);
	345	((TH2F*) fDetEltTTHistList->At(iDet)) -> Fill(posXL, posYL);
	346
	347	Int_t detEltLocalId = 0; //!<Id of the detection element in the station
	348	detEltLocalId = FromDetElt2LocalId(chamber, detElt);
	349	((TH1F*) fChamberTTHistList->At(chamber))->Fill(detEltLocalId);
	350	((TH1F*) fChamberTTHistList->At(fgkNCh))->Fill(chamber + 1);
	351	}
	352	}
	353
	354
	355
	356
	357
	358	//_____________________________________________________________________________
	359	Int_t AliCheckMuonDetEltResponse::FromDetElt2iDet(Int_t chamber,
	360	Int_t detElt) const
	361	{
	362	///
	363	///Connexion between the detection element X and its position in the list of histograms iX.
	364	///
	365
	366	Int_t iDet = 0; //!<Position of the detection element (detElt) in the histograms' list.
	367
	368	if (chamber<4) iDet = detElt-fgkOffset(chamber+1)+ 4 chamber ;
	369	if (chamber>3 && chamber<6) iDet = detElt-fgkOffset(chamber+1)+18(chamber-4)+16;
	370	if (chamber>5) iDet = detElt-fgkOffset(chamber+1)+26(chamber-6)+52;
	371
	372	return iDet;
	373	}
	374
	375
	376
	377	//_____________________________________________________________________________
	378	Int_t AliCheckMuonDetEltResponse::FromDetElt2LocalId(Int_t chamber,
	379	Int_t detElt) const
	380	{
	381	///
	382	///Connexion between the detection element X and its number in the station.
	383	///
	384
	385	Int_t localId = 0; //!<Position of the detection element (detElt) in the histograms' list.
	386	localId = detElt - (chamber+1) * 100;
	387
	388	return localId;
	389	}
	390
	391
	392
	393	//_____________________________________________________________________________
	394	void AliCheckMuonDetEltResponse::FindAndFillMissedDetElt(AliMUONTrackParam* extrapTrackParam,
	395	Int_t firstMissCh,
	396	Int_t nbrMissCh)
	397	{
	398	///
	399	///Find which detection elements should have been hit but were missed,
	400	///and fill the TT histos appropriately
	401	///
	402	for (Int_t iCh = 0; iCh < nbrMissCh; ++iCh)
	403	{
	404	Int_t chamber = firstMissCh + iCh;
	405	Int_t nbrOfDetElt = AliMpDEManager::GetNofDEInChamber(chamber, kTRUE); //!<Number of detection elements in the chamber.
	406
	407	Double_t pos1[6] = {0, 0, 0, 0, 0, 0}; //!<First point used to compute the extrapolated point (first 3 for global coordinates, last 3 for local).
	408	Double_t pos2[6] = {0, 0, 0, 0, 0, 0}; //!<Second point used to compute the extrapolated point (first 3 for global coordinates, last 3 for local).
	409	Double_t posMiss[2] = {0, 0}; //!<(X, Y) local coordinates of the missing cluster.
	410
	411	pos1[2] = AliMUONConstants::DefaultChamberZ(chamber); //!<Z of point 1, defined by being the Z of the chamber in "perfect" position.
	412	AliMUONTrackExtrap::ExtrapToZ(extrapTrackParam, pos1[2]);
	413	pos1[0] = extrapTrackParam->GetNonBendingCoor(); //!<X of point 1, extrapolated by following the Track.
	414	pos1[1] = extrapTrackParam->GetBendingCoor(); //!<Y of point 1, extrapolated by following the Track.
	415
	416	pos2[2] = AliMUONConstants::DefaultChamberZ(chamber) + AliMUONConstants::DzCh(); //!<Z of point 2, defined by being the Z of the chamber in "perfect" position
	417	AliMUONTrackExtrap::ExtrapToZ(extrapTrackParam, pos2[2]); //!< + plus a small shift (the distance between two stations in a same chamber).
	418	pos2[0] = extrapTrackParam->GetNonBendingCoor(); //!<X of point 2, extrapolated by following the Track.
	419	pos2[1] = extrapTrackParam->GetBendingCoor(); //!<Y of point 2, extrapolated by following the Track.
	420
	421
	422
	423	for (Int_t iDE = 0; iDE < nbrOfDetElt; iDE++) //!<Loop on all the detection element of the chamber
	424	{
	425	Int_t deId = (chamber + 1)*fgkOffset + iDE; //!<detection element Id
	426
	427	fkTransformer->Global2Local(deId, pos1[0], pos1[1], pos1[2], pos1[3], pos1[4], pos1[5]); //!<convesrion of point 1 and 2 in the local coordinates
	428	fkTransformer->Global2Local(deId, pos2[0], pos2[1], pos2[2], pos2[3], pos2[4], pos2[5]);
	429
	430	CoordinatesOfMissingCluster(pos1[3], pos1[4], pos1[5], pos2[3], pos2[4], pos2[5], posMiss[0], posMiss[1]);
	431
	432	Bool_t isMissed = kFALSE;
	433	if (chamber < 4)
	434	isMissed = CoordinatesInDetEltSt12(deId, posMiss[0], posMiss[1]);
	435	else
	436	isMissed = CoordinatesInDetEltSt345(deId, posMiss[0], posMiss[1]);
	437
	438	if (isMissed)
	439	FillTTHistos(chamber, deId, posMiss[0], posMiss[1]);
	440	}
	441	}
	442	}
	443
	444
	445
	446	//_____________________________________________________________________________
	447	void AliCheckMuonDetEltResponse::CoordinatesOfMissingCluster(Double_t x1, Double_t y1, Double_t z1,
	448	Double_t x2, Double_t y2, Double_t z2,
	449	Double_t& x, Double_t& y) const
	450	{
	451	//
	452	//Compute the coordinates of the missing cluster.
	453	//There are defined by the intersection between the straigth line joining two extrapolated points (1 and 2) and the detection element plane.
	454	//In the local coordinates, this means Z=0 in the parametric equation of the line.
	455	//
	456
	457	Double_t t = 0;
	458	t = - z1 / (z2 - z1);
	459
	460	x = t * (x2 - x1) + x1;
	461	y = t * (y2 - y1) + y1;
	462	}
	463
	464
	465	//_____________________________________________________________________________
	466	Bool_t AliCheckMuonDetEltResponse::CoordinatesInDetEltSt345(Int_t DeId, Double_t x, Double_t y)
	467	{
	468	//
	469	//Return kTRUE if the coordinates are in the Detection Element, for station 3, 4 and 5.
	470	//This is done by checking if a pad correspond to the (x, y) position.
	471	//
	472
	473	AliMpPad pad1;
	474	AliMpPad pad2;
	475
	476	AliMpSlatSegmentation *segm1 = new AliMpSlatSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSlat(DeId, AliMp::kCath0));
	477	AliMpSlatSegmentation *segm2 = new AliMpSlatSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSlat(DeId, AliMp::kCath1));
	478	pad1 = segm1->PadByPosition(x, y, kFALSE);
	479	pad2 = segm2->PadByPosition(x, y, kFALSE);
	480
	481	if (pad1.IsValid() && pad2.IsValid())
	482	return kTRUE;
	483	else
	484	return kFALSE;
	485	}
	486
	487
	488	//_____________________________________________________________________________
	489	Bool_t AliCheckMuonDetEltResponse::CoordinatesInDetEltSt12(Int_t DeId, Double_t x, Double_t y)
	490	{
	491	//Return kTRUE if the coordinates are in the Detection Element, for station 1 and 2.
	492	//This is done by checking if a pad correspond to the (x, y) position.
	493
	494	AliMpPad pad1;
	495	AliMpPad pad2;
	496
	497	AliMpSectorSegmentation *segm1 = new AliMpSectorSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSector(DeId, AliMp::kCath0));
	498	AliMpSectorSegmentation *segm2 = new AliMpSectorSegmentation(AliMpSegmentation::Instance(kFALSE)->GetSector(DeId, AliMp::kCath1));
	499	pad1 = segm1->PadByPosition(x, y, kFALSE);
	500	pad2 = segm2->PadByPosition(x, y, kFALSE);
	501
	502	if (pad1.IsValid() && pad2.IsValid())
	503	return kTRUE;
	504	else
	505	return kFALSE;
	506	}