HLT/PHOS/AliHLTPHOSSanityInspector.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the ALICE HLT Project        *
   3  * All rights reserved.                                                   *
   4  *                                                                        *
   5  * Primary Authors: Oystein Djuvsland                                     *
   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  * @file   AliHLTPHOSSanityInspector.cxx
  18  * @author Oystein Djuvsland
  19  * @date
  20  * @brief  Sanity inspector for PHOS HLT
  21  */
  22
  23 // see header file for class documentation
  24 // or
  25 // refer to README to build package
  26 // or
  27 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  28
  29 #include "AliHLTPHOSSanityInspector.h"
  30 #include "Rtypes.h"
  31
  32 ClassImp(AliHLTPHOSSanityInspector);
  33
  34
  35 AliHLTPHOSSanityInspector::AliHLTPHOSSanityInspector() :
  36   AliHLTPHOSBase(),
  37   fMaxDifference(120)
  38 {
  39   //See header file for documentation
  40 }
  41
  42
  43 AliHLTPHOSSanityInspector::~AliHLTPHOSSanityInspector()
  44 {
  45   //See header file for documentation
  46 }
  47
  48
  49
  50 const Int_t
  51 AliHLTPHOSSanityInspector::CheckInsanity(const UInt_t* data, const Int_t N) const
  52 {
  53    //See header file for documentation
  54
  55   for(Int_t i = 1; i < N; i++)
  56     {
  57       if((((Int_t)data[i] - (Int_t)data[i-1]) > fMaxDifference) || (((Int_t)data[i-1] - (Int_t)data[i]) > fMaxDifference))
  58         return 1;
  59     }
  60   return 0;
  61 }
  62
  63 /*
  64 Int_t
  65 AliHLTPHOSSanityInspector::CheckInsanity(Int_t* data, Int_t N)
  66 {
  67    //See header file for documentation
  68   for(Int_t i = 1; i < N; i++)
  69   {
  70     if((((Int_t)data[i] - (Int_t)data[i-1]) > fMaxDifference) || (((Int_t)data[i-1] - (Int_t)data[i]) > fMaxDifference))
  71       return 1;
  72   }
  73   return 0;
  74 }
  75 */
  76
  77
  78 Int_t
  79 AliHLTPHOSSanityInspector::CheckAndHealInsanity(UInt_t* data, Int_t N)
  80   //
  81 {
  82    //See header file for documentation
  83
  84   Int_t crazyness = 0;
  85
  86   if(N > 3)
  87     {
  88       //Require a stable start
  89       if((((Int_t)data[0] - (Int_t)data[1]) > fMaxDifference) || (((Int_t)data[1] - (Int_t)data[0]) > fMaxDifference))
  90         return -1;
  91       if((((Int_t)data[1] - (Int_t)data[2]) > fMaxDifference) || (((Int_t)data[2] - (Int_t)data[1]) > fMaxDifference))
  92         return -1;
  93
  94
  95       for(Int_t i = 2; i < N - 3; i++)
  96         {
  97           if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
  98             {
  99               i++;
 100               if((((Int_t)data[i] -(Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
 101                 {
 102                   i++;
 103                   if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
 104                     {
 105                       return -2;  //Too crazy
 106                     }
 107                   data[i-1] = ((Int_t)data[i] + (Int_t)data[i-2])/2;
 108                   crazyness++;
 109                 }
 110               else
 111                 return -3;    //Two spikes in a row?
 112             }
 113         }
 114
 115
 116
 117       if((((Int_t)data[N - 3] -(Int_t) data[N - 2]) > fMaxDifference) ||
 118          (((Int_t)data[N - 2] - (Int_t)data[N - 3]) > fMaxDifference))
 119         {
 120           if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) ||
 121              (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
 122             {
 123               data[N - 2] = ((Int_t)data[N - 3] +  (Int_t)data[N - 1])/2;
 124               return crazyness++;
 125             }
 126           return -4;
 127
 128         }
 129
 130       if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) ||
 131          (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
 132         {
 133           //      (Int_t)data[N - 3] = (Int_t)data[N - 4] -(Int_t) data[N - 5] + (Int_t)data[N-4];
 134           data[N - 1] = data[N - 2];
 135           return crazyness++;
 136         }
 137
 138     }
 139
 140   return crazyness;
 141
 142 }
 143
 144
 145
 146 Int_t
 147 AliHLTPHOSSanityInspector::CheckAndHealInsanity(Int_t* data, Int_t N)
 148 {
 149    //See header file for documentation
 150
 151   Int_t crazyness = 0;
 152
 153   if(N > 3)
 154     {
 155       if((((Int_t)data[0] - (Int_t)data[1]) > fMaxDifference) || (((Int_t)data[1] - (Int_t)data[0]) > fMaxDifference))
 156         return -1;
 157       if((((Int_t)data[1] - (Int_t)data[2]) > fMaxDifference) || (((Int_t)data[2] - (Int_t)data[1]) > fMaxDifference))
 158         return -1;
 159
 160
 161       for(Int_t i = 2; i < N - 3; i++)
 162         {
 163           if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
 164             {
 165               i++;
 166               if((((Int_t)data[i] -(Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
 167                 {
 168                   i++;
 169                   if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
 170                     {
 171                       return -2;  //Too crazy
 172                     }
 173                   data[i-1] = ((Int_t)data[i] + (Int_t)data[i-2])/2;
 174                   crazyness++;
 175                 }
 176               else
 177                 return -3;    //Two spikes in a row?
 178             }
 179         }
 180
 181
 182
 183       if((((Int_t)data[N - 3] -(Int_t) data[N - 2]) > fMaxDifference) ||
 184          (((Int_t)data[N - 2] - (Int_t)data[N - 3]) > fMaxDifference))
 185         {
 186           if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) ||
 187              (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
 188             {
 189               data[N - 2] = ((Int_t)data[N - 3] +  (Int_t)data[N - 1])/2;
 190               return crazyness++;
 191             }
 192           return -4;
 193
 194         }
 195
 196       if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) ||
 197          (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
 198         {
 199           //      (Int_t)data[N - 3] = (Int_t)data[N - 4] -(Int_t) data[N - 5] + (Int_t)data[N-4];
 200           data[N - 1] = data[N - 2];
 201           return crazyness++;
 202         }
 203
 204     }
 205
 206   return crazyness;
 207
 208 }