#include <EDepSimKinemPassThrough.hh>

Public Types
typedef std::map< const TTree *, int >	TreeToInt
	for relating input tree pointers to the input file. More...

Public Member Functions
	~KinemPassThrough ()

bool	AddInputTree (const TTree inputTreePtr, const char inputFileName, const char *generatorName)

bool	AddEntry (const TTree *inputTreePtr, const int origEntry)

int	LastEntryNumber ()

Static Public Member Functions
static EDepSim::KinemPassThrough *	GetInstance ()

Private Member Functions
	KinemPassThrough ()
	Private constructor. More...

void	CreateInternalTrees ()

void	CleanUp ()
	Clean up all of the allocated pointers. More...

void	Init ()
	Set default values for all fields. More...

std::string	SetInputFileName (std::string name)
	Set the name of the input file being read. More...

Private Attributes
TTree *	fPersistentTree
	Persistent tree that stores entries from multiple temp trees. More...

TChain *	fInputTreeChain
	TChain to store input trees. More...

std::string	fFirstTreeName
	Store the first tree name. More...

TreeToInt	fInputTreeMap
	for relating input tree pointers to the input file. More...

TreeToInt	fFirstEntryMap
	for relating input tree to first entry in TChain. More...

std::vector< std::string >	fFileList
	Used to store list of files before they are written to tree. More...

TTree *	fInputKinemTree
	Tree relating all events in the persistent tree to an input file. More...

int	fInputFileNumber

int	fOrigEntryNumber

TTree *	fInputFilesTree
	Tree containing list of input files. More...

char	fInputFileName [1024]
	Used to fill input file list tree with input file name. More...

char	fInputFileGenerator [128]
	Used to fill the name of the generator for this file. More...

char	fInputFileTreeName [128]
	Used to fill the name of the tree for this file. More...

double	fInputFilePOT
	Used to fill input file list tree "filePOT" field. More...

int	fInputFileEntries

Static Private Attributes
static EDepSim::KinemPassThrough *	fKinemPassThrough = NULL
	Static pointer to singleton instance. More...

Detailed Description

Definition at line 54 of file EDepSimKinemPassThrough.hh.

Member Typedef Documentation

typedef std::map<const TTree *, int> EDepSim::KinemPassThrough::TreeToInt

for relating input tree pointers to the input file.

Definition at line 57 of file EDepSimKinemPassThrough.hh.

Constructor & Destructor Documentation

EDepSim::KinemPassThrough::~KinemPassThrough ( )

Definition at line 42 of file EDepSimKinemPassThrough.cc.

                                            {
     CleanUp();
 }

EDepSim::KinemPassThrough::KinemPassThrough ( )

private

Private constructor.

Definition at line 46 of file EDepSimKinemPassThrough.cc.

                                           {
     Init();
     EDepSimNamedDebug("PassThru",
                     "Have called the EDepSim::KinemPassThrough constructor."); 
 }

Member Function Documentation

bool EDepSim::KinemPassThrough::AddEntry	(	const TTree *	inputTreePtr,
		const int	origEntry
	)

Copy the i'th entry from segment of the TChain corresponding to the input tree pointed at (in detsim) by inputTreePtr.

Definition at line 199 of file EDepSimKinemPassThrough.cc.

                                                                        {
     if (!fPersistentTree) {       
         EDepSimNamedDebug("PassThru", "Cannot copy entry from tree "
                         "since  fPersistentTree is NULL."); 
         return false;
     }
 
     CreateInternalTrees();
 
     // Search the input tree maps for a TTree pointer that matches the
     // inputTree.
     TreeToInt::iterator treeid_iter = fInputTreeMap.find(inputTree);
     TreeToInt::iterator firstentry_iter = fFirstEntryMap.find(inputTree);
     if (treeid_iter == fInputTreeMap.end() 
         || firstentry_iter == fFirstEntryMap.end()) {
         EDepSimError("Cannot copy entry from tree not in list of input trees.");
         return false;
     }
   
     fInputFileNumber = treeid_iter->second;
     int first_event_in_chain = firstentry_iter->second;
   
     // Now fill temp tree with i'th entry from first_event_in_chain of TChain
     // of input trees.
     if (fInputTreeChain->GetEntry(origEntry+first_event_in_chain)) {
         fOrigEntryNumber = origEntry;
         fPersistentTree->Fill();
         fInputKinemTree->Fill(); // Also store book keeping info.
     
         EDepSimNamedTrace("PassThru", 
                         "Copied entry " << origEntry
                         << " from " << fFirstTreeName
                         <<  " tree in file "
                         << fFileList[fInputFileNumber]); 
     
         return true;
     }
 
     EDepSimError("Cannot copy entry " << origEntry+first_event_in_chain 
                << " from TChained Tree.  Make sure entry is in input tree!"); 
     return false;
 }

