[u/mrichter/AliRoot.git] / MUON / mapping / AliMpDataProcessor.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$
//
// Category: basic

//-----------------------------------------------------------------------------
// Class AliMpDataProcessor
// -----------------------
// Class for converting ASCII data files in the map of string
// Author: Ivana Hrivnacova, IPN Orsay
//-----------------------------------------------------------------------------

#include "AliMpDataProcessor.h"
#include "AliMpDataMap.h"
#include "AliMpFiles.h"

#include "AliLog.h"

#include <TSystem.h>
#include <TObjString.h>
#include <TFile.h>
#include <Riostream.h>

#include <fstream>
#include <sstream>
#include <map>

//
// static private methods
//

//_____________________________________________________________________________
const TString& AliMpDataProcessor::GetHeaderFileName() 
{
  /// Return the default name for generated header file
  static const TString kHeaderFileName = "add.h";
  return kHeaderFileName;
}    

//_____________________________________________________________________________
const TString& AliMpDataProcessor::GetImplFileName() 
{
  /// Return the default name for generated implementation file
  static const TString kImplFileName = "add.cxx";
  return kImplFileName;
}  

//
// ctors, dtor
//

//_____________________________________________________________________________
AliMpDataProcessor::AliMpDataProcessor()
  : TObject(),
    fCounter(0),
    fHeaderFile(),
    fImplFile()
{
/// Default and standar constructor

  fHeaderFile.open(GetHeaderFileName().Data(), std::ios::out);
  fImplFile.open(GetImplFileName().Data(), std::ios::out);
  
  // Add check

}

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

}

//
// private methods
//


//_____________________________________________________________________________
void AliMpDataProcessor::ProcessDirectory(const TString& path, 
                                          AliMpDataMap* dataMap) 
{
/// Recursive function to process data directory
  
  AliDebugStream(2) << "ProcessDirectory " << path.Data() << endl;

  // skip some directories
  //if ( path.Contains("manu_serial") ) return;
  //if ( path.Contains("stationTrigger") ) return;
  
  gSystem->cd(path);
  gSystem->Exec("ls > /tmp/mpfiles.txt");
  
  ifstream mpfiles("/tmp/mpfiles.txt");
  TString mpfilesStr;
  TString fileName;
  while ( mpfiles >> fileName ) {
    mpfilesStr += fileName.Data();
    mpfilesStr += " ";
  }  

  istringstream mpFilesStream(mpfilesStr.Data());
  while ( mpFilesStream >> fileName ) {
    TString filePath = path + "/" + fileName;
    if ( gSystem->OpenDirectory(filePath.Data()) )
      ProcessDirectory(filePath, dataMap);
    else
      ProcessFile(filePath, dataMap);
  }  

  AliDebugStream(2) << "ProcessDirectory done " << path.Data() << endl;
} 

//_____________________________________________________________________________
void AliMpDataProcessor::ProcessFile(const TString& path, AliMpDataMap* dataMap) 
{
/// Dump the content of the file specified by its path
/// in a string and fill it in the dataMap

  // cut top path
  string top = AliMpFiles::GetTop().Data();
  string fullDataPath = path.Data();
  string dataPath = fullDataPath;
  if ( dataPath.find(top) != string::npos ) dataPath.erase(0, top.size()+1);
  dataPath.erase(0,dataPath.find('/')+1); 
  
  AliDebugStream(2) << "Processing file " << dataPath << endl;

  // skip macros
  if ( dataPath.find(".C") != std::string::npos || 
       dataPath.find(".h") != std::string::npos ) return;
 
  ifstream input(path.Data(), ios::in);
  if ( ! input.is_open() ) {
    cerr << "Cannot open input file " << path.Data() << endl;
    return;
  }  

  string fileString;
  string line;

  do {
    getline(input, line);
    if ( ! input.eof() ) { 
      fileString += line;
      fileString += '\n';
    }  
  }
  while ( ! input.eof() );

  dataMap->Add(dataPath, fileString);
  // dataMap->Add(new TObjString(dataPath.c_str()), new TObjString(fileString.c_str()));
}  

