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

/*
$Log$
Revision 1.2  2007/10/12 13:36:27  cvetan
Coding convention fixes from Stefan

Revision 1.1  2007/09/17 10:23:31  cvetan
New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.

*/ 

//////////////////////////////////////////////////////////////////////////
////
//// AliTPCMonitorConfig class
////
//// Configuration handler class for AliTPCMonitor
////
//// The basic configuration will be read from the file AliTPCMonitorConfig.txt
//// and can be changed online via the Button "Conf. Ranges"
//// Basic configuration settings are e.g. the range for the determination 
//// of the baseline, maximum adc value and the settings for the pedestal calculation.
//// 
//// Author: Stefan Kniege, IKF, Frankfurt
////       
////
/////////////////////////////////////////////////////////////////////////


#include "AliTPCMonitorConfig.h"
#include "AliLog.h" 
#include <Riostream.h>

ClassImp(AliTPCMonitorConfig)

// _______________________________________________________________________________________________________________
AliTPCMonitorConfig::AliTPCMonitorConfig(const Char_t* name, const Char_t* title) : 
  TNamed(name,title),
  fFormat(-1),
  fSector(0),
  fSectorLast(-1),
  fSectorLastDisplayed(-1),
  fSectorArr(new Int_t[36]),
  fFileLast(new Char_t[256]),
  fFileLastSet(0),
  fFileCurrent(new Char_t[256]),
  fEventNext(1),
  fEventNextID(1),
  fEventProcessed(0),
  fRangeMaxAdcMin(50),
  fRangeMaxAdcMax(100),
  fRangeBaseMin(300),
  fRangeBaseMax(600),
  fRangeSumMin(50), 
  fRangeSumMax(100),
  fCanvasXSize(100),
  fCanvasYSize(100), 
  fCanvasXSpace(10), 
  fCanvasYSpace(10), 
  fCanvasXOffset(130),
  fCanvasMainSize(200),
  fMainXSize(100),
  fMainYSize(600),
  fBorderXSize(10),
  fBorderYSize(10),
  fButtonXSize(100), 
  fButtonYSize(20), 
  fButtonFirstX1(10),
  fButtonFirstX2(50),
  fButtonFirstY(300),  
  fWrite10Bit(0),
  fComponents(new Float_t[10]), 
  fSamplingFreq(1000000),
  fPedestals(1),
  fNumOfChannels(16000),
  fTimeBins(1024),
  fMaxHwAddr(24000),
  fFitPulse(1),
  fProcOneSector(0)
{
  // Constructor 
  for(Int_t i =0; i<36; i++) { fSectorArr[i]  =  0;}
  for(Int_t i =0; i<10;i++)  { fComponents[i] =0.0;}
  SetMainSize(130,720,10,26 );
  
} 
 

