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


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Calibration class for DCS sensors                                        //
//  Authors: Marian Ivanov and Haavard Helstrup                              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliDCSSensorArray.h"
#include "AliLog.h"

ClassImp(AliDCSSensorArray)

const Double_t kSecInHour = 3600.; // seconds in one hour

//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray():TNamed(), 
  fMinGraph(10),
  fMinPoints(10),
  fIter(10),
  fMaxDelta(0.0),
  fFitReq(2),
  fValCut(-1),
  fDiffCut(-1),
  fStartTime (2000,1,1,0,0,0),
  fEndTime   (2000,1,1,0,0,0),
  fSensors(0)
{
  //
  // AliDCSSensorArray default constructor
  //

}
//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray(TClonesArray *arr):TNamed(),
  fMinGraph(10),
  fMinPoints(10),
  fIter(10),
  fMaxDelta(0.0),
  fFitReq(2),
  fValCut(-1),
  fDiffCut(-1),
  fStartTime (2000,1,1,0,0,0),
  fEndTime   (2000,1,1,0,0,0),
  fSensors(arr)
{
  //
  // AliDCSSensorArray special constructor taking TClonesArray from ReadList
  //

}
//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray(Int_t run, const char* dbEntry) :
  TNamed(),
  fMinGraph(10),
  fMinPoints(10),
  fIter(10),
  fMaxDelta(0.0),
  fFitReq(2),
  fValCut(-1),
  fDiffCut(-1),
  fStartTime (2000,1,1,0,0,0),
  fEndTime   (2000,1,1,0,0,0),
  fSensors(0)
{
  //
  // Read configuration from OCDB
  //

  AliCDBEntry *entry = AliCDBManager::Instance()->Get(dbEntry,run);
  TTree *tree = (TTree*) entry->GetObject();
  fSensors = AliDCSSensor::ReadTree(tree);
}
//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
                       TTree* confTree) :
  TNamed(),
  fMinGraph(10),
  fMinPoints(10),
  fIter(10),
  fMaxDelta(0.0),
  fFitReq(2),
  fValCut(-1),
  fDiffCut(-1),
  fStartTime (2000,1,1,0,0,0),
  fEndTime   (2000,1,1,0,0,0),
  fSensors(0)

{
  //
  // AliDCSSensorArray constructor for Shuttle preprocessor
  //  (confTree read from OCDB)
  //
  fSensors = AliDCSSensor::ReadTree(confTree);
  fSensors->BypassStreamer(kFALSE);
  fStartTime = TTimeStamp(startTime);
  fEndTime   = TTimeStamp(endTime);
}


//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
                       TClonesArray *sensors) :
  TNamed(),
  fMinGraph(10),
  fMinPoints(10),
  fIter(10),
  fMaxDelta(0.0),
  fFitReq(2),
  fValCut(-1),
  fDiffCut(-1),
  fStartTime (2000,1,1,0,0,0),
  fEndTime   (2000,1,1,0,0,0),
  fSensors(sensors)

{
  //
  // AliDCSSensorArray constructor for Shuttle preprocessor
  //  (TClonesArray of AliDCSSensor objects)
  //
  fStartTime = TTimeStamp(startTime);
  fEndTime   = TTimeStamp(endTime);
}

//_____________________________________________________________________________
AliDCSSensorArray::AliDCSSensorArray(const AliDCSSensorArray &c):TNamed(c),
  fMinGraph(c.fMinGraph),
  fMinPoints(c.fMinPoints),
  fIter(c.fIter),
  fMaxDelta(c.fMaxDelta),
  fFitReq(c.fFitReq),
  fValCut(c.fValCut),
  fDiffCut(c.fDiffCut),
  fStartTime (c.fStartTime),
  fEndTime   (c.fEndTime),
  fSensors(0)

{
  //
  // AliDCSSensorArray copy constructor
  //

  fSensors = (TClonesArray*)c.fSensors->Clone();
}

///_____________________________________________________________________________
AliDCSSensorArray::~AliDCSSensorArray()
{
  //
  // AliDCSSensorArray destructor
  //
  fSensors->Delete();
  delete fSensors;

}

