yoda/event/PamelaRun.cpp

/** @file
 * $Author: kusanagi $
 * $Date: 2004/07/06 13:31:14 $
 * $Revision: 1.2 $
 * 
 * Implementation of the PamelaRun class.
 */
#include <iostream>
#include <iomanip>
#include <sstream>
#include <list>
#include <exception>
#include <string>

#include <log4cpp/Category.hh>

#include <TFile.h>  //Substituted by Maurizio 05 Feb 2004
#include <TTree.h>  //Substituted by Maurizio 05 Feb 2004
#include <TChain.h> //Substituted by Maurizio 05 Feb 2004
#include <TKey.h>   //Substituted by Maurizio 05 Feb 2004
#include <TList.h>  //Substituted by Maurizio 05 Feb 2004


#include "PamelaRun.h"
#include "EventHeader.h"
#include "Algorithm.h"
#include "AlgorithmInfo.h"
#include "Exception.h"
extern "C" {
#include "DirectoryStructure.h"
#include <dirent.h>
}

using namespace pamela;

static log4cpp::Category& cat = log4cpp::Category::getInstance("pamela.PamelaRun");

/**
 * Get the run name according to a certain run number.
 * @param run Run number.
 * @return a string with the run name.
 */
std::string PamelaRun::GetRunName(int run) {
  std::ostringstream t_Stream;
  t_Stream << std::setw( 4 ) << std::setfill( '0' ) << run;
  return "Run" + t_Stream.str();
  //return std::string("aa");
}

/**
 * Check if the run number is already assigned
 * @param int run - Number of the run to check
 * @return int
 */
/*int PamelaRun::RunExists(int run) throw (std::exception){
 int res;
 DIR *dirp;
 std::string pathDir((char*)getenv("YODA_DATA"));
 pathDir = pathDir + "/";
 pathDir = pathDir + GetRunName(run);
// Open the directory
if ((dirp = opendir(pathDir.c_str())) == NULL) {
res = 0;
} else {
closedir(dirp);
res = 1;
}
return res;
}*/


/**
 * Check if the run number is already assigned
 * @param int run - Number of the run to check
 * @return int
 */
 std::string PamelaRun::RunExists(std::string input) throw (std::exception){
 int res;
 DIR *dirp;
 std::string fileName;
 std::string pathDir((char*)getenv("YODA_DATA"));
 std::string tempName;
 std::string::size_type pos;
 std::ostringstream t_Stream;

 pos = input.find_last_of("/");
 //if ((pos == std::string::npos) && !input.empty()) ;//throw Exception("Directories not allowed....");
 fileName = input.substr(pos+1);
 pos = fileName.find_last_of(".");
 fileName = fileName.substr(0,pos);
 pathDir = pathDir + "/";
 tempName = pathDir + fileName;
 
 int i = 0;
 while (res){
    if ((dirp = opendir(tempName.c_str())) == NULL) {
        res = 0;
    } else {
        closedir(dirp);
        t_Stream.str(""); 
        t_Stream << std::setw( 2 ) << std::setfill( '0' ) << ++i;
        tempName = pathDir + fileName + t_Stream.str() ;
        res = 1;
    }
 }
return (fileName + t_Stream.str());
}

/**
 * Create a new Pamela run. 
 * @param run Run number
 * @param path Base path name to the data
 */
PamelaRun::PamelaRun(std::string fileName, std::string path):
  Path(path), 
  RunNumber(1){ //veirificare se è possibilie eliminare questa variabile
  Run = RunExists(fileName);
  info = RunInfo(this);
  cat <<  log4cpp::Priority::DEBUG
      <<  "Constructor"
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
}

/**
 * Get the directory name that contains the files of a certain event
 * type for this run.
 * @param type the packet type.
 * @return the complete path for this event type.
 */
std::string PamelaRun::GetDirName(PacketType const * type) const {
  std::string EventType = type->GetName();
  return Path + "/" + Run + "/" + EventType;
}

/**
 * Get the file name for a certain event type.
 * @param type subpacket type.
 * @param name subpacket name.
 * @return the complete path and file name.
 */
std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) const {
  if (type->IsDetectorSpecific()) {
    return GetDirName(type->GetPacketType()) + "/" 
      + type->GetSubDetector()->GetName() + "/" 
      + Run + "." + type->GetPacketType()->GetName() + "." 
      + type->GetSubDetector()->GetName() + "." 
      + name + ".root";
  } else {
    return GetDirName(type->GetPacketType()) + "/" 
      + Run + "." + type->GetPacketType()->GetName() + "."
      + name + ".root";
  }
}

/**
 * Get the file name for a certain event type.
 * @param type subpacket type.
 * @return the complete path and file name.
 */
std::string PamelaRun::GetFileName(const SubPacket* type) const {
  return GetFileName(type, type->GetSubPacketName());
}

/**
 * Get the branch name that corresponds to a certain
 * subpacket. Usually, this is the name of the subpacket.
 * @param type subpacket type.
 * @return the corresponding branch name.
 */
static std::string GetDefaultBranchName(const SubPacket* type) {
  return type->GetSubPacketName();
}

/**
 * Get the tree name for a certain subpacket. This is the name of the
 * subdetector for detector specific subpackets, and the packet name
 * ("Physics" etc.) for common packets.
 * @param type the packet type.
 * @return the corresponding tree name.
 */
static std::string GetTreeName(const SubPacket* type) {
  if (type->IsDetectorSpecific()) {
    return type->GetSubDetector()->GetName();
  } else {
    return type->GetPacketType()->GetName();
  }
}