//_______________________________________________________________________________________________________________
AliTPCMonitorConfig::AliTPCMonitorConfig(const AliTPCMonitorConfig &config) :
  TNamed(config.GetName(),config.GetTitle()),
  fFormat(config.fFormat),
  fSector(config.fSector),
  fSectorLast(config.fSectorLast),
  fSectorLastDisplayed(config.fSectorLastDisplayed),
  fSectorArr(new Int_t[36]),
  fFileLast(new Char_t[strlen(config.fFileLast)+1]), 
  fFileLastSet(config.fFileLastSet),
  fFileCurrent(new Char_t[strlen(config.fFileCurrent)+1]),
  fEventNext(config.fEventNext),
  fEventNextID(config.fEventNextID),
  fEventProcessed(config.fEventProcessed),
  fRangeMaxAdcMin(config.fRangeMaxAdcMin),
  fRangeMaxAdcMax(config.fRangeMaxAdcMax),
  fRangeBaseMin(config.fRangeBaseMin),
  fRangeBaseMax(config.fRangeBaseMax),
  fRangeSumMin(config.fRangeSumMin),
  fRangeSumMax(config.fRangeSumMax),
  fCanvasXSize(config.fCanvasXSize),
  fCanvasYSize(config.fCanvasYSize),
  fCanvasXSpace(config.fCanvasXSpace),
  fCanvasYSpace(config.fCanvasYSpace),
  fCanvasXOffset(config.fCanvasXOffset),
  fCanvasMainSize(config.fCanvasMainSize),
  fMainXSize(config.fMainXSize),
  fMainYSize(config.fMainYSize),
  fBorderXSize(config.fBorderXSize),
  fBorderYSize(config.fBorderYSize),
  fButtonXSize(config.fBorderXSize),
  fButtonYSize(config.fButtonYSize),
  fButtonFirstX1(config.fButtonFirstX1),
  fButtonFirstX2(config.fButtonFirstX2),
  fButtonFirstY(config.fButtonFirstY),
  fWrite10Bit(config.fWrite10Bit),
  fComponents(new Float_t[10]),
  fSamplingFreq(config.fSamplingFreq),
  fPedestals(config.fPedestals),
  fNumOfChannels(config.fNumOfChannels),
  fTimeBins(config.fTimeBins),
  fMaxHwAddr(config.fMaxHwAddr),
  fFitPulse(config.fFitPulse),
  fProcOneSector(config.fProcOneSector)
{
  // copy constructor
  strcpy(fFileLast,config.fFileLast);
  strcpy(fFileCurrent,config.fFileCurrent);
  
  for(Int_t i =0; i<36; i++) { fSectorArr[i]  =  0;}
  for(Int_t i =0; i<10;i++)  { fComponents[i] =0.0;}


}
//_______________________________________________________________________________________________________________
AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig& config)
{
  // assignement operator
  if(this!=&config){ 
    ((TNamed *)this)->operator=(config);
    fFormat=config.fFormat;
    fSector=config.fSector;
    fSectorLast=config.fSectorLast;
    fSectorLastDisplayed=config.fSectorLastDisplayed;
    fFileLastSet=config.fFileLastSet;
    fEventNext=config.fEventNext;
    fEventNextID=config.fEventNextID;
    fEventProcessed=config.fEventProcessed;
    fRangeMaxAdcMin=config.fRangeMaxAdcMin;
    fRangeMaxAdcMax=config.fRangeMaxAdcMax;
    fRangeBaseMin=config.fRangeBaseMin;
    fRangeBaseMax=config.fRangeBaseMax;
    fRangeSumMin=config.fRangeSumMin;
    fRangeSumMax=config.fRangeSumMax;
    fCanvasXSize=config.fCanvasXSize;
    fCanvasYSize=config.fCanvasYSize;
    fCanvasXSpace=config.fCanvasXSpace;
    fCanvasYSpace=config.fCanvasYSpace;
    fCanvasXOffset=config.fCanvasXOffset;
    fCanvasMainSize=config.fCanvasMainSize;
    fMainXSize=config.fMainXSize;
    fMainYSize=config.fMainYSize;
    fBorderXSize=config.fBorderXSize;
    fButtonYSize=config.fButtonYSize;
    fButtonFirstX1=config.fButtonFirstX1;
    fButtonFirstX2=config.fButtonFirstX2;
    fButtonFirstY=config.fButtonFirstY;
    fWrite10Bit=config.fWrite10Bit;
    fPedestals=config.fPedestals;
    fNumOfChannels=config.fNumOfChannels;
    fTimeBins=config.fTimeBins;
    fMaxHwAddr=config.fMaxHwAddr;
    fFitPulse=config.fFitPulse; 
    fProcOneSector=config.fProcOneSector;

    fFileLast             = new Char_t[strlen(config.fFileLast)+1]; 
    strcpy(fFileLast,config.fFileLast);
    
    
    fFileCurrent          = new Char_t[strlen(config.fFileCurrent)+1];
    strcpy(fFileCurrent,config.fFileCurrent);
    
    fSectorArr            = new Int_t[36];    for(Int_t i =0; i<36; i++) { fSectorArr[i]  =  0;}
    fComponents           = new Float_t[10];  for(Int_t i =0; i<10;i++)  { fComponents[i] =0.0;}
    
      
  }
  return *this;
}


//_______________________________________________________________________________________________________________
AliTPCMonitorConfig::~AliTPCMonitorConfig() 
{
  // Destructor
  delete[] fFileLast; 
  delete[] fFileCurrent;
  delete[] fSectorArr;
  delete[] fComponents;
} 


