#include "AliMUONTrackerHV.h"
#include <algorithm>
#include <map>
#include <set>
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliDCSValue.h"
#include "AliGRPObject.h"
#include "AliMpArrayI.h"
#include "AliMpConstants.h"
#include "AliMpDCSNamer.h"
#include "AliMpDEStore.h"
#include "AliMpDetElement.h"
#include "AliMUON2DMap.h"
#include "AliMUONCalibParamND.h"
#include "AliMUONCalibrationData.h"
#include "AliMUONCDB.h"
#include "AliMUONPainterDataRegistry.h"
#include "AliMUONTrackerData.h"
#include "AliMUONTrackerDataWrapper.h"
#include "AliLog.h"
#include "TCanvas.h"
#include "TGraph.h"
#include "TH2.h"
#include "TLine.h"
#include "TMap.h"
#include "TMultiGraph.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TStyle.h"
#include "Riostream.h"
ClassImp(AliMUONTrackerHV)
AliMUONTrackerHV::AliMUONTrackerHV(const char* runlist, const char* ocdbPath)
: TObject(), fRunList(), fOCDBPath(ocdbPath), fDCSNamer(0x0)
{
SetRunList(runlist);
}
AliMUONTrackerHV::AliMUONTrackerHV(Int_t runNumber, const char* ocdbPath)
: TObject(), fRunList(), fOCDBPath(ocdbPath), fDCSNamer(0x0)
{
SetRunList(runNumber);
}
AliMUONTrackerHV::~AliMUONTrackerHV()
{
delete fDCSNamer;
}
TMultiGraph* AliMUONTrackerHV::CombineMulti(TObjArray& graphs)
{
TMultiGraph* rv = new TMultiGraph;
TIter next(&graphs);
TMultiGraph* mg;
TMultiGraph* ref = static_cast<TMultiGraph*>(next());
Int_t dref = ref->GetListOfGraphs()->GetEntries();
while ( ( mg = static_cast<TMultiGraph*>(next())) )
{
TList* list = mg->GetListOfGraphs();
Int_t d1 = list->GetEntries();
if ( d1 != dref )
{
AliError(Form("%d vs %d",d1,dref));
return 0x0;
}
}
for ( Int_t i = 0; i < dref; ++i )
{
TObjArray graph;
next.Reset();
while ( ( mg = static_cast<TMultiGraph*>(next())) )
{
graph.Add(mg->GetListOfGraphs()->At(i));
TGraph* g = Combine(graph);
rv->Add(g);
}
}
return rv;
}
TGraph* AliMUONTrackerHV::Combine(TObjArray& graphs)
{
std::map<int, std::vector<double> > values;
std::map<int, std::vector<double> >::const_iterator it;
TIter next(&graphs);
TGraph* g;
while ( ( g = static_cast<TGraph*>(next())) )
{
for ( Int_t i = 0; i < g->GetN(); ++i )
{
std::vector<double> pair;
pair.push_back(g->GetX()[i]);
pair.push_back(g->GetY()[i]);
values.insert( std::make_pair(g->GetX()[i],pair));
}
}
TGraph* rv(0x0);
if ( values.size() )
{
std::vector<double> vx;
std::vector<double> vy;
for ( it = values.begin(); it != values.end(); ++it )
{
const std::vector<double>& q = it->second;
vx.push_back(q[0]);
vy.push_back(q[1]);
}
rv = new TGraph(values.size(),&vx[0],&vy[0]);
rv->GetXaxis()->SetNoExponent();
g = static_cast<TGraph*>(graphs.At(0));
rv->SetName(g->GetName());
rv->SetTitle(g->GetTitle());
}
return rv;
}
void AliMUONTrackerHV::ReadIntegers(const char* filename, std::vector<int>& integers)
{
std::ifstream in(gSystem->ExpandPathName(filename));
int i;
std::set<int> runset;
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()) ) )
{
runset.insert(s->String().Atoi());
}
delete a;
}
else
{
runset.insert(sline.Atoi());
while ( in >> i )
{
runset.insert(i);
}
}
for ( std::set<int>::const_iterator it = runset.begin(); it != runset.end(); ++it )
{
integers.push_back((*it));
}
std::sort(integers.begin(),integers.end());
}
AliMpDCSNamer*
AliMUONTrackerHV::DCSNamer() const
{
if (!fDCSNamer)
{
if (!AliMpDEStore::Instance(false))
{
AliMUONCDB::LoadMapping();
}
fDCSNamer = new AliMpDCSNamer("TRACKER");
}
return fDCSNamer;
}
void AliMUONTrackerHV::SetRunList(Int_t runNumber)
{
fRunList.clear();
fRunList.push_back(runNumber);
}
void
AliMUONTrackerHV::SetRunList(const char* runlist)
{
fRunList.clear();
if ( TString(runlist).Contains(",") || TString(runlist).Contains(" ") )
{
TObjArray* runs = 0x0;
if ( TString(runlist).Contains(",") )
{
runs = TString(runlist).Tokenize(",");
}
else
{
runs = TString(runlist).Tokenize(" ");
}
TIter next(runs);
TObjString* s;
std::set<int> runset;
while ( ( s = static_cast<TObjString*>(next()) ) )
{
runset.insert(s->String().Atoi());
}
for ( std::set<int>::const_iterator it = runset.begin(); it != runset.end(); ++it )
{
fRunList.push_back((*it));
}
std::sort(fRunList.begin(),fRunList.end());
delete runs;
}
else
{
ReadIntegers(runlist,fRunList);
}
}
TGraph*
AliMUONTrackerHV::GraphValues(TMap* m, const char* dcsname)
{
if ( TString(dcsname).Contains("sw") )
{
return 0x0;
}
AliInfo(dcsname);
TPair* p = static_cast<TPair*>(m->FindObject(DCSNamer()->DCSAliasFromName(dcsname).Data()));
if (!p) return 0x0;
TObjArray* a = static_cast<TObjArray*>(p->Value());
TIter n2(a);
AliDCSValue* val;
Int_t i(0);
TGraph* g = new TGraph(a->GetEntries());
while ( ( val = static_cast<AliDCSValue*>(n2()) ) )
{
g->SetPoint(i,val->GetTimeStamp(),val->GetFloat());
++i;
}
g->SetName(dcsname);
return g;
}
void
AliMUONTrackerHV::Scan(Int_t verbose)
{
if ( fRunList.empty() )
{
AliError("No runs to process...");
return;
}
AliCDBManager::Instance()->SetDefaultStorage(fOCDBPath.Data());
for ( std::vector<int>::size_type i = 0; i < fRunList.size(); ++i )
{
AliMUONCDB::CheckHV(fRunList[i],verbose);
}
}
void AliMUONTrackerHV::HVoff(const char* logfile, const char* outputBaseName)
{
gStyle->SetOptStat(0);
char line[1024];
std::ifstream in(logfile);
int run(-1),a,b,c,d,e,f,g,h,z,other;
std::map<int,std::string> results;
std::string message;
const char* testProblem = "I-AliMUONCDB::CheckHV::CheckHV: Problem at ";
while ( in.getline(line,1023,'\n') )
{
TString sline(line);
if (sline.Contains("SUMMARY"))
{
AliInfo(line);
int r;
sscanf(line,"I-AliMUONCDB::CheckHV::CheckHV: RUN %09d HVchannel SUMMARY : # of cases A(%3d) B(%3d) C(%3d) D(%3d) E(%3d) F(%3d) G(%3d) H(%3d) Z(%3d) OTHER(%3d)",
&r,&a,&b,&c,&d,&e,&f,&g,&h,&z,&other);
if ( r != run )
{
if ( run == -1 )
{
AliCDBManager::Instance()->SetDefaultStorage(fOCDBPath.Data());
AliCDBManager::Instance()->SetRun(r);
AliMUONCDB::LoadMapping();
}
if ( run > 0 )
{
results.insert(std::make_pair(run,message));
}
message = "";
run = r;
}
}
else if ( sline.Contains(testProblem) )
{
message += "|";
message += sline(strlen(testProblem),sline.Length()-1).Data();
}
}
results.insert(std::make_pair(run,message));
TH2* hvoff = new TH2I(outputBaseName,outputBaseName,1,0,1,1,0,1);
std::map<int,std::string>::const_iterator it;
for ( it = results.begin(); it != results.end(); ++it )
{
AliInfo(Form("%d -> %s",it->first,it->second.c_str()));
TObjArray* split = TString(it->second.c_str()).Tokenize("|");
TIter next(split);
TObjString* str;
while ( ( str = static_cast<TObjString*>(next()) ) )
{
TString s(str->String());
TObjArray* parts = s.Tokenize(":");
TString alias = (static_cast<TObjString*>(parts->At(0)))->String();
TString channel = DCSNamer()->DCSNameFromAlias(alias.Data());
channel += Form("(%4d)",DCSNamer()->DetElemIdFromDCSAlias(alias.Data()));
channel.ReplaceAll(".actual.vMon","");
hvoff->Fill(Form("%6d",it->first),channel.Data(),1.0);
delete parts;
}
delete split;
}
hvoff->LabelsDeflate("x");
hvoff->LabelsDeflate("y");
hvoff->LabelsOption("x","<");
hvoff->LabelsOption("y","<");
TCanvas* c1 = new TCanvas;
c1->SetLeftMargin(0.35);
hvoff->Draw("text");
c1->Print(Form("%s.pdf",outputBaseName));
TCanvas* c2 = new TCanvas;
TH1* hx = hvoff->ProjectionX("hvoffperrun");
hx->Draw();
c2->Print(Form("%s-perrun.pdf",outputBaseName));
TCanvas* c3 = new TCanvas;
c3->SetBottomMargin(0.55);
TH1* perchannel = hvoff->ProjectionY("hvoffperchannel");
perchannel->GetXaxis()->SetBit(TAxis::kLabelsVert);
perchannel->GetXaxis()->LabelsOption(">");
perchannel->Draw("texthist");
c3->Print(Form("%s-perchannel.pdf",outputBaseName));
}
void AliMUONTrackerHV::TimeAxis(TMultiGraph* g)
{
g->GetXaxis()->SetTimeDisplay(1);
g->GetXaxis()->SetTimeFormat("%d/%m %H:%M");
g->GetXaxis()->SetTimeOffset(0,"gmt");
g->GetXaxis()->SetNdivisions(505);
}
TMultiGraph*
AliMUONTrackerHV::GraphHV(TMap* m, const char* dcsname)
{
TIter next(m);
TObjString* s;
TMultiGraph* mg = new TMultiGraph;
while ( ( s = static_cast<TObjString*>(next()) ) )
{
TString name(DCSNamer()->DCSNameFromAlias(s->String()));
if ( dcsname && !name.Contains(dcsname)) continue;
TGraph* g = GraphValues(m,name);
if ( g )
{
g->SetMarkerSize(1.5);
g->SetMarkerStyle(2);
g->SetLineStyle(2);
mg->Add(g,"lp");
g->SetTitle(name.Data());
}
}
return mg;
}
void
AliMUONTrackerHV::Print(Option_t* dcsname) const
{
AliCDBManager::Instance()->SetDefaultStorage(fOCDBPath.Data());
TList messages;
messages.SetOwner(kTRUE);
for ( std::vector<int>::size_type iRun = 0; iRun < fRunList.size(); ++iRun )
{
Int_t runNumber = fRunList[iRun];
AliInfo("---------------------");
AliInfo(Form("RUN %09d",runNumber));
messages.Delete();
AliCDBManager::Instance()->SetRun(runNumber);
Bool_t patchValues(kFALSE);
Bool_t dryRun(kTRUE);
TMap* m = AliMUONCalibrationData::CreateHV(runNumber,0x0,patchValues,&messages,dryRun);
TIter next(m);
TObjString* s;
while ( ( s = static_cast<TObjString*>(next()) ) )
{
TString name(DCSNamer()->DCSNameFromAlias(s->String()));
if ( dcsname && !name.Contains(dcsname)) continue;
TPair* p = static_cast<TPair*>(m->FindObject(s->String()));
if (!p) continue;
TObjArray* a = static_cast<TObjArray*>(p->Value());
TIter n2(a);
AliDCSValue* val;
Int_t i(0);
while ( ( val = static_cast<AliDCSValue*>(n2()) ) )
{
std::cout << Form("i=%5d ",i) << std::endl;
val->Print("");
++i;
}
}
}
}
void
AliMUONTrackerHV::Plot(const char* dcsname, Bool_t withPatch, Bool_t plotIntermediate)
{
AliCDBManager::Instance()->SetDefaultStorage(fOCDBPath.Data());
TList messages;
messages.SetOwner(kTRUE);
TObjArray graphs;
for ( std::vector<int>::size_type i = 0; i < fRunList.size(); ++i )
{
Int_t runNumber = fRunList[i];
messages.Delete();
AliCDBManager::Instance()->SetRun(runNumber);
TMap* m = AliMUONCalibrationData::CreateHV(runNumber,0x0,withPatch,&messages,kTRUE);
TMultiGraph* mg = GraphHV(m,dcsname);
if ( !mg ) continue;
graphs.Add(mg);
TString cname(Form("MCH_HV_RUN%09d",runNumber));
if ( strlen(dcsname) > 0 )
{
TString s(dcsname);
s.ReplaceAll("/","_");
cname += Form("_dcsname_%s",s.Data());
}
AliCDBEntry* e = AliCDBManager::Instance()->Get("GRP/GRP/Data",runNumber);
TLine* startRunLine(0);
TLine* endRunLine(0);
time_t start(0);
time_t end(0);
if ( e )
{
AliGRPObject* grp = static_cast<AliGRPObject*>(e->GetObject());
if (grp)
{
start = grp->GetTimeStart();
end = grp->GetTimeEnd();
}
}
if ( end )
{
TGraph* g = new TGraph(1);
g->SetPoint(0,end,0);
mg->Add(g,"");
}
if ( plotIntermediate )
{
TCanvas* c = new TCanvas(cname.Data(),cname.Data());
c->Draw();
mg->SetTitle(cname.Data());
mg->Draw("AL");
TimeAxis(mg);
if ( start )
{
startRunLine = new TLine(start,mg->GetYaxis()->GetXmin(),start,mg->GetYaxis()->GetXmax());
startRunLine->SetLineColor(2);
startRunLine->SetLineWidth(4);
}
if ( end )
{
endRunLine = new TLine(end,mg->GetYaxis()->GetXmin(),end,mg->GetYaxis()->GetXmax());
endRunLine->SetLineColor(2);
endRunLine->SetLineWidth(4);
}
if ( startRunLine ) startRunLine->Draw();
if ( endRunLine ) endRunLine->Draw();
c->SaveAs(Form("%s.pdf",cname.Data()));
}
}
new TCanvas;
TMultiGraph* g = CombineMulti(graphs);
TIter next(g->GetListOfGraphs());
TGraph* gi;
while ( ( gi = static_cast<TGraph*>(next())))
{
gi->SetMarkerStyle(kPlus);
}
g->Draw("alp");
TimeAxis(g);
}
void
AliMUONTrackerHV::ReportTrips(Bool_t includeLowOnes)
{
AliCDBManager::Instance()->SetDefaultStorage(fOCDBPath.Data());
TList messages;
messages.SetOwner(kTRUE);
TObjString* msg(0);
std::map<std::string,int> channels;
for ( std::vector<int>::size_type i = 0; i < fRunList.size(); ++i )
{
Int_t runNumber = fRunList[i];
AliInfo("---------------------");
Int_t ntrips(0);
messages.Delete();
AliCDBManager::Instance()->SetRun(runNumber);
AliMUONCalibrationData::CreateHV(runNumber,0x0,kTRUE,&messages,kTRUE);
if (!AliMpDEStore::Instance(false))
{
AliMUONCDB::LoadMapping();
}
TIter next(&messages);
while ( ( msg = static_cast<TObjString*>(next())) )
{
if ( msg->String().Contains("TRIP") && ( includeLowOnes || !msg->String().Contains("LOWTRIP") ) )
{
++ntrips;
}
}
AliInfo(Form("RUN %09d - %d trip%c",runNumber,ntrips,(ntrips>1 ? 's':' ')));
next.Reset();
std::map<int,std::string> report;
while ( ( msg = static_cast<TObjString*>(next())) )
{
if ( msg->String().Contains("TRIP") )
{
TObjArray* parts = msg->String().Tokenize(" ");
TString channelName(static_cast<TObjString*>(parts->At(0))->String());
for ( Int_t ip = 0; ip <= parts->GetLast(); ++ip)
{
TString p(static_cast<TObjString*>(parts->At(ip))->String());
if ( p.Contains("TRIP") )
{
if ( includeLowOnes || !p.Contains("LOWTRIP") )
{
TString ts(static_cast<TObjString*>(parts->At(ip+2))->String());
ip += 3;
Int_t index = ts.Index("TS:");
UInt_t timeStamp = TString(ts(index+strlen("TS:"),ts.Length()-index)).Atoi();
TString tmp(msg->String());
tmp.ReplaceAll(channelName.Data(),DCSNamer()->DCSNameFromAlias(channelName.Data()));
report[timeStamp] = tmp.Data();
channels[channelName.Data()]++;
}
}
}
delete parts;
}
}
for ( std::map<int,std::string>::const_iterator it = report.begin(); it != report.end(); ++it )
{
AliInfo(Form("%s %s",TTimeStamp(it->first).AsString("s"),it->second.c_str()));
}
}
AliInfo("--------------------------------------------------------------------");
AliInfo("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
int totalTrips(0);
AliMUON2DMap tripMap(kTRUE);
Int_t nofChannels(AliMpConstants::ManuNofChannels());
for ( std::map<std::string,int>::const_iterator it = channels.begin(); it != channels.end(); ++it )
{
AliInfo(Form("%40s %3d",DCSNamer()->DCSNameFromAlias(it->first.c_str()).Data(),it->second));
totalTrips += it->second;
Int_t detElemId = DCSNamer()->DetElemIdFromDCSAlias(it->first.c_str());
AliMpDetElement* de = AliMpDEStore::Instance()->GetDetElement(detElemId);
AliMpArrayI manuArray;
manuArray.SetSize(300);
Int_t index = DCSNamer()->DCSIndexFromDCSAlias(it->first.c_str());
Int_t firstIndex(index);
Int_t lastIndex(index);
if ( index < 0 )
{
firstIndex = 0;
lastIndex = DCSNamer()->NumberOfPCBs(detElemId)-1;
}
for ( int i = firstIndex; i <= lastIndex ; ++i )
{
const AliMpArrayI* ma = de->ManusForHV(i);
if (!ma)
{
AliError(Form("Could not get ma for de %d index %d",detElemId,i));
continue;
}
for ( int j = 0; j < ma->GetSize(); ++j )
{
manuArray.Add(ma->GetValue(j),kFALSE);
}
}
for ( Int_t iManu = 0; iManu < manuArray.GetSize(); ++iManu )
{
Int_t manuId = manuArray.GetValue(iManu);
AliMUONVCalibParam* tripRate = new AliMUONCalibParamND(1,nofChannels,detElemId,manuId,0);
tripMap.Add(tripRate);
for ( Int_t j = 0 ; j < nofChannels; ++j )
{
tripRate->SetValueAsDouble(j,0,it->second*1.0);
}
}
}
AliInfo("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
AliInfo(Form("Total of %3d trips for %4ld runs",totalTrips,fRunList.size()));
AliMUONTrackerData* data = new AliMUONTrackerData("tripcount","Number of trips",1);
data->Add(tripMap);
data->SetDimensionName(0,"ntrips");
AliMUONVTrackerDataMaker* dw = new AliMUONTrackerDataWrapper(data);
AliMUONPainterDataRegistry::Instance()->Register(dw);
}