/[PAMELA software]/yoda/event/PamelaRun.cpp
ViewVC logotype

Diff of /yoda/event/PamelaRun.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2.1 by kusanagi, Fri Sep 24 11:57:32 2004 UTC revision 6.1 by kusanagi, Wed Feb 15 15:47:14 2006 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/09/21 20:49:57 $   * $Date: 2006/02/07 17:11:07 $
4   * $Revision: 2.0 $   * $Revision: 6.0 $
5   *   *
6   * Implementation of the PamelaRun class.   * Implementation of the PamelaRun class.
7   */   */
8  #include <iostream>  #include <iostream>
9  #include <iomanip>  #include <iomanip>
 #include <sstream>  
10  #include <list>  #include <list>
11  #include <exception>  #include <exception>
 #include <string>  
12  #include <log4cxx/logger.h>  #include <log4cxx/logger.h>
13    
14  #include <TFile.h>  //Substituted by Maurizio 05 Feb 2004  #include <TFile.h>  //Substituted by Maurizio 05 Feb 2004
# Line 35  extern "C" { Line 33  extern "C" {
33  using namespace pamela;  using namespace pamela;
34    
35  static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.PamelaRun"));  static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.PamelaRun"));
 static std::stringstream oss;  
36    
37  /**  /**
38   * Get the run name according to a certain run number.   * Get the run name according to a certain run number.
# Line 43  static std::stringstream oss; Line 40  static std::stringstream oss;
40   * @return a string with the run name.   * @return a string with the run name.
41   */   */
42  std::string PamelaRun::GetRunName(int run) {  std::string PamelaRun::GetRunName(int run) {
43    std::ostringstream t_Stream;    std::stringstream temp;
44    t_Stream << std::setw( 4 ) << std::setfill( '0' ) << run;    temp.str("");
45    return "Run" + t_Stream.str();    temp << std::setw( 4 ) << std::setfill( '0' ) << run;
46      return "Run" + temp.str();
47  }  }
48    
49  /**  /**
# Line 53  std::string PamelaRun::GetRunName(int ru Line 51  std::string PamelaRun::GetRunName(int ru
51   * @param int run - Number of the run to check   * @param int run - Number of the run to check
52   * @return int   * @return int
53   */   */
54  /*int PamelaRun::RunExists(int run) throw (std::exception){   void PamelaRun::RunExists(std::string input) 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){  
55   int res;   int res;
56   DIR *dirp;   DIR *dirp;
57   std::string fileName;   std::string fileName;
58   std::string pathDir((char*)getenv("YODA_DATA"));   std::string pathDir((char*)getenv("YODA_DATA"));
59   std::string tempName;   std::string tempName;
60   std::string::size_type pos;   std::string::size_type pos;
61   std::ostringstream t_Stream;  
   
62   pos = input.find_last_of("/");   pos = input.find_last_of("/");
63   //if ((pos == std::string::npos) && !input.empty()) ;//throw Exception("Directories not allowed....");   //if ((pos == std::string::npos) && !input.empty()) ;//throw Exception("Directories not allowed....");
64   fileName = input.substr(pos+1);   fileName = input.substr(pos+1);
65   pos = fileName.find_last_of(".");   pos = fileName.find_last_of(".");
66   fileName = fileName.substr(0,pos);   fileName = fileName.substr(0,pos);
67   pathDir = pathDir + "/";   pathDir = pathDir + "/";
68   tempName = pathDir + fileName;   tempName = pathDir + fileName + "00";
69     //oss << pathDir << fileName << std::setw( 2 ) << std::setfill( '0' );
70     oss.str(tempName.c_str());
71   int i = 0;   int i = 0;
72   while (res){   while (res){
73      if ((dirp = opendir(tempName.c_str())) == NULL) {      //if ((dirp = opendir(tempName.c_str())) == NULL) {
74        if ((dirp = opendir(oss.str().c_str())) == NULL) {
75          res = 0;          res = 0;
76      } else {      } else {
77          closedir(dirp);          closedir(dirp);
78          t_Stream.str("");          oss.str("");
79          t_Stream << std::setw( 2 ) << std::setfill( '0' ) << ++i;          oss << pathDir << fileName << std::setw( 2 ) << std::setfill( '0' ) << ++i;
         tempName = pathDir + fileName + t_Stream.str() ;  
80          res = 1;          res = 1;
81      }      }
82   }   }
83  return (fileName + t_Stream.str());   oss.str("");
84     oss << Path << "/" << fileName << std::setw( 2 ) << std::setfill( '0' ) << i;
85     Path = oss.str();
86     oss.str("");
87     oss << fileName << std::setw( 2 ) << std::setfill( '0' ) << i;
88     Run = oss.str();
89    //return (oss.str());
90  }  }
91    
92  /**  /**
# Line 112  return (fileName + t_Stream.str()); Line 94  return (fileName + t_Stream.str());
94   * @param run Run number   * @param run Run number
95   * @param path Base path name to the data   * @param path Base path name to the data
96   */   */
97  PamelaRun::PamelaRun(std::string fileName, std::string path):  PamelaRun::PamelaRun(std::string fileName, std::string path, bool multiple, short compr):
98    Path(path),    Path(path),
99    RunNumber(1){ //veirificare se è possibilie eliminare questa variabile    Run(fileName),
100      RunNumber(1),//veirificare se è possibilie eliminare questa variabile
101      Multiple(multiple),
102      SingleFile(0),
103      compression(compr){
104    logger->debug(_T("Constructor"));    logger->debug(_T("Constructor"));
105    Run = RunExists(fileName);    //Run = RunExists(fileName);
106      RunExists(fileName);
107    info = RunInfo(this);    info = RunInfo(this);
108  }  }
109    
# Line 127  PamelaRun::PamelaRun(std::string fileNam Line 114  PamelaRun::PamelaRun(std::string fileNam
114   * @return the complete path for this event type.   * @return the complete path for this event type.
115   */   */
116  std::string PamelaRun::GetDirName(PacketType const * type) const {  std::string PamelaRun::GetDirName(PacketType const * type) const {
117    std::string EventType = type->GetName();      //std::stringstream oss;
118    return Path + "/" + Run + "/" + EventType;      //std::string name = type->GetName();
119        //oss.str("");
120        //oss << Path << "/" << Run << "/" << "pippo";
121        //return oss.str();
122        //return "pippo";
123      //std::string EventType = type->GetName();
124        return Path + "/" + Run + "/" + type->GetName();
125  }  }
126    
127  /**  /**
# Line 137  std::string PamelaRun::GetDirName(Packet Line 130  std::string PamelaRun::GetDirName(Packet
130   * @param name subpacket name.   * @param name subpacket name.
131   * @return the complete path and file name.   * @return the complete path and file name.
132   */   */
133  std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) const {  std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) {
134    if (type->IsDetectorSpecific()) {    if (type->IsDetectorSpecific()) {
135      return GetDirName(type->GetPacketType()) + "/"      return Path + "/" + type->GetPacketType()->GetName() + "/"
136        + type->GetSubDetector()->GetName() + "/"        + Run + "." + type->GetPacketType()->GetName() + "."
       + Run + "." + type->GetPacketType()->GetName() + "."  
137        + type->GetSubDetector()->GetName() + "."        + type->GetSubDetector()->GetName() + "."
138        + name + ".root";        + name + ".root";
139    } else {    } else {
140      return GetDirName(type->GetPacketType()) + "/"      return Path + "/" + type->GetPacketType()->GetName() + "/"
141        + Run + "." + type->GetPacketType()->GetName() + "."        + Run + "." + type->GetPacketType()->GetName() + "."
142        + name + ".root";        + name + ".root";
143       /*
144        return Path + "/" + type->GetPacketType()->GetName() + "/"
145          + Run + "." + type->GetPacketType()->GetName() + "."
146          + name + ".root"; */
147    }    }
148  }  }
149    
# Line 156  std::string PamelaRun::GetFileName(const Line 152  std::string PamelaRun::GetFileName(const
152   * @param type subpacket type.   * @param type subpacket type.
153   * @return the complete path and file name.   * @return the complete path and file name.
154   */   */
155  std::string PamelaRun::GetFileName(const SubPacket* type) const {  std::string PamelaRun::GetFileName(const SubPacket* type)  {
156    return GetFileName(type, type->GetSubPacketName());    //return GetFileName(type, type->GetSubPacketName());
157        return GetFileName(type, "pippo");
158  }  }
159    
160  /**  /**
# Line 194  static std::list<std::string> GetRootFil Line 191  static std::list<std::string> GetRootFil
191    std::list<std::string> files;    std::list<std::string> files;
192    DIR *dir = opendir(path.c_str());    DIR *dir = opendir(path.c_str());
193    if (dir == 0) {    if (dir == 0) {
194      oss.flush();      logger->debug("Could not open " + path);
195      oss <<  "Could not open " << path;      //throw Exception("Could not open " + path);
     logger->debug(oss.str().c_str());  
     throw Exception("Could not open " + path);  
196    }    }
197        
198    for (struct dirent *d = readdir(dir); d != NULL; d = readdir(dir)) {    for (struct dirent *d = readdir(dir); d != NULL; d = readdir(dir)) {
# Line 217  static std::list<std::string> GetRootFil Line 212  static std::list<std::string> GetRootFil
212        if (stat(nextfilename.c_str(), &buf) == 0) {        if (stat(nextfilename.c_str(), &buf) == 0) {
213          filename.insert(filename.size()-5, "*");          filename.insert(filename.size()-5, "*");
214        }        }
215        oss.flush();        logger->debug("Using " + filename);
       oss <<  "Using " << filename;  
       logger->debug(oss.str().c_str());  
216        files.push_back(filename);        files.push_back(filename);
217      }      }
218    }    }
# Line 257  static void AddAllAsFriend(TChain* tree, Line 250  static void AddAllAsFriend(TChain* tree,
250    }    }
251    TFile* File = new TFile(BaseFileName.c_str(), "read");    TFile* File = new TFile(BaseFileName.c_str(), "read");
252    if (!File->IsOpen()) {    if (!File->IsOpen()) {
253      oss.flush();      logger->error("Could not open file " + BaseFileName + " for reading.");
     oss <<  "Could not open file " << BaseFileName << " for reading.";  
     logger->warn(oss.str().c_str());  
254      return;      return;
255    }    }
256    TList* list = File->GetListOfKeys();    TList* list = File->GetListOfKeys();
# Line 270  static void AddAllAsFriend(TChain* tree, Line 261  static void AddAllAsFriend(TChain* tree,
261          TChain* FriendChain = new TChain(TreeName.c_str());          TChain* FriendChain = new TChain(TreeName.c_str());
262          FriendChain->Add(FileName.c_str());          FriendChain->Add(FileName.c_str());
263          tree->AddFriend(FriendChain, TreeName.c_str());          tree->AddFriend(FriendChain, TreeName.c_str());
264          oss.flush();          //logger->warn("Adding chain " + TreeName + " with " + FriendChain->GetEntries() + " entries as Friend");
         oss << "Adding chain " << TreeName << " with "  
             << FriendChain->GetEntries() << " entries as Friend";  
         logger->warn(oss.str().c_str());  
265        }        }
266      }      }
267      File->Close();      File->Close();
# Line 283  static void AddAllAsFriend(TChain* tree, Line 271  static void AddAllAsFriend(TChain* tree,
271          std::string TreeName = k->GetName();          std::string TreeName = k->GetName();
272          TTree* FriendTree = (TTree *)File->Get(TreeName.c_str());          TTree* FriendTree = (TTree *)File->Get(TreeName.c_str());
273          tree->AddFriend(FriendTree, TreeName.c_str());            tree->AddFriend(FriendTree, TreeName.c_str());  
274          oss.flush();          //logger->debug("Adding tree " + TreeName + " with " + FriendTree->GetEntries() + " entries as Friend");
         oss << "Adding tree " << TreeName << " with "  
             << FriendTree->GetEntries() << " entries as Friend";  
         logger->debug(oss.str().c_str());  
275        }        }
276      }      }
277    }    }
# Line 299  static void AddAllAsFriend(TChain* tree, Line 284  static void AddAllAsFriend(TChain* tree,
284   * @return The root trees with the friends.   * @return The root trees with the friends.
285   */   */
286  TTree* PamelaRun::ReadTTree(const PacketType* type) {  TTree* PamelaRun::ReadTTree(const PacketType* type) {
287    oss.flush();    oss.str("");
288    oss <<  "Getting root files of " << type->GetName();    oss <<  "Getting root files of " << type->GetName();
289    logger->debug(oss.str().c_str());    logger->debug(oss.str().c_str());
290    RootTreeMap::iterator t = TTreeMap.find(type);    RootTreeMap::iterator t = TTreeMap.find(type);
291    if (t != TTreeMap.end()) {    if (t != TTreeMap.end()) {
292      return t->second;      return t->second;
293    } else {    } else {
294      oss.flush();      oss.str("");
295      oss <<  "Reading root files of " << type->GetName();      oss <<  "Reading root files of " << type->GetName();
296      logger->debug(oss.str().c_str());      logger->debug(oss.str().c_str());
297      EventHeader header(type);      EventHeader header(type);
# Line 346  void PamelaRun::ReadSubPacket(void* subp Line 331  void PamelaRun::ReadSubPacket(void* subp
331        branch->SetAddress(subpacket);        branch->SetAddress(subpacket);
332        SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));        SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
333      } else {      } else {
334          oss.flush();          oss.str("");
335          oss <<  "Could not find data for " << packet->GetPacketType()->GetName() << "/" << name ;          oss <<  "Could not find data for " << packet->GetPacketType()->GetName() << "/" << name ;
336          logger->error(oss.str().c_str());          logger->error(oss.str().c_str());
337      }      }
# Line 399  void PamelaRun::ReadSubPacket(const Algo Line 384  void PamelaRun::ReadSubPacket(const Algo
384  TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet,  TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet,
385                                std::string name)                                std::string name)
386    throw (std::exception) {    throw (std::exception) {
387    std::string FileName = GetFileName(packet, name);    std::string FileName = "";
388    std::string EventType = packet->GetPacketType()->GetName();    std::string EventType = packet->GetPacketType()->GetName();
389      TFile* File = 0;
390      std::string TreeName = GetTreeName(packet);
391      TTree *tree = 0;
392      FileName = GetFileName(packet, name);
393    CreateDirectoryStructure(FileName.c_str());    CreateDirectoryStructure(FileName.c_str());
394    TFile* File = new TFile(FileName.c_str(), "create");    File = new TFile(FileName.c_str(), "create");
395      tree = new TTree(TreeName.c_str(), algo->GetAlgorithmName().c_str());
396      WritingRootTrees[packet->GetPacketType()].push_back(tree);
397      
398      File->SetCompressionLevel(compression);
399    if (!File->IsOpen()) {    if (!File->IsOpen()) {
400      oss.flush();      logger->error("Could not open file " + FileName);
401      oss <<  "Could not open file " << FileName ;      //throw Exception("Could not open file " + FileName);
     logger->error(oss.str().c_str());  
     throw Exception("Could not open file " + FileName);  
402    }    }
403    std::string TreeName = GetTreeName(packet);    logger->debug("Creating file " + FileName + " with Tree " + TreeName);
   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();  
   oss.flush();  
   oss <<  "Creating file " << FileName << " with Tree " << TreeName;  
   logger->info(oss.str().c_str());  
404    return tree;    return tree;
405  }  }
406    
# Line 436  TTree* PamelaRun::CreateTTree(Algorithm* Line 418  TTree* PamelaRun::CreateTTree(Algorithm*
418  void PamelaRun::WriteSubPacket(Algorithm *algo, void* subpacket,  void PamelaRun::WriteSubPacket(Algorithm *algo, void* subpacket,
419                                 const TClass *c, std::string name) {                                 const TClass *c, std::string name) {
420    SubPacket *packet = *(SubPacket **)subpacket;    SubPacket *packet = *(SubPacket **)subpacket;
421    oss.flush();    oss.str("");
422    oss <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)";    oss <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)";
423    logger->debug(oss.str().c_str());    logger->debug(oss.str().c_str());
424    TTree* HeaderTree = ReadTTree(packet->GetPacketType());    TTree* HeaderTree = ReadTTree(packet->GetPacketType());
   TTree* tree = CreateTTree(algo, packet, name);  
   oss.flush();  
   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());  
   