//_______________________________________________________________________________________________________________
void AliTPCMonitorConfig::SetMainSize(Int_t mainx, Int_t mainy, Int_t borderx=10, Int_t bordery=26) 
{
  // Set Size of Main window, buttons and canvases

  
  // size of main frame ///////////////////////
  fMainXSize            = mainx;
  fMainYSize            = mainy;
  
  // border size depending on window manager///
  fBorderXSize          = borderx;
  fBorderYSize          = bordery;
  
  // y-pos of first sector button /////////////
  fButtonFirstY         = (int) (0.50*fMainYSize);
 
  // canvas size for Minitor Canvases ///////////////////////
  fCanvasMainSize       = (Int_t)(fMainYSize/3);
  
  fCanvasXSize          = (int)fCanvasMainSize;
  fCanvasYSize          = (int)fCanvasMainSize;
  fCanvasXSpace         = (int)(-1*(fCanvasMainSize+ fBorderXSize ));
  fCanvasYSpace         = (int)(    fCanvasMainSize+ fBorderYSize );
  fCanvasXOffset        = (int)(-1*(fMainXSize     + fBorderXSize ));
  
  // adjust main size in y ////////////////////
  fMainYSize            = fMainYSize+fBorderYSize;
  
  // y-size of the main window also defines ///
  fButtonXSize          = (Int_t)(fMainXSize/2-10);
  fButtonYSize          = (Int_t)fMainYSize/47;
  fButtonFirstX1        =         5;
  fButtonFirstX2        = fMainXSize/2+5;

}
 
//_______________________________________________________________________________________________________________
void AliTPCMonitorConfig::SetBaseConfig(Float_t* confarr)
{
  // Set base configuration stored in array confarr 
  
  fRangeBaseMin   = (int)confarr[0];
  fRangeBaseMax   = (int)confarr[1];
  
  fRangeMaxAdcMin = (int)confarr[2];
  fRangeMaxAdcMax = (int)confarr[3];
  
  fRangeSumMin    = (int)confarr[4];
  fRangeSumMax    = (int)confarr[5];
  
  cout << " Set Ranges to : " << endl;
  cout << " range  base       :: " <<  fRangeBaseMin   << "\t :  " << fRangeBaseMax   << endl;
  cout << " range  adc max    :: " <<  fRangeMaxAdcMin << "\t :  " << fRangeMaxAdcMax << endl;
  cout << " range  sum        :: " <<  fRangeSumMin    << "\t :  " << fRangeSumMax    << endl;
  
}

//_______________________________________________________________________________________________________________
void AliTPCMonitorConfig::ReadConfig(Char_t* nameconf) 
{
  // Read base configuration from file
  // Update main window size

  //  string line;
  ifstream datin;
  datin.open(nameconf);
  
  if(!datin) {  AliWarning("Could not read configfile");}
  
  cout << "////  Read Configuration ///////// " << endl;
  while(!datin.eof())
    {
      string line;
      getline(datin,line);
      if(line.find("max adc")!=string::npos)
	{ 
	  datin >> fRangeMaxAdcMin     ; 
	  datin >> fRangeMaxAdcMax     ;
	  cout << " range max          :: " << fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
	}
      
      if(line.find("baseline")!=string::npos)
	{ 
	  datin >> fRangeBaseMin  ;
	  datin >> fRangeBaseMax  ;
	  cout << " range  base        :: " <<  fRangeBaseMin << " : " <<  fRangeBaseMax  << endl;
	}
      if(line.find("adc sum")!=string::npos)
	{ 
	  datin >> fRangeSumMin  ;
	  datin >> fRangeSumMax  ;
	  cout << " range sum          :: " <<  fRangeSumMin << " : " << fRangeSumMax  << endl;
	}
      if(line.find("frequency")!=string::npos)
	{ 
	  datin >> fSamplingFreq  ;
	  cout << " sampling frequency :: " <<  fSamplingFreq << endl;
	}
      if(line.find("timebins")!=string::npos)
	{ 
	  datin >> fTimeBins  ;
	  cout << " timebins           :: " <<  fTimeBins << endl;
	}
      if(line.find("pedestal")!=string::npos)
	{ 
	  datin >> fPedestals  ;
	  cout << " pedestal scheme    :: " <<  fPedestals << endl;
	}
      if(line.find("main window size")!=string::npos)
	{ 
	  datin >> fMainXSize  ;
	  datin >> fMainYSize  ;
	  cout << " main window size   :: " <<  fMainXSize  << "  , " << fMainYSize <<  endl;
	}
      if(line.find("border size")!=string::npos)
	{ 
	  datin >> fBorderXSize  ; 
	  datin >> fBorderYSize  ;
	  cout << " border size        :: " <<  fBorderXSize  << "  , " << fBorderYSize <<  endl;
	}
    }
  cout << "////  Read Configuration done //// " << endl;
  SetMainSize(fMainXSize,fMainYSize,fBorderXSize,fBorderYSize) ;
}

