[u/mrichter/AliRoot.git] / TRD / AliTRDCalibChamberStatus.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// AliTRDCalibChamberStatus: to determine which half chambers are off     //
// Produce a AliTRDCalChamberStatus calibration object                    //
// Check with the AliTRDCalDCSFEE info                                    //
//                                                                        //
//                                                                        //
// Authors:                                                               //
//   J. Book (jbook@ikf.uni-frankfurt.de)                                 //
//   R. Bailhache (rbailhache@ikf.uni-frankfurt.de)                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////


//Root includes
#include <THnSparse.h>

#include <TDirectory.h>
#include <TFile.h>

//AliRoot includes
#include "AliRawReader.h"

//header file
#include "AliLog.h"
#include "AliTRDCalibChamberStatus.h"
#include "AliTRDgeometry.h"
#include "AliTRDdigitsManager.h"
#include "AliTRDSignalIndex.h"
#include "AliTRDrawFastStream.h"
#include "./Cal/AliTRDCalChamberStatus.h"
#include "./Cal/AliTRDCalDCS.h"
#include "./Cal/AliTRDCalDCSFEE.h"

#ifdef ALI_DATE
#include "event.h"
#endif

ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/

//_____________________________________________________________________
AliTRDCalibChamberStatus::AliTRDCalibChamberStatus() : /*FOLD00*/
  TObject(),
  fDetector(-1),
  fNumberOfTimeBins(0),
  fCounterEventNotEmpty(0),
  fCalChamberStatus(0x0),
  fHnSparseI(0x0),
  fHnSparseHCM(0x0),
  fHnSparseEvtDet(0x0),
  fHnSparseDebug(0x0),
  fHnSparseMCM(0x0),
  fDebugLevel(0)
{
    //
    // default constructor
    //

}
//_____________________________________________________________________
AliTRDCalibChamberStatus::AliTRDCalibChamberStatus(const AliTRDCalibChamberStatus &ped) : /*FOLD00*/
  TObject(ped),
  fDetector(ped.fDetector),
  fNumberOfTimeBins(ped.fNumberOfTimeBins),
  fCounterEventNotEmpty(ped.fCounterEventNotEmpty),
  fCalChamberStatus(ped.fCalChamberStatus),
  fHnSparseI(ped.fHnSparseI),
  fHnSparseHCM(ped.fHnSparseHCM),
  fHnSparseEvtDet(ped.fHnSparseEvtDet),
  fHnSparseDebug(ped.fHnSparseDebug),  
  fHnSparseMCM(ped.fHnSparseMCM),
  fDebugLevel(ped.fDebugLevel)
{
    //
    // copy constructor
    //
  
}
//_____________________________________________________________________
AliTRDCalibChamberStatus& AliTRDCalibChamberStatus::operator = (const  AliTRDCalibChamberStatus &source)
{
  //
  // assignment operator
  //
  if (&source == this) return *this;
  new (this) AliTRDCalibChamberStatus(source);

  return *this;
}
//_____________________________________________________________________
AliTRDCalibChamberStatus::~AliTRDCalibChamberStatus() /*FOLD00*/
{
  //
  // destructor
  //
  if(fCalChamberStatus){
    delete fCalChamberStatus;
  }
  if(fHnSparseI) {
    delete fHnSparseI;
  }
  if(fHnSparseHCM) {
    delete fHnSparseHCM;
  }
  if(fHnSparseEvtDet) {
    delete fHnSparseEvtDet;
  }
  if(fHnSparseDebug) {
    delete fHnSparseDebug;
  }
  if(fHnSparseMCM) {
   delete fHnSparseMCM;
 }
}