bool EDepSim::KinemPassThrough::AddInputTree	(	const TTree *	inputTreePtr,
		const char *	inputFileName,
		const char *	generatorName
	)

Add an input tree to the TChain of input trees that rootracker entries will be copied from. A map between the tree pointer that detsim is using and the correct segment of the TChain is also made.

Definition at line 61 of file EDepSimKinemPassThrough.cc.

                                                                     {
     EDepSimNamedDebug("PassThru",
                     "Adding a generator mc-truth input"
                     " tree to the list of input trees that can be used."); 
 
     CreateInternalTrees();
 
     if (!fInputFilesTree || !fInputKinemTree) {
         EDepSimError("Pass-through trees not created.");  
         return false;
     }
     
     if (inputTreePtr == NULL) {
         EDepSimError("NULL input tree pointer.  TTree not saved.");  
         return false;
     }
   
     std::string inputTreeName(inputTreePtr->GetName()); 
     // check that all input trees have the same name. In future may add  
     // functionality so that maintain two persistent trees simultaneously 
     if (!fInputTreeChain) {
         fFirstTreeName = inputTreeName;
         fInputTreeChain = new TChain(fFirstTreeName.c_str());
     }
   
     if (fFirstTreeName != inputTreeName) {
         EDepSimError("Input tree name not compatible: "
                    "  All pass-through trees must have same name.");
         return false;
     }
 
     // check if its already been added
     if (fInputTreeMap.find(inputTreePtr) != fInputTreeMap.end()) {
         EDepSimError("Input tree already in chain.");
         return false;
     }
   
     //  Add input tree to TChain
     fInputTreeChain->Add(inputFileName);
 
     // Clone tree if this has not been done already. We check if fPersistent
     // tree is NULL rather than looking to see if fInputTreeChain has a list
     // of clones (as for a TChain this always returns false). 
     if (fPersistentTree == NULL) {
         EDepSimNamedDebug("PassThru", "Clone the input TTree");
         fPersistentTree = (TTree*) fInputTreeChain->CloneTree(0);
     }
 
     // Add the input file to the file list so it can be saved in the output
     // tree.  This is used for error reporting and debugging. 
     fFileList.push_back(SetInputFileName(inputFileName));
 
     // fill in input tree maps
     fInputTreeMap[inputTreePtr]  = fFileList.size() - 1;
     fFirstEntryMap[inputTreePtr] = (fInputTreeChain->GetEntries() 
                                     - inputTreePtr->GetEntries());
     
     // Copy the input file name and make sure it's 0 terminated.
     std::strncpy(fInputFileName, fFileList.back().c_str(),
                  sizeof(fInputFileName));
     fInputFileName[sizeof(fInputFileName)-1] = 0;
     // Copy the generator name and make sure it's 0 terminated.
     std::strncpy(fInputFileGenerator, generatorName, 
                  sizeof(fInputFileGenerator));
     // Copy the generator name and make sure it's 0 terminated.
     std::strncpy(fInputFileTreeName, inputTreeName.c_str(), 
                  sizeof(fInputFileTreeName));
     fInputFileTreeName[sizeof(fInputFileTreeName)-1] = 0;
     fInputFilePOT = inputTreePtr->GetWeight();
     fInputFileEntries = inputTreePtr->GetEntries();
     fInputFilesTree->Fill();
 
     EDepSimNamedDebug("PassThru", 
                     "Have added a " << fFirstTreeName 
                     << " tree from the input file "<< inputFileName); 
     
     // Now can start copying events
     return true;
 }

void EDepSim::KinemPassThrough::CleanUp ( )

private

Clean up all of the allocated pointers.

Definition at line 262 of file EDepSimKinemPassThrough.cc.

                                       {
     // Delete the output trees so that they can not be written twice (which
     // they would be as detsim calls TFile::Write() which writes anything in
     // memory to the TFile.
   
     if (fPersistentTree) {delete fPersistentTree;}
     if (fInputFilesTree) {delete fInputFilesTree;}
     if (fInputKinemTree) {delete fInputKinemTree;}
     if (fInputTreeChain) {delete fInputTreeChain;}
 
     Init();
 
     return;
 }