/**
 * Get a list of all root files from a certain path.
 * @param path Path name to start the search.
 * @return A list of all file names.
 */
static std::list<std::string> GetRootFiles(std::string path) throw (std::exception) {
  std::list<std::string> files;
  DIR *dir = opendir(path.c_str());
  if (dir == 0) {
    cat <<  log4cpp::Priority::DEBUG
        <<  "Could not open " << path
        <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    throw Exception("Could not open " + path);
  }
  
  for (struct dirent *d = readdir(dir); d != NULL; d = readdir(dir)) {
    if ((strcmp(".",d->d_name) == 0) || (strcmp("..",d->d_name) == 0))
      continue;
    std::string filename = path + "/" + d->d_name;
    struct stat buf;
    stat(filename.c_str(), &buf);
    if S_ISDIR(buf.st_mode) {
      std::list<std::string>toAdd = GetRootFiles(filename);
      files.insert(files.end(), toAdd.begin(), toAdd.end());
    } else if ((filename.substr(filename.size()-5, filename.size()) 
                == ".root")                                 // correct suffix
               && (!isdigit(filename[filename.size()-6]))) {  // base file
      std::string nextfilename = filename;
      nextfilename.insert(filename.size()-5, "_1");
      if (stat(nextfilename.c_str(), &buf) == 0) {
        filename.insert(filename.size()-5, "*");
      }
      cat <<  log4cpp::Priority::DEBUG
          <<  "Using " << filename
          <<  "\n " << log4cpp::CategoryStream::ENDLINE;
      files.push_back(filename);
    }
  }
  return files;
}

/**
 * Helper function to open the ROOT TTree of the header within the run 
 * framework.
 * @param type The packet type.
 * @return the ROOT TTree.
 */ 
TChain* PamelaRun::ReadHeaderTree(const PacketType *type) 
  throw (std::exception) {
  EventHeader header(type);
  std::string FileName = GetFileName(&header);
  std::string TreeName = GetTreeName(&header);
  TChain *tree = new TChain(TreeName.c_str());
  tree->Add(FileName.c_str());
  return tree;
}

/**
 * All add trees of a file as friend to a given tree. The tree name of
 * each tree found in the file is used as the name of the friend alias.
 * @param tree The base tree to add all other as friends.
 * @param FileName The name of the file with other trees.
 */
static void AddAllAsFriend(TChain* tree, std::string FileName) {
  std::string BaseFileName = FileName;
  bool HaveChain = false;
  if (BaseFileName[BaseFileName.size()-6] == '*') {
    BaseFileName.erase(BaseFileName.size()-6, 1);
    HaveChain = true;
  }
  TFile* File = new TFile(BaseFileName.c_str(), "read");
  if (!File->IsOpen()) {
    cat <<  log4cpp::Priority::WARN
        <<  "Could not open file " << BaseFileName << " for reading."
        <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    return;
  }
  TList* list = File->GetListOfKeys();
  if (HaveChain) {
    for (TIter i(list); TKey* k = (TKey*)i();) {
      if (std::string(TTree::Class()->GetName()) == k->GetClassName()) {
        std::string TreeName = k->GetName();
        TChain* FriendChain = new TChain(TreeName.c_str());
        FriendChain->Add(FileName.c_str());
        tree->AddFriend(FriendChain, TreeName.c_str()); 
        std::ostringstream t_Stream;
        t_Stream << "Adding chain " << TreeName << " with "
                 << FriendChain->GetEntries() << " entries as Friend";
        cat.debug(t_Stream.str());
      }
    }
    File->Close();
  } else {
    for (TIter i(list); TKey* k = (TKey*)i();) {
      if (std::string(TTree::Class()->GetName()) == k->GetClassName()) {
        std::string TreeName = k->GetName();
        TTree* FriendTree = (TTree *)File->Get(TreeName.c_str());
        tree->AddFriend(FriendTree, TreeName.c_str());  
        std::ostringstream t_Stream;
        t_Stream << "Adding tree " << TreeName << " with "
                 << FriendTree->GetEntries() << " entries as Friend";
        cat.debug(t_Stream.str());
      }
    }
  }
}

/**
 * Read all Root TTrees which belong to a certain event type and mount them
 * together as "friends".
 * @param type The packet type.
 * @return The root trees with the friends.
 */
TTree* PamelaRun::ReadTTree(const PacketType* type) {
  cat <<  log4cpp::Priority::DEBUG
      <<  "Getting root files of " << type->GetName()
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  RootTreeMap::iterator t = TTreeMap.find(type);
  if (t != TTreeMap.end()) {
    return t->second;
  } else {
    cat <<  log4cpp::Priority::DEBUG
        <<  "Reading root files of " << type->GetName()
        <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    EventHeader header(type);
    std::string HeaderFileName = GetFileName(&header);
    TChain* HeaderTree = ReadHeaderTree(type);
    std::list<std::string> rootfiles = GetRootFiles(GetDirName(type));
    for (std::list<std::string>::iterator i = rootfiles.begin(); 
         i != rootfiles.end(); i++){
      if (*i == HeaderFileName) 
        continue; // dont add the header tree itself.
      AddAllAsFriend(HeaderTree, *i);
    }
    TTreeMap.insert(RootTreeMap::value_type(type, HeaderTree));
    return HeaderTree;
  }
}

