yoda/event/PamelaRun.cpp

/** @file
 * $Author: kusanagi $
 * $Date: 2006/03/08 13:51:45 $
 * $Revision: 6.2 $
 * 
 * Implementation of the PamelaRun class.
 */
#include <iostream>
#include <iomanip>
#include <list>
#include <exception>
#include <log4cxx/logger.h>

#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"
#include <sys/stat.h>

extern "C" {
#include <dirent.h>
#include "DirectoryStructure.h"
}

using namespace pamela;

static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("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::stringstream temp;
  temp.str("");
  temp << std::setw( 4 ) << std::setfill( '0' ) << run;
  return "Run" + temp.str();
}

/**
 * Check if the run number is already assigned
 * @param int run - Number of the run to check
 * @return int
 */
 void PamelaRun::RunExists(std::string input) throw (std::exception){
 int res;
 DIR *dirp;
 std::string fileName;
 //std::string pathDir((char*)getenv("YODA_DATA"));
 std::string pathDir(GetPath());
 std::string tempName;
 std::string::size_type pos;
 
 pos = input.find_last_of("/");
 fileName = input.substr(pos+1);
 pos = fileName.find_last_of(".");
 fileName = fileName.substr(0,pos);
 pathDir = pathDir + "/";
 tempName = pathDir + fileName;
 oss.str("");
 oss << Path << "/" << fileName;
 UnpackPath = oss.str();
 oss.str(""); 
 oss << fileName;
 Run = oss.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, bool multiple, short compr):
  Path(path),
  Run(fileName),
  RunNumber(1),//veirificare se è possibilie eliminare questa variabile
  Multiple(multiple),
  SingleFile(0),
  compression(compr){ 
  logger->debug(_T("Constructor"));
  //Run = RunExists(fileName);
  RunExists(fileName);
  info = RunInfo(this);
}

