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