/**
 * Register a certain SubPacket, identified by its name, to be read 
 * from the repository. This function is made for interactive work.
 * @param subpacket A pointer to the pointer of the packet.
 * @param name The name of the subpacket
 */
void PamelaRun::ReadSubPacket(void* subpacket, std::string name) {
  SubPacket *packet = *(SubPacket**)subpacket;

  // look into the map of subpackets if we already read it.
  std::string FullName = packet->GetPacketType()->GetName() + "." + name;
  SubPacketMap::iterator i = SubPacketAddresses.find(FullName);
  if (i != SubPacketAddresses.end()) { // it is in the map
    *(SubPacket**)subpacket = i->second;
    return;
  } else { // not found in the map of used subpackets
    TTree* tree = ReadTTree(packet->GetPacketType());
    TBranch* branch = tree->GetBranch(name.c_str());
    if (branch != 0) {
      branch->SetAddress(subpacket);
      SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
    } else {
        cat <<  log4cpp::Priority::ERROR
            <<  "Could not find data for " << packet->GetPacketType()->GetName() << "/" << name 
            <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    }
  }
}

/**
 * Register a certain SubPacket, identified by its default name, to be
 * read from the repository. This function is made for
 * interactive work.
 * @param subpacket A pointer to the pointer of the packet. 
*/
void PamelaRun::ReadSubPacket(void* subpacket) {
  SubPacket *packet = *(SubPacket**)subpacket;
  ReadSubPacket(subpacket, GetDefaultBranchName(packet));
}

/**
 * Register a certain SubPacket with its default name, to be read from
 * the repository. This functions is for use from the algorithm.
 * @param algo Algorithm that needs this SubPacket.
 * @param subpacket A pointer to the pointer of the packet. 
 */
void PamelaRun::ReadSubPacket(const Algorithm* algo, void* subpacket) {
  //:TODO: store the request of the algorithm here.
  ReadSubPacket(subpacket);
}

/**
 * Register a certain SubPacket, with a custom name, to
 * be read from the repository. This functions is for use from 
 * the algorithm.
 * @param algo Algorithm that needs this SubPacket.
 * @param subpacket A pointer to the pointer of the packet.
 * @param name The name of the subpacket
 */
void PamelaRun::ReadSubPacket(const Algorithm* algo, void* subpacket, 
                              std::string name) {
  //:TODO: store the request of the algorithm here.
  ReadSubPacket(subpacket, name);
}

/**
 * Helper function to create a ROOT TTree within the run framework.
 * @param algo Algorithm that creates this SubPacket.
 * @param packet subpacket type
 * @param name the name of the subpacket
 * @return the ROOT TTree.
 */ 
TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet, 
                              std::string name) 
  throw (std::exception) {
  std::string FileName = GetFileName(packet, name);
  std::string EventType = packet->GetPacketType()->GetName();
  CreateDirectoryStructure(FileName.c_str());
  TFile* File = new TFile(FileName.c_str(), "create");
  if (!File->IsOpen()) {
    cat <<  log4cpp::Priority::ERROR
        <<  "Could not open file " << FileName 
        <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    throw Exception("Could not open file " + FileName);
  }
  std::string TreeName = GetTreeName(packet);
  TTree *tree = new TTree(TreeName.c_str(), algo->GetAlgorithmName().c_str());
  WritingRootTrees[packet->GetPacketType()].push_back(tree);
  tree->GetCurrentFile()->cd();
  AlgorithmInfo ai(algo);
  ai.Write();
  info.Write();
  cat <<  log4cpp::Priority::INFO
      <<  "Creating file " << FileName << " with Tree " << TreeName
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  return tree;
}


/**
 * Register a certain SubPacket to be written to the repository. A
 * usual call sequence for this function ist
 * MyEvent *event = new MyEvent();
 * run->WriteSubPacket(this, &event, event->Class()
 * @param algo Algorithm that produces this SubPacket.
 * @param subpacket A pointer to the pointer of the subpacket.
 * @param c The class the subpacket belongs to.
 * @param name The name of the packet.
 */
void PamelaRun::WriteSubPacket(Algorithm *algo, void* subpacket, 
                               const TClass *c, std::string name) {
  SubPacket *packet = *(SubPacket **)subpacket;
  cat <<  log4cpp::Priority::DEBUG
      <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)"
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  TTree* HeaderTree = ReadTTree(packet->GetPacketType());
  TTree* tree = CreateTTree(algo, packet, name);
  cat <<  log4cpp::Priority::DEBUG
      <<  "Branch: " << name << " Class: " << c->GetName()
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  tree->Branch(name.c_str(), c->GetName(),  subpacket);
  HeaderTree->AddFriend(tree, tree->GetName());

  std::string FullName = packet->GetPacketType()->GetName() + "." + name;
  SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
}

/**
 * Register a certain SubPacket with its default name to be written to 
 * the repository. A usual call sequence for this function ist
 * MyEvent *event = new MyEvent();
 * run->WriteSubPacket(this, &event, event->Class()
 * @param algo Algorithm that produces this SubPacket.
 * @param subpacket A pointer to the pointer of the subpacket.
 * @param c The class the subpacket belongs to.
 */
void PamelaRun::WriteSubPacket(Algorithm *algo, void* subpacket, 
                               const TClass *c) {
  SubPacket *packet = *(SubPacket **)subpacket;
  WriteSubPacket(algo, subpacket, c, GetDefaultBranchName(packet));
}