//_______________________________________________________________________________________________________________
void AliTPCMonitorConfig::PrintConfig()
{
  // Print base configuration 
  
  cout << " /////// Configuration /////////////////////////////// " << endl;
  cout << " Timebins                :: " <<  fTimeBins                                   << endl;
  cout << " Range to det ADC max    :: " <<  fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
  cout << " Range to det Baseline   :: " <<  fRangeBaseMin   << " : " << fRangeBaseMax   << endl;
  cout << " Range to det ADC sum    :: " <<  fRangeSumMin    << " : " << fRangeSumMax    << endl;
  cout << " Pedestal setting        :: " <<  fPedestals                                  << endl;
  cout << " Sampling Frequency      :: " <<  fSamplingFreq                               << endl;
  cout << " Sector (Last)           :: " <<  fSector <<"  ("<< fSectorLast   <<")"       << endl; 
  cout << " Data Format             :: " <<  fFormat                                     << endl;
  cout << " File current            :: " <<  fFileCurrent                                << endl;
  
  if(fFileLastSet)  {      cout << " File last           :: " <<  fFileLast << endl;    }
  return;										  
  
}

//______________________________________________________________________________________________________________
Char_t* AliTPCMonitorConfig::GetLastProcFile()
{
  // Return name of last processed file
  // Get from file if written  
  if(!fFileLastSet)
    {
      Char_t fnlast[256];
      sprintf(fnlast,"AliTPCMonitorLastFile.txt");
      ifstream datin(fnlast);
      if(!datin.is_open()) {
        AliWarning("Could not read file containing  name of last processed file: Check permissions and path");
	sprintf(fFileLast,"%s","");
	fFileLastSet=0;
        return fFileLast;
      }
      datin >> fFileLast;
      datin.close(); 
      fFileLastSet=1;
    }
  return fFileLast;
}

//_______________________________________________________________________________________________________________
void AliTPCMonitorConfig::SetLastProcFile(Char_t* file)
{
  // Set name of last processed file 
  // Write name to a file 
  
  sprintf(fFileLast,file);
  Char_t fnlast[256];
  sprintf(fnlast,"AliTPCMonitorLastFile.txt");
  ofstream datout(fnlast);
  if(!datout) {  AliWarning("Could not write file containing name of last processed file: Check permissions and path");}
  datout << fFileLast << endl;
  datout.close();
  fFileLastSet =1;
}
Commit	Line	Data
48265b32	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	$Log$
fb3305d1	18	Revision 1.2 2007/10/12 13:36:27 cvetan
	19	Coding convention fixes from Stefan
	20
ca7b8371	21	Revision 1.1 2007/09/17 10:23:31 cvetan
	22	New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
	23
48265b32	24	*/
48265b32	25
fb3305d1	26	//////////////////////////////////////////////////////////////////////////
	27	////
	28	//// AliTPCMonitorConfig class
	29	////
	30	//// Configuration handler class for AliTPCMonitor
	31	////
	32	//// The basic configuration will be read from the file AliTPCMonitorConfig.txt
	33	//// and can be changed online via the Button "Conf. Ranges"
	34	//// Basic configuration settings are e.g. the range for the determination
	35	//// of the baseline, maximum adc value and the settings for the pedestal calculation.
	36	////
	37	//// Author: Stefan Kniege, IKF, Frankfurt
	38	////
	39	////