//_____________________________________________________________________________
void AliMpDataProcessor::GenerateFunction(const TString& path, 
                                          const TString& data) 
{
/// Generate a C++ function which defines a string with the data content 
/// and map it to the given path in the map

  AliDebugStream(2) << "Processing path " << path.Data() << endl;

  // skip motif & padPos
  //if ( dataPath.find("motif") != std::string::npos || 
  //     dataPath.find("padPos") != std::string::npos ) return;
 
  // add function declaration in the header file name
  fHeaderFile << "    void AddData" << ++fCounter << "();" << endl;

  // add function implementation in .cxx
  fImplFile 
    << "//_____________________________________________________________________________" << endl
    << "void AliMpDataMap::AddData" << fCounter << "()" << endl
    << "{" << endl
    << "/// Automatically generated function for data file: " << endl
    << "/// " << path << endl
    << endl
    << "  string path = \"" << path << "\";" << endl << endl;
    
  GenerateFileCode(data);
  
  fImplFile 
    << endl
    << "  fMap[path] = data;" << endl
    << "}" << endl
    << endl;      
} 

//_____________________________________________________________________________
void AliMpDataProcessor::GenerateFileCode(const TString& data) 
{
/// Dump the content of the file specified by its path as a C++ string

  istringstream in(data.Data());

  string line;
  getline(in, line);
  fImplFile << "  string data = \""; 
  //for ( unsigned int i=line.size(); i<58; i++ ) line = line + " ";
  fImplFile << line << " \\n\";";
  if ( in.eof() ) return; 

  do {
    getline(in, line);
    if ( ! in.eof() ) { 
      fImplFile << endl << "  data = data + \"";
      // for ( unsigned int i=line.size(); i<58; i++ ) line = line + " ";
      fImplFile << line << " \\n\";";
    }  
  }
  while ( ! in.eof() );

  fImplFile << endl;
}  

//_____________________________________________________________________________
void AliMpDataProcessor::GenerateFill()
{
/// Generate function which calls all previously generated functions

  // add function declaration in the header file name
  fHeaderFile << endl << "    void Fill();" << endl;

  // add function implementation in .cxx
  fImplFile 
    << "//_____________________________________________________________________________" << endl
    << "void AliMpDataMap::Fill()" << endl
    << "{" << endl
    << "/// Automatically generated function for calling all generated functions " << endl
    << endl;
    
  for ( Int_t i=1; i<=fCounter; ++i ) 
   fImplFile << "  AddData" << i << "();" << endl;   
      
  fImplFile << "}" << endl;
}  
      

//
// public methods
//


//_____________________________________________________________________________
AliMpDataMap* AliMpDataProcessor::CreateDataMap(const TString& dataDir) 
{
/// Process data directory and map a string with the content of each file to
/// the file path.

  TString curDir = gSystem->pwd();
  
  AliMpDataMap* dataMap = new AliMpDataMap();

  TString dataPath = AliMpFiles::GetTop() + "/" + dataDir;
  ProcessDirectory(dataPath, dataMap); 
  
  gSystem->cd(curDir); 
  
  return dataMap;
}
  