//_____________________________________________________________________________
AliDCSSensorArray &AliDCSSensorArray::operator=(const AliDCSSensorArray &c)
{
  //
  // Assignment operator
  //
  if (this != &c) {
     fSensors->Delete();
     new (this) AliDCSSensorArray(c);
     fSensors = (TClonesArray*)c.fSensors->Clone();
  }
  return *this;
}

//____________________________________________________________________________

void AliDCSSensorArray::SetGraph(TMap *map)
{
  //
  // Read graphs from DCS maps
  //
  Int_t nsensors = fSensors->GetEntries();
  for ( Int_t isensor=0; isensor<nsensors; isensor++) {
    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
    TString stringID = entry->GetStringID();
    TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
    if ( gr !=0 ) {
       entry->SetGraph((TGraph*)gr->Clone());
    } else {
       entry->SetGraph(0);
    }
  }
}
//_____________________________________________________________________________
void AliDCSSensorArray::MakeSplineFit(TMap *map, Bool_t keepMap)
{
  //
  // Make spline fits from DCS maps
  //
  Int_t nsensors = fSensors->GetEntries();
  for ( Int_t isensor=0; isensor<nsensors; isensor++) {
    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
    TString stringID = entry->GetStringID();
    TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
    if (!gr ) {
      entry->SetFit(0);
      entry->SetGraph(0);
      AliWarning(Form("sensor %s: no input graph",stringID.Data()));
      continue;
    }
    AliSplineFit *fit = new AliSplineFit();
    fit->SetMinPoints(fMinGraph);
    fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
    fit->SplineFit(fFitReq);
    entry->SetStartTime(fStartTime);
    entry->SetEndTime(fEndTime);
    fit->Cleanup();
    if (fit) {
      entry->SetFit(fit);
    } else {
      AliWarning(Form("sensor %s: no fit performed, DCS graph kept.",stringID.Data()));
      entry->SetGraph(gr);
    }
    if (keepMap) entry->SetGraph(gr);
  }
}

//_____________________________________________________________________________
Int_t AliDCSSensorArray::NumFits() const 
{
 //
 // Return number of sensors where a succesful fit has been made
 //
  Int_t nfit=0;
  Int_t nsensors = fSensors->GetEntries();
  for ( Int_t isensor=0; isensor<nsensors; isensor++) {
    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
    if (entry->GetFit()) nfit++;
  }    
  return nfit;
}
//_____________________________________________________________________________
Double_t AliDCSSensorArray::GetValue(UInt_t timeSec, Int_t sensor)
{
  //
  // Return sensor value at time timeSec (obtained from fitted function)
  //  timeSec = time in seconds from start of run
  //
  AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(sensor);
  return entry->GetValue(timeSec);
}


//_____________________________________________________________________________
TMap* AliDCSSensorArray::ExtractDCS(TMap *dcsMap)
{
 //
 // Extract temperature graphs from DCS maps
 //
 TMap *values = new TMap;
 TObjArray * valueSet;
 Int_t nsensors = fSensors->GetEntries();
 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
   TString stringID = entry->GetStringID();
   TPair *pair = (TPair*)dcsMap->FindObject(stringID.Data());
   if ( pair ) {                            // only try to read values
                                            // if DCS object available
     valueSet = (TObjArray*)pair->Value();
     TGraph *graph = MakeGraph(valueSet);
     values->Add(new TObjString(stringID.Data()),graph);
   }
 }
 return values;
}

