[u/mrichter/AliRoot.git] / TRD / AliTRDDataDCS.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.                  *
 **************************************************************************/

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// This class collects the DCS information and does an AliSplineFit       //
//                                                                        //
// Typical use :                                                          //
//                                                                        //
//   AliTRDDataDCS dataDcs;                                               //
//   dataDcs.ExtractDCS(dcs);                                             //
//   ->call a storeRef function                                           //
//   dataDcs.PerformFit();                                                //                        
//   dataDcs.ClearGraphs();                                               //
//   ->call a store function                                              //
//   dataDcs.ClearFits();                                                 //
//                                                                        //
// Author:                                                                //
//   W. Monange   (wilfried.monange@free.fr)                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <TGraph.h>
#include <TObjArray.h>
#include <AliCDBMetaData.h>
#include <TMap.h>

#include "AliDCSValue.h"
#include "AliDCSValue.h"
#include "AliLog.h"
#include "AliTRDDataDCS.h"
#include "AliSplineFit.h"

ClassImp(AliTRDDataDCS)

//_____________________________________________________________________________
AliTRDDataDCS::AliTRDDataDCS() 
  :TNamed()       
  ,fGraphsAreIni(kFALSE)
  ,fFitsAreIni(kFALSE)
  ,fNAlias(22)
{
  //
  // Default constructor
  //

  Init ();

}

//_____________________________________________________________________________
AliTRDDataDCS::~AliTRDDataDCS()
{
  //
  // Destructor
  //

  ClearFits();
  ClearGraphs();

}

//_____________________________________________________________________________
void AliTRDDataDCS::Init()
{
  //
  // Initialization
  //

  SetConf(kChamberByteStatus, "trd_chamberByteStatus%03d",'c', 540, kTRUE,kFALSE,       10,10,0,2); 
  SetConf(kPreTrigger, 	      "trd_preTrigger", 	  'c',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyHv, 	      "trd_goofyHv", 		  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyPeakPos,      "trd_goofyPeakPos%02d",     'f',   2, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyPeakArea,     "trd_goofyPeakArea%02d",    'f',   2, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyTemp, 	      "trd_goofyTemp%02d", 	  'f',   2, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyPressure,     "trd_goofyPressure", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyVelocity,     "trd_goofyVelocity", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyGain, 	      "trd_goofyGain%02d", 	  'f',   2, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyCO2, 	      "trd_goofyCO2", 		  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGoofyN2, 	      "trd_goofyN2", 		  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGasO2, 	      "trd_gasO2", 		  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kGasOverpressure,   "trd_gasOverpressure", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kEnvTemp, 	      "trd_envTemp%03d", 	  'f', 540, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kHvAnodeImon,       "trd_hvAnodeImon%03d",   	  'f', 540, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kHvDriftImon,       "trd_hvDriftImon%03d", 	  'f', 540, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kHvAnodeUmon,       "trd_hvAnodeUmon%03d", 	  'f', 540, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kHvDriftUmon,       "trd_hvDriftUmon%03d", 	  'f', 540, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kAdcClkPhase,       "trd_adcClkPhase", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kAtmPressure,       "trd_atmPressure", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kLuminosity, 	      "trd_luminosity", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);
  SetConf(kMagneticField,     "trd_magneticField", 	  'f',   1, kTRUE, kTRUE, 	10,10,0,2);		
  
  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
    fDatas[iAlias].GetGraph().SetOwner(1);
    fDatas[iAlias].GetFit().SetOwner(1);
  }

}

//_____________________________________________________________________________
void AliTRDDataDCS::SetConf(UInt_t iAlias, const char *amanda, 
			     char dataType, UInt_t nChannel, 
			     Bool_t enableGraph, Bool_t enableFit, Int_t minPoints, 
			     Int_t iter, Double_t maxDelta, Int_t fitReq)
{
  //
  // Configure a DCS alias
  //

  if (iAlias >= fNAlias) {
    AliWarning (Form("Alias %d is not correct", iAlias));
    return;
  }
  
  fConfs[iAlias].SetAmanda(amanda);
  fConfs[iAlias].SetDataType(dataType);
  fConfs[iAlias].SetNChannel(nChannel);
  fConfs[iAlias].SetEnableGraph(enableGraph);
  fConfs[iAlias].SetEnableFit(enableFit);
  fConfs[iAlias].SetMinPoints(minPoints);
  fConfs[iAlias].SetIter(iter);
  fConfs[iAlias].SetMaxDelta(maxDelta);
  fConfs[iAlias].SetFitReq(fitReq);
  
}