/**
 * Write the header packet of a specified packet type. This is mainly used
 * for the raw reader to create the base for the event structure.
 * @param algo Algorithm that produces this SubPacket.
 * @param subpacket A pointer to the pointer of the packet.
 * @param type The packet type.
 */
void PamelaRun::WriteHeader(Algorithm* algo, EventHeader** subpacket,
                            const PacketType* type) {
  cat <<  log4cpp::Priority::DEBUG
      <<  "Creating header tree for " << type->GetName()
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  EventHeader header(type);
  std::string FileName = GetFileName(&header, GetDefaultBranchName(&header));
  std::string EventType = (&header)->GetPacketType()->GetName();
  CreateDirectoryStructure(FileName.c_str());
  TFile* File = new TFile(FileName.c_str(), "create");
  if (!File->IsOpen()) {
    cat <<  log4cpp::Priority::ERROR
        <<  "Could not open file " << FileName 
        <<  "\n " << log4cpp::CategoryStream::ENDLINE;
    throw Exception("Could not open file " + FileName);
  }
  //std::string TreeName = GetTreeName(packet);
  TTree *tree = new TTree("Pscu", algo->GetAlgorithmName().c_str());
  WritingRootTrees[(&header)->GetPacketType()].push_back(tree);
  tree->GetCurrentFile()->cd();
  AlgorithmInfo ai(algo);
  ai.Write();
  info.Write();
  cat <<  log4cpp::Priority::INFO
      <<  "Creating file " << FileName << " with Tree Pscu"
      <<  "\n " << log4cpp::CategoryStream::ENDLINE;
  tree->Branch(GetDefaultBranchName(&header).c_str(), 
               (*subpacket)->Class()->GetName(), subpacket);
  TTreeMap.insert(RootTreeMap::value_type(type, tree));
}


/**
 * Write the header packet to all ROOT files in the tree. Intended to
 * be used for raw data readers that create the initial event structure.
 * @param algo Algorithm that produces this SubPacket.
 * @param subpacket A pointer to the pointer of the header packet.
 */
void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {
    WriteHeader(algo, subpacket, PacketType::Physics);
    WriteHeader(algo, subpacket, PacketType::TabDump);
    WriteHeader(algo, subpacket, PacketType::VarDump);
    WriteHeader(algo, subpacket, PacketType::ArrDump);
    WriteHeader(algo, subpacket, PacketType::Tmtc);
    WriteHeader(algo, subpacket, PacketType::Mcmd);
    WriteHeader(algo, subpacket, PacketType::Log);
    WriteHeader(algo, subpacket, PacketType::CalibTrk1);
    WriteHeader(algo, subpacket, PacketType::CalibTrk2);
    WriteHeader(algo, subpacket, PacketType::CalibCal);
    WriteHeader(algo, subpacket, PacketType::CalibCalPed);
    WriteHeader(algo, subpacket, PacketType::CalibTrd);
    WriteHeader(algo, subpacket, PacketType::CalibTof);
    WriteHeader(algo, subpacket, PacketType::CalibS4);
    WriteHeader(algo, subpacket, PacketType::CalibAc);
    WriteHeader(algo, subpacket, PacketType::RunHeader);
    WriteHeader(algo, subpacket, PacketType::RunTrailer);
    WriteHeader(algo, subpacket, PacketType::ForcedPkt);
}

/**
 * Write the ROOT files to disk.
 */
void PamelaRun::WriteFiles(void) {
  // Workaround: unlink all friend trees first top avoid to store
  // the links in the header tree file.
  for (RootTreeMap::iterator i = TTreeMap.begin(); i != TTreeMap.end(); i++) {
    if (i->second->GetListOfFriends() != 0) {
      i->second->GetListOfFriends()->Delete();
    }
  }

  for (TTreeListMap::iterator i = WritingRootTrees.begin();
       i != WritingRootTrees.end(); i++) {
    for (TTreeList::iterator j = i->second.begin();
         j != i->second.end(); j++) {
      (*j)->GetCurrentFile()->Write();
    }
  }
}

/**
 * Fill all ROOT trees of a certain type that were opened for writing.
 * @param type the package type of the trees to fill.
 */
void PamelaRun::FillTrees(const PacketType* type) {
  for (TTreeList::iterator j = WritingRootTrees[type].begin();
       j != WritingRootTrees[type].end(); j++) {
    (*j)->Fill();
    ;
  }
}

