[u/mrichter/AliRoot.git] / ITS / AliITSModuleDaSSD.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$  */

///////////////////////////////////////////////////////////////////////////////
///
/// This class provides storage container ITS SSD module callibration data
/// used by DA. 
/// 
/// Date: 18/07/2008
///////////////////////////////////////////////////////////////////////////////

#include "AliITSNoiseSSD.h"
#include "AliITSPedestalSSD.h"
#include "AliITSBadChannelsSSD.h"
#include "AliITSModuleDaSSD.h"
#include "TString.h"
#include "AliLog.h"

ClassImp(AliITSModuleDaSSD)


const Int_t   AliITSModuleDaSSD::fgkStripsPerModule   = 1536;   // Number of strips per SSD module
const Int_t   AliITSModuleDaSSD::fgkPNStripsPerModule = 768;    // Number of N/P strips per SSD module
const Int_t   AliITSModuleDaSSD::fgkStripsPerChip     = 128;    // Number of strips per chip HAL25
const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber       = 9;      // MAx SSD FEROM AD number
const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber      = 13;     // MAx SSD FEROM ADC number
const Int_t   AliITSModuleDaSSD::fgkChipsPerModule    = 12;     // Number of HAL25 chips per SSD module


using namespace std;

//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD() :
  fEquipId(0),
  fEquipType(0),
  fDdlId(0),
  fAd(0),
  fAdc(0),
  fModuleId(0),
  fNumberOfStrips(0),
  fStrips(NULL),
  fNumberOfChips(0),
  fCm(NULL),
  fCmFerom(NULL),
  fEventsNumber(0)
{
// Default constructor
}


//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
  fEquipId(0),
  fEquipType(0),
  fDdlId(ddlID),
  fAd(ad),
  fAdc(adc),
  fModuleId(moduleID),
  fNumberOfStrips(0),
  fStrips(NULL),
  fNumberOfChips(0),
  fCm(NULL),
  fCmFerom(NULL),
  fEventsNumber(0)
{
// Constructor, set module id data
}


//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
  fEquipId(0),
  fEquipType(0),
  fDdlId(0),
  fAd(0),
  fAdc(0),
  fModuleId(0),
  fNumberOfStrips(0),
  fStrips(NULL),
  fNumberOfChips(0),
  fCm(NULL),
  fCmFerom(NULL),
  fEventsNumber(0)
{
// Constructor, allocates memory for AliITSChannelDaSSD* and TArrayS* array for CM calculated in FEROM
  if (numberofstrips != fgkStripsPerModule) 
    AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
  fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
  if (fStrips) {
     fNumberOfStrips = numberofstrips;
     for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
  } else {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
     fNumberOfStrips = 0;
     fStrips = NULL;
  }  
  fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
  if (!fCmFerom) {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
     fCmFerom = NULL;
  }  
}


//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
  fEquipId(0),
  fEquipType(0),
  fDdlId(0),
  fAd(0),
  fAdc(0),
  fModuleId(0),
  fNumberOfStrips(0),
  fStrips(NULL),
  fNumberOfChips(0),
  fCm(NULL),
  fCmFerom(NULL),
  fEventsNumber(0)
{
// Constructor, allocates memory for AliITSChannelDaSSD* and events data
  if (numberofstrips != fgkStripsPerModule) 
    AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
  fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
  if (fStrips) {
     fNumberOfStrips = numberofstrips;
     memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
     for (Int_t i = 0; i < fNumberOfStrips; i++) {
       fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
       if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
     }
  } else {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
     fNumberOfStrips = 0;
     fStrips = NULL;
  }  
  fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
  if (fCmFerom) {
    for (Int_t i = 0; i < fgkChipsPerModule; i++) {
      fCmFerom[i].Set(eventsnumber);
      fCmFerom[i].Reset(0);
    }  
  }
  else {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
     fCmFerom = NULL;
  }  
}


