[u/mrichter/AliRoot.git] / MUON / MUONStatusMap.C

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

/// \ingroup macros
/// \file MUONStatusMap.C
/// \brief Macro to check/test pad status and pad status map makers
///
/// \author Laurent Aphecetche

#if !defined(__CINT__) || defined(__MAKECINT__)
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliLog.h"
#include "AliMpCDB.h"
#include "AliMpDEManager.h"
#include "AliMUONCDB.h"
#include "AliMUONCalibrationData.h"
#include "AliMUONPadStatusMaker.h"
#include "AliMUONPadStatusMapMaker.h"
#include "AliMUONRecoParam.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVStore.h"
#include "AliMpConstants.h"
#include "AliMpDDLStore.h"
#include "AliMpDetElement.h"
#include "AliMpManuIterator.h"
#include "Riostream.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TLegend.h"
#include "TFile.h"
#include "TGraph.h"
#include "TBox.h"
#include "TH2F.h"
#include "TStyle.h"
#include "TText.h"
#include <vector>
#endif

namespace
{
  Int_t NTOTALNUMBEROFPADS(1064008);
}

//______________________________________________________________________________
void ReadIntegers(const char* filename, std::vector<int>& integers)
{
  /// Read integers from filename, where integers are either
  /// separated by "," or by return carriage
  ifstream in(gSystem->ExpandPathName(filename));
  int i;
  
  char line[10000];
  
  in.getline(line,10000,'\n');
  
  TString sline(line);
  
  if (sline.Contains(","))
  {
    TObjArray* a = sline.Tokenize(",");
    TIter next(a);
    TObjString* s;
    while ( ( s = static_cast<TObjString*>(next()) ) )
    {
      integers.push_back(s->String().Atoi());
    }
  }
  else
  {
    integers.push_back(sline.Atoi());
    
    while ( in >> i )
    {
      integers.push_back(i);
    }
  }
  
  std::sort(integers.begin(),integers.end());
}


//______________________________________________________________________________
void MUONStatusMap(AliMUONVStore*& vstatus,
                   AliMUONVStore*& vstatusMap,
                   const char* cdbStorage = "alien://folder=/alice/data/2011/OCDB",
                   Int_t runNumber=145292)
{  

  AliCDBManager::Instance()->SetDefaultStorage(cdbStorage);
  AliCDBManager::Instance()->SetRun(runNumber);
  
  AliMUONCDB::LoadMapping();
  
  AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam();
  
  AliMUONCalibrationData cd(runNumber);
  
  AliMUONPadStatusMaker statusMaker(cd);
  
  statusMaker.SetLimits(*recoParam);
  
  UInt_t mask = recoParam->PadGoodnessMask();

  statusMaker.Report(mask);
  
  vstatus = static_cast<AliMUONVStore*>(statusMaker.StatusStore()->Clone());
  
  const Bool_t deferredInitialization = kFALSE;
  
  AliMUONPadStatusMapMaker statusMapMaker(cd,mask,deferredInitialization);
    
  vstatusMap = static_cast<AliMUONVStore*>(statusMapMaker.StatusMap()->Clone());
}

