MUON/AliMUONClusterInput.cxx

   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 /* $Id$ */
  17
  18 #include <TClonesArray.h>
  19 #include <TMinuit.h>
  20
  21 #include "AliRun.h"
  22 #include "AliMUON.h"
  23 #include "AliMUONChamber.h"
  24 #include "AliMUONConstants.h"
  25 #include "AliMUONClusterInput.h"
  26 #include "AliMUONMathieson.h"
  27 #include "AliMUONRawCluster.h"
  28 #include "AliMUONDigit.h"
  29 #include "AliLog.h"
  30
  31 ClassImp(AliMUONClusterInput)
  32
  33 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
  34 TMinuit* AliMUONClusterInput::fgMinuit = 0;
  35 AliMUONMathieson* AliMUONClusterInput::fgMathieson = 0;
  36
  37 AliMUONClusterInput::AliMUONClusterInput()
  38   : TObject(),
  39     fCluster(0),
  40     fChargeCorrel(1.),
  41     fDetElemId(0)
  42
  43 {
  44   fDigits[0]=0;
  45   fDigits[1]=0;
  46   fSegmentation2[0]=0;
  47   fSegmentation2[1]=0;
  48 }
  49
  50 AliMUONClusterInput* AliMUONClusterInput::Instance()
  51 {
  52 // return pointer to the singleton instance
  53     if (fgClusterInput == 0) {
  54         fgClusterInput = new AliMUONClusterInput();
  55         fgMinuit = new TMinuit(8);
  56     }
  57
  58     return fgClusterInput;
  59 }
  60
  61 AliMUONClusterInput::~AliMUONClusterInput()
  62 {
  63 // Destructor
  64     delete fgMinuit;
  65     delete fgMathieson;
  66 }
  67
  68 AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
  69 {
  70 // Protected copy constructor
  71
  72   AliFatal("Not implemented.");
  73 }
  74
  75 void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
  76 {
  77   // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
  78     fChamber = chamber;
  79     fDetElemId = idDE;
  80     fDigits[0]  = dig1;
  81     fDigits[1]  = dig2;
  82     fNDigits[0] = dig1->GetEntriesFast();
  83     fNDigits[1] = dig2->GetEntriesFast();
  84
  85     AliMUON *pMUON;
  86     AliMUONChamber* iChamber;
  87
  88     pMUON = (AliMUON*) gAlice->GetModule("MUON");
  89     iChamber =  &(pMUON->Chamber(chamber));
  90
  91     fgMathieson = new AliMUONMathieson();
  92
  93     fSegmentation2[0]=iChamber->SegmentationModel2(1);
  94     fSegmentation2[1]=iChamber->SegmentationModel2(2);
  95
  96     fNseg = 2;
  97     if (chamber < AliMUONConstants::NTrackingCh()) {
  98       if (chamber > 1 ) {
  99         fgMathieson->SetPitch(AliMUONConstants::Pitch());
 100         fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3());
 101         fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3());
 102         fChargeCorrel = AliMUONConstants::ChargeCorrel();
 103       } else {
 104         fgMathieson->SetPitch(AliMUONConstants::PitchSt1());
 105         fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3St1());
 106         fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3St1());
 107         fChargeCorrel = AliMUONConstants::ChargeCorrelSt1();
 108       }
 109     }
 110 }
 111
 112 void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig)
 113 {
 114 // Set pointer to digits with corresponding segmentations and responses (one cathode plane)
 115
 116     fChamber = chamber;
 117     fDetElemId = idDE;
 118     fDigits[0] = dig;
 119
 120     AliMUON *pMUON;
 121     AliMUONChamber* iChamber;
 122
 123     pMUON = (AliMUON*) gAlice->GetModule("MUON");
 124     iChamber =  &(pMUON->Chamber(chamber));
 125
 126     fSegmentation2[0]=iChamber->SegmentationModel2(1);
 127
 128     fNseg=1;
 129 }
 130
 131 void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
 132 {
 133 // Set the current cluster
 134   //PH printf("\n %p \n", cluster);
 135   fCluster=cluster;
 136   Float_t qtot;
 137   Int_t   i, cath, ix, iy;
 138   AliMUONDigit* digit;
 139   fNmul[0]=cluster->GetMultiplicity(0);
 140   fNmul[1]=cluster->GetMultiplicity(1);
 141   //PH printf("\n %p %p ", fDigits[0], fDigits[1]);
 142
 143   for (cath=0; cath<2; cath++) {
 144     qtot=0;
 145     for (i=0; i<fNmul[cath]; i++) {
 146       // pointer to digit
 147       digit =(AliMUONDigit*)
 148                 (fDigits[cath]->UncheckedAt(cluster->GetIndex(i,cath)));
 149             // pad coordinates
 150             ix = digit->PadX();
 151             iy = digit->PadY();
 152             // pad charge
 153             fCharge[i][cath] = digit->Signal();
 154             // pad centre coordinates
 155 //          fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
 156             // globals kUsed in fitting functions
 157             fix[i][cath]=ix;
 158             fiy[i][cath]=iy;
 159             // total charge per cluster
 160             qtot+=fCharge[i][cath];
 161             // Current z
 162             Float_t xc, yc;
 163             fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
 164         } // loop over cluster digits
 165         fQtot[cath]=qtot;
 166         fChargeTot[cath]=Int_t(qtot);
 167     }  // loop over cathodes
 168 }
 169
 170
 171
 172 Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
 173 {
 174 // Compute the charge on first cathod only.
 175 return DiscrChargeCombiS1(i,par,0);
 176 }
 177
 178 Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
 179 {
 180 // par[0]    x-position of cluster
 181 // par[1]    y-position of cluster
 182
 183     Float_t q1;
 184     fSegmentation2[cath]->SetPad(fDetElemId, fix[i][cath], fiy[i][cath]);
 185     //  First Cluster
 186     fSegmentation2[cath]->SetHit(fDetElemId, par[0],par[1],fZ);
 187     q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
 188
 189    Float_t value = fQtot[cath]*q1;
 190    return value;
 191 }
 192
 193
 194 Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
 195 {
 196 // par[0]    x-position of first  cluster
 197 // par[1]    y-position of first  cluster
 198 // par[2]    x-position of second cluster
 199 // par[3]    y-position of second cluster
 200 // par[4]    charge fraction of first  cluster
 201 // 1-par[4]  charge fraction of second cluster
 202
 203   Float_t q1, q2;
 204
 205   fSegmentation2[0]->SetPad(fDetElemId, fix[i][0], fiy[i][0]);
 206   //  First Cluster
 207   fSegmentation2[0]->SetHit(fDetElemId, par[0],par[1],fZ);
 208   q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
 209
 210   //  Second Cluster
 211   fSegmentation2[0]->SetHit(fDetElemId,par[2],par[3],fZ);
 212   q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
 213
 214   Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 215   return value;
 216 }
 217
 218 Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
 219 {
 220 // par[0]    x-position of first  cluster
 221 // par[1]    y-position of first  cluster
 222 // par[2]    x-position of second cluster
 223 // par[3]    y-position of second cluster
 224 // par[4]    charge fraction of first  cluster - first cathode
 225 // 1-par[4]  charge fraction of second cluster
 226 // par[5]    charge fraction of first  cluster - second cathode
 227
 228   Float_t q1, q2;
 229
 230   fSegmentation2[cath]->SetPad(fDetElemId,fix[i][cath], fiy[i][cath]);
 231   //  First Cluster
 232   fSegmentation2[cath]->SetHit(fDetElemId,par[0],par[1],fZ);
 233   q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
 234
 235   //  Second Cluster
 236   fSegmentation2[cath]->SetHit(fDetElemId,par[2],par[3],fZ);
 237   q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
 238
 239   Float_t value;
 240   if (cath==0) {
 241     value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 242   } else {
 243     value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
 244   }
 245   return value;
 246 }
 247
 248 AliMUONClusterInput& AliMUONClusterInput
 249 ::operator = (const AliMUONClusterInput& rhs)
 250 {
 251 // Protected assignement operator
 252
 253   if (this == &rhs) return *this;
 254
 255   AliFatal("Not implemented.");
 256
 257   return *this;
 258 }