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