//______________________________________________________________________________
Int_t GetBadChannels(Int_t runNumber,
                     Int_t& nbadped,
                     Int_t& nbadhv,
                     Int_t& nbadgain,
                     Int_t& nbadocc,
                     Int_t& nmissing,
                     Int_t& nreco,
                     Int_t chamber=-1)
{
  if (!AliCDBManager::Instance()->IsDefaultStorageSet())
  {
//    AliCDBManager::Instance()->SetDefaultStorage("alien://folder=/alice/data/2011/OCDB?cacheFold=/local/cdb");
    AliCDBManager::Instance()->SetDefaultStorage("raw://");
  }
  
  AliCDBManager::Instance()->SetRun(runNumber);
  
  AliMpCDB::LoadDDLStore();
  
  AliMUONCalibrationData cd(runNumber,true);
  
  AliMUONPadStatusMaker statusMaker(cd);
  
  AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam();

  statusMaker.SetLimits(*recoParam);
  
  AliMpManuIterator it;
  Int_t detElemId, manuId;
  
  Int_t pedCheck = ( 
                     AliMUONPadStatusMaker::kPedMeanZero |
                     AliMUONPadStatusMaker::kPedMeanTooLow |
                     AliMUONPadStatusMaker::kPedMeanTooHigh |
                     AliMUONPadStatusMaker::kPedSigmaTooLow |
                     AliMUONPadStatusMaker::kPedSigmaTooHigh );
     
  Int_t hvCheck = ( 
                   AliMUONPadStatusMaker::kHVError |
                   AliMUONPadStatusMaker::kHVTooLow |
                   AliMUONPadStatusMaker::kHVTooHigh |
                   AliMUONPadStatusMaker::kHVChannelOFF |
                   AliMUONPadStatusMaker::kHVSwitchOFF );

  
  Int_t occCheck = (
                    AliMUONPadStatusMaker::kManuOccupancyTooHigh 
                   );
                    
  Int_t ntotal(0);
  Int_t nbad(0);
  nbadped=0;
  nbadocc=0;
  nbadgain=0;
  nbadhv=0;
  nmissing=0;
  nreco=0;
  
  while ( it.Next(detElemId,manuId) )
  {
    AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
    
    if ( chamber >= 0 && AliMpDEManager::GetChamberId(detElemId) != chamber ) continue;
    
    for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
    {
      if ( de->IsConnectedChannel(manuId,manuChannel) )
      {
        ++ntotal;
        
        UInt_t status = statusMaker.PadStatus(detElemId, manuId, manuChannel);
        
        if (!status) continue;
        
        bool bad(false);
        
        if ( status & AliMUONPadStatusMaker::BuildStatus(pedCheck,0,0,0) ) 
        {
          ++nbadped;
          bad=true;
        }
        
        if ( status & AliMUONPadStatusMaker::BuildStatus(0,hvCheck,0,0) ) 
        {
          ++nbadhv;
          bad=true;
        }
        
        if ( status & AliMUONPadStatusMaker::BuildStatus(0,0,0,occCheck) ) 
        {
          ++nbadocc;
          bad=true;
        }
        
        if ( status & recoParam->PadGoodnessMask() ) 
        {
          ++nreco;
        }
        
        if ( status & AliMUONPadStatusMaker::BuildStatus(AliMUONPadStatusMaker::kMissing,0,0,AliMUONPadStatusMaker::kMissing) )
        {
          bad=true;
          ++nmissing;
        }
        
        if (bad) ++nbad;
      }
    }
  }
  
  if ( chamber<0 && ntotal!=NTOTALNUMBEROFPADS)
  {
    cerr << Form("ERROR ! NOT THE EXPECTED NUMBER OF CHANNELS (%d vs 1064008) FOR RUN %09d",
                 ntotal,runNumber) << endl;
  }
  else
  {
    cout << Form("Chamber %d - %d channels",chamber,ntotal) << endl;
    cout << Form("nbadped %5d nbadhv %5d nbadgain %5d nbadocc %5d nmissing %5d nreco %5d",
                 nbadped,nbadhv,nbadgain,nbadocc,nmissing,nreco) << endl;
  }
  
  AliCDBManager::Instance()->ClearCache(); 
 
  return nbad;
}

//______________________________________________________________________________
void Draw(TFile* f, const char* gname, TLegend* l, Bool_t normalized)
{
  if (!f) return;
  
  TGraph* g = static_cast<TGraph*>(f->Get(gname));
  
  if (!g) return;
  
  if ( normalized ) 
  {
    g = static_cast<TGraph*>(g->Clone());
    for ( Int_t i = 0; i < g->GetN(); ++i ) 
    {
      Double_t y = g->GetY()[i];
      g->SetPoint(i,g->GetX()[i],y/NTOTALNUMBEROFPADS);
    }
  }
  
  g->Draw("lp");
  g->GetXaxis()->SetNdivisions(505);
  g->GetXaxis()->SetNoExponent();
  
  if (l) l->AddEntry(g,gname,"LP");
}

//______________________________________________________________________________
void DrawPeriod(double run1, double run2, double ymin, double ymax, const char* label)
{
  TBox* b = new TBox(run1,ymin,run2,ymax);
  b->SetFillColor(5);
  b->Draw();
  TText* text = new TText((run1+run2)/2.0,ymax*0.6,label);
  text->SetTextAlign(22);
  text->SetTextSize(0.02);
  text->Draw();
}

