sPhenix code displayed by LXR master/​coresoftware/​offline/​framework/​fun4all/​Fun4AllDstInputManager.cc	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-12-16 09:19:34

 #include "Fun4AllDstInputManager.h"
 
 #include "DBInterface.h"
 #include "Fun4AllReturnCodes.h"
 #include "Fun4AllServer.h"
 
 #include <ffaobjects/RunHeader.h>
 #include <ffaobjects/SyncDefs.h>
 #include <ffaobjects/SyncObject.h>
 
 #include <phool/PHCompositeNode.h>
 #include <phool/PHNodeIOManager.h>
 #include <phool/PHNodeIntegrate.h>
 #include <phool/PHNodeIterator.h>  // for PHNodeIterator
 #include <phool/PHObject.h>        // for PHObject
 #include <phool/getClass.h>
 #include <phool/phool.h>  // for PHWHERE, PHReadOnly, PHRunTree
 #include <phool/phooldefs.h>
 
 #include <TSystem.h>
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #include <boost/algorithm/string.hpp>
 #pragma GCC diagnostic pop
 
 #include <cassert>
 #include <cstdlib>
 #include <iostream>  // for operator<<, basic_ostream, endl
 #include <utility>   // for pair
 #include <vector>    // for vector
 
 class TBranch;
 
 Fun4AllDstInputManager::Fun4AllDstInputManager(const std::string &name, const std::string &nodename, const std::string &topnodename)
   : Fun4AllInputManager(name, nodename, topnodename)
 {
   return;
 }
 
 Fun4AllDstInputManager::~Fun4AllDstInputManager()
 {
   delete m_IManager;
   delete m_RunNodeSum;
   return;
 }
 
 int Fun4AllDstInputManager::fileopen(const std::string &filenam)
 {
   Fun4AllServer *se = Fun4AllServer::instance();
   if (IsOpen())
   {
     std::cout << "Closing currently open file "
               << FileName()
               << " and opening " << filenam << std::endl;
     fileclose();
   }
   FileName(filenam);
   fullfilename = DBInterface::instance()->location(FileName());
   if (Verbosity() > 0)
   {
     std::cout << Name() << ": opening file " << fullfilename << std::endl;
   }
   // sanity check - the IManager must be nullptr when this method is executed
   // if not something is very very wrong and we must not continue
   if (m_IManager)
   {
     std::cout << PHWHERE << " IManager pointer is not nullptr but " << m_IManager
               << std::endl;
     std::cout << "Send mail to off-l with this printout and the macro you used"
               << std::endl;
     std::cout << "Trying to execute IManager->print() to display more info"
               << std::endl;
     std::cout << "Code will probably segfault now" << std::endl;
     m_IManager->print();
     std::cout << "Have someone look into this problem - Exiting now" << std::endl;
     exit(1);
   }
   // first read the runnode if not disabled
   if (m_ReadRunTTree)
   {
     m_IManager = new PHNodeIOManager(fullfilename, PHReadOnly, PHRunTree);
     if (m_IManager->isFunctional())
     {
       m_RunNode = se->getNode(RunNode, TopNodeName());
       m_IManager->read(m_RunNode);
       // get the current run number
       RunHeader *runheader = findNode::getClass<RunHeader>(m_RunNode, "RunHeader");
       if (runheader)
       {
         SetRunNumber(runheader->get_RunNumber());
       }
       // delete our internal copy of the runnode when opening subsequent files
       if (m_RunNodeCopy)
       {
         std::cout << PHWHERE
                   << " The impossible happened, we have a valid copy of the run node "
                   << m_RunNodeCopy->getName() << " which should be a nullptr"
                   << std::endl;
         gSystem->Exit(1);
       }
       m_RunNodeCopy = new PHCompositeNode("RUNNODECOPY");
       if (!m_RunNodeSum)
       {
         m_RunNodeSum = new PHCompositeNode("RUNNODESUM");
       }
       PHNodeIOManager *tmpIman = new PHNodeIOManager(fullfilename, PHReadOnly, PHRunTree);
       tmpIman->read(m_RunNodeCopy);
       delete tmpIman;
 
       PHNodeIntegrate integrate;
       integrate.RunNode(m_RunNode);
       integrate.RunSumNode(m_RunNodeSum);
       // run recursively over internal run node copy and integrate objects
       PHNodeIterator mainIter(m_RunNodeCopy);
       mainIter.forEach(integrate);
       // we do not need to keep the internal copy, keeping it would crate
       // problems in case a subsequent file does not contain all the
       // runwise objects from the previous file. Keeping this copy would then
       // integrate the missing object again with the old copy
       delete m_RunNodeCopy;
       m_RunNodeCopy = nullptr;
     }
     // DLW: move the delete outside the if block to cover the case where isFunctional() fails
     delete m_IManager;
   }
   // now open the dst node
   dstNode = se->getNode(InputNode(), TopNodeName());
   m_IManager = new PHNodeIOManager(fullfilename, PHReadOnly);
   if (m_IManager->isFunctional())
   {
     IsOpen(1);
     events_thisfile = 0;
     setBranches();                // set branch selections
     AddToFileOpened(FileName());  // add file to the list of files which were opened
                                   // check if our input file has a sync object or not
     if (ReadCacheDisabled())
     {
       m_IManager->DisableReadCache();
     }
     if (m_IManager->NodeExist(syncdefs::SYNCNODENAME))
     {
       m_HaveSyncObject = 1;
     }
     else
     {
       m_HaveSyncObject = -1;
     }
 
     return 0;
   }
 
   std::cout << PHWHERE << ": " << Name() << " Could not open file "
             << FileName() << std::endl;
   delete m_IManager;
   m_IManager = nullptr;
   return -1;
 }
 
 int Fun4AllDstInputManager::run(const int nevents)
 {
   if (!IsOpen())
   {
     if (FileListEmpty())
     {
       if (Verbosity() > 0)
       {
         std::cout << Name() << ": No Input file open" << std::endl;
       }
       return -1;
     }
 
     if (OpenNextFile())
     {
       std::cout << Name() << ": No Input file from filelist opened" << std::endl;
       return -1;
     }
   }
   if (Verbosity() > 3)
   {
     std::cout << "Getting Event from " << Name() << std::endl;
   }
 readagain:
   PHCompositeNode *dummy;
   int ncount = 0;
   dummy = m_IManager->read(dstNode);
   while (dummy)
   {
     ncount++;
     if (nevents > 0 && ncount >= nevents)
     {
       break;
     }
     dummy = m_IManager->read(dstNode);
   }
   if (!dummy)
   {
     fileclose();
     if (!OpenNextFile())
     {
       // NOLINTNEXTLINE(hicpp-avoid-goto)
       goto readagain;
     }
     return -1;
   }
   events_total += ncount;
   events_thisfile += ncount;
   // check if the local SubsysReco discards this event
   if (RejectEvent() != Fun4AllReturnCodes::EVENT_OK)
   {
     // NOLINTNEXTLINE(hicpp-avoid-goto)
     goto readagain;
   }
   syncobject = findNode::getClass<SyncObject>(dstNode, syncdefs::SYNCNODENAME);
   return 0;
 }
 
 int Fun4AllDstInputManager::fileclose()
 {
   if (!IsOpen())
   {
     std::cout << Name() << ": fileclose: No Input file open" << std::endl;
     return -1;
   }
   delete m_IManager;
   m_IManager = nullptr;
   IsOpen(0);
   UpdateFileList();
   m_HaveSyncObject = 0;
   return 0;
 }
 
 int Fun4AllDstInputManager::GetSyncObject(SyncObject **mastersync)
 {
   // here we copy the sync object from the current file to the
   // location pointed to by mastersync. If mastersync is a 0 pointer
   // the syncobject is cloned. If mastersync allready exists the content
   // of syncobject is copied
   if (!(*mastersync))
   {
     if (syncobject)
     {
       *mastersync = dynamic_cast<SyncObject *>(syncobject->CloneMe());
       assert(*mastersync);
     }
   }
   else
   {
     *(*mastersync) = *syncobject;  // copy syncobject content
   }
   return Fun4AllReturnCodes::SYNC_OK;
 }
 
 int Fun4AllDstInputManager::SyncIt(const SyncObject *mastersync)
 {
   if (!mastersync)
   {
     std::cout << PHWHERE << Name() << " No MasterSync object, cannot perform synchronization" << std::endl;
     std::cout << "Most likely your first file does not contain a SyncObject and the file" << std::endl;
     std::cout << "opened by the Fun4AllDstInputManager with Name " << Name() << " has one" << std::endl;
     std::cout << "Change your macro and use the file opened by this input manager as first input" << std::endl;
     std::cout << "and you will be okay. Fun4All will not process the current configuration" << std::endl
               << std::endl;
     return Fun4AllReturnCodes::SYNC_FAIL;
   }
   if (!syncobject)
   {
     std::cout << Name() << " no sync object found in this manager but synchronization needed" << std::endl;
     std::cout << "  Check if you have used an empty listfile. If this is not the case - please ask for help" << std::endl;
     std::cout << "This may be a really bad internal problem and cannot continue, exiting now " << std::endl;
     gSystem->Exit(1);
     exit(1);
   }
   int iret = syncobject->Different(mastersync);
   if (iret)  // what to do if files are not in sync
   {
     if (mastersync->EventNumber() == -999999)  // first file does not contain sync object
     {
       std::cout << PHWHERE << " Mastersync not filled, your first file does not contain a SyncObject" << std::endl;
       std::cout << "This Event will not be processed further" << std::endl;
     }
     else  // okay try to resync here
     {
       if (Verbosity() > 3)
       {
         std::cout << "Need to Resync, mastersync evt no: " << mastersync->EventNumber()
                   << ", this Event no: " << syncobject->EventNumber() << std::endl;
         std::cout << "mastersync evt counter: " << mastersync->EventNumber()
                   << ", this Event counter: " << syncobject->EventNumber() << std::endl;
         std::cout << "mastersync run number: " << mastersync->RunNumber()
                   << ", this run number: " << syncobject->RunNumber() << std::endl;
       }
 
       while (syncobject->RunNumber() < mastersync->RunNumber())
       {
         events_skipped_during_sync++;
         if (Verbosity() > 2)
         {
           std::cout << Name() << " Run Number: " << syncobject->RunNumber()
                     << ", master: " << mastersync->RunNumber()
                     << std::endl;
         }
         iret = ReadNextEventSyncObject();
         if (iret)
         {
           return iret;
         }
       }
       int igood = 0;
       if (syncobject->RunNumber() == mastersync->RunNumber())
       {
         igood = 1;
       }
       // only run up the Segment Number if run numbers are identical
       while (syncobject->SegmentNumber() < mastersync->SegmentNumber() && igood)
       {
         events_skipped_during_sync++;
         if (Verbosity() > 2)
         {
           std::cout << Name() << " Segment Number: " << syncobject->SegmentNumber()
                     << ", master: " << mastersync->SegmentNumber()
                     << std::endl;
         }
         iret = ReadNextEventSyncObject();
         if (iret)
         {
           return iret;
         }
       }
       // only run up the Event Counter if run number and segment number are identical
       if (syncobject->SegmentNumber() == mastersync->SegmentNumber() && syncobject->RunNumber() == mastersync->RunNumber())
       {
         igood = 1;
       }
       else
       {
         igood = 0;
       }
       while (syncobject->EventNumber() < mastersync->EventNumber() && igood)
       {
         events_skipped_during_sync++;
         if (Verbosity() > 2)
         {
           std::cout << Name()
                     << ", EventNumber: " << syncobject->EventNumber()
                     << ", master: " << mastersync->EventNumber()
                     << std::endl;
         }
         iret = ReadNextEventSyncObject();
         if (iret)
         {
           return iret;
         }
       }
       // Since up to here we only read the sync object we need to push
       // the current event back into the root file (subtract one from the
       // local root file event counter) so we can read the full event
       // if it syncs, if it does not sync we also read one event too many
       // (otherwise we cannot determine that we are "too far")
       // and also have to push this one back
       PushBackEvents(1);
       if (syncobject->RunNumber() > mastersync->RunNumber() ||        // check if run number too large
           syncobject->EventNumber() > mastersync->EventNumber() ||    // check if event counter too large
           syncobject->SegmentNumber() > mastersync->SegmentNumber())  // check segment number too large
       {
         // the event from first file which determines the mastersync
         // and which we are trying to find on this file does not exist on this file
         // so: return failure. This will cause the input managers to read
         // the next event from the input files file
         return Fun4AllReturnCodes::SYNC_FAIL;
       }
       // Here the event counter and segment number and run number do agree - we found the right match
       // now read the full event (previously we only read the sync object)
       PHCompositeNode *dummy;
       dummy = m_IManager->read(dstNode);
       if (!dummy)
       {
         std::cout << PHWHERE << " " << Name() << " Could not read full Event" << std::endl;
         std::cout << "PLEASE NOTIFY PHENIX-OFF-L and post the macro you used" << std::endl;
         fileclose();
         return Fun4AllReturnCodes::SYNC_FAIL;
       }
       iret = syncobject->Different(mastersync);  // final check if they really agree
       if (iret)                                  // if not things are severely wrong
       {
         std::cout << PHWHERE << " MasterSync and SyncObject of " << Name() << " are different" << std::endl;
         std::cout << "This Event will not be processed further, here is some debugging info:" << std::endl;
         std::cout << "PLEASE NOTIFY PHENIX-OFF-L and post the macro you used" << std::endl;
         std::cout << "MasterSync->identify:" << std::endl;
         mastersync->identify();
         std::cout << Name() << ": SyncObject->identify:" << std::endl;
         syncobject->identify();
         return Fun4AllReturnCodes::SYNC_FAIL;
       }
       if (Verbosity() > 3)
       {
         std::cout << PHWHERE << " Resynchronization successfull for " << Name() << std::endl;
         std::cout << "MasterSync->identify:" << std::endl;
         mastersync->identify();
         std::cout << Name() << ": SyncObject->identify:" << std::endl;
         syncobject->identify();
       }
     }
   }
   //    else
   //        {
   //            std::cout << "No Need to Resync" << std::endl;
   //        }
   return Fun4AllReturnCodes::SYNC_OK;
 }
 
 int Fun4AllDstInputManager::ReadNextEventSyncObject()
 {
 readnextsync:
   static int readfull = 0;  // for some reason all the input managers need to see the same (I think, should look at this at some point)
   if (!m_IManager)          // in case the old file was exhausted and there is no new file opened
   {
     return Fun4AllReturnCodes::SYNC_FAIL;
   }
   if (syncbranchname.empty())
   {
     readfull = 1;  // we need to read a full event to set the root branches to phool nodes right when a new file has been opened
     std::map<std::string, TBranch *>::const_iterator bIter;
     for (bIter = m_IManager->GetBranchMap()->begin(); bIter != m_IManager->GetBranchMap()->end(); ++bIter)
     {
       if (Verbosity() > 2)
       {
         std::cout << Name() << ": branch: " << bIter->first << std::endl;
       }
       std::string delimeters = phooldefs::branchpathdelim;  // + phooldefs::legacypathdelims;
       std::vector<std::string> splitvec;
       boost::split(splitvec, bIter->first, boost::is_any_of(delimeters));
       for (auto &ia : splitvec)  // -1 so we skip the node name
       {
         if (ia == syncdefs::SYNCNODENAME)
         {
           syncbranchname = bIter->first;
           break;
         }
       }
       if (!syncbranchname.empty())
       {
         break;
       }
     }
     if (syncbranchname.empty())
     {
       std::cout << PHWHERE << "Could not locate Sync Branch" << std::endl;
       std::cout << "Please check for it in the following list of branch names and" << std::endl;
       std::cout << "PLEASE NOTIFY PHENIX-OFF-L and post the macro you used" << std::endl;
       for (bIter = m_IManager->GetBranchMap()->begin(); bIter != m_IManager->GetBranchMap()->end(); ++bIter)
       {
         std::cout << bIter->first << std::endl;
       }
       return Fun4AllReturnCodes::SYNC_FAIL;
     }
   }
   size_t EventOnDst = 0;
   int itest = 0;
   if (!readfull)
   {
     // if all files are exhausted, the IManager is deleted and set to nullptr
     // so check if IManager is valid before getting a new event
     if (m_IManager)
     {
       EventOnDst = m_IManager->getEventNumber();  // this returns the next number of the event
       itest = m_IManager->readSpecific(EventOnDst, syncbranchname);
     }
     else
     {
       if (Verbosity() > 2)
       {
         std::cout << Name() << ": File exhausted while resyncing" << std::endl;
       }
       return Fun4AllReturnCodes::SYNC_FAIL;
     }
   }
   else
   {
     if (m_IManager->read(dstNode))
     {
       itest = 1;
     }
     else
     {
       itest = 0;
     }
   }
   if (!itest)
   {
     if (Verbosity() > 2)
     {
       std::cout << Name() << ": File exhausted while resyncing" << std::endl;
     }
     fileclose();
     if (OpenNextFile())
     {
       return Fun4AllReturnCodes::SYNC_FAIL;
     }
     syncbranchname.clear();  // clear the sync branch name, who knows - it might be different on new file
     // NOLINTNEXTLINE(hicpp-avoid-goto)
     goto readnextsync;
   }
   if (!readfull)
   {
     EventOnDst++;
     m_IManager->setEventNumber(EventOnDst);  // update event number in phool io manager
   }
   else
   {
     readfull = 0;
   }
   return 0;
 }
 
 int Fun4AllDstInputManager::BranchSelect(const std::string &branch, const int iflag)
 {
   if (IsOpen())
   {
     std::cout << "BranchSelect(\"" << branch << "\", " << iflag
               << ") : Input branches can only selected for reading before fileopen is called proceeding without input branch selection" << std::endl;
     return -1;
   }
   // if iflag > 0 the branch is set to read
   // if iflag = 0, the branch is set to NOT read
   // if iflag < 0 the branchname is erased from our internal branch read map
   // this does not have any effect on phool yet
   if (iflag < 0)
   {
     std::map<const std::string, int>::iterator branchiter;
     branchiter = branchread.find(branch);
     if (branchiter != branchread.end())
     {
       branchread.erase(branchiter);
     }
     return 0;
   }
   int readit = 0;
   if (iflag > 0)
   {
     if (Verbosity() > 1)
     {
       std::cout << "Setting Root Tree Branch: " << branch << " to read" << std::endl;
     }
     readit = 1;
   }
   else
   {
     if (Verbosity() > 1)
     {
       std::cout << "Setting Root Tree Branch: " << branch << " to NOT read" << std::endl;
     }
   }
   branchread[branch] = readit;
   return 0;
 }
 
 int Fun4AllDstInputManager::setBranches()
 {
   if (m_IManager)
   {
     if (!branchread.empty())
     {
       std::map<const std::string, int>::const_iterator branchiter;
       for (branchiter = branchread.begin(); branchiter != branchread.end(); ++branchiter)
       {
         m_IManager->selectObjectToRead(branchiter->first, branchiter->second);
         if (Verbosity() > 0)
         {
           std::cout << branchiter->first << " set to " << branchiter->second << std::endl;
         }
       }
       // protection against switching off the sync variables
       // only implemented in the Sync Manager
       setSyncBranches(m_IManager);
     }
   }
   else
   {
     std::cout << PHWHERE << " " << Name() << ": You can only call this function after a file has been opened" << std::endl;
     std::cout << "Do not worry, the branches will be set as soon as you open a file" << std::endl;
     return -1;
   }
   return 0;
 }
 
 int Fun4AllDstInputManager::setSyncBranches(PHNodeIOManager *IMan)
 {
   // protection against switching off the sync variables
   for (auto &i : syncdefs::SYNCVARS)
   {
     IMan->selectObjectToRead(i, true);
   }
   return 0;
 }
 
 void Fun4AllDstInputManager::Print(const std::string &what) const
 {
   if (what == "ALL" || what == "BRANCH")
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "List of selected branches in Fun4AllDstInputManager " << Name() << ":" << std::endl;
 
     std::map<const std::string, int>::const_iterator iter;
     for (iter = branchread.begin(); iter != branchread.end(); ++iter)
     {
       std::cout << iter->first << " is switched ";
       if (iter->second)
       {
         std::cout << "ON";
       }
       else
       {
         std::cout << "OFF";
       }
       std::cout << std::endl;
     }
   }
   if ((what == "ALL" || what == "PHOOL") && m_IManager)
   {
     // loop over the map and print out the content (name and location in memory)
     std::cout << "--------------------------------------" << std::endl
               << std::endl;
     std::cout << "PHNodeIOManager print in Fun4AllDstInputManager " << Name() << ":" << std::endl;
     m_IManager->print();
   }
   Fun4AllInputManager::Print(what);
   return;
 }
 
 int Fun4AllDstInputManager::PushBackEvents(const int i)
 {
   if (m_IManager)
   {
     unsigned EventOnDst = m_IManager->getEventNumber();
     EventOnDst -= static_cast<unsigned>(i);
     m_IManager->setEventNumber(EventOnDst);
     return 0;
   }
   std::cout << PHWHERE << Name() << ": could not push back events, Imanager is NULL"
             << " probably the dst is not open yet (you need to call fileopen or run 1 event for lists)" << std::endl;
   return -1;
 }
 
 int Fun4AllDstInputManager::HasSyncObject() const
 {
   if (m_HaveSyncObject)
   {
     return m_HaveSyncObject;
   }
   if (IsOpen())
   {
     std::cout << PHWHERE << "HasSyncObject() not initialized check the calling order" << std::endl;
     gSystem->Exit(1);
     exit(1);
   }
   return 0;
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team