//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
  TObject(module),
  fEquipId(module.fEquipId),
  fEquipType(module.fEquipType),
  fDdlId(module.fDdlId),
  fAd(module.fAd),
  fAdc(module.fAdc),
  fModuleId(module.fModuleId),
  fNumberOfStrips(module.fNumberOfStrips),
  fStrips(NULL),
  fNumberOfChips(module.fNumberOfChips),
  fCm(NULL),
  fCmFerom(NULL),
  fEventsNumber(module.fEventsNumber)
{
// copy constructor
  if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
    fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
    if (fStrips) {
      for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
        if (module.fStrips[strind]) {
	  fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
	  if (!fStrips[strind]) { 
	    AliError("AliITSModuleDaSSD: Error copy constructor");
            for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
	    delete [] fStrips;
	    fStrips = NULL;
	    break;
	  }
	} else fStrips[strind] = NULL; 
      }	  
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
       fNumberOfStrips = 0;
       fStrips = NULL;
    }  
  }
  if (module.fCm) {
    fCm = new (nothrow) TArrayF [module.fNumberOfChips];
    if (fCm) {
      for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
       fNumberOfChips = 0;
       fCm = NULL;
    }  
  }
  
  if (module.fCmFerom) {
    fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
    if (fCmFerom) {
      for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind]; 
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
       fCmFerom = NULL;
    }  
  }
}


//______________________________________________________________________________
AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
{
// assignment operator
  if (this == &module)  return *this;  
  TObject::operator=(module);
  if (fStrips) {
    for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
    delete [] fStrips;
    fStrips = NULL;
  } 
  fEquipId = module.fEquipId;
  fEquipType = module.fEquipType;
  fDdlId = module.fDdlId;
  fAd = module.fAd;
  fAdc = module.fAdc;
  fModuleId = module.fModuleId;
  fStrips = NULL;
  fNumberOfChips = module.fNumberOfChips;
  fCm = NULL;
  fEventsNumber = module.fEventsNumber;
  if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
    fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
    if (fStrips) {
      memset(fStrips, 0, (sizeof(AliITSChannelDaSSD*) * module.fNumberOfStrips));
      for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
        if (module.fStrips[strind]) {
          fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
          if (!fStrips[strind]) { 
            AliError("AliITSModuleDaSSD: Error copy constructor");
            for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
            delete [] fStrips;
            fStrips = NULL;
            fNumberOfStrips = 0;
            break;
          }
        } else fStrips[strind] = NULL; 
      }
      fNumberOfStrips = module.fNumberOfStrips;
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
       fNumberOfStrips = 0;
       fStrips = NULL;
    }  
  }
  if (fCm) delete [] fCm;
  if (module.fCm) {
    fCm = new (nothrow) TArrayF [module.fNumberOfChips];
    if (fCm) {
      for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
       fNumberOfChips = 0;
       fCm = NULL;
    }  
  }  
  if (fCmFerom) delete [] fCmFerom;
  if (module.fCmFerom) {
    fCmFerom = new (nothrow) TArrayS [module.fNumberOfChips];
    if (fCmFerom) {
      for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind]; 
    } else {
       AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
       fCmFerom = NULL;
    }  
  }  
  return *this;
}
    

//______________________________________________________________________________
AliITSModuleDaSSD::~AliITSModuleDaSSD()
{
// Destructor
  if (fStrips)
  {
    for (Long_t i = 0; i < fNumberOfStrips; i++)
    { 
      if (fStrips[i]) delete fStrips[i];
    }
    delete [] fStrips;
  } 
  if (fCm) delete [] fCm;
  if (fCmFerom) delete [] fCmFerom;
}