//______________________________________________________________________________
void DrawEvolution(const char* file, bool normalized=true)
{

  TFile* f = TFile::Open(gSystem->ExpandPathName(file));
  
  if (!f) return;
  
  TCanvas* c = new TCanvas("mch-status-evolution","mch-status-evolution");
  
  c->SetGridy();
  c->SetTicky();
  
  c->Draw();
  
  TLegend* l = new TLegend(0.1,0.7,0.3,0.95,"ch evolution");

  TGraph* g = static_cast<TGraph*>(f->Get("nbad"));
  if (!g) return;
  
  int runmin = TMath::Nint(g->GetX()[0]);
  int runmax = TMath::Nint(g->GetX()[g->GetN()-1]);
  
  cout << Form("Run range found in file %s = %d - %d",file,runmin,runmax) << endl;
  
  double ymax(0.4);
  
  TH2* h = new TH2F("hframe","hframe;Run number;Fraction of dead channels",100,runmin-200,runmax+200,100,0,ymax);

  gStyle->SetOptStat(kFALSE);
  h->Draw();
  h->GetXaxis()->SetNoExponent();
  h->GetXaxis()->SetNdivisions(505);

  gStyle->SetOptTitle(kFALSE);

  DrawPeriod(115881,117222,0,ymax,"10b"); 

  DrawPeriod(119159,120824,0,ymax,"10c");

  DrawPeriod(122374,126424,0,ymax,"10d");

  DrawPeriod(127724,130850,0,ymax,"10e");

  DrawPeriod(133005,134929,0,ymax,"10f");

  DrawPeriod(135658,136376,0,ymax,"10g");

  DrawPeriod(137133,139513,0,ymax,"10h");
  
  DrawPeriod(143856,146860,0,ymax,"11a");

  DrawPeriod(148370,150702,0,ymax,"11b");

  DrawPeriod(151566,154583,0,ymax,"11c");

  DrawPeriod(158084,159606,0,ymax,"11d");

  DrawPeriod(160677,162717,0,ymax,"11e");

  DrawPeriod(162933,165744,0,ymax,"11f");

  DrawPeriod(167703,170593,0,ymax,"11h");

  // 2012
    
    DrawPeriod(176661,177295,0,ymax,"12a");

    DrawPeriod(177384,178053,0,ymax,"12b");

    DrawPeriod(179603,180569,0,ymax,"12c");

    DrawPeriod(183913,186320,0,ymax,"12d");
    
    DrawPeriod(186365,186602,0,ymax,"12e");
    
    DrawPeriod(186668,188123,0,ymax,"12f");
    
    DrawPeriod(188362,188503,0,ymax,"12g");
    
    DrawPeriod(189122,190110,0,ymax,"12h");
  
  // 2013
  
  DrawPeriod(195344,195483,0,ymax,"LHC13b");
  DrawPeriod(195529,195677,0,ymax,"LHC13c");
  DrawPeriod(195681,195873,0,ymax,"LHC13d");
  DrawPeriod(195949,196311,0,ymax,"LHC13e");
  DrawPeriod(196433,197388,0,ymax,"LHC13f");
  
  Draw(f,"nbad",l,normalized);
  Draw(f,"nbadped",l,normalized);
  Draw(f,"nbadocc",l,normalized);
  Draw(f,"nbadhv",l,normalized);
  Draw(f,"nmissing",l,normalized);
  Draw(f,"nreco",l,normalized);
  
  h->Draw("same");

  c->RedrawAxis("g");
  
  l->Draw();
}

