Line data    Source code

       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             : /// \class AliTPCInverseCorrection
      17             : /// \brief AliTPCInverseCorrection class
      18             : ///
      19             : /// This is a wrapper that inverts an AliTPCCorrection. This is done by
      20             : /// swapping the CalculateCorrection and CalculateInverseCorrection functions.
      21             : /// The wrapped correction is supplied as a pointer and the class relies
      22             : /// on the fact, that this pointer keeps pointing to the right object.
      23             : /// However, the ownership is not changed, i.e. the wrapped correction
      24             : /// will not be deleted when this correction is destructed.
      25             : ///
      26             : /// \author Magnus Mager, Stefan Rossegger, Jim Thomas
      27             : /// \date 27/04/2010
      28             : 
      29             : #include <TString.h>
      30             : #include "AliTPCInverseCorrection.h"
      31             : #include <TTimeStamp.h>
      32             : 
      33             : 
      34           0 : AliTPCInverseCorrection::AliTPCInverseCorrection()
      35           0 :   : fCorrection(0) {
      36             :   /// default constructor
      37             :   /// (only meant for ROOT I/O)
      38             : 
      39           0 : }
      40             : 
      41           0 : AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction)
      42           0 :   : fCorrection(correction) {
      43             :   /// Constructor that is creating the inverse of the supplied correction.
      44             :   /// It automatically sets the name ("inv_[correction name]") and tile
      45             :   /// ("Inverse of [correction title]").
      46             : 
      47           0 :   TString name,title;
      48           0 :   name  ="inv_";
      49           0 :   name +=correction->GetName();
      50           0 :   title ="Inverse of ";
      51           0 :   title+=correction->GetTitle();
      52           0 :   SetName(name.Data());
      53           0 :   SetTitle(title.Data());
      54           0 : }
      55             : 
      56           0 : AliTPCInverseCorrection::~AliTPCInverseCorrection() {
      57             :   /// virtual destructor
      58             : 
      59           0 :   if (fCorrection) delete fCorrection;
      60           0 : }
      61             : 
      62             : 
      63             : void AliTPCInverseCorrection::Init() {
      64             :   /// Initialization funtion (not used at the moment)
      65             : 
      66           0 :   if (fCorrection) fCorrection->Init();
      67             : 
      68           0 : }
      69             : 
      70             : void AliTPCInverseCorrection::Update(const TTimeStamp &timeStamp) {
      71             :   /// Update function
      72             : 
      73           0 :   if (fCorrection) fCorrection->Update(timeStamp);
      74             : 
      75           0 : }
      76             : 
      77             : void AliTPCInverseCorrection::Print(Option_t* option) const {
      78             :   /// Print function to check which correction classes are used
      79             :   /// option=="d" prints details regarding the setted magnitude
      80             :   /// option=="a" prints the C0 and C1 coefficents for calibration purposes
      81             : 
      82           0 :   printf("Inverse of ");
      83           0 :   if (fCorrection) fCorrection->Print(option);
      84           0 : }
      85             : 
      86             : void AliTPCInverseCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
      87             :   /// This is just calling the CalculateInverseCorrection of the wrapped
      88             :   /// correction -- or puts dr=0 if the latter is 0.
      89             : 
      90           0 :   if (fCorrection)
      91           0 :     fCorrection->GetDistortion(x,roc,dx);
      92             :   else
      93           0 :     for (Int_t j=0;j<3;++j) dx[j]=0.;
      94           0 : }
      95             : 
      96             : void AliTPCInverseCorrection:: SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
      97             :   /// Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
      98             :   /// t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
      99             :   /// calibration run
     100             : 
     101           0 :   if (fCorrection) fCorrection->SetOmegaTauT1T2(omegaTau, t1, t2);
     102           0 : }
     103             : 
     104             : void AliTPCInverseCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
     105             :   /// This is just calling the CalculateCorrection of the wrapped
     106             :   /// correction -- or puts dr=0 if the latter is 0.
     107             : 
     108           0 :   if (fCorrection)
     109           0 :     fCorrection->GetCorrection(x,roc,dx);
     110             :   else
     111           0 :     for (Int_t j=0;j<3;++j) dx[j]=0.;
     112           0 : }
     113             : 
     114             : /// \cond CLASSIMP
     115          24 : ClassImp(AliTPCInverseCorrection)
     116             : /// \endcond