//_____________________________________________________________________________
TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet){
  //
  // Make graph of temperature values read from DCS map
  //   (spline fit parameters will subsequently be obtained from this graph) 
  //
  Int_t nentries = valueSet->GetEntriesFast(); 
  if ( nentries == 0 ) return 0;
  
  Float_t *x = new Float_t[nentries];
  Float_t *y = new Float_t[nentries];
  Int_t time0=fStartTime.GetSec();
  Int_t out=0;
  Int_t skipped=0;
  AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
  AliDCSValue::Type type = val->GetType();
  if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
  Float_t value;
  for (Int_t i=0; i<nentries; i++){
    val = (AliDCSValue *)valueSet->At(i);
    if (!val) continue;
    if (time0==0){
      time0=val->GetTimeStamp();
    }
    switch ( type )
    { 
      case AliDCSValue::kFloat:
        value = val->GetFloat();
        break;
      case AliDCSValue::kChar:
        value = static_cast<Float_t>(val->GetChar());
	break;
      case AliDCSValue::kInt:
        value = static_cast<Float_t>(val->GetInt());
	break;
      case AliDCSValue::kUInt:
        value = static_cast<Float_t>(val->GetUInt());
	break;
      default:
        continue;
    }
    if (fValCut>0 && TMath::Abs(value)>fValCut) continue;   // refuse values greater than cut
    if (fDiffCut>0 ) {
      if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
        skipped++;                               // refuse values changing 
        continue;                                // by > cut  in one time step
      }                                          
      skipped=0;
    }					      
    if (val->GetTimeStamp()-time0>1000000) continue;
    x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours 
    y[out] = val->GetFloat();
    out++;
    
  }
  TGraph * graph = new TGraph(out,x,y);
  delete [] x;
  delete [] y;
  return graph;
}
  
//_____________________________________________________________________________
AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS) 
{
 //
 //  Return sensor information for sensor specified by IdDCS
 //
 Int_t nsensors = fSensors->GetEntries();
 for (Int_t isensor=0; isensor<nsensors; isensor++) {
   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
   if (entry->GetIdDCS() == IdDCS) return entry;
 }
 return 0;
}
//_____________________________________________________________________________
AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
{
 //
 //  Return sensor information for sensor specified by IdDCS
 //
 Int_t nsensors = fSensors->GetEntries();
 for (Int_t isensor=0; isensor<nsensors; isensor++) {
   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
   if (entry->GetStringID() == stringID) return entry;
 }
 return 0;
}
//_____________________________________________________________________________
AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
{
 //
 //  Return sensor closest to given position
 //
 Int_t nsensors = fSensors->GetEntries();
 Double_t dist2min=1e99;
 Double_t xs,ys,zs,dist2;
 Int_t ind=-1;
 for (Int_t isensor=0; isensor<nsensors; isensor++) {
   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
   xs = entry->GetX();
   ys = entry->GetY();
   zs = entry->GetZ();
   dist2 = (x-xs)*(x-xs) + (y-ys)*(y-ys) + (z-zs)*(z-zs);
   if (dist2 < dist2min) {
      ind=isensor;
      dist2min = dist2;
   }
 }
 if ( ind >= 0 ) {
    return (AliDCSSensor*)fSensors->At(ind);
 } else {
    return 0;
 }
}

AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
{
 //
 //  Return sensor given by array index
 //
 return (AliDCSSensor*)fSensors->At(ind);
}

void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
{
 //
 //  Return sensor given by array index
 //

  delete fSensors->RemoveAt(ind);
  fSensors->Compress();
}
void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
{
 //
 //  Deletes Sensor by given IdDCS
 //

  Int_t nsensors = fSensors->GetEntries();
  for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
    if (entry->GetIdDCS()==IdDCS) {
      delete fSensors->RemoveAt(isensor);
      break;
    }
  }
  fSensors->Compress();
}

Int_t AliDCSSensorArray::GetFirstIdDCS() const
{
 //
 //  Return DCS Id of first sensor
 //
 if ( fSensors != 0 ) {
    return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
 } else {
    return 0;
 }
}