//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
{
// Allocates memory for AliITSChannelDaSSD*
  if (fStrips) {
    for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
    delete [] fStrips;
    fStrips = NULL;
  }  
  if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; } 
  if (numberofstrips != fgkStripsPerModule) 
    AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
  fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
  if (fStrips) {
     fNumberOfStrips = numberofstrips;
     memset(fStrips, 0, sizeof(AliITSChannelDaSSD*) * numberofstrips);
     return kTRUE;
  } else {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
     fNumberOfStrips = 0;
     fStrips = NULL;
     return kFALSE;
  }  
}


//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
{
// Allocate nchips TArrayF objects to save Common Mode
  DeleteCM();
  if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; } 
  if (nchips != fgkChipsPerModule) 
    AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
  fCm = new (nothrow) TArrayF [nchips];
  if (fCm) {
     fNumberOfChips = nchips;
     return kTRUE;
  } else {
     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
     fNumberOfChips = 0;
     fCm = NULL;
     return kFALSE;
  }  
}

  
//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
{
// SetModuleIdData
  if (ad > fgkMaxAdNumber) {
    AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
    return kFALSE;
  }  
  if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
    AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
    return kFALSE;
  }  
  fDdlId = ddlID;
  fAd = ad;
  fAdc = adc;
  fModuleId = moduleID;
  return kTRUE;
}


//______________________________________________________________________________
void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
{
// Set id data of FEE connected to the Module
  fDdlId = ddlID;
  fAd = ad;
  fAdc = adc;
}


//______________________________________________________________________________
void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
{
// Set data to access FEROM registres via DDL
  fEquipId = equipid; 
  fEquipType = equiptype;
}


//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
{
// Allocate the memory for the events data
  Int_t i;
  if (!fStrips) return kFALSE;
  for (i = 0; i < fNumberOfStrips; i++) {
    if (fStrips[i]) { 
      if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
        for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
        AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i",eventsnumber, (Int_t)fModuleId, i));
        return kFALSE;
      }
    }
    else { 
      if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
        for (Int_t j = 0; j < i; j++) delete fStrips[j];
        delete [] fStrips;
        fNumberOfStrips = 0;
        fStrips = NULL;
        AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
        return kFALSE;
      }
    }
  } 
  if (fCmFerom) {
    for (Int_t ie = 0; ie < fgkChipsPerModule; ie++) {
      fCmFerom[ie].Set(eventsnumber);
      fCmFerom[ie].Reset(0);
    }  
  }
  else  AliError("AliITSModuleDaSSD: No memory was allocated for fCmFerom!");
  fEventsNumber = eventsnumber;
  return kTRUE;
}


//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
{ 
// Set value of CM for a given chip and event 
  if ((!fCm) || (chipn >= fNumberOfChips)) return kFALSE;
  if (evn >= fCm[chipn].GetSize()) return kFALSE;
  else fCm[chipn][evn] = cm;
  return kTRUE;
}


//______________________________________________________________________________
Float_t  AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn)   const 
{ 
// Get value of CM for a given chip and event 
  if ((!fCm) || (chipn >= fNumberOfChips)) return 0.0f;
  if (evn >= fCm[chipn].GetSize()) return 0.0f;
  else return fCm[chipn][evn];
}


