/[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 3.0 by kusanagi, Fri Mar 4 15:54:11 2005 UTC revision 6.9 by mocchiut, Mon Oct 16 10:59:12 2006 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: pam-rm2 $
3   * $Date: 2005/03/03 12:57:48 $   * $Date: 2006/08/23 14:39:44 $
4   * $Revision: 2.7 $   * $Revision: 6.8 $
5   *   *
6   * Implementation of the PamelaRun class.   * Implementation of the PamelaRun class.
7   */   */
# Line 9  Line 9 
9  #include <iomanip>  #include <iomanip>
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 31  extern "C" { Line 30  extern "C" {
30  #include "DirectoryStructure.h"  #include "DirectoryStructure.h"
31  }  }
32    
33    extern int GetYODAver();
34    
35  using namespace pamela;  using namespace pamela;
36    
37  static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.PamelaRun"));  static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.PamelaRun"));
# Line 52  std::string PamelaRun::GetRunName(int ru Line 53  std::string PamelaRun::GetRunName(int ru
53   * @param int run - Number of the run to check   * @param int run - Number of the run to check
54   * @return int   * @return int
55   */   */
 /*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  
  */  
56   void PamelaRun::RunExists(std::string input) throw (std::exception){   void PamelaRun::RunExists(std::string input) throw (std::exception){
57   int res;   int res;
58   DIR *dirp;   DIR *dirp;
59   std::string fileName;   std::string fileName;
60   std::string pathDir((char*)getenv("YODA_DATA"));   //std::string pathDir((char*)getenv("YODA_DATA"));
61     std::string pathDir(GetPath());
62   std::string tempName;   std::string tempName;
63   std::string::size_type pos;   std::string::size_type pos;
64    
65   pos = input.find_last_of("/");   pos = input.find_last_of("/");
  //if ((pos == std::string::npos) && !input.empty()) ;//throw Exception("Directories not allowed....");  
66   fileName = input.substr(pos+1);   fileName = input.substr(pos+1);
67   pos = fileName.find_last_of(".");   pos = fileName.find_last_of(".");
68   fileName = fileName.substr(0,pos);   fileName = fileName.substr(0,pos);
69   pathDir = pathDir + "/";   pathDir = pathDir + "/";
70   tempName = pathDir + fileName + "00";   tempName = pathDir + fileName;
71   //oss << pathDir << fileName << std::setw( 2 ) << std::setfill( '0' );   oss.str("");
72   oss.str(tempName.c_str());   oss << Path << "/" << fileName;
73   int i = 0;   UnpackPath = oss.str();
  while (res){  
     //if ((dirp = opendir(tempName.c_str())) == NULL) {  
     if ((dirp = opendir(oss.str().c_str())) == NULL) {  
         res = 0;  
     } else {  
         closedir(dirp);  
         oss.str("");  
         oss << pathDir << fileName << std::setw( 2 ) << std::setfill( '0' ) << ++i;  
         res = 1;  
     }  
  }  
  oss.str("");  
  oss << Path << "/" << fileName << std::setw( 2 ) << std::setfill( '0' ) << i;  
  Path = oss.str();  
74   oss.str("");   oss.str("");
75   oss << fileName << std::setw( 2 ) << std::setfill( '0' ) << i;   oss << fileName;
76   Run = oss.str();   Run = oss.str();
 //return (oss.str());  
77  }  }
78    
79  /**  /**
# Line 117  return res; Line 81  return res;
81   * @param run Run number   * @param run Run number
82   * @param path Base path name to the data   * @param path Base path name to the data
83   */   */
84  PamelaRun::PamelaRun(std::string fileName, std::string path):  PamelaRun::PamelaRun(std::string fileName, std::string path, bool multiple, short compr):
85    Path(path),    Path(path),
86    Run(fileName),    Run(fileName),
87    RunNumber(1){ //veirificare se è possibilie eliminare questa variabile    RunNumber(1),//veirificare se è possibilie eliminare questa variabile
88      Multiple(multiple),
89      SingleFile(0),
90      compression(compr){
91    logger->debug(_T("Constructor"));    logger->debug(_T("Constructor"));
92    //Run = RunExists(fileName);    //Run = RunExists(fileName);
93    RunExists(fileName);    RunExists(fileName);
# Line 152  std::string PamelaRun::GetDirName(Packet Line 119  std::string PamelaRun::GetDirName(Packet
119   */   */
120  std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) {  std::string PamelaRun::GetFileName(const SubPacket* type, std::string name) {
121    if (type->IsDetectorSpecific()) {    if (type->IsDetectorSpecific()) {
122      return Path + "/" + type->GetPacketType()->GetName() + "/"      return UnpackPath + "/" + type->GetPacketType()->GetName() + "/"
123        + Run + "." + type->GetPacketType()->GetName() + "."        + Run + "." + type->GetPacketType()->GetName() + "."
124        + type->GetSubDetector()->GetName() + "."        + type->GetSubDetector()->GetName() + "."
125        + name + ".root";        + name + ".root";
126    } else {    } else {
127      return Path + "/" + type->GetPacketType()->GetName() + "/"      return UnpackPath + "/" + type->GetPacketType()->GetName() + "/"
128        + Run + "." + type->GetPacketType()->GetName() + "."        + Run + "." + type->GetPacketType()->GetName() + "."
129        + name + ".root";        + name + ".root";
130     /*     /*
# Line 404  void PamelaRun::ReadSubPacket(const Algo Line 371  void PamelaRun::ReadSubPacket(const Algo
371  TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet,  TTree* PamelaRun::CreateTTree(Algorithm* algo, const SubPacket* packet,
372                                std::string name)                                std::string name)
373    throw (std::exception) {    throw (std::exception) {
374    std::string FileName = GetFileName(packet, name);    std::string FileName = "";
375    std::string EventType = packet->GetPacketType()->GetName();    std::string EventType = packet->GetPacketType()->GetName();
376      TFile* File = 0;
377      std::string TreeName = GetTreeName(packet);
378      TTree *tree = 0;
379      FileName = GetFileName(packet, name);
380    CreateDirectoryStructure(FileName.c_str());    CreateDirectoryStructure(FileName.c_str());
381    TFile* File = new TFile(FileName.c_str(), "create");    File = new TFile(FileName.c_str(), "create");
382    File->SetCompressionLevel(5);    tree = new TTree(TreeName.c_str(), algo->GetAlgorithmName().c_str());
383      WritingRootTrees[packet->GetPacketType()].push_back(tree);
384      
385      File->SetCompressionLevel(compression);
386    if (!File->IsOpen()) {    if (!File->IsOpen()) {
387      logger->error("Could not open file " + FileName);      logger->error("Could not open file " + FileName);
388      //throw Exception("Could not open file " + FileName);      //throw Exception("Could not open file " + FileName);
389    }    }
   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();  
390    logger->debug("Creating file " + FileName + " with Tree " + TreeName);    logger->debug("Creating file " + FileName + " with Tree " + TreeName);
391    return tree;    return tree;
392  }  }
# Line 442  void PamelaRun::WriteSubPacket(Algorithm Line 409  void PamelaRun::WriteSubPacket(Algorithm
409    oss <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)";    oss <<  "Register: " << name << " for " << algo->GetAlgorithmName() << " (writing)";
410    logger->debug(oss.str().c_str());    logger->debug(oss.str().c_str());
411    TTree* HeaderTree = ReadTTree(packet->GetPacketType());    TTree* HeaderTree = ReadTTree(packet->GetPacketType());
   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());  
   
412    std::string FullName = packet->GetPacketType()->GetName() + "." + name;    std::string FullName = packet->GetPacketType()->GetName() + "." + name;
413    SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));    if (Multiple) {
414            TTree* tree = CreateTTree(algo, packet, name);
415            oss.str("");
416            oss <<  "Branch: " << name << " Class: " << c->GetName();
417            logger->debug(oss.str().c_str());
418            tree->Branch(name.c_str(), c->GetName(),  subpacket);
419            HeaderTree->AddFriend(tree, tree->GetName());
420            SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
421      } else {
422            std::string nameBranch(name);
423            HeaderTree->Branch(nameBranch.c_str(), c->GetName(),  subpacket);
424            SubPacketAddresses.insert(SubPacketMap::value_type(FullName, packet));
425      }
426  }  }
427    
428  /**  /**
# Line 469  void PamelaRun::WriteSubPacket(Algorithm Line 441  void PamelaRun::WriteSubPacket(Algorithm
441  }  }
442    
443  /**  /**
  * 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 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()) {  
     logger->error("Could not open file " + FileName);  
     //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();  
   std::stringstream temp;  
   //temp.str("");  
   //temp << "Created file" << FileName.c_str() << " with Tree Pscu" ;  
   //logger->debug(temp.str());  
   tree->Branch(GetDefaultBranchName(&header).c_str(),  
                (*subpacket)->Class()->GetName(), subpacket);  
   TTreeMap.insert(RootTreeMap::value_type(type, tree));  
 }  
   
   
 /**  
444   * 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
445   * be used for raw data readers that create the initial event structure.   * be used for raw data readers that create the initial event structure.
446   * @param algo Algorithm that produces this SubPacket.   * @param algo Algorithm that produces this SubPacket.
447   * @param subpacket A pointer to the pointer of the header packet.   * @param subpacket A pointer to the pointer of the header packet.
448   */   */
449  void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {  void PamelaRun::WriteHeaders(Algorithm* algo, EventHeader** subpacket) {
   
450      WriteHeader(algo, subpacket, PacketType::PhysEndRun);      WriteHeader(algo, subpacket, PacketType::PhysEndRun);
451      WriteHeader(algo, subpacket, PacketType::CalibCalPulse1);      WriteHeader(algo, subpacket, PacketType::CalibCalPulse1);
452      WriteHeader(algo, subpacket, PacketType::CalibCalPulse2);      WriteHeader(algo, subpacket, PacketType::CalibCalPulse2);
# Line 518  void PamelaRun::WriteHeaders(Algorithm* Line 454  void PamelaRun::WriteHeaders(Algorithm*
454      WriteHeader(algo, subpacket, PacketType::CalibTrkBoth);      WriteHeader(algo, subpacket, PacketType::CalibTrkBoth);
455      WriteHeader(algo, subpacket, PacketType::CalibTrk1);      WriteHeader(algo, subpacket, PacketType::CalibTrk1);
456      WriteHeader(algo, subpacket, PacketType::CalibTrk2);      WriteHeader(algo, subpacket, PacketType::CalibTrk2);
     WriteHeader(algo, subpacket, PacketType::CalibTrd);  
457      WriteHeader(algo, subpacket, PacketType::CalibTof);      WriteHeader(algo, subpacket, PacketType::CalibTof);
458      WriteHeader(algo, subpacket, PacketType::CalibS4);      WriteHeader(algo, subpacket, PacketType::CalibS4);
459      WriteHeader(algo, subpacket, PacketType::CalibCalPed);      WriteHeader(algo, subpacket, PacketType::CalibCalPed);
# Line 533  void PamelaRun::WriteHeaders(Algorithm* Line 468  void PamelaRun::WriteHeaders(Algorithm*
468      WriteHeader(algo, subpacket, PacketType::InitHeader);      WriteHeader(algo, subpacket, PacketType::InitHeader);
469      WriteHeader(algo, subpacket, PacketType::InitTrailer);      WriteHeader(algo, subpacket, PacketType::InitTrailer);
470      WriteHeader(algo, subpacket, PacketType::EventTrk);      WriteHeader(algo, subpacket, PacketType::EventTrk);
     WriteHeader(algo, subpacket, PacketType::TestTrk);  
     WriteHeader(algo, subpacket, PacketType::TestTof);  
471      WriteHeader(algo, subpacket, PacketType::Log);      WriteHeader(algo, subpacket, PacketType::Log);
472      WriteHeader(algo, subpacket, PacketType::VarDump);      WriteHeader(algo, subpacket, PacketType::VarDump);
473      WriteHeader(algo, subpacket, PacketType::ArrDump);      WriteHeader(algo, subpacket, PacketType::ArrDump);
# Line 551  void PamelaRun::WriteHeaders(Algorithm* Line 484  void PamelaRun::WriteHeaders(Algorithm*
484      WriteHeader(algo, subpacket, PacketType::S4Init);          WriteHeader(algo, subpacket, PacketType::S4Init);    
485      WriteHeader(algo, subpacket, PacketType::Ac2Init);      WriteHeader(algo, subpacket, PacketType::Ac2Init);
486      WriteHeader(algo, subpacket, PacketType::CalAlarm);          WriteHeader(algo, subpacket, PacketType::CalAlarm);    
487      WriteHeader(algo, subpacket, PacketType::AcAlarm);          WriteHeader(algo, subpacket, PacketType::Ac1Alarm);    
488      WriteHeader(algo, subpacket, PacketType::TrkAlarm);          WriteHeader(algo, subpacket, PacketType::TrkAlarm);    
489      WriteHeader(algo, subpacket, PacketType::TrgAlarm);          WriteHeader(algo, subpacket, PacketType::TrgAlarm);    
490      WriteHeader(algo, subpacket, PacketType::TofAlarm);      WriteHeader(algo, subpacket, PacketType::TofAlarm);
491      WriteHeader(algo, subpacket, PacketType::S4Alarm);      WriteHeader(algo, subpacket, PacketType::S4Alarm);
492        WriteHeader(algo, subpacket, PacketType::Ac2Alarm);    
493      WriteHeader(algo, subpacket, PacketType::TsbT);      WriteHeader(algo, subpacket, PacketType::TsbT);
494      WriteHeader(algo, subpacket, PacketType::TsbB);      WriteHeader(algo, subpacket, PacketType::TsbB);
495  }  }
# Line 572  void PamelaRun::WriteFiles(void) { Line 506  void PamelaRun::WriteFiles(void) {
506      }      }
507    }    }
508    
509      TTree *softinfo = 0;
510      Int_t version=GetYODAver();
511      //Int_t version= 60312;
512      //printf("version = %f \n",version);
513      softinfo = new TTree("SoftInfo","YODA software info");
514      softinfo->Branch("SoftInfo",&version,"version/I");
515      softinfo->Fill();
516    
517    for (TTreeListMap::iterator i = WritingRootTrees.begin();    for (TTreeListMap::iterator i = WritingRootTrees.begin();
518         i != WritingRootTrees.end(); i++) {         i != WritingRootTrees.end(); i++) {
519      for (TTreeList::iterator j = i->second.begin();      for (TTreeList::iterator j = i->second.begin();
520           j != i->second.end(); j++) {           j != i->second.end(); j++) {
521        (*j)->GetCurrentFile()->Write();        (*j)->GetCurrentFile()->Write(0,TObject::kOverwrite);
522      }      }
523    }    }
524      
525      softinfo->Delete();
526  }  }
527    
528  /**  /**
# Line 586  void PamelaRun::WriteFiles(void) { Line 530  void PamelaRun::WriteFiles(void) {
530   * @param type the package type of the trees to fill.   * @param type the package type of the trees to fill.
531   */   */
532  void PamelaRun::FillTrees(const PacketType* type) {  void PamelaRun::FillTrees(const PacketType* type) {
533    for (TTreeList::iterator j = WritingRootTrees[type].begin();    try{
534         j != WritingRootTrees[type].end(); j++) {      for (TTreeList::iterator j = WritingRootTrees[type].begin();
535      (*j)->Fill();          j != WritingRootTrees[type].end(); j++) {
536      ;              (*j)->Fill();
537        }
538      } catch(Exception exc){
539        logger->fatal("ORRORE!!!");
540    }    }
541  }  }
542    
543    
544    /**
545     * Write the header packet of a specified packet type. This is mainly used
546     * for the raw reader to create the base for the event structure.
547     * @param algo Algorithm that produces this SubPacket.
548     * @param subpacket A pointer to the pointer of the packet.
549     * @param type The packet type.
550     */
551    void PamelaRun::WriteHeader(Algorithm* algo, EventHeader** subpacket,
552                                const PacketType* type) {
553      EventHeader header(type);
554      std::string EventType = (&header)->GetPacketType()->GetName();
555    
556      std::string FileName = "";
557      TFile* File = 0;
558      Long64_t maxsize = 5000000000LL;
559      TTree::SetMaxTreeSize(maxsize);
560      TTree *tree = 0;
561      if ( Multiple ){
562            FileName = GetFileName(&header, GetDefaultBranchName(&header));
563            CreateDirectoryStructure(FileName.c_str());
564            File = new TFile(FileName.c_str(), "create");
565            File->SetCompressionLevel(compression);
566            tree = new TTree("Pscu", algo->GetAlgorithmName().c_str());
567            WritingRootTrees[(&header)->GetPacketType()].push_back(tree);
568            tree->GetCurrentFile()->cd();
569            tree->Branch(GetDefaultBranchName(&header).c_str(),
570                   (*subpacket)->Class()->GetName(), subpacket);
571            TTreeMap.insert(RootTreeMap::value_type(type, tree));
572      } else {
573            if (!Multiple && (SingleFile == NULL)){
574                    //std::string pathDir((char*)getenv("YODA_DATA"));
575                    SingleFile = new TFile((GetPath() + "/" + Run + ".root").c_str(), "update");
576                    SingleFile->SetCompressionLevel(compression);
577            }
578            tree = new TTree(EventType.c_str(), algo->GetAlgorithmName().c_str());
579            WritingRootTrees[type].push_back(tree);
580            tree->GetCurrentFile()->cd();
581            tree->Branch(GetDefaultBranchName(&header).c_str(),
582                   (*subpacket)->Class()->GetName(), subpacket);
583            TTreeMap.insert(RootTreeMap::value_type(type, tree));
584      }
585    }
Legend:
Removed from v.3.0  
changed lines
  Added in v.6.9
  ViewVC Help
Powered by ViewVC 1.1.23