//______________________________________________________________________________
void MUONStatusMapEvolution(const char* runlist, const char* outfile)
{
  // Compute the number of bad pads (because of bad ped, bad hv, bad occupancy
  // or missing in configuration)
  //
  // output a root file with the different graphs.
  //
  // output can be then plotted using the DrawEvolution function
  //
  // Note that the output of different runlists can then be merged simply using
  // the hadd program, and so then the DrawEvolution can be used over
  // a huge period, e.g. a full year, while this method is better restricted
  // to a period or even less (depending on your success of accessing the OCDB)
  //
  
  std::vector<int> runs;

  ReadIntegers(runlist,runs);
  
  if ( runs.empty() ) 
  {
    cout << "No runs to process..." << endl;
    return;    
  }
  
  int year(2013);
  
  if ( runs[0] <= 139699 ) year=2010;
  
  if ( runs[0] <= 176000 ) year=2011;
  
  if ( runs[0] <= 195344 ) year = 2012;
      
  AliCDBManager::Instance()->SetDefaultStorage(Form("alien://folder=/alice/data/%d/OCDB?cacheFold=/local/cdb",year));

//  AliCDBManager::Instance()->SetDefaultStorage("local:///Users/laurent/Alice/OCDBcopy2013");
//
  TList glist;
  
  glist.SetOwner(kTRUE);
  
  TGraph* gnbad = new TGraph(runs.size());
  gnbad->SetName("nbad");
  glist.Add(gnbad);
  
  TGraph* gnbadped = new TGraph(runs.size());
  gnbadped->SetName("nbadped");
  glist.Add(gnbadped);
  
  TGraph* gnbadocc = new TGraph(runs.size());
  gnbadocc->SetName("nbadocc");
  glist.Add(gnbadocc);
  
  TGraph* gnbadhv = new TGraph(runs.size());
  gnbadhv->SetName("nbadhv");
  glist.Add(gnbadhv);
  
  TGraph* gnmissing = new TGraph(runs.size());
  gnmissing->SetName("nmissing");
  glist.Add(gnmissing);

  TGraph* gnreco = new TGraph(runs.size());
  gnreco->SetName("nreco");
  glist.Add(gnreco);
  
  for ( std::vector<int>::size_type i = 0; i < runs.size(); ++i ) 
  {
    Int_t runNumber = runs[i];
    Int_t nbadped;
    Int_t nbadhv;
    Int_t nbadgain;
    Int_t nbadocc;
    Int_t nmissing;
    Int_t nreco;
    
    Int_t nbad = GetBadChannels(runNumber,nbadped,nbadhv,nbadgain,nbadocc,nmissing,nreco);
    
    gnbad->SetPoint(i,runNumber,nbad);
    gnbadped->SetPoint(i,runNumber,nbadped);
    gnbadhv->SetPoint(i,runNumber,nbadhv);
    gnbadocc->SetPoint(i,runNumber,nbadocc);
    gnmissing->SetPoint(i,runNumber,nmissing);
    gnreco->SetPoint(i,runNumber,nreco);
  }
  
  TIter next(&glist);
  TGraph* g;
  Int_t index(0);

  TFile f(outfile,"recreate");
  Int_t  color[] = {  1 ,  2 ,  3 ,  4,  6, 8 };
  Int_t marker[] = { 28 , 24 , 23 , 26, 30, 5 };

  while ( ( g = static_cast<TGraph*>(next() ) ) )
  {
    g->GetXaxis()->SetNdivisions(505);
    g->GetXaxis()->SetNoExponent();
    g->SetMinimum(0);
    g->GetYaxis()->SetNoExponent();
    g->SetLineColor(color[index]);
    g->SetMarkerStyle(marker[index]);
    g->SetMarkerColor(color[index]);
    g->SetMarkerSize(1.0);
    ++index;
    g->Write();
  }
    
  f.Close();
  
  
}
Commit	Line	Data
d565d56c	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	/* $Id$ */
	17
e54bf126	18	/// \ingroup macros
	19	/// \file MUONStatusMap.C
	20	/// \brief Macro to check/test pad status and pad status map makers
3fb89a07	21	///
e54bf126	22	/// \author Laurent Aphecetche
d565d56c	23
	24	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	25	#include "AliCDBManager.h"
e30ab20a	26	#include "AliCDBEntry.h"
	27	#include "AliLog.h"
	28	#include "AliMpCDB.h"
f2b4a3d1	29	#include "AliMpDEManager.h"
e30ab20a	30	#include "AliMUONCDB.h"
d565d56c	31	#include "AliMUONCalibrationData.h"
d565d56c	32	#include "AliMUONPadStatusMaker.h"
d565d56c	33	#include "AliMUONPadStatusMapMaker.h"
411a502a	34	#include "AliMUONRecoParam.h"
d565d56c	35	#include "AliMUONVCalibParam.h"
7190ece1	36	#include "AliMUONVStore.h"
7190ece1	37	#include "AliMpConstants.h"
	38	#include "AliMpDDLStore.h"
	39	#include "AliMpDetElement.h"
7190ece1	40	#include "AliMpManuIterator.h"
d565d56c	41	#include "Riostream.h"
e30ab20a	42	#include "TAxis.h"
	43	#include "TCanvas.h"
	44	#include "TLegend.h"
	45	#include "TFile.h"
	46	#include "TGraph.h"
	47	#include "TBox.h"
	48	#include "TH2F.h"
	49	#include "TStyle.h"
	50	#include "TText.h"
	51	#include <vector>