1	/** @file
2	* $Author: kusanagi $
3	* $Date: 2004/07/06 13:31:14 $
4	* $Revision: 1.2 $
5	*
6	* Implementation of the PamelaRun class.
7	*/
8	#include <iostream>
9	#include <iomanip>
10	#include <sstream>
11	#include <list>
12	#include <exception>
13	#include <string>
14
15	#include <log4cpp/Category.hh>
16
17	#include <TFile.h> //Substituted by Maurizio 05 Feb 2004
18	#include <TTree.h> //Substituted by Maurizio 05 Feb 2004
19	#include <TChain.h> //Substituted by Maurizio 05 Feb 2004
20	#include <TKey.h> //Substituted by Maurizio 05 Feb 2004
21	#include <TList.h> //Substituted by Maurizio 05 Feb 2004
22
23
24	#include "PamelaRun.h"
25	#include "EventHeader.h"
26	#include "Algorithm.h"
27	#include "AlgorithmInfo.h"
28	#include "Exception.h"
29	extern "C" {
30	#include "DirectoryStructure.h"
31	#include <dirent.h>
32	}
33
34	using namespace pamela;
35
36	static log4cpp::Category& cat = log4cpp::Category::getInstance("pamela.PamelaRun");
37
38	/**
39	* Get the run name according to a certain run number.
40	* @param run Run number.
41	* @return a string with the run name.
42	*/
43	std::string PamelaRun::GetRunName(int run) {
44	std::ostringstream t_Stream;
45	t_Stream << std::setw( 4 ) << std::setfill( '0' ) << run;
46	return "Run" + t_Stream.str();
47	//return std::string("aa");
48	}
49
50	/**
51	* Check if the run number is already assigned
52	* @param int run - Number of the run to check
53	* @return int
54	*/
55	/*int PamelaRun::RunExists(int run) throw (std::exception){
56	int res;
57	DIR *dirp;
58	std::string pathDir((char*)getenv("YODA_DATA"));
59	pathDir = pathDir + "/";
60	pathDir = pathDir + GetRunName(run);
61	// Open the directory
62	if ((dirp = opendir(pathDir.c_str())) == NULL) {
63	res = 0;
64	} else {
65	closedir(dirp);
66	res = 1;
67	}
68	return res;
69	}*/
70
71
72	/**
73	* Check if the run number is already assigned
74	* @param int run - Number of the run to check
75	* @return int
76	*/
77	std::string PamelaRun::RunExists(std::string input) throw (std::exception){
78	int res;
79	DIR *dirp;
80	std::string fileName;
81	std::string pathDir((char*)getenv("YODA_DATA"));
82	std::string tempName;
83	std::string::size_type pos;
84	std::ostringstream t_Stream;
85
86	pos = input.find_last_of("/");
87	//if ((pos == std::string::npos) && !input.empty()) ;//throw Exception("Directories not allowed....");
88	fileName = input.substr(pos+1);
89	pos = fileName.find_last_of(".");
90	fileName = fileName.substr(0,pos);
91	pathDir = pathDir + "/";
92	tempName = pathDir + fileName;
93
94	int i = 0;
95	while (res){
96	if ((dirp = opendir(tempName.c_str())) == NULL) {
97	res = 0;
98	} else {
99	closedir(dirp);
100	t_Stream.str("");
101	t_Stream << std::setw( 2 ) << std::setfill( '0' ) << ++i;
102	tempName = pathDir + fileName + t_Stream.str() ;
103	res = 1;
104	}
105	}
106	return (fileName + t_Stream.str());
107	}
108
109	/**
110	* Create a new Pamela run.
111	* @param run Run number
112	* @param path Base path name to the data
113	*/
114	PamelaRun::PamelaRun(std::string fileName, std::string path):
115	Path(path),
116	RunNumber(1){ //veirificare se è possibilie eliminare questa variabile
117	Run = RunExists(fileName);
118	info = RunInfo(this);
119	cat << log4cpp::Priority::DEBUG
120	<< "Constructor"
121	<< "\n " << log4cpp::CategoryStream::ENDLINE;
122	}
123
124	/**
125	* Get the directory name that contains the files of a certain event
126	* type for this run.
127	* @param type the packet type.
128	* @return the complete path for this event type.
129	*/
130	std::string PamelaRun::GetDirName(PacketType const * type) const {
131	std::string EventType = type->GetName();
132	return Path + "/" + Run + "/" + EventType;
133	}
134
135	/**
136	* Get the file name for a certain event type.
137	* @param type subpacket type.
138	* @param name subpacket name.
139	* @return the complete path and file name.
140	*/
141	std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) const {
142	if (type->IsDetectorSpecific()) {
143	return GetDirName(type->GetPacketType()) + "/"
144	+ type->GetSubDetector()->GetName() + "/"
145	+ Run + "." + type->GetPacketType()->GetName() + "."
146	+ type->GetSubDetector()->GetName() + "."
147	+ name + ".root";
148	} else {
149	return GetDirName(type->GetPacketType()) + "/"
150	+ Run + "." + type->GetPacketType()->GetName() + "."
151	+ name + ".root";
152	}
153	}
154
155	/**
156	* Get the file name for a certain event type.
157	* @param type subpacket type.
158	* @return the complete path and file name.
159	*/
160	std::string PamelaRun::GetFileName(const SubPacket* type) const {
161	return GetFileName(type, type->GetSubPacketName());
162	}
163
164	/**
165	* Get the branch name that corresponds to a certain
166	* subpacket. Usually, this is the name of the subpacket.
167	* @param type subpacket type.
168	* @return the corresponding branch name.
169	*/
170	static std::string GetDefaultBranchName(const SubPacket* type) {
171	return type->GetSubPacketName();
172	}
173
174	/**
175	* Get the tree name for a certain subpacket. This is the name of the
176	* subdetector for detector specific subpackets, and the packet name
177	* ("Physics" etc.) for common packets.
178	* @param type the packet type.
179	* @return the corresponding tree name.
180	*/
181	static std::string GetTreeName(const SubPacket* type) {
182	if (type->IsDetectorSpecific()) {
183	return type->GetSubDetector()->GetName();
184	} else {
185	return type->GetPacketType()->GetName();
186	}
187	}
188
189	/**
190	* Get a list of all root files from a certain path.
191	* @param path Path name to start the search.
192	* @return A list of all file names.
193	*/
194	static std::list<std::string> GetRootFiles(std::string path) throw (std::exception) {
195	std::list<std::string> files;
196	DIR *dir = opendir(path.c_str());
197	if (dir == 0) {
198	cat << log4cpp::Priority::DEBUG
199	<< "Could not open " << path
200	<< "\n " << log4cpp::CategoryStream::ENDLINE;
201	throw Exception("Could not open " + path);
202	}
203
204	for (struct dirent *d = readdir(dir); d != NULL; d = readdir(dir)) {
205	if ((strcmp(".",d->d_name) == 0) \|\| (strcmp("..",d->d_name) == 0))
206	continue;
207	std::string filename = path + "/" + d->d_name;
208	struct stat buf;
209	stat(filename.c_str(), &buf);
210	if S_ISDIR(buf.st_mode) {
211	std::list<std::string>toAdd = GetRootFiles(filename);
212	files.insert(files.end(), toAdd.begin(), toAdd.end());
213	} else if ((filename.substr(filename.size()-5, filename.size())
214	== ".root") // correct suffix
215	&& (!isdigit(filename[filename.size()-6]))) { // base file
216	std::string nextfilename = filename;
217	nextfilename.insert(filename.size()-5, "_1");
218	if (stat(nextfilename.c_str(), &buf) == 0) {
219	filename.insert(filename.size()-5, "*");
220	}
221	cat << log4cpp::Priority::DEBUG
222	<< "Using " << filename
223	<< "\n " << log4cpp::CategoryStream::ENDLINE;
224	files.push_back(filename);
225	}
226	}
227	return files;
228	}
229
230	/**
231	* Helper function to open the ROOT TTree of the header within the run
232	* framework.
233	* @param type The packet type.
234	* @return the ROOT TTree.
235	*/
236	TChain* PamelaRun::ReadHeaderTree(const PacketType *type)
237	throw (std::exception) {
238	EventHeader header(type);
239	std::string FileName = GetFileName(&header);
240	std::string TreeName = GetTreeName(&header);
241	TChain *tree = new TChain(TreeName.c_str());
242	tree->Add(FileName.c_str());
243	return tree;
244	}
245
246	/**
247	* All add trees of a file as friend to a given tree. The tree name of
248	* each tree found in the file is used as the name of the friend alias.
249	* @param tree The base tree to add all other as friends.
250	* @param FileName The name of the file with other trees.
251	*/
252	static void AddAllAsFriend(TChain* tree, std::string FileName) {
253	std::string BaseFileName = FileName;
254	bool HaveChain = false;
255	if (BaseFileName[BaseFileName.size()-6] == '*') {
256	BaseFileName.erase(BaseFileName.size()-6, 1);
257	HaveChain = true;
258	}
259	TFile* File = new TFile(BaseFileName.c_str(), "read");
260	if (!File->IsOpen()) {
261	cat << log4cpp::Priority::WARN
262	<< "Could not open file " << BaseFileName << " for reading."
263	<< "\n " << log4cpp::CategoryStream::ENDLINE;
264	return;
265	}
266	TList* list = File->GetListOfKeys();
267	if (HaveChain) {
268	for (TIter i(list); TKey* k = (TKey*)i();) {
269	if (std::string(TTree::Class()->GetName()) == k->GetClassName()) {
270	std::string TreeName = k->GetName();
271	TChain* FriendChain = new TChain(TreeName.c_str());
272	FriendChain->Add(FileName.c_str());
273	tree->AddFriend(FriendChain, TreeName.c_str());
274	std::ostringstream t_Stream;
275	t_Stream << "Adding chain " << TreeName << " with "
276	<< FriendChain->GetEntries() << " entries as Friend";
277	cat.debug(t_Stream.str());
278	}
279	}
280	File->Close();
281	} else {
282	for (TIter i(list); TKey* k = (TKey*)i();) {
283	if (std::string(TTree::Class()->GetName()) == k->GetClassName()) {
284	std::string TreeName = k->GetName();
285	TTree* FriendTree = (TTree *)File->Get(TreeName.c_str());
286	tree->AddFriend(FriendTree, TreeName.c_str());
287	std::ostringstream t_Stream;
288	t_Stream << "Adding tree " << TreeName << " with "
289	<< FriendTree->GetEntries() << " entries as Friend";
290	cat.debug(t_Stream.str());
291	}
292	}
293	}
294	}
295
296	/**
297	* Read all Root TTrees which belong to a certain event type and mount them
298	* together as "friends".
299	* @param type The packet type.
300	* @return The root trees with the friends.
301	*/
302	TTree* PamelaRun::ReadTTree(const PacketType* type) {
303	cat << log4cpp::Priority::DEBUG
304	<< "Getting root files of " << type->GetName()
305	<< "\n " << log4cpp::CategoryStream::ENDLINE;
306	RootTreeMap::iterator t = TTreeMap.find(type);
307	if (t != TTreeMap.end()) {
308	return t->second;
309	} else {
310	cat << log4cpp::Priority::DEBUG
311	<< "Reading root files of " << type->GetName()
312	<< "\n " << log4cpp::CategoryStream::ENDLINE;
313	EventHeader header(type);
314	std::string HeaderFileName = GetFileName(&header);
315	TChain* HeaderTree = ReadHeaderTree(type);
316	std::list<std::string> rootfiles = GetRootFiles(GetDirName(type));
317	for (std::list<std::string>::iterator i = rootfiles.begin();
318	i != rootfiles.end(); i++){
319	if (*i == HeaderFileName)
320	continue; // dont add the header tree itself.
321	AddAllAsFriend(HeaderTree, *i);
322	}
323	TTreeMap.insert(RootTreeMap::value_type(type, HeaderTree));
324	return HeaderTree;
325	}
326	}
327
328	/**
329	* Register a certain SubPacket, identified by its name, to be read
330	* from the repository. This function is made for interactive work.
331	* @param subpacket A pointer to the pointer of the packet.
332	* @param name The name of the subpacket
333	*/
334	void PamelaRun::ReadSubPacket(void* subpacket, std::string name) {
335	SubPacket packet = (SubPacket**)subpacket;
336
337	// look into the map of subpackets if we already read it.
338	std::string FullName = packet->GetPacketType()->GetName() + "." + name;
339	SubPacketMap::iterator i = SubPacketAddresses.find(FullName);
340	if (i != SubPacketAddresses.end()) { // it is in the map
341	(SubPacket*)subpacket = i->second;
342	return;
343	} else { // not found in the map of used subpackets
344	TTree* tree = ReadTTree(packet->GetPacketType());
345	TBranch* branch = tree->GetBranch(name.c_str());
346	if (branch != 0) {
347	branch->SetAddress(subpacket);
348	SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
349	} else {
350	cat << log4cpp::Priority::ERROR
351	<< "Could not find data for " << packet->GetPacketType()->GetName() << "/" << name
352	<< "\n " << log4cpp::CategoryStream::ENDLINE;
353	}
354	}
355	}
356
357	/**
358	* Register a certain SubPacket, identified by its default name, to be
359	* read from the repository. This function is made for
360	* interactive work.
361	* @param subpacket A pointer to the pointer of the packet.
362	*/
363	void PamelaRun::ReadSubPacket(void* subpacket) {
364	SubPacket packet = (SubPacket**)subpacket;
365	ReadSubPacket(subpacket, GetDefaultBranchName(packet));
366	}
367
368	/**
369	* Register a certain SubPacket with its default name, to be read from
370	* the repository. This functions is for use from the algorithm.
371	* @param algo Algorithm that needs this SubPacket.
372	* @param subpacket A pointer to the pointer of the packet.
373	*/
374	void PamelaRun::ReadSubPacket(const Algorithm* algo, void* subpacket) {
375	//:TODO: store the request of the algorithm here.
376	ReadSubPacket(subpacket);
377	}
378
379	/**
380	* Register a certain SubPacket, with a custom name, to
381	* be read from the repository. This functions is for use from
382	* the algorithm.
383	* @param algo Algorithm that needs this SubPacket.
384	* @param subpacket A pointer to the pointer of the packet.
385	* @param name The name of the subpacket
386	*/
387	void PamelaRun::ReadSubPacket(const Algorithm* algo, void* subpacket,
388	std::string name) {
389	//:TODO: store the request of the algorithm here.
390	ReadSubPacket(subpacket, name);
391	}
392
393	/**
394	* Helper function to create a ROOT TTree within the run framework.
395	* @param algo Algorithm that creates this SubPacket.
396	* @param packet subpacket type
397	* @param name the name of the subpacket
398	* @return the ROOT TTree.
399	*/
400	TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet,
401	std::string name)
402	throw (std::exception) {
403	std::string FileName = GetFileName(packet, name);
404	std::string EventType = packet->GetPacketType()->GetName();
405	CreateDirectoryStructure(FileName.c_str());
406	TFile* File = new TFile(FileName.c_str(), "create");
407	if (!File->IsOpen()) {
408	cat << log4cpp::Priority::ERROR
409	<< "Could not open file " << FileName
410	<< "\n " << log4cpp::CategoryStream::ENDLINE;
411	throw Exception("Could not open file " + FileName);
412	}
413	std::string TreeName = GetTreeName(packet);
414	TTree *tree = new TTree(TreeName.c_str(), algo->GetAlgorithmName().c_str());
415	WritingRootTrees[packet->GetPacketType()].push_back(tree);
416	tree->GetCurrentFile()->cd();
417	AlgorithmInfo ai(algo);
418	ai.Write();
419	info.Write();
420	cat << log4cpp::Priority::INFO
421	<< "Creating file " << FileName << " with Tree " << TreeName
422	<< "\n " << log4cpp::CategoryStream::ENDLINE;
423	return tree;
424	}
425
426
427	/**
428	* Register a certain SubPacket to be written to the repository. A
429	* usual call sequence for this function ist
430	* MyEvent *event = new MyEvent();
431	* run->WriteSubPacket(this, &event, event->Class()
432	* @param algo Algorithm that produces this SubPacket.
433	* @param subpacket A pointer to the pointer of the subpacket.
434	* @param c The class the subpacket belongs to.
435	* @param name The name of the packet.
436	*/
437	void PamelaRun::WriteSubPacket(Algorithm algo, void subpacket,
438	const TClass *c, std::string name) {
439	SubPacket packet = (SubPacket **)subpacket;
440	cat << log4cpp::Priority::DEBUG
441	<< "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)"
442	<< "\n " << log4cpp::CategoryStream::ENDLINE;
443	TTree* HeaderTree = ReadTTree(packet->GetPacketType());
444	TTree* tree = CreateTTree(algo, packet, name);
445	cat << log4cpp::Priority::DEBUG
446	<< "Branch: " << name << " Class: " << c->GetName()
447	<< "\n " << log4cpp::CategoryStream::ENDLINE;
448	tree->Branch(name.c_str(), c->GetName(), subpacket);
449	HeaderTree->AddFriend(tree, tree->GetName());
450
451	std::string FullName = packet->GetPacketType()->GetName() + "." + name;
452	SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
453	}
454
455	/**
456	* Register a certain SubPacket with its default name to be written to
457	* the repository. A usual call sequence for this function ist
458	* MyEvent *event = new MyEvent();
459	* run->WriteSubPacket(this, &event, event->Class()
460	* @param algo Algorithm that produces this SubPacket.
461	* @param subpacket A pointer to the pointer of the subpacket.
462	* @param c The class the subpacket belongs to.
463	*/
464	void PamelaRun::WriteSubPacket(Algorithm algo, void subpacket,
465	const TClass *c) {
466	SubPacket packet = (SubPacket **)subpacket;
467	WriteSubPacket(algo, subpacket, c, GetDefaultBranchName(packet));
468	}
469
470	/**
471	* Write the header packet of a specified packet type. This is mainly used
472	* for the raw reader to create the base for the event structure.
473	* @param algo Algorithm that produces this SubPacket.
474	* @param subpacket A pointer to the pointer of the packet.
475	* @param type The packet type.
476	*/
477	void PamelaRun::WriteHeader(Algorithm* algo, EventHeader** subpacket,
478	const PacketType* type) {
479	cat << log4cpp::Priority::DEBUG
480	<< "Creating header tree for " << type->GetName()
481	<< "\n " << log4cpp::CategoryStream::ENDLINE;
482	EventHeader header(type);
483	std::string FileName = GetFileName(&header, GetDefaultBranchName(&header));
484	std::string EventType = (&header)->GetPacketType()->GetName();
485	CreateDirectoryStructure(FileName.c_str());
486	TFile* File = new TFile(FileName.c_str(), "create");
487	if (!File->IsOpen()) {
488	cat << log4cpp::Priority::ERROR
489	<< "Could not open file " << FileName
490	<< "\n " << log4cpp::CategoryStream::ENDLINE;
491	throw Exception("Could not open file " + FileName);
492	}
493	//std::string TreeName = GetTreeName(packet);
494	TTree *tree = new TTree("Pscu", algo->GetAlgorithmName().c_str());
495	WritingRootTrees[(&header)->GetPacketType()].push_back(tree);
496	tree->GetCurrentFile()->cd();
497	AlgorithmInfo ai(algo);
498	ai.Write();
499	info.Write();
500	cat << log4cpp::Priority::INFO
501	<< "Creating file " << FileName << " with Tree Pscu"
502	<< "\n " << log4cpp::CategoryStream::ENDLINE;
503	tree->Branch(GetDefaultBranchName(&header).c_str(),
504	(*subpacket)->Class()->GetName(), subpacket);
505	TTreeMap.insert(RootTreeMap::value_type(type, tree));
506	}
507
508
509	/**
510	* Write the header packet to all ROOT files in the tree. Intended to
511	* be used for raw data readers that create the initial event structure.
512	* @param algo Algorithm that produces this SubPacket.
513	* @param subpacket A pointer to the pointer of the header packet.
514	*/
515	void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {
516	WriteHeader(algo, subpacket, PacketType::Physics);
517	WriteHeader(algo, subpacket, PacketType::TabDump);
518	WriteHeader(algo, subpacket, PacketType::VarDump);
519	WriteHeader(algo, subpacket, PacketType::ArrDump);
520	WriteHeader(algo, subpacket, PacketType::Tmtc);
521	WriteHeader(algo, subpacket, PacketType::Mcmd);
522	WriteHeader(algo, subpacket, PacketType::Log);
523	WriteHeader(algo, subpacket, PacketType::CalibTrk1);
524	WriteHeader(algo, subpacket, PacketType::CalibTrk2);
525	WriteHeader(algo, subpacket, PacketType::CalibCal);
526	WriteHeader(algo, subpacket, PacketType::CalibCalPed);
527	WriteHeader(algo, subpacket, PacketType::CalibTrd);
528	WriteHeader(algo, subpacket, PacketType::CalibTof);
529	WriteHeader(algo, subpacket, PacketType::CalibS4);
530	WriteHeader(algo, subpacket, PacketType::CalibAc);
531	WriteHeader(algo, subpacket, PacketType::RunHeader);
532	WriteHeader(algo, subpacket, PacketType::RunTrailer);
533	WriteHeader(algo, subpacket, PacketType::ForcedPkt);
534	}
535
536	/**
537	* Write the ROOT files to disk.
538	*/
539	void PamelaRun::WriteFiles(void) {
540	// Workaround: unlink all friend trees first top avoid to store
541	// the links in the header tree file.
542	for (RootTreeMap::iterator i = TTreeMap.begin(); i != TTreeMap.end(); i++) {
543	if (i->second->GetListOfFriends() != 0) {
544	i->second->GetListOfFriends()->Delete();
545	}
546	}
547
548	for (TTreeListMap::iterator i = WritingRootTrees.begin();
549	i != WritingRootTrees.end(); i++) {
550	for (TTreeList::iterator j = i->second.begin();
551	j != i->second.end(); j++) {
552	(*j)->GetCurrentFile()->Write();
553	}
554	}
555	}
556
557	/**
558	* Fill all ROOT trees of a certain type that were opened for writing.
559	* @param type the package type of the trees to fill.
560	*/
561	void PamelaRun::FillTrees(const PacketType* type) {
562	for (TTreeList::iterator j = WritingRootTrees[type].begin();
563	j != WritingRootTrees[type].end(); j++) {
564	(*j)->Fill();
565	;
566	}
567	}
568