//______________________________________________________________________________
Bool_t  AliITSModuleDaSSD::SetCMFeromEventsNumber(const Long_t eventsnumber)
{
// Allocates memory for the values of CM calculated in Ferom
  if (!fCmFerom) return kFALSE;
  for (Int_t chipind = 0; chipind < fgkChipsPerModule; chipind++) {
      fCmFerom[chipind].Set(eventsnumber);
      fCmFerom[chipind].Reset(0);
  }
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetCMFerom (const Short_t cm, const Int_t chipn, const Int_t evn)
{ 
// Set value of FeromCM for a given chip and event 
  if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return kFALSE;
  if (evn >= fCmFerom[chipn].GetSize()) return kFALSE;
  else fCmFerom[chipn][evn] = cm;
  return kTRUE;
}


//______________________________________________________________________________
Short_t  AliITSModuleDaSSD::GetCMFerom(const Int_t chipn, const Long_t evn)   const 
{ 
// Get value of FeromCM for a given chip and event 
  if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return 0;
  if (evn >= fCmFerom[chipn].GetSize()) return 0;
  else return fCmFerom[chipn][evn];
}


UChar_t AliITSModuleDaSSD::CheckIfBad(const Int_t stripn) const
{
//Applies the bad channel creteria and set the appropriate flags for returned valie 
  UInt_t          bcflags = 0;
  const UInt_t    WOffsetMask = 0x000003FF;
  if (!fStrips[stripn]) bcflags |= 3;
  else {
    if (fStrips[stripn]->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags |= 8;
    if (fStrips[stripn]->GetNoiseCM() > 20) bcflags |= 8;
    if (fStrips[stripn]->GetNoiseCM() < 1) bcflags |= 16;
    if (fStrips[stripn]->GetPedestal() > ((WOffsetMask >> 1) - 1))  bcflags |= 4;
    else if ((-(fStrips[stripn]->GetPedestal())) > (WOffsetMask >> 1))  bcflags |= 4;
    if (bcflags) bcflags |= 3;
  }
  return bcflags;
}
Commit	Line	Data
223dda26	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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
371588bb	16	/* $Id$ */
223dda26	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	///
	20	/// This class provides storage container ITS SSD module callibration data
	21	/// used by DA.
61a57d07	22	///
61a57d07	23	/// Date: 18/07/2008
223dda26	24	///////////////////////////////////////////////////////////////////////////////
	25
	26	#include "AliITSNoiseSSD.h"
2e2c6def	27	#include "AliITSPedestalSSD.h"
2e2c6def	28	#include "AliITSBadChannelsSSD.h"
f67db810	29	#include "AliITSModuleDaSSD.h"
c4d90345	30	#include "TString.h"
c4d90345	31	#include "AliLog.h"
f67db810	32
	33	ClassImp(AliITSModuleDaSSD)
	34
c4d90345	35
	36	const Int_t AliITSModuleDaSSD::fgkStripsPerModule = 1536; // Number of strips per SSD module
	37	const Int_t AliITSModuleDaSSD::fgkPNStripsPerModule = 768; // Number of N/P strips per SSD module
	38	const Int_t AliITSModuleDaSSD::fgkStripsPerChip = 128; // Number of strips per chip HAL25
	39	const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber = 9; // MAx SSD FEROM AD number
	40	const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber = 13; // MAx SSD FEROM ADC number
	41	const Int_t AliITSModuleDaSSD::fgkChipsPerModule = 12; // Number of HAL25 chips per SSD module
	42
	43
	44
f67db810	45	using namespace std;
f67db810	46
c4d90345	47	//______________________________________________________________________________
f67db810	48	AliITSModuleDaSSD::AliITSModuleDaSSD() :
	49	fEquipId(0),
	50	fEquipType(0),
	51	fDdlId(0),
	52	fAd(0),
	53	fAdc(0),
	54	fModuleId(0),
	55	fNumberOfStrips(0),
	56	fStrips(NULL),
c4d90345	57	fNumberOfChips(0),
c4d90345	58	fCm(NULL),
371588bb	59	fCmFerom(NULL),
f67db810	60	fEventsNumber(0)
f67db810	61	{
223dda26	62	// Default constructor
f67db810	63	}
	64
	65
c4d90345	66	//______________________________________________________________________________
f67db810	67	AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
	68	fEquipId(0),
	69	fEquipType(0),
	70	fDdlId(ddlID),
	71	fAd(ad),
	72	fAdc(adc),
	73	fModuleId(moduleID),
	74	fNumberOfStrips(0),
	75	fStrips(NULL),
c4d90345	76	fNumberOfChips(0),
c4d90345	77	fCm(NULL),
371588bb	78	fCmFerom(NULL),
f67db810	79	fEventsNumber(0)
f67db810	80	{
223dda26	81	// Constructor, set module id data
f67db810	82	}
	83
	84
	85
c4d90345	86	//______________________________________________________________________________
f67db810	87	AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
	88	fEquipId(0),
	89	fEquipType(0),
	90	fDdlId(0),
	91	fAd(0),
	92	fAdc(0),
	93	fModuleId(0),
	94	fNumberOfStrips(0),
	95	fStrips(NULL),
c4d90345	96	fNumberOfChips(0),
c4d90345	97	fCm(NULL),
371588bb	98	fCmFerom(NULL),
f67db810	99	fEventsNumber(0)
f67db810	100	{
371588bb	101	// Constructor, allocates memory for AliITSChannelDaSSD* and TArrayS* array for CM calculated in FEROM
f67db810	102	if (numberofstrips != fgkStripsPerModule)
c4d90345	103	AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
223dda26	104	fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
223dda26	105	if (fStrips) {
f67db810	106	fNumberOfStrips = numberofstrips;
f67db810	107	for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
223dda26	108	} else {
c4d90345	109	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
f67db810	110	fNumberOfStrips = 0;
f67db810	111	fStrips = NULL;
223dda26	112	}
371588bb	113	fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
	114	if (!fCmFerom) {
	115	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
	116	fCmFerom = NULL;
	117	}
f67db810	118	}
	119
	120
c4d90345	121	//______________________________________________________________________________
f67db810	122	AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
	123	fEquipId(0),
	124	fEquipType(0),
	125	fDdlId(0),
	126	fAd(0),
	127	fAdc(0),
	128	fModuleId(0),
	129	fNumberOfStrips(0),
	130	fStrips(NULL),
c4d90345	131	fNumberOfChips(0),
c4d90345	132	fCm(NULL),
371588bb	133	fCmFerom(NULL),
f67db810	134	fEventsNumber(0)
f67db810	135	{
223dda26	136	// Constructor, allocates memory for AliITSChannelDaSSD* and events data
f67db810	137	if (numberofstrips != fgkStripsPerModule)
c4d90345	138	AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
223dda26	139	fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
223dda26	140	if (fStrips) {
f67db810	141	fNumberOfStrips = numberofstrips;
223dda26	142	memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
	143	for (Int_t i = 0; i < fNumberOfStrips; i++) {
	144	fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
c4d90345	145	if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
223dda26	146	}
223dda26	147	} else {
c4d90345	148	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
f67db810	149	fNumberOfStrips = 0;
f67db810	150	fStrips = NULL;
f67db810	151	}
371588bb	152	fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
	153	if (fCmFerom) {
	154	for (Int_t i = 0; i < fgkChipsPerModule; i++) {
	155	fCmFerom[i].Set(eventsnumber);
	156	fCmFerom[i].Reset(0);
	157	}
	158	}
	159	else {
	160	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
	161	fCmFerom = NULL;
	162	}
f67db810	163	}
	164
	165
	166
c4d90345	167	//______________________________________________________________________________
f67db810	168	AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
	169	TObject(module),
	170	fEquipId(module.fEquipId),
	171	fEquipType(module.fEquipType),
	172	fDdlId(module.fDdlId),
	173	fAd(module.fAd),
	174	fAdc(module.fAdc),
	175	fModuleId(module.fModuleId),
	176	fNumberOfStrips(module.fNumberOfStrips),
a69c8ba0	177	fStrips(NULL),
c4d90345	178	fNumberOfChips(module.fNumberOfChips),
a69c8ba0	179	fCm(NULL),
371588bb	180	fCmFerom(NULL),
f67db810	181	fEventsNumber(module.fEventsNumber)
f67db810	182	{
223dda26	183	// copy constructor
a69c8ba0	184	if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
	185	fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
	186	if (fStrips) {
	187	for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
	188	if (module.fStrips[strind]) {
	189	fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
	190	if (!fStrips[strind]) {
	191	AliError("AliITSModuleDaSSD: Error copy constructor");
	192	for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
	193	delete [] fStrips;
	194	fStrips = NULL;
	195	break;
	196	}
	197	} else fStrips[strind] = NULL;
	198	}
	199	} else {
	200	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
	201	fNumberOfStrips = 0;
	202	fStrips = NULL;
	203	}
	204	}
	205	if (module.fCm) {
	206	fCm = new (nothrow) TArrayF [module.fNumberOfChips];
	207	if (fCm) {
	208	for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
	209	} else {
	210	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
	211	fNumberOfChips = 0;
	212	fCm = NULL;
	213	}
371588bb	214	}
	215
	216	if (module.fCmFerom) {
	217	fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
	218	if (fCmFerom) {
	219	for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind];
	220	} else {
	221	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
	222	fCmFerom = NULL;
	223	}
61a57d07	224	}
f67db810	225	}
	226
	227
	228