d565d56c	52	#endif
d565d56c	53
e30ab20a	54	namespace
	55	{
	56	Int_t NTOTALNUMBEROFPADS(1064008);
	57	}
	58
	59	//______________________________________________________________________________
	60	void ReadIntegers(const char* filename, std::vector<int>& integers)
	61	{
	62	/// Read integers from filename, where integers are either
	63	/// separated by "," or by return carriage
	64	ifstream in(gSystem->ExpandPathName(filename));
	65	int i;
	66
	67	char line[10000];
	68
	69	in.getline(line,10000,'\n');
	70
	71	TString sline(line);
	72
	73	if (sline.Contains(","))
	74	{
	75	TObjArray* a = sline.Tokenize(",");
	76	TIter next(a);
	77	TObjString* s;
	78	while ( ( s = static_cast<TObjString*>(next()) ) )
	79	{
	80	integers.push_back(s->String().Atoi());
	81	}
	82	}
	83	else
	84	{
	85	integers.push_back(sline.Atoi());
	86
	87	while ( in >> i )
	88	{
	89	integers.push_back(i);
	90	}
	91	}
	92
	93	std::sort(integers.begin(),integers.end());
	94	}
	95
	96
	97	//______________________________________________________________________________
	98	void MUONStatusMap(AliMUONVStore*& vstatus,
	99	AliMUONVStore*& vstatusMap,
	100	const char* cdbStorage = "alien://folder=/alice/data/2011/OCDB",
	101	Int_t runNumber=145292)