//_____________________________________________________________________
void AliTRDCalibChamberStatus::Init() 
{
  //
  // Init the different THnSparse
  //
  //

  //
  // Init the fHnSparseI
  //

  //create the map
  Int_t thnDimEvt[4]; // sm, layer, stack, halfchamber
  thnDimEvt[0] = 18;
  thnDimEvt[1] = 6;
  thnDimEvt[2] = 5;
  thnDimEvt[3] = 2;
  //arrays for lower bounds :
  Double_t* binEdgesEvt[4];
  for(Int_t ivar = 0; ivar < 4; ivar++)
    binEdgesEvt[ivar] = new Double_t[thnDimEvt[ivar] + 1];
  //values for bin lower bounds
  for(Int_t i=0; i<=thnDimEvt[0]; i++) binEdgesEvt[0][i]= 0.0  + (18.0)/thnDimEvt[0]*(Double_t)i;
  for(Int_t i=0; i<=thnDimEvt[1]; i++) binEdgesEvt[1][i]= 0.0  + (6.0)/thnDimEvt[1]*(Double_t)i;
  for(Int_t i=0; i<=thnDimEvt[2]; i++) binEdgesEvt[2][i]= 0.0  + (5.0)/thnDimEvt[2]*(Double_t)i;
  for(Int_t i=0; i<=thnDimEvt[3]; i++) binEdgesEvt[3][i]= 0.0  + (2.0)/thnDimEvt[3]*(Double_t)i;
  
  //create the THnSparse
  fHnSparseI = new THnSparseI("NumberOfEntries","NumberOfEntries",4,thnDimEvt);
  for (int k=0; k<4; k++) {
    fHnSparseI->SetBinEdges(k,binEdgesEvt[k]);
  }
  fHnSparseI->Sumw2();

  //
  // Init the fHnSparseHCM (THnSparseI)
  //

  //create the THnSparse
  fHnSparseHCM = new THnSparseI("HCMerrors","HCMerrors",4,thnDimEvt);
  for (int k=0; k<4; k++) {
    fHnSparseHCM->SetBinEdges(k,binEdgesEvt[k]);
  }
  fHnSparseHCM->Sumw2();


  //---------//
  //  Debug  //
  if(fDebugLevel > 0) {
  
    //
    // Init the fHnSparseEvtDet (THnSparseI)
    //
    
    //create the map
    Int_t thnDimEvts[3]; // event, detector, halfchamber
    thnDimEvts[0] = 10000;
    thnDimEvts[1] = 540;
    thnDimEvts[2] = 2;
    //arrays for lower bounds :
    Double_t* binEdgesEvts[3];
    for(Int_t ivar = 0; ivar < 3; ivar++)
      binEdgesEvts[ivar] = new Double_t[thnDimEvts[ivar] + 1];
    //values for bin lower bounds
    for(Int_t i=0; i<=thnDimEvts[0]; i++) binEdgesEvts[0][i]= 0.0  + (10000.0)/thnDimEvts[0]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvts[1]; i++) binEdgesEvts[1][i]= 0.0  + (540.0)/thnDimEvts[1]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvts[2]; i++) binEdgesEvts[2][i]= 0.0  + (2.0)/thnDimEvts[2]*(Double_t)i;
    
    //create the THnSparse
    fHnSparseEvtDet = new THnSparseI("NumberOfEntriesPerEvent","NumberOfEntriesPerEvent",3,thnDimEvts);
    for (int k=0; k<3; k++) {
      fHnSparseEvtDet->SetBinEdges(k,binEdgesEvts[k]);
    }
    fHnSparseEvtDet->Sumw2();

    //
    // Init the fHnSparseDebug (THnSparseI)
    //
    
    //create the THnSparse
    fHnSparseDebug = new THnSparseI("NumberOfDifferentDecisions","NumberOfDifferentDecisions",4,thnDimEvt);
    for (int k=0; k<4; k++) {
      fHnSparseDebug->SetBinEdges(k,binEdgesEvt[k]);
    }
    fHnSparseDebug->Sumw2();
        
    //
    // Init the fHnSparseMCM (THnSparseI)
    //
    
    //create the map
    Int_t thnDimEvtt[6]; // sm, layer, stack, ROB, MCM
    thnDimEvtt[0] = 18;
    thnDimEvtt[1] = 6;
    thnDimEvtt[2] = 5;
    thnDimEvtt[3] = 8;
    thnDimEvtt[4] = 16;
    thnDimEvtt[5] = 16;
    //arrays for lower bounds :
    Double_t* binEdgesEvtt[6];
    for(Int_t ivar = 0; ivar < 6; ivar++)
      binEdgesEvtt[ivar] = new Double_t[thnDimEvtt[ivar] + 1];
    //values for bin lower bounds
    for(Int_t i=0; i<=thnDimEvtt[0]; i++) binEdgesEvtt[0][i]= 0.0  + (18.0)/thnDimEvtt[0]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvtt[1]; i++) binEdgesEvtt[1][i]= 0.0  + (6.0)/thnDimEvtt[1]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvtt[2]; i++) binEdgesEvtt[2][i]= 0.0  + (5.0)/thnDimEvtt[2]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvtt[3]; i++) binEdgesEvtt[3][i]= 0.0  + (8.0)/thnDimEvtt[3]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvtt[4]; i++) binEdgesEvtt[4][i]= 0.0  + (16.0)/thnDimEvtt[4]*(Double_t)i;
    for(Int_t i=0; i<=thnDimEvtt[5]; i++) binEdgesEvtt[5][i]= 0.0  + (16.0)/thnDimEvtt[5]*(Double_t)i;
    
    //create the THnSparse
    fHnSparseMCM = new THnSparseI("MCMerrorDCS","MCMerrorDCS",6,thnDimEvtt);
    for (int k=0; k<6; k++) {
      fHnSparseMCM->SetBinEdges(k,binEdgesEvtt[k]);
    }
    fHnSparseMCM->Sumw2();
  
  }
  //  Debug  //
  //---------//

}
//_____________________________________________________________________
void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics)
{
  //
  // Event Processing loop 
  //
  //
  
  Bool_t notEmpty = kFALSE;
    
  AliTRDrawFastStream *rawStream = new AliTRDrawFastStream(rawReader);
  rawStream->SetSharedPadReadout(kFALSE);

  AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
  digitsManager->CreateArrays();
  
  Int_t det    = 0;
  while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { 

    //nextchamber loop
    
    // do the QA analysis
    if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
      // printf("there is ADC data on this chamber!\n");
      
      AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
      if (indexes->IsAllocated() == kFALSE) {
	// AliError("Indexes do not exist!");
	break;
      }
      
      Int_t iRow  = 0;
      Int_t iCol  = 0;
      indexes->ResetCounters();
      
      while (indexes->NextRCIndex(iRow, iCol)){
	Int_t iMcm        = (Int_t)(iCol/18);   // current group of 18 col pads
	
	Int_t layer = AliTRDgeometry::GetLayer(det);
	Int_t sm    = AliTRDgeometry::GetSector(det);
	Int_t stac  = AliTRDgeometry::GetStack(det);
	Double_t rphi = 0.5;
	if(iMcm > 3) rphi = 1.5;

	Double_t val[4] = {sm,layer,stac,rphi}; 
	fHnSparseI->Fill(&val[0]); 
	notEmpty = kTRUE;
	
	//---------//
	//  Debug  //
	if(fDebugLevel > 0) {
	  Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm);
	  Double_t valu[3] = {nevents_physics,detector,rphi};
	  fHnSparseEvtDet->Fill(&valu[0]); 
	}
	//  Debug  //
	//---------//
      }
      
    }
    digitsManager->ClearArrays(det);
  }

  if(notEmpty) fCounterEventNotEmpty++;

  if(digitsManager) delete digitsManager;
  if(rawStream) delete rawStream;
   
}
//_____________________________________________________________________
Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/
{
  //
  //  Test event loop
  // fill the fHnSparseI with entries
  //
  
  AliTRDgeometry geo;


  for(Int_t ievent=0; ievent<nevent; ievent++){
    for (Int_t ism=0; ism<18; ism++){
      for (Int_t istack=0; istack<5; istack++){
	for (Int_t ipl=0; ipl<6; ipl++){
	  for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){
	    Int_t side = 0;
	    if(icol > 72) side = 1;
	    Double_t val[4] = {ism,ipl,istack,side}; 
	    fHnSparseI->Fill(&val[0]); 
	  }
	}
      }
    }
  }
  
  return kTRUE;

}
//_____________________________________________________________________
void AliTRDCalibChamberStatus::AnalyseHisto() /*FOLD00*/
{
    //
    //  Create the AliTRDCalChamberStatus according to the fHnSparseI
    //

  if(fCalChamberStatus) delete fCalChamberStatus;
  fCalChamberStatus = new AliTRDCalChamberStatus();

  // Check if enough events to say something
  if(fCounterEventNotEmpty < 30) {
    // Say all installed
    for (Int_t ism=0; ism<18; ism++) {
      for (Int_t ipl=0; ipl<6; ipl++) {
	for (Int_t istack=0; istack<5; istack++) {
	  // layer, stack, sector
	  Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
	  fCalChamberStatus->SetStatus(det,1);
	}
      }
    }
    return;
  }

  // Mask out all chambers
  for (Int_t ism=0; ism<18; ism++) {
    for (Int_t ipl=0; ipl<6; ipl++) {
      for (Int_t istack=0; istack<5; istack++) {
	// layer, stack, sector
	Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
	fCalChamberStatus->SetStatus(det,2);
      }
    }
  }

  // Unmask good chambers 
  Int_t coord[4];
  for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
    
    fHnSparseI->GetBinContent(bin,coord);
    // layer, stack, sector
    Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1);

    //
    // Check which halfchamber side corresponds to the bin number (0=A, 1=B)
    // Change the status accordingly
    //

    switch(fCalChamberStatus->GetStatus(detector)) 
      {    
      case 1: break;  // no changes
      case 2: 
	if(coord[3]-1==0) {
	  fCalChamberStatus->SetStatus(detector,4); break;      // only SideB is masked
	}
	else {
	  fCalChamberStatus->SetStatus(detector,3); break;      // only SideA is masked
	}
      case 3:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideA
      case 4:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideB
      }
  }


}
//_____________________________________________________________________
void AliTRDCalibChamberStatus::CheckEORStatus(AliTRDCalDCS *calDCS) /*FOLD00*/
{
  //
  //  Correct the AliTRDCalChamberStatus according to the AliTRDCalDCS
  //  Using globale state of the HalfChamberMerger (HCM)
  //
  
  for(Int_t det = 0; det < 540; det++) {
    AliTRDCalDCSFEE* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det);
    if(!calDCSFEEEOR) { continue;}
    
    // MCM Global State Machine State Definitions
    //  low_power =  0,
    //  test      =  1,
    //  wait_pre  =  3,
    //  preproc   =  7,
    //  zero_sp   =  8,
    //  full_rd   =  9,
    //  clear_st  = 11,
    //  wait_L1   = 12,
    //  tr_send   = 14,
    //  tr_proc   = 15 

    Int_t sm   = AliTRDgeometry::GetSector(det);
    Int_t lay  = AliTRDgeometry::GetLayer(det);
    Int_t stac = AliTRDgeometry::GetStack(det);
    
    Int_t stateA = calDCSFEEEOR->GetMCMGlobalState(4,17); // HCM Side A
    Int_t stateB = calDCSFEEEOR->GetMCMGlobalState(5,17); // HCM Side B
    Int_t rphi = -1;

    //printf("DCS: stateA %d \t stateB %d \n",stateA,stateB);
    if(stateA!=3 && stateA!=9) rphi = 1;
    Double_t vals[4] = {sm,lay,stac,rphi};
    if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
    
    if(stateB!=3 && stateB!=9) rphi = 2;
    vals[3] = rphi;
    if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
    
    //---------//
    //  Debug  //
    if(fDebugLevel > 0) {
      if( (fCalChamberStatus->GetStatus(det) <= 1) && (stateA!=3 && stateA!=9) || 
	  (fCalChamberStatus->GetStatus(det) <= 1) && (stateB!=3 && stateB!=9) || 
	  (fCalChamberStatus->GetStatus(det) >= 2) && (stateA==3 || stateA==9) || 
	  (fCalChamberStatus->GetStatus(det) >= 2) && (stateB==3 || stateB==9)  )
	{
	  //printf(" Different half chamber status in DCS and DATA!!\n");
	  Double_t val[4] = {sm,lay,stac,1};
	  fHnSparseDebug->Fill(&val[0]); 
	  
	  if(rphi!=-1) {  // error in DCS information
	    // Fill MCM status map
	    for(Int_t ii = 0; ii < 8; ii++) { //ROB loop
	      for(Int_t i = 0; i < 16; i++) { //MCM loop
		Double_t valss[6] = {sm,lay,stac,ii,i
				     ,calDCSFEEEOR->GetMCMGlobalState(ii,i)};
		fHnSparseMCM->Fill(&valss[0]);
	      }
	    } 
	  }
	}
    }
    //---------//
    //  Debug  //
  }

}