ca7b8371	40	/////////////////////////////////////////////////////////////////////////
	41
	42
48265b32	43	#include "AliTPCMonitorConfig.h"
ca7b8371	44	#include "AliLog.h"
	45	#include <Riostream.h>
	46
48265b32	47	ClassImp(AliTPCMonitorConfig)
48265b32	48
ca7b8371	49	// _______________________________________________________________________________________________________________
	50	AliTPCMonitorConfig::AliTPCMonitorConfig(const Char_t* name, const Char_t* title) :
	51	TNamed(name,title),
	52	fFormat(-1),
	53	fSector(0),
	54	fSectorLast(-1),
	55	fSectorLastDisplayed(-1),
	56	fSectorArr(new Int_t[36]),
	57	fFileLast(new Char_t[256]),
	58	fFileLastSet(0),
	59	fFileCurrent(new Char_t[256]),
	60	fEventNext(1),
	61	fEventNextID(1),
	62	fEventProcessed(0),
	63	fRangeMaxAdcMin(50),
	64	fRangeMaxAdcMax(100),
	65	fRangeBaseMin(300),
	66	fRangeBaseMax(600),
	67	fRangeSumMin(50),
	68	fRangeSumMax(100),
	69	fCanvasXSize(100),
	70	fCanvasYSize(100),
	71	fCanvasXSpace(10),
	72	fCanvasYSpace(10),
	73	fCanvasXOffset(130),
	74	fCanvasMainSize(200),
	75	fMainXSize(100),
	76	fMainYSize(600),
	77	fBorderXSize(10),
	78	fBorderYSize(10),
	79	fButtonXSize(100),
	80	fButtonYSize(20),
	81	fButtonFirstX1(10),
	82	fButtonFirstX2(50),
	83	fButtonFirstY(300),
	84	fWrite10Bit(0),
	85	fComponents(new Float_t[10]),
	86	fSamplingFreq(1000000),
	87	fPedestals(1),
	88	fNumOfChannels(16000),
	89	fTimeBins(1024),
	90	fMaxHwAddr(24000),
	91	fFitPulse(1),
fb3305d1	92	fProcOneSector(0)
48265b32	93	{
48265b32	94	// Constructor
ca7b8371	95	for(Int_t i =0; i<36; i++) { fSectorArr[i] = 0;}
ca7b8371	96	for(Int_t i =0; i<10;i++) { fComponents[i] =0.0;}
48265b32	97	SetMainSize(130,720,10,26 );
48265b32	98
	99	}
	100
	101
