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 /*
  17 $Log$
  18 Revision 1.6  2000/10/06 09:04:50  morsch
  19
  20 - Dummy z-arguments in GetPadI, SetHit, FirstPad replaced by real z-coordinate
  21         to make code work with slat chambers.
  22
  23 Revision 1.5  2000/10/02 16:58:29  egangler
  24 Cleaning of the code :
  25 -> coding conventions
  26 -> void Streamers
  27 -> some useless includes removed or replaced by "class" statement
  28
  29 Revision 1.4  2000/07/03 11:54:57  morsch
  30 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  31 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  32
  33 Revision 1.3  2000/06/28 15:16:35  morsch
  34 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
  35 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
  36 framework. The changes should have no side effects (mostly dummy arguments).
  37 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
  38 of chambers with overlapping modules (MakePadHits, Disintegration).
  39
  40 Revision 1.2  2000/06/28 12:19:18  morsch
  41 More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
  42 cluster and hit reconstruction algorithms in AliMUONClusterFinderVS.
  43 AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
  44 It requires two cathode planes. Small modifications in the code will make it usable for
  45 one cathode plane and, hence, more general (for test beam data).
  46 AliMUONClusterFinder is now obsolete.
  47
  48 Revision 1.1  2000/06/28 08:06:10  morsch
  49 Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
  50 algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
  51 It also naturally takes care of the TMinuit instance.
  52
  53 */
  54 #include "AliRun.h"
  55 #include "AliMUON.h"
  56 #include "AliMUONChamber.h"
  57 #include "AliMUONClusterInput.h"
  58 #include "AliSegmentation.h"
  59 #include "AliMUONResponse.h"
  60 #include "AliMUONRawCluster.h"
  61 #include "AliMUONDigit.h"
  62
  63 #include <TClonesArray.h>
  64 #include <TMinuit.h>
  65
  66 ClassImp(AliMUONClusterInput)
  67
  68 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
  69 TMinuit* AliMUONClusterInput::fgMinuit = 0;
  70
  71 AliMUONClusterInput* AliMUONClusterInput::Instance()
  72 {
  73 // return pointer to the singleton instance
  74     if (fgClusterInput == 0) {
  75         fgClusterInput = new AliMUONClusterInput();
  76         fgMinuit = new TMinuit(8);
  77     }
  78
  79     return fgClusterInput;
  80 }
  81
  82 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
  83 {
  84 // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
  85     fChamber=chamber;
  86     fDigits[0]=dig1;
  87     fDigits[1]=dig2;
  88     fNDigits[0]=dig1->GetEntriesFast();
  89     fNDigits[1]=dig2->GetEntriesFast();
  90
  91     AliMUON *pMUON;
  92     AliMUONChamber* iChamber;
  93
  94     pMUON = (AliMUON*) gAlice->GetModule("MUON");
  95     iChamber =  &(pMUON->Chamber(chamber));
  96
  97     fSegmentation[0]=iChamber->SegmentationModel(1);
  98     fSegmentation[1]=iChamber->SegmentationModel(2);
  99     fResponse=iChamber->ResponseModel();
 100     fNseg = 2;
 101 }
 102
 103 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
 104 {
 105 // Set pointer to digits with corresponding segmentations and responses (one cathode plane)
 106     fDigits[0]=dig;
 107     AliMUON *pMUON;
 108     AliMUONChamber* iChamber;
 109
 110     pMUON = (AliMUON*) gAlice->GetModule("MUON");
 111     iChamber =  &(pMUON->Chamber(chamber));
 112
 113     fSegmentation[0]=iChamber->SegmentationModel(1);
 114     fResponse=iChamber->ResponseModel();
 115     fNseg=1;
 116 }
 117
 118 void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
 119 {
 120 // Set the current cluster
 121     printf("\n %p \n", cluster);
 122     fCluster=cluster;
 123     Float_t qtot;
 124     Int_t   i, cath, ix, iy;
 125     AliMUONDigit* digit;
 126     fNmul[0]=cluster->fMultiplicity[0];
 127     fNmul[1]=cluster->fMultiplicity[1];
 128     printf("\n %p %p ", fDigits[0], fDigits[1]);
 129
 130     for (cath=0; cath<2; cath++) {
 131         qtot=0;
 132         for (i=0; i<fNmul[cath]; i++) {
 133             // pointer to digit
 134             digit =(AliMUONDigit*)
 135                 (fDigits[cath]->UncheckedAt(cluster->fIndexMap[i][cath]));
 136             // pad coordinates
 137             ix = digit->fPadX;
 138             iy = digit->fPadY;
 139             // pad charge
 140             fCharge[i][cath] = digit->fSignal;
 141             // pad centre coordinates
 142 //          fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
 143             // globals kUsed in fitting functions
 144             fix[i][cath]=ix;
 145             fiy[i][cath]=iy;
 146             // total charge per cluster
 147             qtot+=fCharge[i][cath];
 148             // Current z
 149             Float_t xc, yc;
 150             fSegmentation[cath]->GetPadC(ix,iy,xc,yc,fZ);
 151         } // loop over cluster digits
 152         fQtot[cath]=qtot;
 153         fChargeTot[cath]=Int_t(qtot);
 154     }  // loop over cathodes
 155 }
 156
 157
 158
 159 Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
 160 {
 161 // par[0]    x-position of cluster
 162 // par[1]    y-position of cluster
 163
 164    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
 165 //  First Cluster
 166    fSegmentation[0]->SetHit(par[0],par[1],fZ);
 167    Float_t q1=fResponse->IntXY(fSegmentation[0]);
 168
 169    Float_t value = fQtot[0]*q1;
 170    return value;
 171 }
 172
 173 Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
 174 {
 175 // par[0]    x-position of cluster
 176 // par[1]    y-position of cluster
 177
 178    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 179 //  First Cluster
 180    fSegmentation[cath]->SetHit(par[0],par[1],fZ);
 181    Float_t q1=fResponse->IntXY(fSegmentation[cath]);
 182
 183    Float_t value = fQtot[cath]*q1;
 184    return value;
 185 }
 186
 187
 188 Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
 189 {
 190 // par[0]    x-position of first  cluster
 191 // par[1]    y-position of first  cluster
 192 // par[2]    x-position of second cluster
 193 // par[3]    y-position of second cluster
 194 // par[4]    charge fraction of first  cluster
 195 // 1-par[4]  charge fraction of second cluster
 196
 197    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
 198 //  First Cluster
 199    fSegmentation[0]->SetHit(par[0],par[1],fZ);
 200    Float_t q1=fResponse->IntXY(fSegmentation[0]);
 201
 202 //  Second Cluster
 203    fSegmentation[0]->SetHit(par[2],par[3],fZ);
 204    Float_t q2=fResponse->IntXY(fSegmentation[0]);
 205
 206    Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 207    return value;
 208 }
 209
 210 Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
 211 {
 212 // par[0]    x-position of first  cluster
 213 // par[1]    y-position of first  cluster
 214 // par[2]    x-position of second cluster
 215 // par[3]    y-position of second cluster
 216 // par[4]    charge fraction of first  cluster
 217 // 1-par[4]  charge fraction of second cluster
 218
 219    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 220 //  First Cluster
 221    fSegmentation[cath]->SetHit(par[0],par[1],fZ);
 222    Float_t q1=fResponse->IntXY(fSegmentation[cath]);
 223
 224 //  Second Cluster
 225    fSegmentation[cath]->SetHit(par[2],par[3],fZ);
 226    Float_t q2=fResponse->IntXY(fSegmentation[cath]);
 227    Float_t value;
 228    if (cath==0) {
 229        value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 230    } else {
 231        value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
 232    }
 233    return value;
 234 }
 235
 236 AliMUONClusterInput& AliMUONClusterInput
 237 ::operator = (const AliMUONClusterInput& rhs)
 238 {
 239 // Dummy assignment operator
 240     return *this;
 241 }
 242
 243