c4d90345	229	//______________________________________________________________________________
f67db810	230	AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
	231	{
	232	// assignment operator
a69c8ba0	233	if (this == &module) return *this;
61a57d07	234	TObject::operator=(module);
a69c8ba0	235	if (fStrips) {
	236	for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
	237	delete [] fStrips;
61a57d07	238	fStrips = NULL;
a69c8ba0	239	}
	240	fEquipId = module.fEquipId;
	241	fEquipType = module.fEquipType;
	242	fDdlId = module.fDdlId;
	243	fAd = module.fAd;
	244	fAdc = module.fAdc;
	245	fModuleId = module.fModuleId;
a69c8ba0	246	fStrips = NULL;
	247	fNumberOfChips = module.fNumberOfChips;
	248	fCm = NULL;
	249	fEventsNumber = module.fEventsNumber;
	250	if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
	251	fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
	252	if (fStrips) {
61a57d07	253	memset(fStrips, 0, (sizeof(AliITSChannelDaSSD) module.fNumberOfStrips));
a69c8ba0	254	for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
a69c8ba0	255	if (module.fStrips[strind]) {
61a57d07	256	fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
	257	if (!fStrips[strind]) {
	258	AliError("AliITSModuleDaSSD: Error copy constructor");
a69c8ba0	259	for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
61a57d07	260	delete [] fStrips;
	261	fStrips = NULL;
	262	fNumberOfStrips = 0;
	263	break;
	264	}
	265	} else fStrips[strind] = NULL;
	266	}
	267	fNumberOfStrips = module.fNumberOfStrips;
a69c8ba0	268	} else {
	269	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
	270	fNumberOfStrips = 0;
	271	fStrips = NULL;
	272	}
	273	}
	274	if (fCm) delete [] fCm;
	275	if (module.fCm) {
	276	fCm = new (nothrow) TArrayF [module.fNumberOfChips];
	277	if (fCm) {
	278	for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
	279	} else {
	280	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
	281	fNumberOfChips = 0;
	282	fCm = NULL;
	283	}
	284	}