411a502a	102	{
411a502a	103
8dd92431	104	AliCDBManager::Instance()->SetDefaultStorage(cdbStorage);
8dd92431	105	AliCDBManager::Instance()->SetRun(runNumber);
7190ece1	106
8dd92431	107	AliMUONCDB::LoadMapping();
	108
	109	AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam();
d565d56c	110
d565d56c	111	AliMUONCalibrationData cd(runNumber);
	112
	113	AliMUONPadStatusMaker statusMaker(cd);
	114
411a502a	115	statusMaker.SetLimits(*recoParam);
d565d56c	116
411a502a	117	UInt_t mask = recoParam->PadGoodnessMask();
8dd92431	118
411a502a	119	statusMaker.Report(mask);
d565d56c	120
e30ab20a	121	vstatus = static_cast<AliMUONVStore*>(statusMaker.StatusStore()->Clone());
d565d56c	122
7190ece1	123	const Bool_t deferredInitialization = kFALSE;
d565d56c	124
7190ece1	125	AliMUONPadStatusMapMaker statusMapMaker(cd,mask,deferredInitialization);
7190ece1	126
e30ab20a	127	vstatusMap = static_cast<AliMUONVStore*>(statusMapMaker.StatusMap()->Clone());
	128	}
	129
	130	//______________________________________________________________________________
	131	Int_t GetBadChannels(Int_t runNumber,
	132	Int_t& nbadped,
	133	Int_t& nbadhv,
	134	Int_t& nbadgain,
	135	Int_t& nbadocc,
	136	Int_t& nmissing,
f2b4a3d1	137	Int_t& nreco,
f2b4a3d1	138	Int_t chamber=-1)
e30ab20a	139	{
	140	if (!AliCDBManager::Instance()->IsDefaultStorageSet())
	141	{
f2b4a3d1	142	// AliCDBManager::Instance()->SetDefaultStorage("alien://folder=/alice/data/2011/OCDB?cacheFold=/local/cdb");
e30ab20a	143	AliCDBManager::Instance()->SetDefaultStorage("raw://");
	144	}
	145
	146	AliCDBManager::Instance()->SetRun(runNumber);
	147
	148	AliMpCDB::LoadDDLStore();
	149
	150	AliMUONCalibrationData cd(runNumber,true);
	151
	152	AliMUONPadStatusMaker statusMaker(cd);
	153
	154	AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam();
	155
	156	statusMaker.SetLimits(*recoParam);
	157
	158	AliMpManuIterator it;
	159	Int_t detElemId, manuId;
	160
	161	Int_t pedCheck = (
	162	AliMUONPadStatusMaker::kPedMeanZero \|
	163	AliMUONPadStatusMaker::kPedMeanTooLow \|
	164	AliMUONPadStatusMaker::kPedMeanTooHigh \|
	165	AliMUONPadStatusMaker::kPedSigmaTooLow \|
	166	AliMUONPadStatusMaker::kPedSigmaTooHigh );
	167
	168	Int_t hvCheck = (
	169	AliMUONPadStatusMaker::kHVError \|
	170	AliMUONPadStatusMaker::kHVTooLow \|
	171	AliMUONPadStatusMaker::kHVTooHigh \|
	172	AliMUONPadStatusMaker::kHVChannelOFF \|
	173	AliMUONPadStatusMaker::kHVSwitchOFF );
	174
	175
	176	Int_t occCheck = (
	177	AliMUONPadStatusMaker::kManuOccupancyTooHigh
	178	);
	179
	180	Int_t ntotal(0);
	181	Int_t nbad(0);
	182	nbadped=0;
	183	nbadocc=0;
	184	nbadgain=0;
	185	nbadhv=0;
	186	nmissing=0;
	187	nreco=0;
	188
	189	while ( it.Next(detElemId,manuId) )
	190	{
	191	AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
f2b4a3d1	192
	193	if ( chamber >= 0 && AliMpDEManager::GetChamberId(detElemId) != chamber ) continue;
	194
e30ab20a	195	for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
	196	{
	197	if ( de->IsConnectedChannel(manuId,manuChannel) )
	198	{
	199	++ntotal;
	200
	201	UInt_t status = statusMaker.PadStatus(detElemId, manuId, manuChannel);
	202
	203	if (!status) continue;
	204
	205	bool bad(false);
	206
	207	if ( status & AliMUONPadStatusMaker::BuildStatus(pedCheck,0,0,0) )
	208	{
	209	++nbadped;
	210	bad=true;
	211	}
	212
	213	if ( status & AliMUONPadStatusMaker::BuildStatus(0,hvCheck,0,0) )
	214	{
	215	++nbadhv;
	216	bad=true;
	217	}
	218
	219	if ( status & AliMUONPadStatusMaker::BuildStatus(0,0,0,occCheck) )
	220	{
	221	++nbadocc;
	222	bad=true;
	223	}
	224
	225	if ( status & recoParam->PadGoodnessMask() )
	226	{
	227	++nreco;
	228	}
	229
	230	if ( status & AliMUONPadStatusMaker::BuildStatus(AliMUONPadStatusMaker::kMissing,0,0,AliMUONPadStatusMaker::kMissing) )
	231	{
	232	bad=true;
	233	++nmissing;
	234	}
	235
	236	if (bad) ++nbad;
	237	}
	238	}
	239	}
	240
f2b4a3d1	241	if ( chamber<0 && ntotal!=NTOTALNUMBEROFPADS)
e30ab20a	242	{
	243	cerr << Form("ERROR ! NOT THE EXPECTED NUMBER OF CHANNELS (%d vs 1064008) FOR RUN %09d",
	244	ntotal,runNumber) << endl;
	245	}
f2b4a3d1	246	else
	247	{
	248	cout << Form("Chamber %d - %d channels",chamber,ntotal) << endl;
	249	cout << Form("nbadped %5d nbadhv %5d nbadgain %5d nbadocc %5d nmissing %5d nreco %5d",
	250	nbadped,nbadhv,nbadgain,nbadocc,nmissing,nreco) << endl;
	251	}
e30ab20a	252
	253	AliCDBManager::Instance()->ClearCache();
	254
	255	return nbad;
	256	}
	257
	258	//______________________________________________________________________________
	259	void Draw(TFile* f, const char* gname, TLegend* l, Bool_t normalized)
	260	{
	261	if (!f) return;
	262
	263	TGraph* g = static_cast<TGraph*>(f->Get(gname));
	264
	265	if (!g) return;
	266
	267	if ( normalized )
	268	{
	269	g = static_cast<TGraph*>(g->Clone());
	270	for ( Int_t i = 0; i < g->GetN(); ++i )
	271	{
	272	Double_t y = g->GetY()[i];
	273	g->SetPoint(i,g->GetX()[i],y/NTOTALNUMBEROFPADS);
	274	}
	275	}
	276
	277	g->Draw("lp");
	278	g->GetXaxis()->SetNdivisions(505);
	279	g->GetXaxis()->SetNoExponent();
	280
	281	if (l) l->AddEntry(g,gname,"LP");
	282	}
	283
	284	//______________________________________________________________________________
	285	void DrawPeriod(double run1, double run2, double ymin, double ymax, const char* label)
	286	{
	287	TBox* b = new TBox(run1,ymin,run2,ymax);
	288	b->SetFillColor(5);
	289	b->Draw();
	290	TText* text = new TText((run1+run2)/2.0,ymax*0.6,label);
75c49867	291	text->SetTextAlign(22);
75c49867	292	text->SetTextSize(0.02);
e30ab20a	293	text->Draw();
	294	}
	295
	296	//______________________________________________________________________________
	297	void DrawEvolution(const char* file, bool normalized=true)
	298	{
b57816bd	299
4f17a2a7	300	TFile* f = TFile::Open(gSystem->ExpandPathName(file));
e30ab20a	301
	302	if (!f) return;
	303
	304	TCanvas* c = new TCanvas("mch-status-evolution","mch-status-evolution");
	305
	306	c->SetGridy();
	307	c->SetTicky();
	308
	309	c->Draw();
	310
	311	TLegend* l = new TLegend(0.1,0.7,0.3,0.95,"ch evolution");
	312
	313	TGraph* g = static_cast<TGraph*>(f->Get("nbad"));
	314	if (!g) return;
	315
	316	int runmin = TMath::Nint(g->GetX()[0]);
	317	int runmax = TMath::Nint(g->GetX()[g->GetN()-1]);
	318
4f17a2a7	319	cout << Form("Run range found in file %s = %d - %d",file,runmin,runmax) << endl;
4f17a2a7	320
e30ab20a	321	double ymax(0.4);
	322
	323	TH2* h = new TH2F("hframe","hframe;Run number;Fraction of dead channels",100,runmin-200,runmax+200,100,0,ymax);
	324
	325	gStyle->SetOptStat(kFALSE);
	326	h->Draw();
	327	h->GetXaxis()->SetNoExponent();
	328	h->GetXaxis()->SetNdivisions(505);
	329
	330	gStyle->SetOptTitle(kFALSE);
	331
	332	DrawPeriod(115881,117222,0,ymax,"10b");
	333
	334	DrawPeriod(119159,120824,0,ymax,"10c");
	335
	336	DrawPeriod(122374,126424,0,ymax,"10d");
	337
	338	DrawPeriod(127724,130850,0,ymax,"10e");
	339
	340	DrawPeriod(133005,134929,0,ymax,"10f");
	341
	342	DrawPeriod(135658,136376,0,ymax,"10g");
	343
	344	DrawPeriod(137133,139513,0,ymax,"10h");
	345
	346	DrawPeriod(143856,146860,0,ymax,"11a");
	347
	348	DrawPeriod(148370,150702,0,ymax,"11b");
	349
b57816bd	350	DrawPeriod(151566,154583,0,ymax,"11c");
	351
	352	DrawPeriod(158084,159606,0,ymax,"11d");
e30ab20a	353
f2b4a3d1	354	DrawPeriod(160677,162717,0,ymax,"11e");
e30ab20a	355
4f17a2a7	356	DrawPeriod(162933,165744,0,ymax,"11f");
	357
	358	DrawPeriod(167703,170593,0,ymax,"11h");
	359
05a216c9	360	// 2012
	361
	362	DrawPeriod(176661,177295,0,ymax,"12a");
	363
	364	DrawPeriod(177384,178053,0,ymax,"12b");
4f17a2a7	365
05a216c9	366	DrawPeriod(179603,180569,0,ymax,"12c");
4f17a2a7	367
05a216c9	368	DrawPeriod(183913,186320,0,ymax,"12d");
	369
	370	DrawPeriod(186365,186602,0,ymax,"12e");
	371
	372	DrawPeriod(186668,188123,0,ymax,"12f");
	373
	374	DrawPeriod(188362,188503,0,ymax,"12g");
	375
	376	DrawPeriod(189122,190110,0,ymax,"12h");
	377
75c49867	378	// 2013
	379
	380	DrawPeriod(195344,195483,0,ymax,"LHC13b");
	381	DrawPeriod(195529,195677,0,ymax,"LHC13c");
	382	DrawPeriod(195681,195873,0,ymax,"LHC13d");
	383	DrawPeriod(195949,196311,0,ymax,"LHC13e");
	384	DrawPeriod(196433,197388,0,ymax,"LHC13f");
	385
e30ab20a	386	Draw(f,"nbad",l,normalized);
	387	Draw(f,"nbadped",l,normalized);
	388	Draw(f,"nbadocc",l,normalized);
	389	Draw(f,"nbadhv",l,normalized);
	390	Draw(f,"nmissing",l,normalized);
	391	Draw(f,"nreco",l,normalized);
	392
	393	h->Draw("same");
	394
	395	c->RedrawAxis("g");
	396
	397	l->Draw();
	398	}
	399
	400	//______________________________________________________________________________
	401	void MUONStatusMapEvolution(const char* runlist, const char* outfile)
	402	{
	403	// Compute the number of bad pads (because of bad ped, bad hv, bad occupancy
	404	// or missing in configuration)
	405	//
	406	// output a root file with the different graphs.
	407	//
	408	// output can be then plotted using the DrawEvolution function
	409	//
b57816bd	410	// Note that the output of different runlists can then be merged simply using
	411	// the hadd program, and so then the DrawEvolution can be used over
	412	// a huge period, e.g. a full year, while this method is better restricted
	413	// to a period or even less (depending on your success of accessing the OCDB)
	414	//
e30ab20a	415
	416	std::vector<int> runs;
	417
	418	ReadIntegers(runlist,runs);
	419
	420	if ( runs.empty() )
	421	{
	422	cout << "No runs to process..." << endl;
	423	return;
	424	}
	425
75c49867	426	int year(2013);
e30ab20a	427
	428	if ( runs[0] <= 139699 ) year=2010;
	429
4f17a2a7	430	if ( runs[0] <= 176000 ) year=2011;
75c49867	431
75c49867	432	if ( runs[0] <= 195344 ) year = 2012;
4f17a2a7	433
e30ab20a	434	AliCDBManager::Instance()->SetDefaultStorage(Form("alien://folder=/alice/data/%d/OCDB?cacheFold=/local/cdb",year));
75c49867	435
	436	// AliCDBManager::Instance()->SetDefaultStorage("local:///Users/laurent/Alice/OCDBcopy2013");
	437	//
e30ab20a	438	TList glist;
	439
	440	glist.SetOwner(kTRUE);
	441
	442	TGraph* gnbad = new TGraph(runs.size());
	443	gnbad->SetName("nbad");
	444	glist.Add(gnbad);
	445
	446	TGraph* gnbadped = new TGraph(runs.size());
	447	gnbadped->SetName("nbadped");
	448	glist.Add(gnbadped);
	449
	450	TGraph* gnbadocc = new TGraph(runs.size());
	451	gnbadocc->SetName("nbadocc");
	452	glist.Add(gnbadocc);
	453
	454	TGraph* gnbadhv = new TGraph(runs.size());
	455	gnbadhv->SetName("nbadhv");
	456	glist.Add(gnbadhv);
	457
	458	TGraph* gnmissing = new TGraph(runs.size());
	459	gnmissing->SetName("nmissing");
	460	glist.Add(gnmissing);
	461
	462	TGraph* gnreco = new TGraph(runs.size());
	463	gnreco->SetName("nreco");
	464	glist.Add(gnreco);
	465
	466	for ( std::vector<int>::size_type i = 0; i < runs.size(); ++i )
	467	{
	468	Int_t runNumber = runs[i];
	469	Int_t nbadped;
	470	Int_t nbadhv;
	471	Int_t nbadgain;
	472	Int_t nbadocc;
	473	Int_t nmissing;
	474	Int_t nreco;
	475
	476	Int_t nbad = GetBadChannels(runNumber,nbadped,nbadhv,nbadgain,nbadocc,nmissing,nreco);
	477
	478	gnbad->SetPoint(i,runNumber,nbad);
	479	gnbadped->SetPoint(i,runNumber,nbadped);
	480	gnbadhv->SetPoint(i,runNumber,nbadhv);
	481	gnbadocc->SetPoint(i,runNumber,nbadocc);
	482	gnmissing->SetPoint(i,runNumber,nmissing);
	483	gnreco->SetPoint(i,runNumber,nreco);
	484	}
	485
	486	TIter next(&glist);
	487	TGraph* g;
	488	Int_t index(0);
	489
	490	TFile f(outfile,"recreate");
	491	Int_t color[] = { 1 , 2 , 3 , 4, 6, 8 };
	492	Int_t marker[] = { 28 , 24 , 23 , 26, 30, 5 };
	493
	494	while ( ( g = static_cast<TGraph*>(next() ) ) )
	495	{
	496	g->GetXaxis()->SetNdivisions(505);
	497	g->GetXaxis()->SetNoExponent();
	498	g->SetMinimum(0);
	499	g->GetYaxis()->SetNoExponent();
	500	g->SetLineColor(color[index]);
	501	g->SetMarkerStyle(marker[index]);
502	g->SetMarkerColor(color[index]);
503	g->SetMarkerSize(1.0);
504	++index;
505	g->Write();
506	}
507
508	f.Close();
509
510
d565d56c	511	}