//_____________________________________________________________________________
Bool_t AliMpDataProcessor::GenerateData(AliMpDataMap* dataMap,
                                        const TString& outputDataDir) 
{
/// Generate ASCII data files in outputDataDir from dataMap

  TString curDir = gSystem->pwd();  

  TString outputDataPath = AliMpFiles::GetTop() + "/" + outputDataDir;
  if ( gSystem->OpenDirectory(outputDataPath.Data()) ) {
    AliErrorStream() 
      << "Directory " << outputDataPath.Data() << " already exists" << endl;
    return kFALSE;
  }
  else {
    AliDebugStream(2) << "Making directory " <<  outputDataPath.Data() << endl;
    gSystem->mkdir(outputDataPath.Data());
  }  
  
/*
  // std::map implementation

  const map<string, string>& kMap = dataMap->GetMap();
  map<string, string>::const_iterator it;
  
  for ( it = kMap.begin(); it != kMap.end(); it++ ) {
    string path = it->first;
    string data = it->second; 
*/    

  const TMap& kMap = dataMap->GetMap();
  TMapIter it(&kMap);
  TObject* keyObj;
  while ( ( keyObj = it.Next() ) ) {

    TString tpath = ((TObjString*)keyObj)->String();

    TObject* dataObj = kMap.GetValue(keyObj);
    if ( ! dataObj ) {
      AliErrorStream() 
        << "Cannot find value when iterating over map." << endl;
      return kFALSE;
    }      
    TString tdata = ((TObjString*)dataObj)->String();   
  
    string path = tpath.Data();
    string data = tdata.Data(); 
  
    string::size_type slashPos =  path.find_last_of("/");
    if ( slashPos != string::npos ) {
      string dataDir(path, 0, slashPos);
      TString dataDirPath
        = outputDataPath + "/" + dataDir.c_str();
      if ( ! gSystem->OpenDirectory(dataDirPath.Data()) ) {
        AliDebugStream(2) << "Making directory " <<  dataDirPath.Data() << endl;
        gSystem->mkdir(dataDirPath.Data(), kTRUE);
      }
    }     

    TString dataPath
      = outputDataPath + "/" + path.c_str();

    ofstream out(dataPath.Data(), ios::out);
    if ( ! out.good() ) {
      AliErrorStream() 
        << "Cannot open output file  " << outputDataPath.Data() << endl;
   
      return kFALSE;  
    }
    
    out << data;
    out.close();
  }

  delete dataMap;
  return kTRUE;
}
  
//_____________________________________________________________________________
Bool_t AliMpDataProcessor::GenerateCode(AliMpDataMap* dataMap) 
{
/// Generate C++ code from dataMap.
/// <pre>
/// AliMpDataProcessor mp;
/// AliMpDataMap* dataMap = mp.CreateDataMap();
/// mp.GenerateCode(dataMap);
/// </pre>
/// Not really used, but kept for eventual future explorations.

/*
  // std::map implementation

  const map<string, string>& kMap = dataMap->GetMap();
  map<string, string>::const_iterator it;
  
  for ( it = kMap.begin(); it != kMap.end(); it++ ) {
    string path = it->first;
    string data = it->second; 
*/

  const TMap& kMap = dataMap->GetMap();
  TMapIter it(&kMap);
  TObject* keyObj;
  while ( ( keyObj = it.Next() ) ) {

    TString tpath = ((TObjString*)keyObj)->String();

    TObject* dataObj = kMap.GetValue(keyObj);
    if ( ! dataObj ) {
      AliErrorStream() 
        << "Cannot find value when iterating over map." << endl;
      return kFALSE;
    }      
    TString tdata = ((TObjString*)dataObj)->String();   
  
    GenerateFunction(tpath, tdata);
  }
  
  GenerateFill();

  return kTRUE;
}
Commit	Line	Data
228fd720	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	// Category: basic
	19
	20	//-----------------------------------------------------------------------------
	21	// Class AliMpDataProcessor
	22	// -----------------------
	23	// Class for converting ASCII data files in the map of string
	24	// Author: Ivana Hrivnacova, IPN Orsay
	25	//-----------------------------------------------------------------------------
	26
	27	#include "AliMpDataProcessor.h"
	28	#include "AliMpDataMap.h"
	29	#include "AliMpFiles.h"
	30
	31	#include "AliLog.h"
	32
	33	#include <TSystem.h>
	34	#include <TObjString.h>
	35	#include <TFile.h>
	36	#include <Riostream.h>
	37
	38	#include <fstream>
	39	#include <sstream>
	40	#include <map>
	41
31edb2d7	42	//
	43	// static private methods
	44	//
	45
	46	//_____________________________________________________________________________
	47	const TString& AliMpDataProcessor::GetHeaderFileName()
	48	{
	49	/// Return the default name for generated header file
	50	static const TString kHeaderFileName = "add.h";
	51	return kHeaderFileName;
	52	}