//_____________________________________________________________________________
void AliTRDDataDCS::InitFits()
{
  //
  // Initialize the fits
  //

  if (fFitsAreIni)
    return;
  
  UInt_t nChannel;
  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
    nChannel = fConfs[iAlias].GetEnableFit() ? fConfs[iAlias].GetNChannel() : 0;
    fDatas[iAlias].GetFit().Expand(nChannel);	
  }
  
  fFitsAreIni = kTRUE;
}

//_____________________________________________________________________________
void AliTRDDataDCS::InitGraphs()
{
  //
  // Initialize the graphs
  //

  if (fGraphsAreIni)
    return;
  
  UInt_t nChannel;	
  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
    nChannel = fConfs[iAlias].GetEnableGraph() ? fConfs[iAlias].GetNChannel() : 0;	 
    fDatas[iAlias].GetGraph().Expand(nChannel);
  }
  
  fGraphsAreIni = kTRUE;
}

//_____________________________________________________________________________
void AliTRDDataDCS::ClearFits()
{
  //
  // Clear the fits
  //

  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
    fDatas[iAlias].GetFit().Clear();
    fDatas[iAlias].GetFit().Expand(0);
  }
  
  fFitsAreIni = kFALSE;
}

//_____________________________________________________________________________
void AliTRDDataDCS::ClearGraphs()
{
  //
  // Clear the grpahs
  //

  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
    fDatas[iAlias].GetGraph().Clear();
    fDatas[iAlias].GetGraph().Expand(0);
  }
  
  fGraphsAreIni = kFALSE;
}

// //_____________________________________________________________________________
// void AliTRDDataDCS::Streamer(TBuffer &R__b) 
// {
//   //
//   // Custom streamer
//   //
  
//   if (R__b.IsReading()) {
    
//     R__b.ReadBool (fGraphsAreIni);
//     R__b.ReadBool (fFitsAreIni);
    
    
//     for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++) {
//       TString::ReadString (R__b, TString::Class());
//       R__b.ReadChar (fConfs[iAlias].fDataType);
//       R__b.ReadUInt (fConfs[iAlias].fNChannel);
//       R__b.ReadBool (fConfs[iAlias].fEnableGraph);
//       R__b.ReadBool (fConfs[iAlias].fEnableFit);
//       R__b.ReadInt  (fConfs[iAlias].fMinPoints);
//       R__b.ReadInt  (fConfs[iAlias].fIter);
//       R__b.ReadDouble  (fConfs[iAlias].fMaxDelta);
//       R__b.ReadInt  (fConfs[iAlias].fFitReq);
//     }
    
    
//     if (fGraphsAreIni) {
//       for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
// 	fDatas[iAlias].GetGraph() = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
//     }
    
//     if (fFitsAreIni) {
//       for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
// 	fDatas[iAlias].GetFit() = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
//     }
    
//     AliInfo (Form("Read %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
    
//   } else {
//     R__b.WriteBool (fGraphsAreIni);
//     R__b.WriteBool (fFitsAreIni);
    
//     for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
//       TString::WriteString (R__b, &fConfs[iAlias].fAmanda);
//       R__b.WriteChar (fConfs[iAlias].fDataType);
//       R__b.WriteUInt (fConfs[iAlias].fNChannel);
//       R__b.WriteBool (fConfs[iAlias].fEnableGraph);
//       R__b.WriteBool (fConfs[iAlias].fEnableFit);
//       R__b.WriteInt  (fConfs[iAlias].fMinPoints);
//       R__b.WriteInt  (fConfs[iAlias].fIter);
//       R__b.WriteDouble  (fConfs[iAlias].fMaxDelta);
//       R__b.WriteInt  (fConfs[iAlias].fFitReq);
//     }
    
//     if (fGraphsAreIni) {
//       for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
// 	R__b.WriteObject ((TObject*)&fDatas[iAlias].GetGraph());
//     }
    
//     if (fFitsAreIni) {
//       for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
// 	R__b.WriteObject ((TObject*)&fDatas[iAlias].GetFit());
//     }
    
//     AliInfo (Form("Write %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
//   }
// }

//_____________________________________________________________________________
Bool_t AliTRDDataDCS::ExtractDCS (TMap *dcsAlias)
{
  //
  // Extract the DCS information
  //

  if (dcsAlias == 0x0) {
    AliWarning ("No DCS Map");
    return kFALSE;
  }
  
  ClearGraphs();
  InitGraphs();
  
  TGraph *graphTemp;
  UInt_t nChannel;
  
  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
    
    // extract dcs only when it is needed
    nChannel = fDatas[iAlias].GetGraph().GetSize();
    
    for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
      
      graphTemp = FindAndMakeGraph(dcsAlias, 
				   Form(fConfs[iAlias].GetAmanda().Data(), iSensor), 
				   fConfs[iAlias].GetDataType()); 
      
      fDatas[iAlias].GetGraph().AddAt(graphTemp, iSensor);
    }
  }
  
  return kTRUE;
}