371588bb	285	if (fCmFerom) delete [] fCmFerom;
	286	if (module.fCmFerom) {
	287	fCmFerom = new (nothrow) TArrayS [module.fNumberOfChips];
	288	if (fCmFerom) {
	289	for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind];
	290	} else {
	291	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
	292	fCmFerom = NULL;
	293	}
	294	}
f67db810	295	return *this;
	296	}
	297
	298
	299
c4d90345	300	//______________________________________________________________________________
f67db810	301	AliITSModuleDaSSD::~AliITSModuleDaSSD()
f67db810	302	{
223dda26	303	// Destructor
f67db810	304	if (fStrips)
	305	{
	306	for (Long_t i = 0; i < fNumberOfStrips; i++)
	307	{
	308	if (fStrips[i]) delete fStrips[i];
f67db810	309	}
	310	delete [] fStrips;
	311	}
c4d90345	312	if (fCm) delete [] fCm;
371588bb	313	if (fCmFerom) delete [] fCmFerom;
c4d90345	314	}
	315
	316
	317
	318	//______________________________________________________________________________
	319	Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
	320	{
	321	// Allocates memory for AliITSChannelDaSSD*
	322	if (fStrips) {
	323	for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
	324	delete [] fStrips;
	325	fStrips = NULL;
	326	}
	327	if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; }
	328	if (numberofstrips != fgkStripsPerModule)
	329	AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
	330	fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
	331	if (fStrips) {
	332	fNumberOfStrips = numberofstrips;
	333	memset(fStrips, 0, sizeof(AliITSChannelDaSSD) numberofstrips);
	334	return kTRUE;
	335	} else {
	336	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
	337	fNumberOfStrips = 0;
	338	fStrips = NULL;
	339	return kFALSE;
	340	}