228fd720	53
31edb2d7	54	//_____________________________________________________________________________
	55	const TString& AliMpDataProcessor::GetImplFileName()
	56	{
	57	/// Return the default name for generated implementation file
	58	static const TString kImplFileName = "add.cxx";
	59	return kImplFileName;
	60	}
	61
	62	//
	63	// ctors, dtor
	64	//
228fd720	65
	66	//_____________________________________________________________________________
	67	AliMpDataProcessor::AliMpDataProcessor()
	68	: TObject(),
	69	fCounter(0),
	70	fHeaderFile(),
	71	fImplFile()
	72	{
	73	/// Default and standar constructor
	74
31edb2d7	75	fHeaderFile.open(GetHeaderFileName().Data(), std::ios::out);
31edb2d7	76	fImplFile.open(GetImplFileName().Data(), std::ios::out);
228fd720	77
	78	// Add check
	79
	80	}
	81
	82	//_____________________________________________________________________________
	83	AliMpDataProcessor:: ~AliMpDataProcessor()
	84	{
	85	/// Destructor
	86
	87	}
	88
	89	//
	90	// private methods
	91	//
	92
	93
	94	//_____________________________________________________________________________
	95	void AliMpDataProcessor::ProcessDirectory(const TString& path,
	96	AliMpDataMap* dataMap)
	97	{
	98	/// Recursive function to process data directory
	99
	100	AliDebugStream(2) << "ProcessDirectory " << path.Data() << endl;
	101
	102	// skip some directories
	103	//if ( path.Contains("manu_serial") ) return;
	104	//if ( path.Contains("stationTrigger") ) return;
	105
	106	gSystem->cd(path);
	107	gSystem->Exec("ls > /tmp/mpfiles.txt");
	108
	109	ifstream mpfiles("/tmp/mpfiles.txt");
	110	TString mpfilesStr;
	111	TString fileName;
	112	while ( mpfiles >> fileName ) {
	113	mpfilesStr += fileName.Data();
	114	mpfilesStr += " ";
	115	}
	116
	117	istringstream mpFilesStream(mpfilesStr.Data());
	118	while ( mpFilesStream >> fileName ) {
	119	TString filePath = path + "/" + fileName;
	120	if ( gSystem->OpenDirectory(filePath.Data()) )
	121	ProcessDirectory(filePath, dataMap);
	122	else
	123	ProcessFile(filePath, dataMap);
	124	}
	125
	126	AliDebugStream(2) << "ProcessDirectory done " << path.Data() << endl;
	127	}
	128
	129	//_____________________________________________________________________________
	130	void AliMpDataProcessor::ProcessFile(const TString& path, AliMpDataMap* dataMap)
	131	{
	132	/// Dump the content of the file specified by its path
	133	/// in a string and fill it in the dataMap
	134
	135	// cut top path
	136	string top = AliMpFiles::GetTop().Data();
	137	string fullDataPath = path.Data();
ab167304	138	string dataPath = fullDataPath;
	139	if ( dataPath.find(top) != string::npos ) dataPath.erase(0, top.size()+1);
	140	dataPath.erase(0,dataPath.find('/')+1);
228fd720	141
	142	AliDebugStream(2) << "Processing file " << dataPath << endl;
	143
	144	// skip macros
	145	if ( dataPath.find(".C") != std::string::npos \|\|
	146	dataPath.find(".h") != std::string::npos ) return;
	147
	148	ifstream input(path.Data(), ios::in);
	149	if ( ! input.is_open() ) {
	150	cerr << "Cannot open input file " << path.Data() << endl;
	151	return;
	152	}
	153
	154	string fileString;
	155	string line;
	156
	157	do {
	158	getline(input, line);
	159	if ( ! input.eof() ) {
	160	fileString += line;
	161	fileString += '\n';
	162	}
	163	}
	164	while ( ! input.eof() );
	165
	166	dataMap->Add(dataPath, fileString);
	167	// dataMap->Add(new TObjString(dataPath.c_str()), new TObjString(fileString.c_str()));
	168	}
	169
	170	//_____________________________________________________________________________
	171	void AliMpDataProcessor::GenerateFunction(const TString& path,
	172	const TString& data)
	173	{
	174	/// Generate a C++ function which defines a string with the data content
	175	/// and map it to the given path in the map
	176
	177	AliDebugStream(2) << "Processing path " << path.Data() << endl;
	178
	179	// skip motif & padPos
	180	//if ( dataPath.find("motif") != std::string::npos \|\|
	181	// dataPath.find("padPos") != std::string::npos ) return;
	182
	183	// add function declaration in the header file name
	184	fHeaderFile << " void AddData" << ++fCounter << "();" << endl;
	185
	186	// add function implementation in .cxx
	187	fImplFile
	188	<< "//_____________________________________________________________________________" << endl
	189	<< "void AliMpDataMap::AddData" << fCounter << "()" << endl
	190	<< "{" << endl
	191	<< "/// Automatically generated function for data file: " << endl
	192	<< "/// " << path << endl
	193	<< endl
	194	<< " string path = \"" << path << "\";" << endl << endl;
	195
	196	GenerateFileCode(data);
	197
	198	fImplFile
	199	<< endl
	200	<< " fMap[path] = data;" << endl
	201	<< "}" << endl
	202	<< endl;
	203	}
	204