void EDepSim::KinemPassThrough::CreateInternalTrees ( )

private

Create the bookkeeping and file list trees. This also creates the directory.

Definition at line 143 of file EDepSimKinemPassThrough.cc.

                                                   {
     TFile* output = NULL;;
     TIter files(gROOT->GetListOfFiles());
     TObject* object;
     while ((object = files.Next())) {
         TFile* file = dynamic_cast<TFile*>(object);
         if (!file) continue;
         if (!file->IsOpen()) continue;
         std::string fileOption(file->GetOption());
         if (fileOption.find("CREATE") != std::string::npos) {
             output = file;
             continue;
         }
     }
     
     if (!output) {
         return;
     }
     
     output->cd();
 
     // Check if the directory exists (and possibly create it).
     if (!output->Get(PASSTHRUDIR)) {
         output->mkdir(PASSTHRUDIR,"DETSIM Pass-Through Information");
     }
 
     // Make sure we are in the pass-thru directory.
     output->cd(PASSTHRUDIR);
 
     // Create the book keeping three that connects a particular entry to the
     // entry in the original file.
     if (fInputKinemTree == NULL) {
         EDepSimNamedDebug("PassThru", "Create InputKinem TTree");
         // This adds the tree to the current output file.
         fInputKinemTree = new TTree("InputKinem",
                                      "Map kinematics with input files");
         fInputKinemTree->Branch("inputFileNum" , &fInputFileNumber); 
         fInputKinemTree->Branch("inputEntryNum", &fOrigEntryNumber);
     }
 
     if (fInputFilesTree == NULL) {
         EDepSimNamedDebug("PassThru","Create inputFileList TTree");
         // This adds the tree to the current output file.
         fInputFilesTree = new TTree("InputFiles","Input file information");
         fInputFilesTree->Branch("fileName", &fInputFileName,
                                 "fileName/C");
         fInputFilesTree->Branch("generatorName", &fInputFileGenerator, 
                                 "generatorName/C");
         fInputFilesTree->Branch("treeName", &fInputFileTreeName, 
                                 "treeName/C");
         fInputFilesTree->Branch("filePOT", &fInputFilePOT);
         fInputFilesTree->Branch("fileEntries", &fInputFileEntries);
     }
 }

EDepSim::KinemPassThrough * EDepSim::KinemPassThrough::GetInstance ( )

static

Returns (or initialises if first time) the instance of the singleton.

Definition at line 52 of file EDepSimKinemPassThrough.cc.

                                                                {
     EDepSimNamedTrace("PassThru",
                     "Get pointer to EDepSim::KinemPassThrough instance."); 
     if (fKinemPassThrough) return fKinemPassThrough;
     fKinemPassThrough = new EDepSim::KinemPassThrough();
     if (!fKinemPassThrough) std::abort();
     return fKinemPassThrough;
 }

void EDepSim::KinemPassThrough::Init ( void )

private

Set default values for all fields.

Definition at line 277 of file EDepSimKinemPassThrough.cc.

                                    {
     fPersistentTree = NULL; 
     fInputFilesTree = NULL;
     fInputKinemTree = NULL;
     fInputTreeChain = NULL;
     fFirstTreeName.clear();
     fFileList.clear();
     fInputFileNumber = -1;
     fOrigEntryNumber = -1;
     fInputFileName[0] = 0;
     fInputFileGenerator[0] = 0;
     fInputFileTreeName[0] = 0;
     return;
 }

int EDepSim::KinemPassThrough::LastEntryNumber ( )

Return the position (entry number) that the most recent entry to be copied to the pass-through tree will have.

Definition at line 242 of file EDepSimKinemPassThrough.cc.

                                              {
     // The most recent entry number is the sum of the entry number in
     // the current tree plus the number of entries already stored in 
     // persistent tree.
     if (!fPersistentTree) {
         EDepSimError("No entries in fPersistent tree.");
         return -1;
     }
     return fPersistentTree->GetEntries() - 1;
 }

std::string EDepSim::KinemPassThrough::SetInputFileName ( std::string name )

private

Set the name of the input file being read.

Definition at line 253 of file EDepSimKinemPassThrough.cc.

                                                                   {
     // Remove the path from the input file name. 
     std::string::size_type start_pos = name.rfind("/");
     if (start_pos == std::string::npos) start_pos = 0; else ++start_pos;
     std::string baseName(name,start_pos);
 
     return baseName;
 }