//_____________________________________________________________________________________
void AliTRDCalibChamberStatus::Add(AliTRDCalibChamberStatus *calibChamberStatus) /*FOLD00*/
{
    //
    //  Add the THnSparseI of this calibChamberStatus
    //

  fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty();

  THnSparseI *hnSparseI = calibChamberStatus->GetSparseI();
  if(!hnSparseI) return;

  if(!fHnSparseI) {
    fHnSparseI = (THnSparseI *) hnSparseI->Clone();
  }
  else {
    fHnSparseI->Add(hnSparseI);
  }
  

}
//_____________________________________________________________________
void AliTRDCalibChamberStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
{
    //
    //  Write class to file
    //

    TString sDir(dir);
    TString option;

    if ( append )
	option = "update";
    else
        option = "recreate";

    TDirectory *backup = gDirectory;
    TFile f(filename,option.Data());
    f.cd();
    if ( !sDir.IsNull() ){
	f.mkdir(sDir.Data());
	f.cd(sDir);
    }
    this->Write();
    f.Close();

    if ( backup ) backup->cd();
}
Commit	Line	Data
6c1053a8	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	////////////////////////////////////////////////////////////////////////////
	17	// //
	18	// AliTRDCalibChamberStatus: to determine which half chambers are off //
	19	// Produce a AliTRDCalChamberStatus calibration object //
	20	// Check with the AliTRDCalDCSFEE info //
	21	// //
	22	// //
	23	// Authors: //
	24	// J. Book (jbook@ikf.uni-frankfurt.de) //
	25	// R. Bailhache (rbailhache@ikf.uni-frankfurt.de) //
	26	// //
	27	////////////////////////////////////////////////////////////////////////////
	28
	29
	30	//Root includes
	31	#include <THnSparse.h>
	32
	33	#include <TDirectory.h>
	34	#include <TFile.h>
	35
	36	//AliRoot includes
	37	#include "AliRawReader.h"
	38
	39	//header file
	40	#include "AliLog.h"
	41	#include "AliTRDCalibChamberStatus.h"
	42	#include "AliTRDgeometry.h"
	43	#include "AliTRDdigitsManager.h"
	44	#include "AliTRDSignalIndex.h"
	45	#include "AliTRDrawFastStream.h"
	46	#include "./Cal/AliTRDCalChamberStatus.h"
	47	#include "./Cal/AliTRDCalDCS.h"
	48	#include "./Cal/AliTRDCalDCSFEE.h"
	49
	50	#ifdef ALI_DATE
	51	#include "event.h"
	52	#endif
	53
	54	ClassImp(AliTRDCalibChamberStatus) /FOLD00/
	55
	56	//_____________________________________________________________________
	57	AliTRDCalibChamberStatus::AliTRDCalibChamberStatus() : /FOLD00/
	58	TObject(),
	59	fDetector(-1),
	60	fNumberOfTimeBins(0),
	61	fCounterEventNotEmpty(0),
	62	fCalChamberStatus(0x0),
	63	fHnSparseI(0x0),
	64	fHnSparseHCM(0x0),
