---

/Go4DynamicList/TGo4DynamicEntry.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4DynamicEntry.h"

#include <iostream.h>

#include "TDataMember.h"
#include "TBaseClass.h"

#include "Go4Log/TGo4Log.h"
#include "Go4ConditionsBase/TGo4Condition.h"
#include "Go4Event/TGo4EventElement.h"
#include "Go4Analysis/TGo4AnalysisImp.h"
#include "TGo4DynamicEntryStatus.h"
#include "TGo4DynamicListException.h"

const Text_t TGo4DynamicEntry::fgcNOCONDITION[]="No Condition";
const Text_t TGo4DynamicEntry::fgcNODATA[]="No Data";
const Text_t TGo4DynamicEntry::fgcNOEVENT[]="No Event";
const UInt_t TGo4DynamicEntry::fguMAXCONDIMENSION=__MAXCONDIM__;

TGo4DynamicEntry::TGo4DynamicEntry()
//: TNamed("Default dynamic Entry","This is a Go4 dynamic entry"),
:  fbProcessEntry(kTRUE),fbPointerInitDone(kFALSE),fxCondition(0)
{
TRACE((15,"TGo4DynamicEntry::TGo4DynamicEntry()",__LINE__, __FILE__));
//fxConditionName=fgcNOCONDITION;
//for (UInt_t t=0; t<fguMAXCONDIMENSION;++t)
//   {
//       // set names to defaults.
//       SetConEventName(t,fgcNOEVENT);
//       SetConVarName(t,fgcNODATA);
//   }
//Reset();
}


TGo4DynamicEntry::TGo4DynamicEntry(const Text_t* name)
: TNamed(const_cast <Text_t*> (name) ,"This is a Go4 dynamic entry"),
   fbProcessEntry(kTRUE), fbPointerInitDone(kFALSE), fxCondition(0)
{
TRACE((15,"TGo4DynamicEntry::TGo4DynamicEntry(Text_t *)",__LINE__, __FILE__));
fxConditionName=fgcNOCONDITION;
for (UInt_t t=0; t<fguMAXCONDIMENSION;++t)
   {
       // set names to defaults.
       SetConEventName(t,fgcNOEVENT);
       SetConVarName(t,fgcNODATA);
   }
Reset();
}

TGo4DynamicEntry::~TGo4DynamicEntry()
{
TRACE((15,"TGo4DynamicEntry::~TGo4DynamicEntry()",__LINE__, __FILE__));
//delete [] fcConEventName;
//delete [] fcConVarName;
}

void TGo4DynamicEntry::UpdateStatus(TGo4DynamicEntryStatus * state)
{
TRACE((12,"TGo4DynamicEntry::UpdateStatus(TGo4DynamicEntryStatus* )",__LINE__, __FILE__));
   if (state)
      {
         if(fxCondition)
            {
               state->SetCondition(fxCondition);
            }
         else
            {
               state->fxConditionName=fxConditionName;
               state->fxConditionClass="no pointer";
            }
         state->SetFlags(fbProcessEntry, fbPointerInitDone);
         state->SetConEventNames(fxConEventName);
         state->SetConVarNames(fxConVarName);
      }
   else
      { }
}

void TGo4DynamicEntry::CleanupCondition(TGo4Condition * con)
{
TRACE((12,"TGo4DynamicEntry::CleanupCondition(TGo4Condition*)",__LINE__, __FILE__));
if(fxCondition==con)
   TGo4DynamicEntry::Reset();
}

void TGo4DynamicEntry::Reset()
{
TRACE((12,"TGo4DynamicEntry::Reset()",__LINE__, __FILE__));
   fxCondition=0;
   fbPointerInitDone=kFALSE;
   for(UInt_t t =0; t<fguMAXCONDIMENSION; ++t)
   {
      fxConDataFloat[t]=0;
      fxConDataDouble[t]=0;
      fxConDataInt[t]=0;
      fxConDataShort[t]=0;
      fxConDataChar[t]=0;
      fxConDataLong[t]=0;
      fxConDataBool[t]=0;
      fxConDataUInt[t]=0;
      fxConDataUShort[t]=0;
      fxConDataUChar[t]=0;
      fxConDataULong[t]=0;
      fxConEvent[t]=0;
   }

}