f67db810	341	}
	342
	343
c4d90345	344	//______________________________________________________________________________
	345	Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
	346	{
	347	// Allocate nchips TArrayF objects to save Common Mode
	348	DeleteCM();
	349	if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; }
	350	if (nchips != fgkChipsPerModule)
	351	AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
	352	fCm = new (nothrow) TArrayF [nchips];
	353	if (fCm) {
	354	fNumberOfChips = nchips;
	355	return kTRUE;
	356	} else {
	357	AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
	358	fNumberOfChips = 0;
	359	fCm = NULL;
	360	return kFALSE;
	361	}
	362	}
	363
f67db810	364
c4d90345	365	//______________________________________________________________________________
c4d90345	366	Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
f67db810	367	{
223dda26	368	// SetModuleIdData
f67db810	369	if (ad > fgkMaxAdNumber) {
c4d90345	370	AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
f67db810	371	return kFALSE;
	372	}
	373	if (adc > fgkMaxAdcNumber \|\| ForbiddenAdcNumber(adc)) {
c4d90345	374	AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
f67db810	375	return kFALSE;
	376	}
	377	fDdlId = ddlID;
	378	fAd = ad;
	379	fAdc = adc;
	380	fModuleId = moduleID;
	381	return kTRUE;
	382	}
	383
	384
c4d90345	385	//______________________________________________________________________________
f67db810	386	void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
f67db810	387	{
223dda26	388	// Set id data of FEE connected to the Module
f67db810	389	fDdlId = ddlID;
	390	fAd = ad;
	391	fAdc = adc;
	392	}
	393
	394
c4d90345	395	//______________________________________________________________________________
f67db810	396	void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
f67db810	397	{
223dda26	398	// Set data to access FEROM registres via DDL
f67db810	399	fEquipId = equipid;
	400	fEquipType = equiptype;
	401	}
	402
	403
c4d90345	404	//______________________________________________________________________________
f67db810	405	Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
f67db810	406	{
00e18e8f	407	// Allocate the memory for the events data
f67db810	408	Int_t i;
f67db810	409	if (!fStrips) return kFALSE;
00e18e8f	410	for (i = 0; i < fNumberOfStrips; i++) {
5af4a2d0	411	if (fStrips[i]) {
00e18e8f	412	if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
00e18e8f	413	for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
5af4a2d0	414	AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i",eventsnumber, (Int_t)fModuleId, i));
00e18e8f	415	return kFALSE;
00e18e8f	416	}
5af4a2d0	417	}
5af4a2d0	418	else {
00e18e8f	419	if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
	420	for (Int_t j = 0; j < i; j++) delete fStrips[j];
	421	delete [] fStrips;
	422	fNumberOfStrips = 0;
	423	fStrips = NULL;
c4d90345	424	AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
00e18e8f	425	return kFALSE;
00e18e8f	426	}
5af4a2d0	427	}
00e18e8f	428	}
371588bb	429	if (fCmFerom) {
4adcf390	430	for (Int_t ie = 0; ie < fgkChipsPerModule; ie++) {
	431	fCmFerom[ie].Set(eventsnumber);
	432	fCmFerom[ie].Reset(0);
371588bb	433	}
	434	}
	435	else AliError("AliITSModuleDaSSD: No memory was allocated for fCmFerom!");
	436	fEventsNumber = eventsnumber;