65	fHnSparseEvtDet(0x0),
66	fHnSparseDebug(0x0),
67	fHnSparseMCM(0x0),
68	fDebugLevel(0)
69	{
70	//
71	// default constructor
72	//
73
74	}
75	//_____________________________________________________________________
76	AliTRDCalibChamberStatus::AliTRDCalibChamberStatus(const AliTRDCalibChamberStatus &ped) : /FOLD00/
77	TObject(ped),
78	fDetector(ped.fDetector),
79	fNumberOfTimeBins(ped.fNumberOfTimeBins),
80	fCounterEventNotEmpty(ped.fCounterEventNotEmpty),
81	fCalChamberStatus(ped.fCalChamberStatus),
82	fHnSparseI(ped.fHnSparseI),
83	fHnSparseHCM(ped.fHnSparseHCM),
84	fHnSparseEvtDet(ped.fHnSparseEvtDet),
85	fHnSparseDebug(ped.fHnSparseDebug),
86	fHnSparseMCM(ped.fHnSparseMCM),
87	fDebugLevel(ped.fDebugLevel)
88	{
89	//
90	// copy constructor
91	//
92
93	}
94	//_____________________________________________________________________
95	AliTRDCalibChamberStatus& AliTRDCalibChamberStatus::operator = (const AliTRDCalibChamberStatus &source)
96	{
97	//
98	// assignment operator
99	//
100	if (&source == this) return *this;
101	new (this) AliTRDCalibChamberStatus(source);
102
103	return *this;
104	}
105	//_____________________________________________________________________
106	AliTRDCalibChamberStatus::~AliTRDCalibChamberStatus() /FOLD00/
107	{
108	//
109	// destructor
110	//
111	if(fCalChamberStatus){
112	delete fCalChamberStatus;
113	}
114	if(fHnSparseI) {
115	delete fHnSparseI;
116	}
117	if(fHnSparseHCM) {
118	delete fHnSparseHCM;
119	}
120	if(fHnSparseEvtDet) {
121	delete fHnSparseEvtDet;
122	}
123	if(fHnSparseDebug) {
124	delete fHnSparseDebug;
125	}
126	if(fHnSparseMCM) {
127	delete fHnSparseMCM;
128	}
129	}
130
131	//_____________________________________________________________________
132	void AliTRDCalibChamberStatus::Init()
133	{
134	//
135	// Init the different THnSparse
136	//
137	//
138
139	//
140	// Init the fHnSparseI
141	//
142
143	//create the map
144	Int_t thnDimEvt[4]; // sm, layer, stack, halfchamber
145	thnDimEvt[0] = 18;
146	thnDimEvt[1] = 6;
147	thnDimEvt[2] = 5;
148	thnDimEvt[3] = 2;
149	//arrays for lower bounds :
150	Double_t* binEdgesEvt[4];
151	for(Int_t ivar = 0; ivar < 4; ivar++)
152	binEdgesEvt[ivar] = new Double_t[thnDimEvt[ivar] + 1];
153	//values for bin lower bounds
154	for(Int_t i=0; i<=thnDimEvt[0]; i++) binEdgesEvt[0][i]= 0.0 + (18.0)/thnDimEvt[0]*(Double_t)i;
155	for(Int_t i=0; i<=thnDimEvt[1]; i++) binEdgesEvt[1][i]= 0.0 + (6.0)/thnDimEvt[1]*(Double_t)i;
156	for(Int_t i=0; i<=thnDimEvt[2]; i++) binEdgesEvt[2][i]= 0.0 + (5.0)/thnDimEvt[2]*(Double_t)i;
157	for(Int_t i=0; i<=thnDimEvt[3]; i++) binEdgesEvt[3][i]= 0.0 + (2.0)/thnDimEvt[3]*(Double_t)i;
158
159	//create the THnSparse
160	fHnSparseI = new THnSparseI("NumberOfEntries","NumberOfEntries",4,thnDimEvt);
161	for (int k=0; k<4; k++) {
162	fHnSparseI->SetBinEdges(k,binEdgesEvt[k]);
163	}
164	fHnSparseI->Sumw2();
165
166	//
167	// Init the fHnSparseHCM (THnSparseI)
168	//
169
170	//create the THnSparse
171	fHnSparseHCM = new THnSparseI("HCMerrors","HCMerrors",4,thnDimEvt);
172	for (int k=0; k<4; k++) {
173	fHnSparseHCM->SetBinEdges(k,binEdgesEvt[k]);
174	}
175	fHnSparseHCM->Sumw2();
176
177
178	//---------//
179	// Debug //
180	if(fDebugLevel > 0) {
181
182	//
183	// Init the fHnSparseEvtDet (THnSparseI)
184	//
185
186	//create the map
187	Int_t thnDimEvts[3]; // event, detector, halfchamber
188	thnDimEvts[0] = 10000;
189	thnDimEvts[1] = 540;
190	thnDimEvts[2] = 2;
191	//arrays for lower bounds :
192	Double_t* binEdgesEvts[3];
193	for(Int_t ivar = 0; ivar < 3; ivar++)
194	binEdgesEvts[ivar] = new Double_t[thnDimEvts[ivar] + 1];
195	//values for bin lower bounds
196	for(Int_t i=0; i<=thnDimEvts[0]; i++) binEdgesEvts[0][i]= 0.0 + (10000.0)/thnDimEvts[0]*(Double_t)i;
197	for(Int_t i=0; i<=thnDimEvts[1]; i++) binEdgesEvts[1][i]= 0.0 + (540.0)/thnDimEvts[1]*(Double_t)i;
198	for(Int_t i=0; i<=thnDimEvts[2]; i++) binEdgesEvts[2][i]= 0.0 + (2.0)/thnDimEvts[2]*(Double_t)i;
199
200	//create the THnSparse
201	fHnSparseEvtDet = new THnSparseI("NumberOfEntriesPerEvent","NumberOfEntriesPerEvent",3,thnDimEvts);
202	for (int k=0; k<3; k++) {
203	fHnSparseEvtDet->SetBinEdges(k,binEdgesEvts[k]);
204	}
205	fHnSparseEvtDet->Sumw2();
206
207	//
208	// Init the fHnSparseDebug (THnSparseI)
209	//
210
211	//create the THnSparse
212	fHnSparseDebug = new THnSparseI("NumberOfDifferentDecisions","NumberOfDifferentDecisions",4,thnDimEvt);
213	for (int k=0; k<4; k++) {
214	fHnSparseDebug->SetBinEdges(k,binEdgesEvt[k]);
215	}
216	fHnSparseDebug->Sumw2();
217
218	//
219	// Init the fHnSparseMCM (THnSparseI)
220	//
221
222	//create the map
223	Int_t thnDimEvtt[6]; // sm, layer, stack, ROB, MCM
224	thnDimEvtt[0] = 18;
225	thnDimEvtt[1] = 6;
226	thnDimEvtt[2] = 5;
227	thnDimEvtt[3] = 8;
228	thnDimEvtt[4] = 16;
229	thnDimEvtt[5] = 16;
230	//arrays for lower bounds :
231	Double_t* binEdgesEvtt[6];
232	for(Int_t ivar = 0; ivar < 6; ivar++)
233	binEdgesEvtt[ivar] = new Double_t[thnDimEvtt[ivar] + 1];
234	//values for bin lower bounds
235	for(Int_t i=0; i<=thnDimEvtt[0]; i++) binEdgesEvtt[0][i]= 0.0 + (18.0)/thnDimEvtt[0]*(Double_t)i;
236	for(Int_t i=0; i<=thnDimEvtt[1]; i++) binEdgesEvtt[1][i]= 0.0 + (6.0)/thnDimEvtt[1]*(Double_t)i;
237	for(Int_t i=0; i<=thnDimEvtt[2]; i++) binEdgesEvtt[2][i]= 0.0 + (5.0)/thnDimEvtt[2]*(Double_t)i;
238	for(Int_t i=0; i<=thnDimEvtt[3]; i++) binEdgesEvtt[3][i]= 0.0 + (8.0)/thnDimEvtt[3]*(Double_t)i;
239	for(Int_t i=0; i<=thnDimEvtt[4]; i++) binEdgesEvtt[4][i]= 0.0 + (16.0)/thnDimEvtt[4]*(Double_t)i;
240	for(Int_t i=0; i<=thnDimEvtt[5]; i++) binEdgesEvtt[5][i]= 0.0 + (16.0)/thnDimEvtt[5]*(Double_t)i;
241
242	//create the THnSparse
243	fHnSparseMCM = new THnSparseI("MCMerrorDCS","MCMerrorDCS",6,thnDimEvtt);
244	for (int k=0; k<6; k++) {
245	fHnSparseMCM->SetBinEdges(k,binEdgesEvtt[k]);
246	}
247	fHnSparseMCM->Sumw2();
248
249	}
250	// Debug //
251	//---------//
252
253	}
254	//_____________________________________________________________________
255	void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics)
256	{
257	//
258	// Event Processing loop
259	//
260	//
261
262	Bool_t notEmpty = kFALSE;
263
264	AliTRDrawFastStream *rawStream = new AliTRDrawFastStream(rawReader);
265	rawStream->SetSharedPadReadout(kFALSE);
266
267	AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
268	digitsManager->CreateArrays();
269
270	Int_t det = 0;
271	while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) {
272
273	//nextchamber loop
274
275	// do the QA analysis
276	if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
277	// printf("there is ADC data on this chamber!\n");
278
279	AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
280	if (indexes->IsAllocated() == kFALSE) {
281	// AliError("Indexes do not exist!");
282	break;
283	}
284
285	Int_t iRow = 0;
286	Int_t iCol = 0;
287	indexes->ResetCounters();
288
289	while (indexes->NextRCIndex(iRow, iCol)){
290	Int_t iMcm = (Int_t)(iCol/18); // current group of 18 col pads
291
292	Int_t layer = AliTRDgeometry::GetLayer(det);
293	Int_t sm = AliTRDgeometry::GetSector(det);
294	Int_t stac = AliTRDgeometry::GetStack(det);
295	Double_t rphi = 0.5;
296	if(iMcm > 3) rphi = 1.5;
297
298	Double_t val[4] = {sm,layer,stac,rphi};
299	fHnSparseI->Fill(&val[0]);
300	notEmpty = kTRUE;
301
302	//---------//
303	// Debug //
304	if(fDebugLevel > 0) {
305	Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm);
306	Double_t valu[3] = {nevents_physics,detector,rphi};
307	fHnSparseEvtDet->Fill(&valu[0]);
308	}
309	// Debug //
310	//---------//
311	}
312
313	}
314	digitsManager->ClearArrays(det);
315	}
316
317	if(notEmpty) fCounterEventNotEmpty++;
318
319	if(digitsManager) delete digitsManager;
320	if(rawStream) delete rawStream;
321
322	}
323	//_____________________________________________________________________
324	Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /FOLD00/
325	{
326	//
327	// Test event loop
328	// fill the fHnSparseI with entries
329	//
330
331	AliTRDgeometry geo;
332
333
334	for(Int_t ievent=0; ievent<nevent; ievent++){
335	for (Int_t ism=0; ism<18; ism++){
336	for (Int_t istack=0; istack<5; istack++){
337	for (Int_t ipl=0; ipl<6; ipl++){
338	for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){
339	Int_t side = 0;
340	if(icol > 72) side = 1;
341	Double_t val[4] = {ism,ipl,istack,side};
342	fHnSparseI->Fill(&val[0]);
343	}
344	}
345	}
346	}
347	}
348
349	return kTRUE;
350
351	}
352	//_____________________________________________________________________
353	void AliTRDCalibChamberStatus::AnalyseHisto() /FOLD00/
354	{
355	//
356	// Create the AliTRDCalChamberStatus according to the fHnSparseI
357	//
358
359	if(fCalChamberStatus) delete fCalChamberStatus;
360	fCalChamberStatus = new AliTRDCalChamberStatus();
361
362	// Check if enough events to say something
363	if(fCounterEventNotEmpty < 30) {
364	// Say all installed
365	for (Int_t ism=0; ism<18; ism++) {
366	for (Int_t ipl=0; ipl<6; ipl++) {
367	for (Int_t istack=0; istack<5; istack++) {
368	// layer, stack, sector
369	Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
370	fCalChamberStatus->SetStatus(det,1);
371	}
372	}
373	}
374	return;
375	}
376
377	// Mask out all chambers
378	for (Int_t ism=0; ism<18; ism++) {
379	for (Int_t ipl=0; ipl<6; ipl++) {
380	for (Int_t istack=0; istack<5; istack++) {
381	// layer, stack, sector
382	Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
383	fCalChamberStatus->SetStatus(det,2);
384	}
385	}
386	}
387
388	// Unmask good chambers
389	Int_t coord[4];
390	for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
391
392	fHnSparseI->GetBinContent(bin,coord);
393	// layer, stack, sector
394	Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1);
395
396	//
397	// Check which halfchamber side corresponds to the bin number (0=A, 1=B)
398	// Change the status accordingly
399	//
400
401	switch(fCalChamberStatus->GetStatus(detector))
402	{
403	case 1: break; // no changes
404	case 2:
405	if(coord[3]-1==0) {
406	fCalChamberStatus->SetStatus(detector,4); break; // only SideB is masked
407	}
408	else {
409	fCalChamberStatus->SetStatus(detector,3); break; // only SideA is masked
410	}
411	case 3: fCalChamberStatus->SetStatus(detector,1); break; // unmask SideA
412	case 4: fCalChamberStatus->SetStatus(detector,1); break; // unmask SideB
413	}
414	}
415
416
417	}
418	//_____________________________________________________________________
419	void AliTRDCalibChamberStatus::CheckEORStatus(AliTRDCalDCS calDCS) /FOLD00*/
420	{
421	//
422	// Correct the AliTRDCalChamberStatus according to the AliTRDCalDCS
423	// Using globale state of the HalfChamberMerger (HCM)
424	//
425
426	for(Int_t det = 0; det < 540; det++) {
427	AliTRDCalDCSFEE* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det);
428	if(!calDCSFEEEOR) { continue;}
429
430	// MCM Global State Machine State Definitions
431	// low_power = 0,
432	// test = 1,
433	// wait_pre = 3,
434	// preproc = 7,
435	// zero_sp = 8,
436	// full_rd = 9,
437	// clear_st = 11,
438	// wait_L1 = 12,
439	// tr_send = 14,
440	// tr_proc = 15
441
442	Int_t sm = AliTRDgeometry::GetSector(det);
443	Int_t lay = AliTRDgeometry::GetLayer(det);
444	Int_t stac = AliTRDgeometry::GetStack(det);
445
446	Int_t stateA = calDCSFEEEOR->GetMCMGlobalState(4,17); // HCM Side A
447	Int_t stateB = calDCSFEEEOR->GetMCMGlobalState(5,17); // HCM Side B
448	Int_t rphi = -1;
449
450	//printf("DCS: stateA %d \t stateB %d \n",stateA,stateB);
451	if(stateA!=3 && stateA!=9) rphi = 1;
452	Double_t vals[4] = {sm,lay,stac,rphi};
453	if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
454
455	if(stateB!=3 && stateB!=9) rphi = 2;
456	vals[3] = rphi;
457	if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
458
459	//---------//
460	// Debug //
461	if(fDebugLevel > 0) {
462	if( (fCalChamberStatus->GetStatus(det) <= 1) && (stateA!=3 && stateA!=9) \|\|
463	(fCalChamberStatus->GetStatus(det) <= 1) && (stateB!=3 && stateB!=9) \|\|
464	(fCalChamberStatus->GetStatus(det) >= 2) && (stateA==3 \|\| stateA==9) \|\|
465	(fCalChamberStatus->GetStatus(det) >= 2) && (stateB==3 \|\| stateB==9) )
466	{
467	//printf(" Different half chamber status in DCS and DATA!!\n");
468	Double_t val[4] = {sm,lay,stac,1};
469	fHnSparseDebug->Fill(&val[0]);
470
471	if(rphi!=-1) { // error in DCS information
472	// Fill MCM status map
473	for(Int_t ii = 0; ii < 8; ii++) { //ROB loop
474	for(Int_t i = 0; i < 16; i++) { //MCM loop
475	Double_t valss[6] = {sm,lay,stac,ii,i
476	,calDCSFEEEOR->GetMCMGlobalState(ii,i)};
477	fHnSparseMCM->Fill(&valss[0]);
478	}
479	}
480	}
481	}
482	}
483	//---------//
484	// Debug //
485	}
486
487	}
488
489	//_____________________________________________________________________________________
490	void AliTRDCalibChamberStatus::Add(AliTRDCalibChamberStatus calibChamberStatus) /FOLD00*/
491	{
492	//
493	// Add the THnSparseI of this calibChamberStatus
494	//
495
496	fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty();
497
498	THnSparseI *hnSparseI = calibChamberStatus->GetSparseI();
499	if(!hnSparseI) return;
500
501	if(!fHnSparseI) {
502	fHnSparseI = (THnSparseI *) hnSparseI->Clone();
503	}
504	else {
505	fHnSparseI->Add(hnSparseI);
506	}
507
508
509	}
510	//_____________________________________________________________________
511	void AliTRDCalibChamberStatus::DumpToFile(const Char_t filename, const Char_t dir, Bool_t append) /FOLD00/
512	{
513	//
514	// Write class to file
515	//
516
517	TString sDir(dir);
518	TString option;
519
520	if ( append )
521	option = "update";
522	else
523	option = "recreate";
524
525	TDirectory *backup = gDirectory;
526	TFile f(filename,option.Data());
527	f.cd();
528	if ( !sDir.IsNull() ){
529	f.mkdir(sDir.Data());
530	f.cd(sDir);
531	}
532	this->Write();
533	f.Close();
534
535	if ( backup ) backup->cd();
536	}
537
538