425    std::string FullName = packet->GetPacketType()->GetName() + "." + name;    std::string FullName = packet->GetPacketType()->GetName() + "." + name;
426    SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));    if (Multiple) {
427            TTree* tree = CreateTTree(algo, packet, name);
428            oss.str("");
429            oss <<  "Branch: " << name << " Class: " << c->GetName();
430            logger->debug(oss.str().c_str());
431            tree->Branch(name.c_str(), c->GetName(),  subpacket);
432            HeaderTree->AddFriend(tree, tree->GetName());
433            SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
434      } else {
435            std::string nameBranch(name);
436            HeaderTree->Branch(nameBranch.c_str(), c->GetName(),  subpacket);
437            SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
438      }
439  }  }
440    
441  /**  /**
# Line 467  void PamelaRun::WriteSubPacket(Algorithm Line 454  void PamelaRun::WriteSubPacket(Algorithm
454  }  }
455    
456  /**  /**
  * 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) {  
   oss.flush();  
   oss <<  "Creating header tree for " << type->GetName();  
   logger->debug(oss.str().c_str());  
   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()) {  
     oss.flush();  
     oss     <<  "Could not open file " << FileName ;  
     logger->error(oss.str().c_str());  
     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();  
   oss.flush();  
   oss <<  "Creating file " << FileName << " with Tree Pscu";  
   logger->info(oss.str().c_str());  
   tree->Branch(GetDefaultBranchName(&header).c_str(),  
                (*subpacket)->Class()->GetName(), subpacket);  
   TTreeMap.insert(RootTreeMap::value_type(type, tree));  
 }  
   
   
 /**  
457   * Write the header packet to all ROOT files in the tree. Intended to   * Write the header packet to all ROOT files in the tree. Intended to
458   * be used for raw data readers that create the initial event structure.   * be used for raw data readers that create the initial event structure.
459   * @param algo Algorithm that produces this SubPacket.   * @param algo Algorithm that produces this SubPacket.
460   * @param subpacket A pointer to the pointer of the header packet.   * @param subpacket A pointer to the pointer of the header packet.
461   */   */
462  void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {  void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {
   
463      WriteHeader(algo, subpacket, PacketType::PhysEndRun);      WriteHeader(algo, subpacket, PacketType::PhysEndRun);
464      WriteHeader(algo, subpacket, PacketType::CalibCalPulse1);      WriteHeader(algo, subpacket, PacketType::CalibCalPulse1);
465      WriteHeader(algo, subpacket, PacketType::CalibCalPulse2);      WriteHeader(algo, subpacket, PacketType::CalibCalPulse2);
466      WriteHeader(algo, subpacket, PacketType::Physics);      WriteHeader(algo, subpacket, PacketType::Physics);
     WriteHeader(algo, subpacket, PacketType::CalibTrkBoth);  
467      WriteHeader(algo, subpacket, PacketType::CalibTrk1);      WriteHeader(algo, subpacket, PacketType::CalibTrk1);
468      WriteHeader(algo, subpacket, PacketType::CalibTrk2);      WriteHeader(algo, subpacket, PacketType::CalibTrk2);
     WriteHeader(algo, subpacket, PacketType::CalibTrd);  
469      WriteHeader(algo, subpacket, PacketType::CalibTof);      WriteHeader(algo, subpacket, PacketType::CalibTof);
470      WriteHeader(algo, subpacket, PacketType::CalibS4);      WriteHeader(algo, subpacket, PacketType::CalibS4);
471      WriteHeader(algo, subpacket, PacketType::CalibCalPed);      WriteHeader(algo, subpacket, PacketType::CalibCalPed);
472      WriteHeader(algo, subpacket, PacketType::CalibAc);      WriteHeader(algo, subpacket, PacketType::Calib1_Ac1);
473        WriteHeader(algo, subpacket, PacketType::Calib1_Ac2);
474        WriteHeader(algo, subpacket, PacketType::Calib2_Ac1);
475        WriteHeader(algo, subpacket, PacketType::Calib2_Ac2);
476      WriteHeader(algo, subpacket, PacketType::RunHeader);      WriteHeader(algo, subpacket, PacketType::RunHeader);
477      WriteHeader(algo, subpacket, PacketType::RunTrailer);      WriteHeader(algo, subpacket, PacketType::RunTrailer);
478      WriteHeader(algo, subpacket, PacketType::CalibHeader);      WriteHeader(algo, subpacket, PacketType::CalibHeader);
# Line 532  void PamelaRun::WriteHeaders(Algorithm* Line 480  void PamelaRun::WriteHeaders(Algorithm*
480      WriteHeader(algo, subpacket, PacketType::InitHeader);      WriteHeader(algo, subpacket, PacketType::InitHeader);
481      WriteHeader(algo, subpacket, PacketType::InitTrailer);      WriteHeader(algo, subpacket, PacketType::InitTrailer);
482      WriteHeader(algo, subpacket, PacketType::EventTrk);      WriteHeader(algo, subpacket, PacketType::EventTrk);
     WriteHeader(algo, subpacket, PacketType::TestTrk);  
     WriteHeader(algo, subpacket, PacketType::TestTof);  
483      WriteHeader(algo, subpacket, PacketType::Log);      WriteHeader(algo, subpacket, PacketType::Log);
484      WriteHeader(algo, subpacket, PacketType::VarDump);      WriteHeader(algo, subpacket, PacketType::VarDump);
485      WriteHeader(algo, subpacket, PacketType::ArrDump);      WriteHeader(algo, subpacket, PacketType::ArrDump);
# Line 541  void PamelaRun::WriteHeaders(Algorithm* Line 487  void PamelaRun::WriteHeaders(Algorithm*
487      WriteHeader(algo, subpacket, PacketType::Tmtc);      WriteHeader(algo, subpacket, PacketType::Tmtc);
488      WriteHeader(algo, subpacket, PacketType::Mcmd);      WriteHeader(algo, subpacket, PacketType::Mcmd);
489      WriteHeader(algo, subpacket, PacketType::ForcedFECmd);      WriteHeader(algo, subpacket, PacketType::ForcedFECmd);
490      WriteHeader(algo, subpacket, PacketType::AcInit);      WriteHeader(algo, subpacket, PacketType::Ac1Init);
491      WriteHeader(algo, subpacket, PacketType::CalInit);      WriteHeader(algo, subpacket, PacketType::CalInit);
492      WriteHeader(algo, subpacket, PacketType::TrkInit);      WriteHeader(algo, subpacket, PacketType::TrkInit);
493      WriteHeader(algo, subpacket, PacketType::TofInit);      WriteHeader(algo, subpacket, PacketType::TofInit);
494      WriteHeader(algo, subpacket, PacketType::TrgInit);          WriteHeader(algo, subpacket, PacketType::TrgInit);    
495      WriteHeader(algo, subpacket, PacketType::NdInit);          WriteHeader(algo, subpacket, PacketType::NdInit);    
496        WriteHeader(algo, subpacket, PacketType::S4Init);    
497        WriteHeader(algo, subpacket, PacketType::Ac2Init);
498      WriteHeader(algo, subpacket, PacketType::CalAlarm);          WriteHeader(algo, subpacket, PacketType::CalAlarm);    
499      WriteHeader(algo, subpacket, PacketType::AcAlarm);          WriteHeader(algo, subpacket, PacketType::AcAlarm);    
500      WriteHeader(algo, subpacket, PacketType::TrkAlarm);          WriteHeader(algo, subpacket, PacketType::TrkAlarm);    
501      WriteHeader(algo, subpacket, PacketType::TrgAlarm);          WriteHeader(algo, subpacket, PacketType::TrgAlarm);    
502      WriteHeader(algo, subpacket, PacketType::TofAlarm);          WriteHeader(algo, subpacket, PacketType::TofAlarm);
503        WriteHeader(algo, subpacket, PacketType::S4Alarm);
504        WriteHeader(algo, subpacket, PacketType::TsbT);
505        WriteHeader(algo, subpacket, PacketType::TsbB);
506  }  }
507    
508  /**  /**
# Line 570  void PamelaRun::WriteFiles(void) { Line 521  void PamelaRun::WriteFiles(void) {
521         i != WritingRootTrees.end(); i++) {         i != WritingRootTrees.end(); i++) {
522      for (TTreeList::iterator j = i->second.begin();      for (TTreeList::iterator j = i->second.begin();
523           j != i->second.end(); j++) {           j != i->second.end(); j++) {
524        (*j)->GetCurrentFile()->Write();        (*j)->GetCurrentFile()->Write(0,TObject::kOverwrite);
525      }      }
526    }    }
527  }  }
# Line 580  void PamelaRun::WriteFiles(void) { Line 531  void PamelaRun::WriteFiles(void) {
531   * @param type the package type of the trees to fill.   * @param type the package type of the trees to fill.
532   */   */
533  void PamelaRun::FillTrees(const PacketType* type) {  void PamelaRun::FillTrees(const PacketType* type) {
534    for (TTreeList::iterator j = WritingRootTrees[type].begin();    try{
535         j != WritingRootTrees[type].end(); j++) {      for (TTreeList::iterator j = WritingRootTrees[type].begin();
536      (*j)->Fill();          j != WritingRootTrees[type].end(); j++) {
537      ;              (*j)->Fill();
538        }
539      } catch(Exception exc){
540        logger->fatal("ORRORE!!!");
541    }    }
542  }  }
543    
544    
545    /**
546     * Write the header packet of a specified packet type. This is mainly used
547     * for the raw reader to create the base for the event structure.
548     * @param algo Algorithm that produces this SubPacket.
549     * @param subpacket A pointer to the pointer of the packet.
550     * @param type The packet type.
551     */
552    void PamelaRun::WriteHeader(Algorithm* algo, EventHeader** subpacket,
553                                const PacketType* type) {
554      EventHeader header(type);
555      std::string EventType = (&header)->GetPacketType()->GetName();
556    
557      std::string FileName = "";
558      TFile* File = 0;
559      TTree *tree = 0;
560      if ( Multiple ){
561            FileName = GetFileName(&header, GetDefaultBranchName(&header));
562            CreateDirectoryStructure(FileName.c_str());
563            File = new TFile(FileName.c_str(), "create");
564            File->SetCompressionLevel(compression);
565            tree = new TTree("Pscu", algo->GetAlgorithmName().c_str());
566            WritingRootTrees[(&header)->GetPacketType()].push_back(tree);
567            tree->GetCurrentFile()->cd();
568            tree->Branch(GetDefaultBranchName(&header).c_str(),
569                   (*subpacket)->Class()->GetName(), subpacket);
570            TTreeMap.insert(RootTreeMap::value_type(type, tree));
571      } else {
572            if (!Multiple && (SingleFile == NULL)){
573                    std::string pathDir((char*)getenv("YODA_DATA"));
574                    SingleFile = new TFile((pathDir + "/" + Run + ".root").c_str(), "update");
575                    SingleFile->SetCompressionLevel(compression);
576            }
577            tree = new TTree(EventType.c_str(), algo->GetAlgorithmName().c_str());
578            WritingRootTrees[type].push_back(tree);
579            tree->GetCurrentFile()->cd();
580            tree->Branch(GetDefaultBranchName(&header).c_str(),
581                   (*subpacket)->Class()->GetName(), subpacket);
582            TTreeMap.insert(RootTreeMap::value_type(type, tree));
583      }
584    }
Legend:
Removed from v.2.1  
changed lines
  Added in v.6.1
  ViewVC Help
Powered by ViewVC 1.1.23