//_____________________________________________________________________________
TGraph *AliTRDDataDCS::FindAndMakeGraph (TMap *dcsMap, const char *amandaStr, 
					  char dataType)
{
  //
  // Create the graphs
  //

  TGraph *graph;
  
  TPair *pair = (TPair *) dcsMap->FindObject(amandaStr);
  if (pair == 0x0) {
    AliWarning (Form("Can't find %s in dcsMap", amandaStr));
    return 0x0;
  }
  
  TObjArray *valueSet = (TObjArray *) pair->Value();
  
  //
  // Make graph of values read from DCS map
  //   (spline fit parameters will subsequently be obtained from this graph) 
  //
  
  Int_t nEntries = valueSet->GetEntriesFast();
  if (nEntries == 0) {
    AliWarning (Form("Entry %s in dcsMap contain no datas", amandaStr));
    return 0x0;
  }
  
  Float_t * x = new Float_t[nEntries];
  Float_t * y = new Float_t[nEntries];
  
  Bool_t ok = kTRUE;
  Int_t time0 = 0;
  Int_t iEntries;
  for (iEntries = 0;  iEntries< nEntries; iEntries++) {
    
    AliDCSValue *val = (AliDCSValue *) valueSet->At(iEntries);
    
    if (val == 0x0) { 
      ok = false;
      AliError(Form("Entry %s at %d contain no datas", amandaStr, iEntries));
      break;
    }
    
    if (time0 == 0) 
      time0 = val->GetTimeStamp();
    
    
    x[iEntries] = (val->GetTimeStamp() - time0)/3600.0; // give times in fractions of hours 
    
    switch (dataType) {
    case 'f' :
      y[iEntries] = val->GetFloat();
      break;
      
    case 'c' :
      y[iEntries] = (Float_t) val->GetChar();
      break;
      
    default :
      ok = false;
      AliError(Form("Bad type for entry %s", amandaStr));
      break;
    }
  }
  
  if (ok)
    graph = new TGraph(iEntries, x, y);
  else
    graph = 0x0;
  
  delete [] x;
  delete [] y;
  
  return graph;
}

//_____________________________________________________________________________
Bool_t AliTRDDataDCS::PerformFit()
{
  //
  // Do the fit
  //

  AliSplineFit *fitTemp;
  
  ClearFits();
  InitFits();
  
  UInt_t nChannel;
  
  for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
    
    // perform fit only when it is needed
    nChannel = fDatas[iAlias].GetFit().GetSize();
    
    for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
      
      fitTemp = Fit((TGraph*)fDatas[iAlias].GetGraph(iSensor),
		     fConfs[iAlias].GetMinPoints(),
		     fConfs[iAlias].GetIter(),
		     fConfs[iAlias].GetMaxDelta(),
		     fConfs[iAlias].GetFitReq()); 
      
      if (fitTemp == 0x0)
	AliInfo(Form("Can't fit %s", Form(fConfs[iAlias].GetAmanda().Data(), iSensor)));
      
      fDatas[iAlias].GetFit().AddAt(fitTemp, iSensor);
    }
  }
  
  return kTRUE;
  
}

//_____________________________________________________________________________
AliSplineFit *AliTRDDataDCS::Fit(TGraph *graph, 
			         Int_t  minPoints, Int_t  iter, 
			         Double_t  maxDelta, Int_t  fitReq)
{
  if (graph == 0x0) {
    AliError("No graph for fit");
    return 0x0;
  }
  
  AliSplineFit *spline = new AliSplineFit();
  spline->InitKnots(new TGraph (*graph), minPoints, iter, maxDelta);
  spline->SplineFit(fitReq);
  spline->Cleanup();   // delete also new TGraph (*graph)
  
  return spline;
}

//_____________________________________________________________________________
void AliTRDDataDCS::Print(Option_t* option) const
{
  //
  // Print function
  //

  if (option[0]=='g' || option[0]=='\0'){
    
    if (fGraphsAreIni){
      
      for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
	
	for (Int_t iSensor = 0; iSensor < fDatas[iAlias].GetGraph().GetSize(); iSensor++) {
	  
	  if (fDatas[iAlias].GetGraph(iSensor) != 0x0)
	    AliInfo(Form("Graph %s contain %d point(s)", 
			  Form(fConfs[iAlias].GetAmanda(), iSensor), 
			  ((TGraph*)(fDatas[iAlias].GetGraph(iSensor)))->GetN()));
	}
      }
    }
    else{
      AliInfo("Graphs don't exist");
    }
  }
  
  
  if (option[0] == 'f' || option[0]=='\0'){
    
    AliInfo("no print for fit");
    
  }
  
}