void TGo4DynamicEntry::InitPointers()
{
TRACE((42,"TGo4DynamicEntry::InitPointers()",__LINE__, __FILE__));
   Reset(); // make sure pointers init to 0
   TGo4Analysis* ana= TGo4Analysis::Instance();
   if(fxConditionName.Contains(fgcNOCONDITION))
      {
         //cout <<"iiiiiiiiiInitPointers no Condition "<< endl;
         fxCondition=0;
      }
   else
      {
         fxCondition= ana->GetAnalysisCondition(fxConditionName.Data());
      }
   if(fxCondition)
      {
         for(UInt_t u=0; u< fguMAXCONDIMENSION; ++u)
            {
             if(fxConEventName[u].Contains(fgcNOEVENT))
                {
                   //cout <<"iiiiiiiiicInitPointers condevent zero for " << u << endl;
                   fxConEvent[u]=0;
                }
              else
                {
                   fxConEvent[u]=ana->GetEventStructure(fxConEventName[u].Data());
                   //cout <<"iiiiiiiiicInitPointers found event "<<fxConEventName[u].Data()<< " for " << u << endl;
                }
            // now try to find pointer to data: use offset of TClass?
            if(fxConEvent[u])
               {
                  // we have pointer to the event in u direction!
                  //cout <<"iiiiiiiiiInitPointers ceventname["<<u<<"]= " << fxConEvent[u]->Data() << endl;
                  // note: root assigns Long_t according to
                  // architecture, i.e. 4 byte on 32bit, 8 byte on 64bit sytems
                  // this should be correct type for address:
                  Long_t base = (Long_t) (fxConEvent[u]);
                  Long_t offset=0;
                  TClass* eventclass=fxConEvent[u]->IsA();
                  if(eventclass)
                     {
                        TDataMember* eventmember;
                        if(fxConVarName[u].Contains(fgcNODATA))
                           {
                               //cout <<"iiiiiiiiiInitPointers no event data "<<u << endl;
                               eventmember=0;
                           }
                         else
                            {
                               const Text_t* memname=fxConVarName[u].Data();
                               //cout <<"iiiiiiiiiInitPointers got membername: "<< memname<< endl;
                               eventmember=FindDataMember(eventclass,memname,&offset);
                            }
                         if(eventmember)
                            {
                                const Text_t* tname=eventmember->GetFullTypeName();
                                if(!strcmp(tname,"Float_t"))
                                {
                                   //cout <<"iiiiiiiiiInitPointers Condition inits Float_t for "<< u  << endl;
                                   fxConDataFloat[u]=(Float_t*) (base+offset);
                                }
                                else if (!strcmp(tname,"Double_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Double_t for "<< u  << endl;
                                       fxConDataDouble[u]=(Double_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"Int_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Int_t for "<< u  << endl;
                                       fxConDataInt[u]=(Int_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"Short_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Short_t for "<< u  << endl;
                                       fxConDataShort[u]=(Short_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"Char_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Char_t for "<< u  << endl;
                                       fxConDataChar[u]=(Char_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"Long_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Long_t for "<< u  << endl;
                                       fxConDataLong[u]=(Long_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"Bool_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits Bool_t for "<< u  << endl;
                                       fxConDataBool[u]=(Bool_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"UInt_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits UInt_t for "<< u  << endl;
                                       fxConDataUInt[u]=(UInt_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"UShort_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits UShort_t for "<< u  << endl;
                                       fxConDataUShort[u]=(UShort_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"UChar_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits UChar_t for "<< u  << endl;
                                       fxConDataUChar[u]=(UChar_t*) (base+offset);
                                  }
                                else if (!strcmp(tname,"ULong_t"))
                                  {
                                       //cout <<"iiiiiiiiiInitPointers Condition inits ULong_t for "<< u  << endl;
                                       fxConDataULong[u]=(ULong_t*) (base+offset);
                                  }
                                else
                                   {
                                    throw TGo4DynamicListException(this,
                                    "Dynamic Dynamic Entry %s failed to Init Data Pointers: Type %s of member %s is currently not supported !!!",
                                       GetName(), tname, eventmember->GetName());
                                   } // if(!strcmp(tname,"Float_t"))
                            }
                            else
                               {
                                  //cout <<"iiiiiiiii cond InitPointers no member" << u << endl;
                               } // if(eventmember)
                     } // if(eventclass)
               }
               else
                  {
                     //cout <<"iiiiiiiii cond InitPointers no eventpointer "<< u << endl;
                  } // if fxConEvent[u]
            }// for
      }
      else
      {
         //cout <<"iiiiiiiii cond InitPointers no condition" << endl;
      } // if(fxCondition)
   fbPointerInitDone=kTRUE;
}

Bool_t TGo4DynamicEntry::TestCondition()
{
TRACE((12,"TGo4DynamicEntry::TestCondition()",__LINE__, __FILE__));
Bool_t rev=kFALSE;
if(!fbPointerInitDone) InitPointers();
if(fxCondition)
   {
// first test how many pointers to external data are exisiting.
// depending on that, call test functions of conditions with
// one, two, or n variables. Otherwise get last result of
// given condition.
   Axis_t dat[fguMAXCONDIMENSION]={0};
   UInt_t j,dimension;
   // find out how many dimensions are set for condition:
   for(dimension=0;dimension<fguMAXCONDIMENSION; ++dimension)
      {
          if ( (fxConDataFloat[dimension]==0) &&
               (fxConDataDouble[dimension]==0) &&
               (fxConDataInt[dimension]==0) &&
               (fxConDataShort[dimension]==0) &&
               (fxConDataChar[dimension]==0) &&
               (fxConDataLong[dimension]==0) &&
               (fxConDataBool[dimension]==0) &&
               (fxConDataUInt[dimension]==0) &&
               (fxConDataUShort[dimension]==0) &&
               (fxConDataUChar[dimension]==0) &&
               (fxConDataULong[dimension]==0)    )
                    {
                        break; // maximum condition dimension defined by first index
                               // with all data pointers set to zero.
                    }
      }


   // fill pointers to test variables:
   for(j=0;j<dimension; ++j)
      {
         if(fxConDataFloat[j])             dat[j]   = (*fxConDataFloat[j]);
         else if (fxConDataDouble[j])       dat[j]   = (*fxConDataDouble[j]);
         else if (fxConDataInt[j])          dat[j]   = (*fxConDataInt[j]);
         else if (fxConDataShort[j])       dat[j]   = (*fxConDataShort[j]);
         else if (fxConDataChar[j])       dat[j]   = (*fxConDataChar[j]);
         else if (fxConDataLong[j])        dat[j]   = (*fxConDataLong[j]);
         else if (fxConDataBool[j])        dat[j]   = (*fxConDataBool[j]);
         else if (fxConDataUInt[j])       dat[j]   = (*fxConDataUInt[j]);
         else if (fxConDataUShort[j])       dat[j]   = (*fxConDataUShort[j]);
         else if (fxConDataUChar[j])       dat[j]   = (*fxConDataUChar[j]);
         else if (fxConDataULong[j])        dat[j]   = (*fxConDataULong[j]);

         else throw TGo4DynamicListException(this,
            "Dynamic Dynamic Entry %s Process error: condition value pointer not initialized for axis %d !!!",
                     GetName(), j);
      }

   switch(dimension)
      {
         case 0:
            rev=fxCondition->GetLast(); // no own variables: last result
            //cout << "found zero dimension for condition" << endl;
            break;
         case 1:
            rev=fxCondition->Test(dat[0]);
            //cout << "found one dimension for condition" << endl;
            break;
         case 2:
            rev=fxCondition->Test(dat[0], dat[1]);
            //cout << "found two dimensions for condition" << endl;
            break;
         default:
            rev=fxCondition->GetLast(); // no own variables: last result
            break;
      } // switch(maxt)
  } // if(fxCondition)
else
   {
       rev=kTRUE;
   }
return rev;
}

void TGo4DynamicEntry::SetConVarName(UInt_t ix, const Text_t * name)
{
TRACE((12,"TGo4DynamicEntry::SetConVarName(UInt_t, Text_t*)",__LINE__, __FILE__));
   if(ix>=fguMAXCONDIMENSION) return;
   fxConVarName[ix]=name;
}
void TGo4DynamicEntry::SetConEventName(UInt_t ix, const Text_t * name)
{
TRACE((12,"TGo4DynamicEntry::SetConEventName(UInt_t, Text_t*)",__LINE__, __FILE__));
   if(ix>=fguMAXCONDIMENSION) return;
   fxConEventName[ix]=name;
}
void TGo4DynamicEntry::SetConditionName(const Text_t * name)
       {
            fxConditionName=name;
       }

void TGo4DynamicEntry::SetStatus(TGo4DynamicEntryStatus * state)
{
TRACE((12,"TGo4DynamicEntry::SetStatus(TGo4DynamicEntryStatus*)",__LINE__, __FILE__));
   if(state==0) return;
   SetName(state->GetName());
   EnableProcessing(state->AutoProcessIsEnabled());
   SetConditionName(state->GetConditionName());
   for(UInt_t i=0; i< fguMAXCONDIMENSION; ++i)
      {
         SetConEventName(i,state->GetConEventName(i));
         SetConVarName(i,state->GetConVarName(i));
      }
   Reset();
}

void TGo4DynamicEntry::CleanupEvent(TGo4EventElement * ev)
{
TRACE((12,"TGo4DynamicEntry::CleanupEvent(TGo4EventElement*)",__LINE__, __FILE__));
   for(UInt_t t =0; t<fguMAXCONDIMENSION; ++t)
      {
         if(fxConEvent[t]==ev)
            {
               TGo4DynamicEntry::Reset();
               break;
            }
      }
}

void TGo4DynamicEntry::CleanupHistogram(TH1 * his)
{
 // default implementation, do nothing here since histogram belongs to subclasses
}


TDataMember* TGo4DynamicEntry::FindDataMember(TClass* eventclass,
                                                const Text_t* memname,
                                                Long_t* totaloffset)
{
TRACE((12,"TGo4DynamicEntry::FindDataMember(TClass*)",__LINE__, __FILE__));
if(!eventclass) return 0;
// here we might parse the memname for dots to figure out aggregated classes

// check for array member index:
Long_t indexoffset=0;
Text_t ixtext[256];
Text_t* ixbegin=strstr(memname,"[");
if(ixbegin)
{
//   cout <<"-------------FindDataMember of Entry " << GetName() << endl;
//   cout <<"Found index in member" << memname << endl;
   ixbegin++;
   Text_t* ixend=strstr(ixbegin,"]");
   if(ixend)
   {
      Int_t ixlen=ixend-ixbegin;
      snprintf(ixtext,ixlen+1,"%s",ixbegin);
      indexoffset=atoi(ixtext); // to be used downstream
      if(indexoffset<0) indexoffset=0;
   }
   else {}
}
else {}

TDataMember* eventmember= eventclass->GetDataMember(memname);
if(eventmember)
   {
     *totaloffset+=eventmember->GetOffset();
    }
else
   {
     // if not found directly, check for baseclass members:
     TList* baselist=eventclass->GetListOfBases();
     TIterator* baseiter=baselist->MakeIterator();
     TObject* ob=0;
     while((ob=baseiter->Next()) !=0)
        {
           TBaseClass* baseclass=dynamic_cast<TBaseClass*>(ob);
           if(baseclass)
              {
                  // we have a baseclass
                  TClass* bclass=baseclass->GetClassPointer();
                  // search for member in all superclasses recursively:
                  eventmember=FindDataMember(bclass,memname,totaloffset);
                  if(eventmember)
                    {
                       // we found member in any of the baseclasses
                       *totaloffset+=baseclass->GetDelta();
                          // inc total offset to this by baseclass offset
                          // member offset is relative to TClass (i.e. baseclass here)
                       //cout <<"iiiiiiiiiInitPointers baseclass member: " << eventmember << endl;
                       //cout <<"iiiiiiiiiInitPointers baseclass delta: " << baseclass->GetDelta() << endl;
                       break;
                    } else{ }
              } // if(baseclass)
        } // while
    delete baseiter;
    } // if (eventmember)

// finally, we check for eventmember type to add
//correct offset in case of array:
if(eventmember)
   {
   const Text_t* tname=eventmember->GetFullTypeName();
   //cout <<"Found type "<< tname<<", size:"<< Membersize(tname) << endl;
   // check if given index is inside allocated size:
   Int_t maxindex=eventmember->GetMaxIndex(0);
   if(maxindex<0) maxindex=1; // for non-array members maxindex is -1
   if(indexoffset<maxindex)
      {
         *totaloffset+=indexoffset*Membersize(tname);
         //cout <<"totaloffset:"<< *totaloffset<<endl;
      }
   else
      {
      throw TGo4DynamicListException(this,
         "Index %d for array member:%s out of range %s[%d]",
            indexoffset, memname, tname, maxindex);
      }
   // for now, we only handle 1d arrays
   // root allows to check higher dimensions, maybe later...?
   //for(Int_t ii=0; ii<4; ++ii)
   //{
   //   Int_t maxindex=eventmember->GetMaxIndex(ii);
   //   cout <<"Found maxindex "<<maxindex<<" for dimension "<<ii << endl;
   //}
   }



return eventmember;
}

Int_t TGo4DynamicEntry::Membersize(const Text_t* tname)
{
Int_t rev=0;
if(!strcmp(tname,"Float_t"))          rev=sizeof(Float_t);
else if (!strcmp(tname,"Double_t")) rev=sizeof(Double_t);
else if (!strcmp(tname,"Int_t"))      rev=sizeof(Int_t);
else if (!strcmp(tname,"Short_t"))   rev=sizeof(Short_t);
else if (!strcmp(tname,"Char_t"))   rev=sizeof(Char_t);
else if (!strcmp(tname,"Long_t"))   rev=sizeof(Long_t);
else if (!strcmp(tname,"Bool_t"))   rev=sizeof(Bool_t);
else if (!strcmp(tname,"UInt_t"))   rev=sizeof(UInt_t);
else if (!strcmp(tname,"UShort_t"))   rev=sizeof(UShort_t);
else if (!strcmp(tname,"UChar_t"))   rev=sizeof(UChar_t);
else if (!strcmp(tname,"ULong_t"))   rev=sizeof(ULong_t);
else   rev=0;
return rev;
}



ClassImp(TGo4DynamicEntry)




//----------------------------END OF GO4 SOURCE FILE ---------------------

---