ca7b8371	102	//_______________________________________________________________________________________________________________
	103	AliTPCMonitorConfig::AliTPCMonitorConfig(const AliTPCMonitorConfig &config) :
	104	TNamed(config.GetName(),config.GetTitle()),
	105	fFormat(config.fFormat),
	106	fSector(config.fSector),
	107	fSectorLast(config.fSectorLast),
	108	fSectorLastDisplayed(config.fSectorLastDisplayed),
	109	fSectorArr(new Int_t[36]),
	110	fFileLast(new Char_t[strlen(config.fFileLast)+1]),
	111	fFileLastSet(config.fFileLastSet),
	112	fFileCurrent(new Char_t[strlen(config.fFileCurrent)+1]),
	113	fEventNext(config.fEventNext),
	114	fEventNextID(config.fEventNextID),
	115	fEventProcessed(config.fEventProcessed),
	116	fRangeMaxAdcMin(config.fRangeMaxAdcMin),
	117	fRangeMaxAdcMax(config.fRangeMaxAdcMax),
	118	fRangeBaseMin(config.fRangeBaseMin),
	119	fRangeBaseMax(config.fRangeBaseMax),
	120	fRangeSumMin(config.fRangeSumMin),
	121	fRangeSumMax(config.fRangeSumMax),
	122	fCanvasXSize(config.fCanvasXSize),
	123	fCanvasYSize(config.fCanvasYSize),
	124	fCanvasXSpace(config.fCanvasXSpace),
	125	fCanvasYSpace(config.fCanvasYSpace),
	126	fCanvasXOffset(config.fCanvasXOffset),
	127	fCanvasMainSize(config.fCanvasMainSize),
	128	fMainXSize(config.fMainXSize),
	129	fMainYSize(config.fMainYSize),
	130	fBorderXSize(config.fBorderXSize),
	131	fBorderYSize(config.fBorderYSize),
	132	fButtonXSize(config.fBorderXSize),
	133	fButtonYSize(config.fButtonYSize),
	134	fButtonFirstX1(config.fButtonFirstX1),
	135	fButtonFirstX2(config.fButtonFirstX2),
	136	fButtonFirstY(config.fButtonFirstY),
	137	fWrite10Bit(config.fWrite10Bit),
	138	fComponents(new Float_t[10]),
	139	fSamplingFreq(config.fSamplingFreq),
	140	fPedestals(config.fPedestals),
	141	fNumOfChannels(config.fNumOfChannels),
	142	fTimeBins(config.fTimeBins),
	143	fMaxHwAddr(config.fMaxHwAddr),
	144	fFitPulse(config.fFitPulse),
	145	fProcOneSector(config.fProcOneSector)
	146	{
	147	// copy constructor
	148	strcpy(fFileLast,config.fFileLast);
	149	strcpy(fFileCurrent,config.fFileCurrent);
	150
	151	for(Int_t i =0; i<36; i++) { fSectorArr[i] = 0;}
	152	for(Int_t i =0; i<10;i++) { fComponents[i] =0.0;}
	153
	154
	155	}
	156	//_______________________________________________________________________________________________________________
	157	AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig& config)
	158	{
	159	// assignement operator
	160	if(this!=&config){
	161	((TNamed *)this)->operator=(config);
	162	fFormat=config.fFormat;
	163	fSector=config.fSector;
	164	fSectorLast=config.fSectorLast;
	165	fSectorLastDisplayed=config.fSectorLastDisplayed;
166	fFileLastSet=config.fFileLastSet;
167	fEventNext=config.fEventNext;
168	fEventNextID=config.fEventNextID;
169	fEventProcessed=config.fEventProcessed;
170	fRangeMaxAdcMin=config.fRangeMaxAdcMin;
171	fRangeMaxAdcMax=config.fRangeMaxAdcMax;
172	fRangeBaseMin=config.fRangeBaseMin;
173	fRangeBaseMax=config.fRangeBaseMax;
174	fRangeSumMin=config.fRangeSumMin;
175	fRangeSumMax=config.fRangeSumMax;
176	fCanvasXSize=config.fCanvasXSize;
177	fCanvasYSize=config.fCanvasYSize;
178	fCanvasXSpace=config.fCanvasXSpace;
179	fCanvasYSpace=config.fCanvasYSpace;
180	fCanvasXOffset=config.fCanvasXOffset;
181	fCanvasMainSize=config.fCanvasMainSize;
182	fMainXSize=config.fMainXSize;
183	fMainYSize=config.fMainYSize;
184	fBorderXSize=config.fBorderXSize;
185	fButtonYSize=config.fButtonYSize;
186	fButtonFirstX1=config.fButtonFirstX1;
187	fButtonFirstX2=config.fButtonFirstX2;
188	fButtonFirstY=config.fButtonFirstY;
189	fWrite10Bit=config.fWrite10Bit;
190	fPedestals=config.fPedestals;
191	fNumOfChannels=config.fNumOfChannels;
192	fTimeBins=config.fTimeBins;
193	fMaxHwAddr=config.fMaxHwAddr;
194	fFitPulse=config.fFitPulse;
195	fProcOneSector=config.fProcOneSector;
196
197	fFileLast = new Char_t[strlen(config.fFileLast)+1];
198	strcpy(fFileLast,config.fFileLast);
199
200
201	fFileCurrent = new Char_t[strlen(config.fFileCurrent)+1];
202	strcpy(fFileCurrent,config.fFileCurrent);
203
204	fSectorArr = new Int_t[36]; for(Int_t i =0; i<36; i++) { fSectorArr[i] = 0;}
205	fComponents = new Float_t[10]; for(Int_t i =0; i<10;i++) { fComponents[i] =0.0;}
206
207
208	}
209	return *this;
210	}
211
212
48265b32	213	//_______________________________________________________________________________________________________________
	214	AliTPCMonitorConfig::~AliTPCMonitorConfig()
	215	{
	216	// Destructor
ca7b8371	217	delete[] fFileLast;
	218	delete[] fFileCurrent;
	219	delete[] fSectorArr;
	220	delete[] fComponents;
48265b32	221	}
	222
	223
	224	//_______________________________________________________________________________________________________________
	225	void AliTPCMonitorConfig::SetMainSize(Int_t mainx, Int_t mainy, Int_t borderx=10, Int_t bordery=26)
	226	{
	227	// Set Size of Main window, buttons and canvases
	228
	229
	230	// size of main frame ///////////////////////
	231	fMainXSize = mainx;
	232	fMainYSize = mainy;
	233
	234	// border size depending on window manager///
	235	fBorderXSize = borderx;
	236	fBorderYSize = bordery;
	237
	238	// y-pos of first sector button /////////////
	239	fButtonFirstY = (int) (0.50*fMainYSize);
	240
	241	// canvas size for Minitor Canvases ///////////////////////
	242	fCanvasMainSize = (Int_t)(fMainYSize/3);
	243
	244	fCanvasXSize = (int)fCanvasMainSize;
	245	fCanvasYSize = (int)fCanvasMainSize;
	246	fCanvasXSpace = (int)(-1*(fCanvasMainSize+ fBorderXSize ));
	247	fCanvasYSpace = (int)( fCanvasMainSize+ fBorderYSize );
	248	fCanvasXOffset = (int)(-1*(fMainXSize + fBorderXSize ));
	249
	250	// adjust main size in y ////////////////////
	251	fMainYSize = fMainYSize+fBorderYSize;
	252
	253	// y-size of the main window also defines ///
	254	fButtonXSize = (Int_t)(fMainXSize/2-10);
	255	fButtonYSize = (Int_t)fMainYSize/47;
	256	fButtonFirstX1 = 5;
	257	fButtonFirstX2 = fMainXSize/2+5;
	258
	259	}
	260
	261	//_______________________________________________________________________________________________________________