//_____________________________________________________________________________
TGraph *AliTRDDataDCS::GetGraph(UInt_t iAlias, UInt_t iChannel) const
{
  //
  // Get a graph
  //

  if (iAlias >= fNAlias) {
    AliWarning(Form("Alias %d is not correct", iAlias));
    return 0x0;
  }
  
  if (iChannel >= (UInt_t) fDatas[iAlias].GetGraph().GetSize()) {
    AliWarning(Form("Alias %s is not correct", 
		     Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
    return 0x0;
  }
  
  return (TGraph *)fDatas[iAlias].GetGraph(iChannel);
}

//_____________________________________________________________________________
AliSplineFit *AliTRDDataDCS::GetFit(UInt_t iAlias, UInt_t iChannel) const
{
  //
  // Get the spline fit
  //

  if (iAlias >= fNAlias) {
    AliWarning (Form("Alias %d is not correct", iAlias));
    return 0x0;
  }
  
  if (iChannel >= (UInt_t) fDatas[iAlias].GetFit().GetSize()) {
    AliWarning(Form("Alias %s is not correct", 
		     Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
    return 0x0;
  }
  
  return (AliSplineFit *) fDatas[iAlias].GetFit(iChannel);
}

//_____________________________________________________________________________
TString AliTRDDataDCS::GetAmandaStr (UInt_t iAlias) const 
{
  //
  // Return the AMANDA string
  //

  if (iAlias < fNAlias)
    return fConfs[iAlias].GetAmanda();
  else return TString ();
}

//_____________________________________________________________________________
UInt_t AliTRDDataDCS::GetNChannel (UInt_t iAlias) const 
{
  //
  // Get the channel number
  //

  if (iAlias < fNAlias)
    return fConfs[iAlias].GetNChannel();
  else return 0;
}
Commit	Line	Data
67b87932	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
	18	////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// This class collects the DCS information and does an AliSplineFit //
	21	// //
54d68e69	22	// Typical use : //
	23	// //
	24	// AliTRDDataDCS dataDcs; //
	25	// dataDcs.ExtractDCS(dcs); //
	26	// ->call a storeRef function //
	27	// dataDcs.PerformFit(); //
	28	// dataDcs.ClearGraphs(); //
	29	// ->call a store function //
	30	// dataDcs.ClearFits(); //
	31	// //
67b87932	32	// Author: //
	33	// W. Monange (wilfried.monange@free.fr) //
	34	// //
	35	////////////////////////////////////////////////////////////////////////////
a5e1169e	36
a5e1169e	37	#include <TGraph.h>
	38	#include <TObjArray.h>
	39	#include <AliCDBMetaData.h>
	40	#include <TMap.h>
	41
	42	#include "AliDCSValue.h"
	43	#include "AliDCSValue.h"
	44	#include "AliLog.h"
	45	#include "AliTRDDataDCS.h"
	46	#include "AliSplineFit.h"
	47
	48	ClassImp(AliTRDDataDCS)
	49
a5e1169e	50	//_____________________________________________________________________________
54d68e69	51	AliTRDDataDCS::AliTRDDataDCS()
	52	:TNamed()
	53	,fGraphsAreIni(kFALSE)
	54	,fFitsAreIni(kFALSE)
	55	,fNAlias(22)
a5e1169e	56	{
54d68e69	57	//
	58	// Default constructor
	59	//
	60
a5e1169e	61	Init ();
54d68e69	62
a5e1169e	63	}
	64
	65	//_____________________________________________________________________________
54d68e69	66	AliTRDDataDCS::~AliTRDDataDCS()
a5e1169e	67	{
54d68e69	68	//
	69	// Destructor
	70	//
	71
	72	ClearFits();
	73	ClearGraphs();
	74
a5e1169e	75	}
	76
	77	//_____________________________________________________________________________
54d68e69	78	void AliTRDDataDCS::Init()
a5e1169e	79	{
54d68e69	80	//
	81	// Initialization
	82	//
	83
	84	SetConf(kChamberByteStatus, "trd_chamberByteStatus%03d",'c', 540, kTRUE,kFALSE, 10,10,0,2);
	85	SetConf(kPreTrigger, "trd_preTrigger", 'c', 1, kTRUE, kTRUE, 10,10,0,2);
	86	SetConf(kGoofyHv, "trd_goofyHv", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	87	SetConf(kGoofyPeakPos, "trd_goofyPeakPos%02d", 'f', 2, kTRUE, kTRUE, 10,10,0,2);
	88	SetConf(kGoofyPeakArea, "trd_goofyPeakArea%02d", 'f', 2, kTRUE, kTRUE, 10,10,0,2);
	89	SetConf(kGoofyTemp, "trd_goofyTemp%02d", 'f', 2, kTRUE, kTRUE, 10,10,0,2);
	90	SetConf(kGoofyPressure, "trd_goofyPressure", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	91	SetConf(kGoofyVelocity, "trd_goofyVelocity", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	92	SetConf(kGoofyGain, "trd_goofyGain%02d", 'f', 2, kTRUE, kTRUE, 10,10,0,2);
	93	SetConf(kGoofyCO2, "trd_goofyCO2", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	94	SetConf(kGoofyN2, "trd_goofyN2", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	95	SetConf(kGasO2, "trd_gasO2", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	96	SetConf(kGasOverpressure, "trd_gasOverpressure", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	97	SetConf(kEnvTemp, "trd_envTemp%03d", 'f', 540, kTRUE, kTRUE, 10,10,0,2);
	98	SetConf(kHvAnodeImon, "trd_hvAnodeImon%03d", 'f', 540, kTRUE, kTRUE, 10,10,0,2);
	99	SetConf(kHvDriftImon, "trd_hvDriftImon%03d", 'f', 540, kTRUE, kTRUE, 10,10,0,2);
	100	SetConf(kHvAnodeUmon, "trd_hvAnodeUmon%03d", 'f', 540, kTRUE, kTRUE, 10,10,0,2);
	101	SetConf(kHvDriftUmon, "trd_hvDriftUmon%03d", 'f', 540, kTRUE, kTRUE, 10,10,0,2);
	102	SetConf(kAdcClkPhase, "trd_adcClkPhase", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	103	SetConf(kAtmPressure, "trd_atmPressure", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	104	SetConf(kLuminosity, "trd_luminosity", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
	105	SetConf(kMagneticField, "trd_magneticField", 'f', 1, kTRUE, kTRUE, 10,10,0,2);
a5e1169e	106
a5e1169e	107	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
54d68e69	108	fDatas[iAlias].GetGraph().SetOwner(1);
54d68e69	109	fDatas[iAlias].GetFit().SetOwner(1);
a5e1169e	110	}
54d68e69	111
a5e1169e	112	}
	113
	114	//_____________________________________________________________________________
54d68e69	115	void AliTRDDataDCS::SetConf(UInt_t iAlias, const char *amanda,
a5e1169e	116	char dataType, UInt_t nChannel,
54d68e69	117	Bool_t enableGraph, Bool_t enableFit, Int_t minPoints,
54d68e69	118	Int_t iter, Double_t maxDelta, Int_t fitReq)
a5e1169e	119	{
54d68e69	120	//
	121	// Configure a DCS alias
	122	//
	123
a5e1169e	124	if (iAlias >= fNAlias) {
	125	AliWarning (Form("Alias %d is not correct", iAlias));
	126	return;
	127	}
	128
54d68e69	129	fConfs[iAlias].SetAmanda(amanda);
	130	fConfs[iAlias].SetDataType(dataType);
	131	fConfs[iAlias].SetNChannel(nChannel);
	132	fConfs[iAlias].SetEnableGraph(enableGraph);
	133	fConfs[iAlias].SetEnableFit(enableFit);
	134	fConfs[iAlias].SetMinPoints(minPoints);
	135	fConfs[iAlias].SetIter(iter);
	136	fConfs[iAlias].SetMaxDelta(maxDelta);
	137	fConfs[iAlias].SetFitReq(fitReq);
a5e1169e	138
	139	}
	140
	141	//_____________________________________________________________________________
54d68e69	142	void AliTRDDataDCS::InitFits()
a5e1169e	143	{
54d68e69	144	//
	145	// Initialize the fits
	146	//
	147
	148	if (fFitsAreIni)
a5e1169e	149	return;
	150
	151	UInt_t nChannel;
	152	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
54d68e69	153	nChannel = fConfs[iAlias].GetEnableFit() ? fConfs[iAlias].GetNChannel() : 0;
54d68e69	154	fDatas[iAlias].GetFit().Expand(nChannel);
a5e1169e	155	}
a5e1169e	156
54d68e69	157	fFitsAreIni = kTRUE;
a5e1169e	158	}
	159
	160	//_____________________________________________________________________________
54d68e69	161	void AliTRDDataDCS::InitGraphs()
a5e1169e	162	{
54d68e69	163	//
	164	// Initialize the graphs
	165	//
	166
	167	if (fGraphsAreIni)
a5e1169e	168	return;
	169
	170	UInt_t nChannel;
	171	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
54d68e69	172	nChannel = fConfs[iAlias].GetEnableGraph() ? fConfs[iAlias].GetNChannel() : 0;
54d68e69	173	fDatas[iAlias].GetGraph().Expand(nChannel);
a5e1169e	174	}
a5e1169e	175
54d68e69	176	fGraphsAreIni = kTRUE;
a5e1169e	177	}
	178
	179	//_____________________________________________________________________________
54d68e69	180	void AliTRDDataDCS::ClearFits()
a5e1169e	181	{
54d68e69	182	//
	183	// Clear the fits
	184	//
	185
a5e1169e	186	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
54d68e69	187	fDatas[iAlias].GetFit().Clear();
54d68e69	188	fDatas[iAlias].GetFit().Expand(0);
a5e1169e	189	}
a5e1169e	190
54d68e69	191	fFitsAreIni = kFALSE;
a5e1169e	192	}
	193
	194	//_____________________________________________________________________________
54d68e69	195	void AliTRDDataDCS::ClearGraphs()
	196	{
	197	//
	198	// Clear the grpahs
	199	//
	200
a5e1169e	201	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
54d68e69	202	fDatas[iAlias].GetGraph().Clear();
54d68e69	203	fDatas[iAlias].GetGraph().Expand(0);
a5e1169e	204	}
a5e1169e	205
54d68e69	206	fGraphsAreIni = kFALSE;
a5e1169e	207	}
a5e1169e	208
54d68e69	209	// //_____________________________________________________________________________
	210	// void AliTRDDataDCS::Streamer(TBuffer &R__b)
	211	// {
	212	// //
	213	// // Custom streamer
	214	// //
	215
	216	// if (R__b.IsReading()) {
a5e1169e	217
54d68e69	218	// R__b.ReadBool (fGraphsAreIni);
54d68e69	219	// R__b.ReadBool (fFitsAreIni);
a5e1169e	220
a5e1169e	221
54d68e69	222	// for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++) {
	223	// TString::ReadString (R__b, TString::Class());
	224	// R__b.ReadChar (fConfs[iAlias].fDataType);
	225	// R__b.ReadUInt (fConfs[iAlias].fNChannel);
	226	// R__b.ReadBool (fConfs[iAlias].fEnableGraph);
	227	// R__b.ReadBool (fConfs[iAlias].fEnableFit);
	228	// R__b.ReadInt (fConfs[iAlias].fMinPoints);
	229	// R__b.ReadInt (fConfs[iAlias].fIter);
	230	// R__b.ReadDouble (fConfs[iAlias].fMaxDelta);
	231	// R__b.ReadInt (fConfs[iAlias].fFitReq);
	232	// }
a5e1169e	233
a5e1169e	234
54d68e69	235	// if (fGraphsAreIni) {
	236	// for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
	237	// fDatas[iAlias].GetGraph() = (TObjArray)R__b.ReadObject (TObjArray::Class());
	238	// }
a5e1169e	239
54d68e69	240	// if (fFitsAreIni) {
	241	// for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
	242	// fDatas[iAlias].GetFit() = (TObjArray)R__b.ReadObject (TObjArray::Class());
	243	// }
a5e1169e	244
54d68e69	245	// AliInfo (Form("Read %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
a5e1169e	246
54d68e69	247	// } else {
	248	// R__b.WriteBool (fGraphsAreIni);
	249	// R__b.WriteBool (fFitsAreIni);
a5e1169e	250
54d68e69	251	// for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
	252	// TString::WriteString (R__b, &fConfs[iAlias].fAmanda);
	253	// R__b.WriteChar (fConfs[iAlias].fDataType);
	254	// R__b.WriteUInt (fConfs[iAlias].fNChannel);
	255	// R__b.WriteBool (fConfs[iAlias].fEnableGraph);
	256	// R__b.WriteBool (fConfs[iAlias].fEnableFit);
	257	// R__b.WriteInt (fConfs[iAlias].fMinPoints);
	258	// R__b.WriteInt (fConfs[iAlias].fIter);
	259	// R__b.WriteDouble (fConfs[iAlias].fMaxDelta);
	260	// R__b.WriteInt (fConfs[iAlias].fFitReq);
	261	// }
a5e1169e	262
54d68e69	263	// if (fGraphsAreIni) {
	264	// for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++)
	265	// R__b.WriteObject ((TObject*)&fDatas[iAlias].GetGraph());
	266	// }
a5e1169e	267
54d68e69	268	// if (fFitsAreIni) {
	269	// for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++)
	270	// R__b.WriteObject ((TObject*)&fDatas[iAlias].GetFit());
	271	// }
a5e1169e	272
54d68e69	273	// AliInfo (Form("Write %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
	274	// }
	275	// }
a5e1169e	276
a5e1169e	277	//_____________________________________________________________________________
54d68e69	278	Bool_t AliTRDDataDCS::ExtractDCS (TMap *dcsAlias)
a5e1169e	279	{
54d68e69	280	//
	281	// Extract the DCS information
	282	//
	283
a5e1169e	284	if (dcsAlias == 0x0) {
	285	AliWarning ("No DCS Map");
	286	return kFALSE;
	287	}
	288
54d68e69	289	ClearGraphs();
54d68e69	290	InitGraphs();
a5e1169e	291
54d68e69	292	TGraph *graphTemp;
a5e1169e	293	UInt_t nChannel;
	294
	295	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
	296
	297	// extract dcs only when it is needed
54d68e69	298	nChannel = fDatas[iAlias].GetGraph().GetSize();
a5e1169e	299
	300	for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
	301
54d68e69	302	graphTemp = FindAndMakeGraph(dcsAlias,
	303	Form(fConfs[iAlias].GetAmanda().Data(), iSensor),
	304	fConfs[iAlias].GetDataType());
a5e1169e	305
54d68e69	306	fDatas[iAlias].GetGraph().AddAt(graphTemp, iSensor);
a5e1169e	307	}
	308	}
	309
	310	return kTRUE;
	311	}
	312
	313	//_____________________________________________________________________________
54d68e69	314	TGraph AliTRDDataDCS::FindAndMakeGraph (TMap dcsMap, const char *amandaStr,
a5e1169e	315	char dataType)
a5e1169e	316	{
54d68e69	317	//
	318	// Create the graphs
	319	//
	320
	321	TGraph *graph;
a5e1169e	322
54d68e69	323	TPair pair = (TPair ) dcsMap->FindObject(amandaStr);
a5e1169e	324	if (pair == 0x0) {
	325	AliWarning (Form("Can't find %s in dcsMap", amandaStr));
	326	return 0x0;
	327	}
	328
54d68e69	329	TObjArray valueSet = (TObjArray ) pair->Value();
a5e1169e	330
	331	//
	332	// Make graph of values read from DCS map
	333	// (spline fit parameters will subsequently be obtained from this graph)
	334	//
	335
	336	Int_t nEntries = valueSet->GetEntriesFast();
	337	if (nEntries == 0) {
	338	AliWarning (Form("Entry %s in dcsMap contain no datas", amandaStr));
	339	return 0x0;
	340	}
	341
54d68e69	342	Float_t * x = new Float_t[nEntries];
54d68e69	343	Float_t * y = new Float_t[nEntries];
a5e1169e	344
54d68e69	345	Bool_t ok = kTRUE;
a5e1169e	346	Int_t time0 = 0;
	347	Int_t iEntries;
	348	for (iEntries = 0; iEntries< nEntries; iEntries++) {
	349
54d68e69	350	AliDCSValue val = (AliDCSValue ) valueSet->At(iEntries);
a5e1169e	351
	352	if (val == 0x0) {
	353	ok = false;
54d68e69	354	AliError(Form("Entry %s at %d contain no datas", amandaStr, iEntries));
a5e1169e	355	break;
	356	}
	357
	358	if (time0 == 0)
	359	time0 = val->GetTimeStamp();
	360
	361
	362	x[iEntries] = (val->GetTimeStamp() - time0)/3600.0; // give times in fractions of hours
	363
	364	switch (dataType) {
	365	case 'f' :
	366	y[iEntries] = val->GetFloat();
	367	break;
	368
	369	case 'c' :
	370	y[iEntries] = (Float_t) val->GetChar();
	371	break;
	372
	373	default :
	374	ok = false;
54d68e69	375	AliError(Form("Bad type for entry %s", amandaStr));
a5e1169e	376	break;
	377	}
	378	}
	379
	380	if (ok)
54d68e69	381	graph = new TGraph(iEntries, x, y);
a5e1169e	382	else
	383	graph = 0x0;
	384
	385	delete [] x;
	386	delete [] y;
	387
	388	return graph;
	389	}
	390
a5e1169e	391	//_____________________________________________________________________________
54d68e69	392	Bool_t AliTRDDataDCS::PerformFit()
a5e1169e	393	{
54d68e69	394	//
	395	// Do the fit
	396	//
	397
	398	AliSplineFit *fitTemp;
a5e1169e	399
54d68e69	400	ClearFits();
54d68e69	401	InitFits();
a5e1169e	402
	403	UInt_t nChannel;
	404
	405	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
	406
	407	// perform fit only when it is needed
54d68e69	408	nChannel = fDatas[iAlias].GetFit().GetSize();
a5e1169e	409
	410	for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
	411
54d68e69	412	fitTemp = Fit((TGraph*)fDatas[iAlias].GetGraph(iSensor),
	413	fConfs[iAlias].GetMinPoints(),
	414	fConfs[iAlias].GetIter(),
	415	fConfs[iAlias].GetMaxDelta(),
	416	fConfs[iAlias].GetFitReq());
a5e1169e	417
a5e1169e	418	if (fitTemp == 0x0)
54d68e69	419	AliInfo(Form("Can't fit %s", Form(fConfs[iAlias].GetAmanda().Data(), iSensor)));
a5e1169e	420
54d68e69	421	fDatas[iAlias].GetFit().AddAt(fitTemp, iSensor);
a5e1169e	422	}
	423	}
	424
	425	return kTRUE;
	426
	427	}
	428
	429	//_____________________________________________________________________________
54d68e69	430	AliSplineFit AliTRDDataDCS::Fit(TGraph graph,
	431	Int_t minPoints, Int_t iter,
	432	Double_t maxDelta, Int_t fitReq)
a5e1169e	433	{
a5e1169e	434	if (graph == 0x0) {
54d68e69	435	AliError("No graph for fit");
a5e1169e	436	return 0x0;
	437	}
	438
54d68e69	439	AliSplineFit *spline = new AliSplineFit();
	440	spline->InitKnots(new TGraph (*graph), minPoints, iter, maxDelta);
	441	spline->SplineFit(fitReq);
a5e1169e	442	spline->Cleanup(); // delete also new TGraph (*graph)
	443
	444	return spline;
	445	}
	446
a5e1169e	447	//_____________________________________________________________________________
54d68e69	448	void AliTRDDataDCS::Print(Option_t* option) const
a5e1169e	449	{
54d68e69	450	//
	451	// Print function
	452	//
	453
a5e1169e	454	if (option[0]=='g' \|\| option[0]=='\0'){
a5e1169e	455
54d68e69	456	if (fGraphsAreIni){
a5e1169e	457
	458	for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
	459
54d68e69	460	for (Int_t iSensor = 0; iSensor < fDatas[iAlias].GetGraph().GetSize(); iSensor++) {
a5e1169e	461
54d68e69	462	if (fDatas[iAlias].GetGraph(iSensor) != 0x0)
	463	AliInfo(Form("Graph %s contain %d point(s)",
	464	Form(fConfs[iAlias].GetAmanda(), iSensor),
	465	((TGraph*)(fDatas[iAlias].GetGraph(iSensor)))->GetN()));
a5e1169e	466	}
a5e1169e	467	}
54d68e69	468	}
	469	else{
	470	AliInfo("Graphs don't exist");
a5e1169e	471	}
	472	}
	473
	474
	475	if (option[0] == 'f' \|\| option[0]=='\0'){
	476
54d68e69	477	AliInfo("no print for fit");
a5e1169e	478
	479	}
	480
	481	}
	482
	483	//_____________________________________________________________________________
54d68e69	484	TGraph *AliTRDDataDCS::GetGraph(UInt_t iAlias, UInt_t iChannel) const
a5e1169e	485	{
54d68e69	486	//
	487	// Get a graph
	488	//
	489
a5e1169e	490	if (iAlias >= fNAlias) {
54d68e69	491	AliWarning(Form("Alias %d is not correct", iAlias));
a5e1169e	492	return 0x0;
	493	}
	494
54d68e69	495	if (iChannel >= (UInt_t) fDatas[iAlias].GetGraph().GetSize()) {
	496	AliWarning(Form("Alias %s is not correct",
	497	Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
a5e1169e	498	return 0x0;
	499	}
	500
54d68e69	501	return (TGraph *)fDatas[iAlias].GetGraph(iChannel);
a5e1169e	502	}
	503
	504	//_____________________________________________________________________________
54d68e69	505	AliSplineFit *AliTRDDataDCS::GetFit(UInt_t iAlias, UInt_t iChannel) const
a5e1169e	506	{
54d68e69	507	//
	508	// Get the spline fit
	509	//
	510
a5e1169e	511	if (iAlias >= fNAlias) {
	512	AliWarning (Form("Alias %d is not correct", iAlias));
	513	return 0x0;
	514	}
	515
54d68e69	516	if (iChannel >= (UInt_t) fDatas[iAlias].GetFit().GetSize()) {
	517	AliWarning(Form("Alias %s is not correct",
	518	Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
a5e1169e	519	return 0x0;
	520	}
	521
54d68e69	522	return (AliSplineFit *) fDatas[iAlias].GetFit(iChannel);
a5e1169e	523	}
	524
	525	//_____________________________________________________________________________
	526	TString AliTRDDataDCS::GetAmandaStr (UInt_t iAlias) const
	527	{
54d68e69	528	//
	529	// Return the AMANDA string
	530	//
	531
a5e1169e	532	if (iAlias < fNAlias)
54d68e69	533	return fConfs[iAlias].GetAmanda();
a5e1169e	534	else return TString ();
	535	}
	536
	537	//_____________________________________________________________________________
	538	UInt_t AliTRDDataDCS::GetNChannel (UInt_t iAlias) const
	539	{
54d68e69	540	//
	541	// Get the channel number
	542	//
	543
a5e1169e	544	if (iAlias < fNAlias)
54d68e69	545	return fConfs[iAlias].GetNChannel();
a5e1169e	546	else return 0;
a5e1169e	547	}