Int_t AliDCSSensorArray::GetLastIdDCS() const 
{
 //
 //  Return DCS Id of last sensor
 //
 if ( fSensors != 0 ) {
    Int_t last = fSensors->GetEntries();
    return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
 } else {
    return 0;
 }
}
void AliDCSSensorArray::ClearGraph()
{
  //
  // Delete DCS graphs from all sensors in array
  //
   
   Int_t nsensors = fSensors->GetEntries();
   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
     AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
     TGraph *gr = sensor->GetGraph();
     if ( gr != 0 ) {
       delete gr;
       gr = 0;
     }
     sensor->SetGraph(0);
   }
}
void AliDCSSensorArray::ClearFit()
{
  //
  // Delete spline fits from all sensors in array
  //

   Int_t nsensors = fSensors->GetEntries();
   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
     AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
     AliSplineFit *fit = sensor->GetFit();
     if ( fit != 0 ) {
       delete fit;
       fit = 0;
     }
     sensor->SetFit(0);
   }
}
Commit	Line	Data
	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	// //
	19	// Calibration class for DCS sensors //
	20	// Authors: Marian Ivanov and Haavard Helstrup //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24	#include "AliDCSSensorArray.h"
	25	#include "AliLog.h"
	26
	27	ClassImp(AliDCSSensorArray)
	28
	29	const Double_t kSecInHour = 3600.; // seconds in one hour
	30
	31	//_____________________________________________________________________________
	32	AliDCSSensorArray::AliDCSSensorArray():TNamed(),
	33	fMinGraph(10),
	34	fMinPoints(10),
	35	fIter(10),
	36	fMaxDelta(0.0),
	37	fFitReq(2),
	38	fValCut(-1),
	39	fDiffCut(-1),
	40	fStartTime (2000,1,1,0,0,0),
	41	fEndTime (2000,1,1,0,0,0),
	42	fSensors(0)
	43	{
	44	//
	45	// AliDCSSensorArray default constructor
	46	//
	47
	48	}
	49	//_____________________________________________________________________________
	50	AliDCSSensorArray::AliDCSSensorArray(TClonesArray *arr):TNamed(),
	51	fMinGraph(10),
	52	fMinPoints(10),
	53	fIter(10),
	54	fMaxDelta(0.0),
	55	fFitReq(2),
	56	fValCut(-1),
	57	fDiffCut(-1),
	58	fStartTime (2000,1,1,0,0,0),
	59	fEndTime (2000,1,1,0,0,0),
	60	fSensors(arr)
	61	{
	62	//
	63	// AliDCSSensorArray special constructor taking TClonesArray from ReadList
	64	//
	65
	66	}
	67	//_____________________________________________________________________________
	68	AliDCSSensorArray::AliDCSSensorArray(Int_t run, const char* dbEntry) :
	69	TNamed(),
	70	fMinGraph(10),
	71	fMinPoints(10),
	72	fIter(10),
	73	fMaxDelta(0.0),
	74	fFitReq(2),
	75	fValCut(-1),
	76	fDiffCut(-1),
	77	fStartTime (2000,1,1,0,0,0),
	78	fEndTime (2000,1,1,0,0,0),
	79	fSensors(0)
	80	{
	81	//
	82	// Read configuration from OCDB
	83	//
	84
	85	AliCDBEntry *entry = AliCDBManager::Instance()->Get(dbEntry,run);
	86	TTree tree = (TTree) entry->GetObject();
	87	fSensors = AliDCSSensor::ReadTree(tree);
	88	}
	89	//_____________________________________________________________________________
	90	AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
	91	TTree* confTree) :
	92	TNamed(),
	93	fMinGraph(10),
	94	fMinPoints(10),
	95	fIter(10),
	96	fMaxDelta(0.0),
	97	fFitReq(2),
	98	fValCut(-1),
	99	fDiffCut(-1),
	100	fStartTime (2000,1,1,0,0,0),
	101	fEndTime (2000,1,1,0,0,0),
	102	fSensors(0)
	103
	104	{
	105	//
	106	// AliDCSSensorArray constructor for Shuttle preprocessor
	107	// (confTree read from OCDB)
	108	//
	109	fSensors = AliDCSSensor::ReadTree(confTree);
	110	fSensors->BypassStreamer(kFALSE);
	111	fStartTime = TTimeStamp(startTime);
	112	fEndTime = TTimeStamp(endTime);
	113	}
	114
	115
	116	//_____________________________________________________________________________
	117	AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
	118	TClonesArray *sensors) :
	119	TNamed(),
	120	fMinGraph(10),
	121	fMinPoints(10),
	122	fIter(10),
	123	fMaxDelta(0.0),
	124	fFitReq(2),
	125	fValCut(-1),
	126	fDiffCut(-1),
	127	fStartTime (2000,1,1,0,0,0),
	128	fEndTime (2000,1,1,0,0,0),
	129	fSensors(sensors)
	130
	131	{
	132	//
	133	// AliDCSSensorArray constructor for Shuttle preprocessor
	134	// (TClonesArray of AliDCSSensor objects)
	135	//
	136	fStartTime = TTimeStamp(startTime);
	137	fEndTime = TTimeStamp(endTime);
	138	}
	139
	140	//_____________________________________________________________________________
	141	AliDCSSensorArray::AliDCSSensorArray(const AliDCSSensorArray &c):TNamed(c),
	142	fMinGraph(c.fMinGraph),
	143	fMinPoints(c.fMinPoints),
	144	fIter(c.fIter),
	145	fMaxDelta(c.fMaxDelta),
	146	fFitReq(c.fFitReq),
	147	fValCut(c.fValCut),
	148	fDiffCut(c.fDiffCut),
	149	fStartTime (c.fStartTime),
	150	fEndTime (c.fEndTime),
	151	fSensors(0)
	152
	153	{
	154	//
	155	// AliDCSSensorArray copy constructor
	156	//
	157
	158	fSensors = (TClonesArray*)c.fSensors->Clone();
	159	}
	160
	161	///_____________________________________________________________________________
	162	AliDCSSensorArray::~AliDCSSensorArray()
	163	{
	164	//
	165	// AliDCSSensorArray destructor
	166	//
	167	fSensors->Delete();
	168	delete fSensors;
	169
	170	}
	171
	172	//_____________________________________________________________________________
	173	AliDCSSensorArray &AliDCSSensorArray::operator=(const AliDCSSensorArray &c)
	174	{
	175	//
	176	// Assignment operator
	177	//
	178	if (this != &c) {
	179	fSensors->Delete();
	180	new (this) AliDCSSensorArray(c);
	181	fSensors = (TClonesArray*)c.fSensors->Clone();
	182	}
	183	return *this;
	184	}
	185
	186	//____________________________________________________________________________
	187
	188	void AliDCSSensorArray::SetGraph(TMap *map)
	189	{
	190	//
	191	// Read graphs from DCS maps
	192	//
	193	Int_t nsensors = fSensors->GetEntries();
	194	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	195	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	196	TString stringID = entry->GetStringID();
	197	TGraph gr = (TGraph)map->GetValue(stringID.Data());
	198	if ( gr !=0 ) {
	199	entry->SetGraph((TGraph*)gr->Clone());
	200	} else {
	201	entry->SetGraph(0);
	202	}
	203	}
	204	}
	205	//_____________________________________________________________________________
	206	void AliDCSSensorArray::MakeSplineFit(TMap *map, Bool_t keepMap)
	207	{
	208	//
	209	// Make spline fits from DCS maps
	210	//
	211	Int_t nsensors = fSensors->GetEntries();
	212	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	213	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	214	TString stringID = entry->GetStringID();
	215	TGraph gr = (TGraph)map->GetValue(stringID.Data());
	216	if (!gr ) {
	217	entry->SetFit(0);
	218	entry->SetGraph(0);
	219	AliWarning(Form("sensor %s: no input graph",stringID.Data()));
	220	continue;
	221	}
	222	AliSplineFit *fit = new AliSplineFit();
	223	fit->SetMinPoints(fMinGraph);
	224	fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
	225	fit->SplineFit(fFitReq);
	226	entry->SetStartTime(fStartTime);
	227	entry->SetEndTime(fEndTime);
	228	fit->Cleanup();
	229	if (fit) {
	230	entry->SetFit(fit);
	231	} else {
	232	AliWarning(Form("sensor %s: no fit performed, DCS graph kept.",stringID.Data()));
	233	entry->SetGraph(gr);
	234	}
	235	if (keepMap) entry->SetGraph(gr);
	236	}
	237	}
	238
	239	//_____________________________________________________________________________
	240	Int_t AliDCSSensorArray::NumFits() const
	241	{
	242	//
	243	// Return number of sensors where a succesful fit has been made
	244	//
	245	Int_t nfit=0;
	246	Int_t nsensors = fSensors->GetEntries();
	247	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	248	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	249	if (entry->GetFit()) nfit++;
	250	}
	251	return nfit;
	252	}
	253	//_____________________________________________________________________________
	254	Double_t AliDCSSensorArray::GetValue(UInt_t timeSec, Int_t sensor)
	255	{
	256	//
	257	// Return sensor value at time timeSec (obtained from fitted function)
	258	// timeSec = time in seconds from start of run
	259	//
	260	AliDCSSensor entry = (AliDCSSensor)fSensors->At(sensor);
	261	return entry->GetValue(timeSec);
	262	}
	263
	264
	265	//_____________________________________________________________________________
	266	TMap* AliDCSSensorArray::ExtractDCS(TMap *dcsMap)
	267	{
	268	//
	269	// Extract temperature graphs from DCS maps
	270	//
	271	TMap *values = new TMap;
	272	TObjArray * valueSet;
	273	Int_t nsensors = fSensors->GetEntries();
	274	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	275	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	276	TString stringID = entry->GetStringID();
	277	TPair pair = (TPair)dcsMap->FindObject(stringID.Data());
	278	if ( pair ) { // only try to read values
	279	// if DCS object available
	280	valueSet = (TObjArray*)pair->Value();
	281	TGraph *graph = MakeGraph(valueSet);
	282	values->Add(new TObjString(stringID.Data()),graph);
	283	}
	284	}
	285	return values;
	286	}
	287
	288	//_____________________________________________________________________________
	289	TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet){
	290	//
	291	// Make graph of temperature values read from DCS map
	292	// (spline fit parameters will subsequently be obtained from this graph)
	293	//
	294	Int_t nentries = valueSet->GetEntriesFast();
	295	if ( nentries == 0 ) return 0;
	296
	297	Float_t *x = new Float_t[nentries];
	298	Float_t *y = new Float_t[nentries];
	299	Int_t time0=fStartTime.GetSec();
	300	Int_t out=0;
	301	Int_t skipped=0;
	302	AliDCSValue val = (AliDCSValue )valueSet->At(0);
	303	AliDCSValue::Type type = val->GetType();
	304	if ( type == AliDCSValue::kInvalid \|\| type == AliDCSValue::kBool ) return 0;
	305	Float_t value;
	306	for (Int_t i=0; i<nentries; i++){
	307	val = (AliDCSValue *)valueSet->At(i);
	308	if (!val) continue;
	309	if (time0==0){
	310	time0=val->GetTimeStamp();
	311	}
	312	switch ( type )
	313	{
	314	case AliDCSValue::kFloat:
	315	value = val->GetFloat();
	316	break;
	317	case AliDCSValue::kChar:
	318	value = static_cast<Float_t>(val->GetChar());
	319	break;
	320	case AliDCSValue::kInt:
	321	value = static_cast<Float_t>(val->GetInt());
	322	break;
	323	case AliDCSValue::kUInt:
	324	value = static_cast<Float_t>(val->GetUInt());
	325	break;
	326	default:
	327	continue;
	328	}
	329	if (fValCut>0 && TMath::Abs(value)>fValCut) continue; // refuse values greater than cut
	330	if (fDiffCut>0 ) {
	331	if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
	332	skipped++; // refuse values changing
	333	continue; // by > cut in one time step
	334	}
	335	skipped=0;
	336	}
	337	if (val->GetTimeStamp()-time0>1000000) continue;
	338	x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours
	339	y[out] = val->GetFloat();
	340	out++;
	341
	342	}
	343	TGraph * graph = new TGraph(out,x,y);
	344	delete [] x;
	345	delete [] y;
	346	return graph;
	347	}
	348
	349	//_____________________________________________________________________________
	350	AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS)
	351	{
	352	//
	353	// Return sensor information for sensor specified by IdDCS
	354	//
	355	Int_t nsensors = fSensors->GetEntries();
	356	for (Int_t isensor=0; isensor<nsensors; isensor++) {
	357	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	358	if (entry->GetIdDCS() == IdDCS) return entry;
	359	}
	360	return 0;
	361	}
	362	//_____________________________________________________________________________
	363	AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
	364	{
	365	//
	366	// Return sensor information for sensor specified by IdDCS
	367	//
	368	Int_t nsensors = fSensors->GetEntries();
	369	for (Int_t isensor=0; isensor<nsensors; isensor++) {
	370	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	371	if (entry->GetStringID() == stringID) return entry;
	372	}
	373	return 0;
	374	}
	375	//_____________________________________________________________________________
	376	AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
	377	{
	378	//
	379	// Return sensor closest to given position
	380	//
	381	Int_t nsensors = fSensors->GetEntries();
	382	Double_t dist2min=1e99;
	383	Double_t xs,ys,zs,dist2;
	384	Int_t ind=-1;
	385	for (Int_t isensor=0; isensor<nsensors; isensor++) {
	386	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	387	xs = entry->GetX();
	388	ys = entry->GetY();
	389	zs = entry->GetZ();
	390	dist2 = (x-xs)(x-xs) + (y-ys)(y-ys) + (z-zs)*(z-zs);
	391	if (dist2 < dist2min) {
	392	ind=isensor;
	393	dist2min = dist2;
	394	}
	395	}
	396	if ( ind >= 0 ) {
	397	return (AliDCSSensor*)fSensors->At(ind);
	398	} else {
	399	return 0;
	400	}
	401	}
	402
	403	AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
	404	{
	405	//
	406	// Return sensor given by array index
	407	//
	408	return (AliDCSSensor*)fSensors->At(ind);
	409	}
	410
	411	void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
	412	{
	413	//
	414	// Return sensor given by array index
	415	//
	416
	417	delete fSensors->RemoveAt(ind);
	418	fSensors->Compress();
	419	}
	420	void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
	421	{
	422	//
	423	// Deletes Sensor by given IdDCS
	424	//
	425
	426	Int_t nsensors = fSensors->GetEntries();
	427	for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
	428	AliDCSSensor entry = (AliDCSSensor)fSensors->At(isensor);
	429	if (entry->GetIdDCS()==IdDCS) {
	430	delete fSensors->RemoveAt(isensor);
	431	break;
	432	}
	433	}
	434	fSensors->Compress();
	435	}
	436
	437	Int_t AliDCSSensorArray::GetFirstIdDCS() const
	438	{
	439	//
	440	// Return DCS Id of first sensor
	441	//
	442	if ( fSensors != 0 ) {
	443	return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
	444	} else {
	445	return 0;
	446	}
	447	}
	448
	449	Int_t AliDCSSensorArray::GetLastIdDCS() const
	450	{
	451	//
	452	// Return DCS Id of last sensor
	453	//
	454	if ( fSensors != 0 ) {
	455	Int_t last = fSensors->GetEntries();
	456	return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
	457	} else {
	458	return 0;
	459	}
	460	}
	461	void AliDCSSensorArray::ClearGraph()
	462	{
	463	//
	464	// Delete DCS graphs from all sensors in array
	465	//
	466
	467	Int_t nsensors = fSensors->GetEntries();
	468	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	469	AliDCSSensor sensor = (AliDCSSensor)fSensors->At(isensor);
	470	TGraph *gr = sensor->GetGraph();
	471	if ( gr != 0 ) {
	472	delete gr;
	473	gr = 0;
	474	}
	475	sensor->SetGraph(0);
	476	}
	477	}
	478	void AliDCSSensorArray::ClearFit()
	479	{
	480	//
	481	// Delete spline fits from all sensors in array
	482	//
	483
	484	Int_t nsensors = fSensors->GetEntries();
	485	for ( Int_t isensor=0; isensor<nsensors; isensor++) {
	486	AliDCSSensor sensor = (AliDCSSensor)fSensors->At(isensor);
	487	AliSplineFit *fit = sensor->GetFit();
	488	if ( fit != 0 ) {
	489	delete fit;
	490	fit = 0;
	491	}
	492	sensor->SetFit(0);
	493	}
	494	}