ca7b8371	262	void AliTPCMonitorConfig::SetBaseConfig(Float_t* confarr)
48265b32	263	{
ca7b8371	264	// Set base configuration stored in array confarr
48265b32	265
ca7b8371	266	fRangeBaseMin = (int)confarr[0];
ca7b8371	267	fRangeBaseMax = (int)confarr[1];
48265b32	268
ca7b8371	269	fRangeMaxAdcMin = (int)confarr[2];
ca7b8371	270	fRangeMaxAdcMax = (int)confarr[3];
48265b32	271
ca7b8371	272	fRangeSumMin = (int)confarr[4];
ca7b8371	273	fRangeSumMax = (int)confarr[5];
48265b32	274
	275	cout << " Set Ranges to : " << endl;
	276	cout << " range base :: " << fRangeBaseMin << "\t : " << fRangeBaseMax << endl;
	277	cout << " range adc max :: " << fRangeMaxAdcMin << "\t : " << fRangeMaxAdcMax << endl;
	278	cout << " range sum :: " << fRangeSumMin << "\t : " << fRangeSumMax << endl;
	279
	280	}
	281
	282	//_______________________________________________________________________________________________________________
	283	void AliTPCMonitorConfig::ReadConfig(Char_t* nameconf)
	284	{
	285	// Read base configuration from file
	286	// Update main window size
	287
77f88633	288	// string line;
48265b32	289	ifstream datin;
	290	datin.open(nameconf);
	291
	292	if(!datin) { AliWarning("Could not read configfile");}
	293
	294	cout << "//// Read Configuration ///////// " << endl;
	295	while(!datin.eof())
	296	{
	297	string line;
	298	getline(datin,line);
	299	if(line.find("max adc")!=string::npos)
	300	{
	301	datin >> fRangeMaxAdcMin ;
	302	datin >> fRangeMaxAdcMax ;
	303	cout << " range max :: " << fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
	304	}
	305
	306	if(line.find("baseline")!=string::npos)
	307	{
	308	datin >> fRangeBaseMin ;
	309	datin >> fRangeBaseMax ;
	310	cout << " range base :: " << fRangeBaseMin << " : " << fRangeBaseMax << endl;
	311	}
	312	if(line.find("adc sum")!=string::npos)
	313	{
	314	datin >> fRangeSumMin ;
	315	datin >> fRangeSumMax ;
	316	cout << " range sum :: " << fRangeSumMin << " : " << fRangeSumMax << endl;
	317	}
	318	if(line.find("frequency")!=string::npos)
	319	{
	320	datin >> fSamplingFreq ;
	321	cout << " sampling frequency :: " << fSamplingFreq << endl;
	322	}
	323	if(line.find("timebins")!=string::npos)
	324	{
	325	datin >> fTimeBins ;
	326	cout << " timebins :: " << fTimeBins << endl;
	327	}
	328	if(line.find("pedestal")!=string::npos)
	329	{
	330	datin >> fPedestals ;
	331	cout << " pedestal scheme :: " << fPedestals << endl;
	332	}
	333	if(line.find("main window size")!=string::npos)
	334	{
	335	datin >> fMainXSize ;
	336	datin >> fMainYSize ;
	337	cout << " main window size :: " << fMainXSize << " , " << fMainYSize << endl;
	338	}
	339	if(line.find("border size")!=string::npos)
	340	{
	341	datin >> fBorderXSize ;
	342	datin >> fBorderYSize ;
	343	cout << " border size :: " << fBorderXSize << " , " << fBorderYSize << endl;
	344	}
	345	}
	346	cout << "//// Read Configuration done //// " << endl;
	347	SetMainSize(fMainXSize,fMainYSize,fBorderXSize,fBorderYSize) ;
	348	}
	349
	350	//_______________________________________________________________________________________________________________
	351	void AliTPCMonitorConfig::PrintConfig()
	352	{
353	// Print base configuration
354
355	cout << " /////// Configuration /////////////////////////////// " << endl;
356	cout << " Timebins :: " << fTimeBins << endl;
357	cout << " Range to det ADC max :: " << fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
358	cout << " Range to det Baseline :: " << fRangeBaseMin << " : " << fRangeBaseMax << endl;
359	cout << " Range to det ADC sum :: " << fRangeSumMin << " : " << fRangeSumMax << endl;
360	cout << " Pedestal setting :: " << fPedestals << endl;
361	cout << " Sampling Frequency :: " << fSamplingFreq << endl;
362	cout << " Sector (Last) :: " << fSector <<" ("<< fSectorLast <<")" << endl;
363	cout << " Data Format :: " << fFormat << endl;
364	cout << " File current :: " << fFileCurrent << endl;
365
366	if(fFileLastSet) { cout << " File last :: " << fFileLast << endl; }
367	return;
368
369	}
370
371	//______________________________________________________________________________________________________________
372	Char_t* AliTPCMonitorConfig::GetLastProcFile()
373	{
374	// Return name of last processed file
375	// Get from file if written
376	if(!fFileLastSet)
377	{
378	Char_t fnlast[256];
379	sprintf(fnlast,"AliTPCMonitorLastFile.txt");
380	ifstream datin(fnlast);
ac940b58	381	if(!datin.is_open()) {
	382	AliWarning("Could not read file containing name of last processed file: Check permissions and path");
	383	sprintf(fFileLast,"%s","");
	384	fFileLastSet=0;
	385	return fFileLast;
	386	}
48265b32	387	datin >> fFileLast;
	388	datin.close();
	389	fFileLastSet=1;
	390	}
	391	return fFileLast;
	392	}
	393
	394	//_______________________________________________________________________________________________________________
	395	void AliTPCMonitorConfig::SetLastProcFile(Char_t* file)
	396	{
	397	// Set name of last processed file
	398	// Write name to a file
	399
	400	sprintf(fFileLast,file);
	401	Char_t fnlast[256];
	402	sprintf(fnlast,"AliTPCMonitorLastFile.txt");
	403	ofstream datout(fnlast);
	404	if(!datout) { AliWarning("Could not write file containing name of last processed file: Check permissions and path");}
	405	datout << fFileLast << endl;
	406	datout.close();
	407	fFileLastSet =1;
	408	}