f67db810	437	return kTRUE;
	438	}
	439
	440
	441
c4d90345	442	//______________________________________________________________________________
	443	Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
	444	{
	445	// Set value of CM for a given chip and event
	446	if ((!fCm) \|\| (chipn >= fNumberOfChips)) return kFALSE;
	447	if (evn >= fCm[chipn].GetSize()) return kFALSE;
	448	else fCm[chipn][evn] = cm;
	449	return kTRUE;
	450	}
	451
	452
	453
	454	//______________________________________________________________________________
	455	Float_t AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn) const
	456	{
	457	// Get value of CM for a given chip and event
	458	if ((!fCm) \|\| (chipn >= fNumberOfChips)) return 0.0f;
	459	if (evn >= fCm[chipn].GetSize()) return 0.0f;
	460	else return fCm[chipn][evn];
	461	}
	462
	463
	464
371588bb	465	//______________________________________________________________________________
	466	Bool_t AliITSModuleDaSSD::SetCMFeromEventsNumber(const Long_t eventsnumber)
	467	{
	468	// Allocates memory for the values of CM calculated in Ferom
	469	if (!fCmFerom) return kFALSE;
	470	for (Int_t chipind = 0; chipind < fgkChipsPerModule; chipind++) {
	471	fCmFerom[chipind].Set(eventsnumber);
	472	fCmFerom[chipind].Reset(0);
	473	}
	474	return kTRUE;
	475	}
	476
	477	//______________________________________________________________________________
	478	Bool_t AliITSModuleDaSSD::SetCMFerom (const Short_t cm, const Int_t chipn, const Int_t evn)
	479	{
	480	// Set value of FeromCM for a given chip and event
	481	if ((!fCmFerom) \|\| (chipn >= fgkChipsPerModule)) return kFALSE;
	482	if (evn >= fCmFerom[chipn].GetSize()) return kFALSE;
	483	else fCmFerom[chipn][evn] = cm;
	484	return kTRUE;
	485	}
	486
	487
	488
	489	//______________________________________________________________________________
	490	Short_t AliITSModuleDaSSD::GetCMFerom(const Int_t chipn, const Long_t evn) const
	491	{
	492	// Get value of FeromCM for a given chip and event
	493	if ((!fCmFerom) \|\| (chipn >= fgkChipsPerModule)) return 0;
	494	if (evn >= fCmFerom[chipn].GetSize()) return 0;
	495	else return fCmFerom[chipn][evn];
	496	}
	497
	498
	499
61a57d07	500	UChar_t AliITSModuleDaSSD::CheckIfBad(const Int_t stripn) const
2e2c6def	501	{
61a57d07	502	//Applies the bad channel creteria and set the appropriate flags for returned valie
	503	UInt_t bcflags = 0;
	504	const UInt_t WOffsetMask = 0x000003FF;
	505	if (!fStrips[stripn]) bcflags \|= 3;
	506	else {
	507	if (fStrips[stripn]->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags \|= 8;
	508	if (fStrips[stripn]->GetNoiseCM() > 20) bcflags \|= 8;
	509	if (fStrips[stripn]->GetNoiseCM() < 1) bcflags \|= 16;
	510	if (fStrips[stripn]->GetPedestal() > ((WOffsetMask >> 1) - 1)) bcflags \|= 4;
	511	else if ((-(fStrips[stripn]->GetPedestal())) > (WOffsetMask >> 1)) bcflags \|= 4;
	512	if (bcflags) bcflags \|= 3;
2e2c6def	513	}
61a57d07	514	return bcflags;
2e2c6def	515	}