RALICE/AliSignal.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.2  1999/09/29 09:24:28  fca
  19 Introduction of the Copyright and cvs Log
  20
  21 */
  22
  23 ///////////////////////////////////////////////////////////////////////////
  24 // Class AliSignal
  25 // Handling of ALICE (extrapolated) signals.
  26 //
  27 // Note :
  28 // ------
  29 // Signal positions (r) and reference frames (f) are specified via
  30 // SetPosition(r,f) under the following conventions :
  31 //
  32 // f="car" ==> r is Cartesian   (x,y,z)
  33 // f="sph" ==> r is Spherical   (r,theta,phi)
  34 // f="cyl" ==> r is Cylindrical (rho,phi,z)
  35 //
  36 // The same holds for SetPositionErrors().
  37 //
  38 // All angles are in radians.
  39 //
  40 // Example :
  41 // ---------
  42 //
  43 // AliSignal s;
  44 // Float_t pos[3]={-1,25,7};
  45 // Float_t err[3]={0.03,0.7,0.18};
  46 // Float_t signal=120.8;
  47 // Float_t error=1.73;
  48 // s.SetPosition(pos,"car");
  49 // s.SetPositionErrors(err,"car");
  50 // s.SetSignal(signal);
  51 // s.SetSignalError(error);
  52 // Float_t loc[3],dr[3],sigma;
  53 // s.GetPosition(loc,"sph");
  54 // s.GetPositionErrors(dr,"sph");
  55 // Float_t adc=s.GetSignal();
  56 // Float_t sigma=s.GetSignalError();
  57 //
  58 // AliSignal q(3); // q can store 3 signal values with their errors
  59 //                 // In the example below a signal contains the
  60 //                 // following data : timing, ADC and dE/dx
  61 // q.SetPosition(pos,"car");
  62 // q.SetPositionErrors(err,"car");
  63 // signal=82.5; // e.q. signal time in ns
  64 // error=2.01;
  65 // q.SetSignal(signal,1);
  66 // q.SetSignalError(error,1);
  67 // signal=268.1; // e.g. ADC value of signal
  68 // error=3.75;
  69 // q.SetSignal(signal,2);
  70 // q.SetSignalError(error,2);
  71 // signal=23.7; // e.g. corresponding dE/dx value
  72 // error=0.48;
  73 // q.SetSignal(signal,3);
  74 // q.SetSignalError(error,3);
  75 //
  76 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
  77 //- Modified: NvE 30-oct-1999 UU-SAP Utrecht
  78 ///////////////////////////////////////////////////////////////////////////
  79
  80 #include "AliSignal.h"
  81
  82 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
  83
  84 AliSignal::AliSignal(Int_t n)
  85 {
  86 // Creation of an AliSignal object and initialisation of parameters.
  87 // A total of n (default n=1) values (with errors) can be stored.
  88  fNvalues=n;
  89  fSignal=0;
  90  fDsignal=0;
  91 }
  92 ///////////////////////////////////////////////////////////////////////////
  93 AliSignal::~AliSignal()
  94 {
  95 // Destructor to delete dynamically allocated memory
  96  if (fSignal)
  97  {
  98   delete fSignal;
  99   fSignal=0;
 100  }
 101  if (fDsignal)
 102  {
 103   delete fDsignal;
 104   fDsignal=0;
 105  }
 106 }
 107 ///////////////////////////////////////////////////////////////////////////
 108 void AliSignal::Reset()
 109 {
 110 // Reset all signal and position values and errors to 0.
 111 // The data arrays are also created if not already existing.
 112
 113  if (!fSignal) fSignal=new TArrayF(fNvalues);
 114  if (!fDsignal) fDsignal=new TArrayF(fNvalues);
 115
 116  Double_t r[3]={0,0,0};
 117  SetPosition(r,"sph");
 118  SetErrors(r,"car");
 119  for (Int_t i=0; i<fSignal->GetSize(); i++)
 120  {
 121   fSignal->AddAt(0,i);
 122   fDsignal->AddAt(0,i);
 123  }
 124 }
 125 ///////////////////////////////////////////////////////////////////////////
 126 void AliSignal::ResetSignals()
 127 {
 128 // Reset all signal values and errors to 0.
 129 // The data arrays are also created if not already existing.
 130
 131  if (!fSignal) fSignal=new TArrayF(fNvalues);
 132  if (!fDsignal) fDsignal=new TArrayF(fNvalues);
 133
 134  for (Int_t i=0; i<fSignal->GetSize(); i++)
 135  {
 136   fSignal->AddAt(0,i);
 137   fDsignal->AddAt(0,i);
 138  }
 139 }
 140 ///////////////////////////////////////////////////////////////////////////
 141 void AliSignal::ResetPosition()
 142 {
 143 // Reset position and errors to 0.
 144  Double_t r[3]={0,0,0};
 145  SetPosition(r,"sph");
 146  SetErrors(r,"car");
 147 }
 148 ///////////////////////////////////////////////////////////////////////////
 149 void AliSignal::SetSignal(Double_t sig,Int_t j)
 150 {
 151 // Store j-th (default j=1) signal value.
 152 // Note : The first signal value is at j=1.
 153
 154  if (!fSignal) ResetSignals();
 155
 156  Int_t size=fSignal->GetSize();
 157  if (j<=size)
 158  {
 159   fSignal->AddAt(float(sig),j-1);
 160  }
 161  else
 162  {
 163   cout << "*AliSignal::SetSignal* Index mismatch j : " << j
 164        << " size : " << size << endl;
 165  }
 166 }
 167 ///////////////////////////////////////////////////////////////////////////
 168 void AliSignal::AddSignal(Double_t sig,Int_t j)
 169 {
 170 // Add value to j-th (default j=1) signal value.
 171 // Note : The first signal value is at j=1.
 172
 173  if (!fSignal) ResetSignals();
 174
 175  Int_t size=fSignal->GetSize();
 176  if (j<=size)
 177  {
 178   Float_t sum=(fSignal->At(j-1))+sig;
 179   fSignal->AddAt(sum,j-1);
 180  }
 181  else
 182  {
 183   cout << "*AliSignal::AddSignal* Index mismatch j : " << j
 184        << " size : " << size << endl;
 185  }
 186 }
 187 ///////////////////////////////////////////////////////////////////////////
 188 Float_t AliSignal::GetSignal(Int_t j)
 189 {
 190 // Provide j-th (default j=1) signal value.
 191 // Note : The first signal value is at j=1.
 192  if (fSignal)
 193  {
 194   return fSignal->At(j-1);
 195  }
 196  else
 197  {
 198   return 0;
 199  }
 200 }
 201 ///////////////////////////////////////////////////////////////////////////
 202 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
 203 {
 204 // Store error on j-th (default j=1) signal value.
 205 // Note : The error on the first signal value is at j=1.
 206
 207  if (!fDsignal) ResetSignals();
 208
 209  Int_t size=fDsignal->GetSize();
 210  if (j<=size)
 211  {
 212   fDsignal->AddAt(float(dsig),j-1);
 213  }
 214  else
 215  {
 216   cout << "*AliSignal::SetSignalError* Index mismatch j : " << j
 217        << " size : " << size << endl;
 218  }
 219 }
 220 ///////////////////////////////////////////////////////////////////////////
 221 Float_t AliSignal::GetSignalError(Int_t j)
 222 {
 223 // Provide error on the j-th (default j=1) signal value.
 224 // Note : The error on the first signal value is at j=1.
 225  if (fDsignal)
 226  {
 227   return fDsignal->At(j-1);
 228  }
 229  else
 230  {
 231   return 0;
 232  }
 233 }
 234 ///////////////////////////////////////////////////////////////////////////
 235 void AliSignal::Info(TString f)
 236 {
 237 // Provide signal information within the coordinate frame f
 238  cout << " *AliSignal::Info* " << endl;
 239  cout << " Position";
 240  Ali3Vector::Info(f);
 241
 242  if (fSignal && fDsignal)
 243  {
 244   for (Int_t i=0; i<fSignal->GetSize(); i++)
 245   {
 246    cout << "   Signal value : " << fSignal->At(i)
 247         << " error : " << fDsignal->At(i) << endl;
 248   }
 249  }
 250 }
 251 ///////////////////////////////////////////////////////////////////////////