/**
 * 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::stringstream oss;
    //std::string name = type->GetName();
    //oss.str("");
    //oss << Path << "/" << Run << "/" << "pippo";
    //return oss.str();
    //return "pippo";
  //std::string EventType = type->GetName();
    return Path + "/" + Run + "/" + type->GetName();
}

/**
 * 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) {
  if (type->IsDetectorSpecific()) {
    return UnpackPath + "/" + type->GetPacketType()->GetName() + "/" 
      + Run + "." + type->GetPacketType()->GetName() + "."
      + type->GetSubDetector()->GetName() + "." 
      + name + ".root";
  } else {
    return UnpackPath + "/" + type->GetPacketType()->GetName() + "/" 
      + Run + "." + type->GetPacketType()->GetName() + "."
      + name + ".root";
   /*
    return Path + "/" + type->GetPacketType()->GetName() + "/" 
      + 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)  {
  //return GetFileName(type, type->GetSubPacketName());
    return GetFileName(type, "pippo");
}

/**
 * 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) {
    logger->debug("Could not open " + path);
    //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, "*");
      }
      logger->debug("Using " + filename);
      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()) {
    logger->error("Could not open file " + BaseFileName + " for reading.");
    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()); 
        //logger->warn("Adding chain " + TreeName + " with " + FriendChain->GetEntries() + " entries as Friend");
      }
    }
    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());  
        //logger->debug("Adding tree " + TreeName + " with " + FriendTree->GetEntries() + " entries as Friend");
      }
    }
  }
}

/**
 * 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) {
  oss.str("");
  oss <<  "Getting root files of " << type->GetName();
  logger->debug(oss.str().c_str());
  RootTreeMap::iterator t = TTreeMap.find(type);
  if (t != TTreeMap.end()) {
    return t->second;
  } else {
    oss.str("");
    oss <<  "Reading root files of " << type->GetName();
    logger->debug(oss.str().c_str());
    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 {
        oss.str("");
        oss <<  "Could not find data for " << packet->GetPacketType()->GetName() << "/" << name ;
        logger->error(oss.str().c_str());
    }
  }
}

/**
 * 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 = "";
  std::string EventType = packet->GetPacketType()->GetName();
  TFile* File = 0;
  std::string TreeName = GetTreeName(packet);
  TTree *tree = 0;
  FileName = GetFileName(packet, name);
  CreateDirectoryStructure(FileName.c_str());
  File = new TFile(FileName.c_str(), "create");
  tree = new TTree(TreeName.c_str(), algo->GetAlgorithmName().c_str()); 
  WritingRootTrees[packet->GetPacketType()].push_back(tree);
  
  File->SetCompressionLevel(compression);
  if (!File->IsOpen()) {
    logger->error("Could not open file " + FileName);
    //throw Exception("Could not open file " + FileName);
  }
  logger->debug("Creating file " + FileName + " with Tree " + TreeName);
  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;
  oss.str("");
  oss <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)";
  logger->debug(oss.str().c_str());
  TTree* HeaderTree = ReadTTree(packet->GetPacketType());
  std::string FullName = packet->GetPacketType()->GetName() + "." + name;
  if (Multiple) {
        TTree* tree = CreateTTree(algo, packet, name);
        oss.str("");
        oss <<  "Branch: " << name << " Class: " << c->GetName();
        logger->debug(oss.str().c_str());
        tree->Branch(name.c_str(), c->GetName(),  subpacket);
        HeaderTree->AddFriend(tree, tree->GetName());
        SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
  } else {
        std::string nameBranch(name);
        HeaderTree->Branch(nameBranch.c_str(), c->GetName(),  subpacket);
        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 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::PhysEndRun);
    WriteHeader(algo, subpacket, PacketType::CalibCalPulse1);
    WriteHeader(algo, subpacket, PacketType::CalibCalPulse2);
    WriteHeader(algo, subpacket, PacketType::Physics);
    WriteHeader(algo, subpacket, PacketType::CalibTrk1);
    WriteHeader(algo, subpacket, PacketType::CalibTrk2);
    WriteHeader(algo, subpacket, PacketType::CalibTof);
    WriteHeader(algo, subpacket, PacketType::CalibS4);
    WriteHeader(algo, subpacket, PacketType::CalibCalPed);
    WriteHeader(algo, subpacket, PacketType::Calib1_Ac1);
    WriteHeader(algo, subpacket, PacketType::Calib1_Ac2);
    WriteHeader(algo, subpacket, PacketType::Calib2_Ac1);
    WriteHeader(algo, subpacket, PacketType::Calib2_Ac2);
    WriteHeader(algo, subpacket, PacketType::RunHeader);
    WriteHeader(algo, subpacket, PacketType::RunTrailer);
    WriteHeader(algo, subpacket, PacketType::CalibHeader);
    WriteHeader(algo, subpacket, PacketType::CalibTrailer);
    WriteHeader(algo, subpacket, PacketType::InitHeader);
    WriteHeader(algo, subpacket, PacketType::InitTrailer);
    WriteHeader(algo, subpacket, PacketType::EventTrk);
    WriteHeader(algo, subpacket, PacketType::Log);
    WriteHeader(algo, subpacket, PacketType::VarDump);
    WriteHeader(algo, subpacket, PacketType::ArrDump);
    WriteHeader(algo, subpacket, PacketType::TabDump);
    WriteHeader(algo, subpacket, PacketType::Tmtc);
    WriteHeader(algo, subpacket, PacketType::Mcmd);
    WriteHeader(algo, subpacket, PacketType::ForcedFECmd);
    WriteHeader(algo, subpacket, PacketType::Ac1Init);
    WriteHeader(algo, subpacket, PacketType::CalInit);
    WriteHeader(algo, subpacket, PacketType::TrkInit);
    WriteHeader(algo, subpacket, PacketType::TofInit);
    WriteHeader(algo, subpacket, PacketType::TrgInit);    
    WriteHeader(algo, subpacket, PacketType::NdInit);    
    WriteHeader(algo, subpacket, PacketType::S4Init);    
    WriteHeader(algo, subpacket, PacketType::Ac2Init);
    WriteHeader(algo, subpacket, PacketType::CalAlarm);    
    WriteHeader(algo, subpacket, PacketType::AcAlarm);    
    WriteHeader(algo, subpacket, PacketType::TrkAlarm);    
    WriteHeader(algo, subpacket, PacketType::TrgAlarm);    
    WriteHeader(algo, subpacket, PacketType::TofAlarm);
    WriteHeader(algo, subpacket, PacketType::S4Alarm);
    WriteHeader(algo, subpacket, PacketType::TsbT);
    WriteHeader(algo, subpacket, PacketType::TsbB);
}

/**
 * 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(0,TObject::kOverwrite);
    }
  }
}

/**
 * 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) {
  try{
    for (TTreeList::iterator j = WritingRootTrees[type].begin();
        j != WritingRootTrees[type].end(); j++) {
            (*j)->Fill();
    }
  } catch(Exception exc){
    logger->fatal("ORRORE!!!");
  }
}


/**
 * 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) {
  EventHeader header(type);
  std::string EventType = (&header)->GetPacketType()->GetName();

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