/afs/in2p3.fr/throng/virgo/virgoDev/SoftFlorent/GWOLLUM/v2r2/src/Coinc/Ntuple.h

Go to the documentation of this file.

//  Author : florent robinet (LAL - Orsay): robinet@lal.in2p3.fr
#ifndef __Ntuple__
#define __Ntuple__

#include "CUtils.h"
#include "TMath.h"
using namespace std;

#define NETMAX 10

class Tuple {

 public:

  Tuple(vector <int> aStreamIndex);

  virtual ~Tuple(void);
  inline bool IsStreamInside(const int aStreamIndex){
    for(int s=0; s<(int)StreamIndex.size(); s++) if(aStreamIndex==StreamIndex[s]) return true;
    return false;
  };

  inline string GetName(void){ return tname; };

  inline bool IsTheSame(Tuple *aTestTuple){
    if((int)StreamIndex.size()!=aTestTuple->GetNstreams()) return false;
    if((int)Event[0].size()!=aTestTuple->GetNevents()) return false;
    //FIXME: the stream numbers are not compared!!
    for(int s=0; s<(int)StreamIndex.size(); s++)
      for(int e=0; e<(int)Event[0].size(); e++)
    if(Event[s][e]!=aTestTuple->GetEvent(s,e)) return false;
    return false;
  };

  inline bool AddTuple(vector <int> aEvent){
    for(int s=0; s<(int)StreamIndex.size(); s++) Event[s].push_back(aEvent[s]);
    return true;
  };

  inline bool ResetEvents(void){
    for(int s=0; s<(int)StreamIndex.size(); s++) Event[s].clear();
    return true;
  };

  inline bool RemoveEvent(const int aPosition){
    for(int s=0; s<(int)StreamIndex.size(); s++) Event[s].erase (Event[s].begin()+aPosition);
    return true;
  };

  inline int GetNstreams(void){ return (int)StreamIndex.size(); };

  inline int GetNevents(void){ return (int)Event[0].size(); };

  inline int GetEvent(const int aStreamNumber, const int aPosition){
    return Event[aStreamNumber][aPosition];
  };

  inline int GetEventFromStream(const int aStreamIndex, const int aPosition){
    return Event[IndexFromStream[aStreamIndex]][aPosition];
  };
  
  inline vector <int> GetEvents(const int aStreamNumber){
    return Event[aStreamNumber];
  };

  inline vector <int> GetEventsFromStream(const int aStreamIndex){ 
    return Event[IndexFromStream[aStreamIndex]]; 
  };

  inline void PrintEvents(void){
    for(int e=0; e<(int)Event[0].size(); e++){
      for(int s=0; s<(int)StreamIndex.size(); s++) cout<<Event[s][e]<<" ";
      cout<<endl;
    }
    return;
  };

 private:

  string tname;                   
  vector <int> StreamIndex;       
  vector <int> IndexFromStream;   
  vector <int> Event[NETMAX];     

};


class Ntuple {

 public:

  Ntuple(const int aNstreams);

  virtual ~Ntuple(void);
  bool IsStreamInside(const int aStreamNumber, const int aTupleIndex);
 
  bool AddPair(const int aStreamNumber0, const int aStreamNumber1, const int aEventIndex0, const int aEventIndex1);

  bool MakeNtuple(const int aNmax, const bool aUniq=false);

  vector <int> GetEvents(const int aTupleIndex, const int aStreamIndex);

  inline bool ResetEvents(void){
    for(int n=0; n<ntuples; n++) if(!tuple[n]->ResetEvents()) return false;
    return true;
  };

  inline int GetNtuples(void){ return (int)pow(2.0,(double)Nstreams); };

  inline int GetTupleType(const int aTupleIndex){ return GetType(aTupleIndex); };

  inline int GetNevents(const int aTupleIndex){
    if(aTupleIndex<0||aTupleIndex>=ntuples){
      cerr<<"Ntuple::GetNevents: the tuple number "<<aTupleIndex<<" does not exist"<<endl;
      return -1;
    }

    return tuple[aTupleIndex]->GetNevents();
  };

  void PrintEvents(void);
  
 private:

  int Nstreams;            
  
  // TUPLES
  int Ncomb[NETMAX+1];     
  int ntuples;             
  Tuple **tuple;           

  // INTERNALS
  bool MakeUniq(const int aNmax);

  // returns the type for a given Tuple
  inline int GetType(const int aTupleIndex){
    if(aTupleIndex<0) return -1;
    if(aTupleIndex>=ntuples) return -1;
    int count = 0;
    int n=aTupleIndex;
    while(n){
      n &= (n-1) ;
      count++;
    }
    return count;
  };
  
  // increment permutation
  inline bool NextPerm(const int aN, int *aComb, int *aNcombmax, int *aCombMin){
    aComb[aN-1]++;
    for(int i=aN-1; i>=0; i--){
      if(aComb[i]>=aNcombmax[i]){
    if(i==0) return false;
    aComb[i]=aCombMin[i];
    aComb[i-1]++;
      }
      if(aComb[i]<aCombMin[i]) aComb[i]=aCombMin[i];
    }
    return true;
  };
  
  ClassDef(Ntuple,0)  
};

#endif

---