205	//_____________________________________________________________________________
206	void AliMpDataProcessor::GenerateFileCode(const TString& data)
207	{
208	/// Dump the content of the file specified by its path as a C++ string
209
210	istringstream in(data.Data());
211
212	string line;
213	getline(in, line);
214	fImplFile << " string data = \"";
215	//for ( unsigned int i=line.size(); i<58; i++ ) line = line + " ";
216	fImplFile << line << " \\n\";";
217	if ( in.eof() ) return;
218
219	do {
220	getline(in, line);
221	if ( ! in.eof() ) {
222	fImplFile << endl << " data = data + \"";
223	// for ( unsigned int i=line.size(); i<58; i++ ) line = line + " ";
224	fImplFile << line << " \\n\";";
225	}
226	}
227	while ( ! in.eof() );
228
229	fImplFile << endl;
230	}
231
232	//_____________________________________________________________________________
233	void AliMpDataProcessor::GenerateFill()
234	{
235	/// Generate function which calls all previously generated functions
236
237	// add function declaration in the header file name
238	fHeaderFile << endl << " void Fill();" << endl;
239
240	// add function implementation in .cxx
241	fImplFile
242	<< "//_____________________________________________________________________________" << endl
243	<< "void AliMpDataMap::Fill()" << endl
244	<< "{" << endl
245	<< "/// Automatically generated function for calling all generated functions " << endl
246	<< endl;
247
248	for ( Int_t i=1; i<=fCounter; ++i )
249	fImplFile << " AddData" << i << "();" << endl;
250
251	fImplFile << "}" << endl;
252	}
253
254
255	//
256	// public methods
257	//
258
259
260	//_____________________________________________________________________________
261	AliMpDataMap* AliMpDataProcessor::CreateDataMap(const TString& dataDir)
262	{
263	/// Process data directory and map a string with the content of each file to
264	/// the file path.
265
266	TString curDir = gSystem->pwd();
ab167304	267
228fd720	268	AliMpDataMap* dataMap = new AliMpDataMap();
	269
	270	TString dataPath = AliMpFiles::GetTop() + "/" + dataDir;
	271	ProcessDirectory(dataPath, dataMap);
	272
	273	gSystem->cd(curDir);
	274
	275	return dataMap;
	276	}
	277
	278
	279	//_____________________________________________________________________________
	280	Bool_t AliMpDataProcessor::GenerateData(AliMpDataMap* dataMap,
	281	const TString& outputDataDir)
	282	{
	283	/// Generate ASCII data files in outputDataDir from dataMap
	284
	285	TString curDir = gSystem->pwd();
	286
	287	TString outputDataPath = AliMpFiles::GetTop() + "/" + outputDataDir;
	288	if ( gSystem->OpenDirectory(outputDataPath.Data()) ) {
	289	AliErrorStream()
	290	<< "Directory " << outputDataPath.Data() << " already exists" << endl;
	291	return kFALSE;
	292	}
	293	else {
	294	AliDebugStream(2) << "Making directory " << outputDataPath.Data() << endl;
	295	gSystem->mkdir(outputDataPath.Data());
	296	}
	297
	298	/*
	299	// std::map implementation
	300
	301	const map<string, string>& kMap = dataMap->GetMap();
	302	map<string, string>::const_iterator it;
	303
	304	for ( it = kMap.begin(); it != kMap.end(); it++ ) {
	305	string path = it->first;
	306	string data = it->second;
	307	*/
	308
	309	const TMap& kMap = dataMap->GetMap();
	310	TMapIter it(&kMap);
	311	TObject* keyObj;
	312	while ( ( keyObj = it.Next() ) ) {
	313
	314	TString tpath = ((TObjString*)keyObj)->String();
	315
	316	TObject* dataObj = kMap.GetValue(keyObj);
	317	if ( ! dataObj ) {
	318	AliErrorStream()
	319	<< "Cannot find value when iterating over map." << endl;
	320	return kFALSE;
	321	}
	322	TString tdata = ((TObjString*)dataObj)->String();
	323
	324	string path = tpath.Data();
	325	string data = tdata.Data();
	326
76e1274b	327	string::size_type slashPos = path.find_last_of("/");
	328	if ( slashPos != string::npos ) {
	329	string dataDir(path, 0, slashPos);
228fd720	330	TString dataDirPath
	331	= outputDataPath + "/" + dataDir.c_str();
	332	if ( ! gSystem->OpenDirectory(dataDirPath.Data()) ) {
	333	AliDebugStream(2) << "Making directory " << dataDirPath.Data() << endl;
	334	gSystem->mkdir(dataDirPath.Data(), kTRUE);
	335	}
	336	}
	337
	338	TString dataPath
	339	= outputDataPath + "/" + path.c_str();
	340
	341	ofstream out(dataPath.Data(), ios::out);
	342	if ( ! out.good() ) {
	343	AliErrorStream()
	344	<< "Cannot open output file " << outputDataPath.Data() << endl;
	345
	346	return kFALSE;
	347	}
	348
	349	out << data;
	350	out.close();
	351	}
	352
	353	delete dataMap;
	354	return kTRUE;
	355	}
	356
	357	//_____________________________________________________________________________
	358	Bool_t AliMpDataProcessor::GenerateCode(AliMpDataMap* dataMap)
	359	{
	360	/// Generate C++ code from dataMap.
	361	/// <pre>
	362	/// AliMpDataProcessor mp;
	363	/// AliMpDataMap* dataMap = mp.CreateDataMap();
	364	/// mp.GenerateCode(dataMap);
	365	/// </pre>
	366	/// Not really used, but kept for eventual future explorations.
	367
	368	/*
	369	// std::map implementation
	370
	371	const map<string, string>& kMap = dataMap->GetMap();
	372	map<string, string>::const_iterator it;
	373
	374	for ( it = kMap.begin(); it != kMap.end(); it++ ) {
	375	string path = it->first;
	376	string data = it->second;
	377	*/
	378
	379	const TMap& kMap = dataMap->GetMap();
	380	TMapIter it(&kMap);
	381	TObject* keyObj;
	382	while ( ( keyObj = it.Next() ) ) {
	383
	384	TString tpath = ((TObjString*)keyObj)->String();
	385
	386	TObject* dataObj = kMap.GetValue(keyObj);
	387	if ( ! dataObj ) {
	388	AliErrorStream()
	389	<< "Cannot find value when iterating over map." << endl;
	390	return kFALSE;
	391	}
	392	TString tdata = ((TObjString*)dataObj)->String();
	393
394	GenerateFunction(tpath, tdata);
395	}
396
397	GenerateFill();
398
399	return kTRUE;
400	}
401
402