HLT/CALO/AliHLTCaloSanityInspector.cxx

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