/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/event/Event.cpp

Go to the documentation of this file.

/* @version $Revision: 1765 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-06-07 17:01:44 +0200 (Thu, 07 Jun 2012) $ */

//#include <c++/4.0.0/bits/stl_map.h>



#include "event/ChannelHit.hh"
#include "event/Event.hh"
#include "event/Run.hh"
#include "geometry/Chip.hh"
#include "geometry/Dif.hh"
#include "geometry/Board.hh"
#include "geometry/Chamber.hh"
#include "geometry/Detector.hh"
#include "geometry/Channel.hh"

#include "tools/MicroException.hh"
#include "tools/Log.hh"
#include "slowControl/SlowControlEntry.hh"
#include "slowControl/ChamberSlowControl.hh"


#include <string>
/*
#include "UTIL/LCTime.h"
#include "IMPL/LCFlagImpl.h"
#include "IMPL/LCCollectionVec.h"
#include "UTIL/CellIDEncoder.h"
#include "IMPL/RawCalorimeterHitImpl.h"
#include "IMPL/CalorimeterHitImpl.h"
#include "IMPL/LCTOOLS.h"

#include "IO/LCWriter.h"
#include "EVENT/LCIO.h"
#include "DATA/LCFloatVec.h"
#include "DATA/LCIntVec.h"

#include "IMPL/LCEventImpl.h"
#include "IMPL/LCRunHeaderImpl.h"
#include "IMPL/LCCollectionVec.h"
#include "IMPL/RawCalorimeterHitImpl.h"
#include "IMPL/SimTrackerHitImpl.h"
#include "IMPL/MCParticleImpl.h"
#include "IMPL/LCFlagImpl.h"
#include "IMPL/LCTOOLS.h"

#include "IMPL/TrackerRawDataImpl.h"
#include "IMPL/TrackerDataImpl.h"
#include "IMPL/TrackerPulseImpl.h"

#include "UTIL/LCRelationNavigator.h"
#include "UTIL/LCTime.h"
#include "UTIL/CellIDEncoder.h"
#include "UTIL/LCTypedVector.h"

#include "UTIL/LCSplitWriter.h"

static const int NEVENT = 10 ; // events
static const int NMCPART = 10 ;  // mc particles per event
static const int NHITS = 5 ;  // calorimeter hits per event
*/








using namespace std;


  std::ostream& operator <<(std::ostream &out, const Event &x) {
    return(x.operator <<(out));
  }


Event::Event(Run& aRun):run(aRun), slowControlEntry(NULL)
{
  //FILE_LOG(logDEBUG) << "-Event contructor"<< endl;
//  initChannelHitVector();
timestamp = 0;
difSynchro = 0;
id = 0;
slowControlEntry = NULL;
crcIsCorrect = true;
valid = VALID;
}

 Event::Event(Run& aRun, i64 aTimestamp, i32 aId):run(aRun), timestamp(aTimestamp), id(aId), slowControlEntry(NULL)
 {
  timestamp = 0;
  difSynchro = 0;
  id = 0;
  slowControlEntry = NULL;
  crcIsCorrect = true;
  valid = VALID;
     //FILE_LOG(logDEBUG) << "-Event contructor with id: "<< aId << endl;
 }

Event::~Event()
{
  //FILE_LOG(logDEBUG) << "-Event destructor"<< endl;

   map<ui16, multiset<ChannelHit*,sorter>* >::iterator iter;

  for (iter=channelHits.begin(); iter!=channelHits.end(); iter++)
  {
      multiset<ChannelHit*,sorter>* list = (*iter).second;
      for (multiset<ChannelHit*,sorter>::iterator iterList = list->begin(); iterList!=list->end(); iterList++ )
      {
          delete (*iterList);
      }
      delete list;
  }

}

/*---------------------------------------------------*/
ostream& Event::operator <<(ostream &out) const {
  return(out << "-Event id["<< id << "]" << endl
             << "-Event timestamp[" << timestamp << "]"  << endl);
}

/*---------------------------------------------------*/
void Event::initChannelHitVector()
    {
      ChamberMap_t chambers = this->run.getDetector().getChambers();

      for (ChamberMap_t::iterator iter = chambers.begin() ; iter != chambers.end() ; iter++)
      {
        i32 chamberId  = (*iter).first;
        multiset<ChannelHit*, sorter> *list = new multiset<ChannelHit*, sorter>();
             FILE_LOG(logINFO) << "INIT map size BEFORE INSERT:[" << channelHits.size() << "]" << endl;
        channelHits[chamberId] = list;  // a ChannilHits* vector per Chamber
             FILE_LOG(logINFO) << "INIT map size AFTER INSERT:[" << channelHits.size() << "]" << endl;
      }
    }
/*---------------------------------------------------*/
    const multiset<ChannelHit*,sorter>& Event::getChannelHitVector(const Chamber& aChamber) const
    {

         map<ui16, multiset<ChannelHit*,sorter>* >::const_iterator iter = channelHits.find(aChamber.getId());
         if( iter != channelHits.end() ) {
             return (*iter->second);
         }

         throw ( MicroException("No channelHit vector for this chamber"));
    //    return channelHits.find(aChamber.getId())->second;
    }
/*------------------------------------------------------------------------------------*/
    void Event::insertHit(Chamber& aChamber, ChannelHit *aChannelHit)
    {
         ui16 chamberId  = aChamber.getId();

         multiset<ChannelHit*,sorter>* hits = NULL;

         map<ui16, multiset<ChannelHit*,sorter> *>::iterator iter = channelHits.find(chamberId);

         if( iter == channelHits.end() ) {
             hits = new  multiset<ChannelHit*, sorter>();
             channelHits.insert(pair<i32, multiset<ChannelHit*,sorter>* > (chamberId,hits));
         }

         else
         {
            hits = iter->second;
         }

         hits->insert(aChannelHit);


    }
/*------------------------------------------------------------------------------------*/

 const ChannelHit& Event::getChannelHitByOrder( ui64 order ,const Chamber& aChamber, i16 aThreshold)
 {
     if ( getChannelHitByOrder(order+1,aChamber).getAnalogValue() <= aThreshold )
     {
         return getChannelHitByOrder(order,aChamber);
     }
     else
     {
         throw MicroException("No Channel respond for this event, this order, this threshold and this chamber ");
     }
 }

/*------------------------------------------------------------------------------------*/
 const ChannelHit& Event::getChannelHitByOrder(ui64 order ,const Chamber& aChamber)
 {
        multiset<ChannelHit*,sorter>* chamberChannelHit = this->channelHits.find(aChamber.getId())->second;//channelHits[aChamber.getId()];
        ui64 items=0;
                // Find first chamberChannelHit for select chamber
        for (multiset<ChannelHit*,sorter>::const_iterator iter=chamberChannelHit->begin(); iter!=chamberChannelHit->end(); iter++)
        {
                if ( (*iter)->getChannel().getChamber().getId() == aChamber.getId() )
                {
                    if ( order == items)
                    {
                        return *(*iter);
                    }

                    items++;
                }

        }
  throw MicroException("No Channel respond or this event, this order and this chamber ");

 }
 /*
 //------------------------------------------------------------------------------------
 ui64 Event::getChannelHitOrder(const ChannelHit& aChannelHit ,const Chamber& aChamber, bool sort)
 {
     return this->getChannelHitOrder(aChannelHit.getChannel(),aChamber, sort);
 }
 //------------------------------------------------------------------------------------
 ui64 Event::getChannelHitOrder(const Channel& achannel  ,const Chamber& aChamber)
 {
     multiset< ChannelHit*,sorter>* list = this->channelHits.find(aChamber.getId())->second;//channelHits[aChamber.getId()];
     ui64 order=0;
  // Find corresponding channelHit
     for (multiset<ChannelHit*,sorter>::const_iterator iter=list->begin(); iter!=list->end(); iter++)
     {
             if ( (*iter)->getChannel().getSoftId() == achannel.getSoftId())
             {
                 return order;
             }
             order++;  // incremente le numero d'ordre pour les channela de la chambre

    }
  throw MicroException("No Channel respond for this event, this order and this chamber ");

 }
        */
/*------------------------------------------------------------------------------------*/
void Event::setSlowControlParam(const SlowControlEntry* params)
{
  slowControlEntry = params;
  FILE_LOG(logDEBUG1) << "Event temperature["<< slowControlEntry->getTemperature() << "]" << endl;
  FILE_LOG(logDEBUG1) << "Event overPressure["<< slowControlEntry->getOverPressure() << "]" << endl;
  FILE_LOG(logDEBUG1) << "Event Pressure["<< slowControlEntry->getPressure() << "]" << endl;
}

/*------------------------------------------------------------------------------------*/

void Event::print(void) const
{
  FILE_LOG(logINFO) << "-Event id["<< id << "]" << endl;
  FILE_LOG(logINFO) << "-Event timestamp[" << timestamp << "]"  << endl ;
}

/*------------------------------------------------------------------------------------*/
const float Event::getPressure() const
{
    if ( slowControlEntry != NULL)
    {
        return slowControlEntry->getPressure();
    }
    else
    {
        return 0;
    }

}
/*------------------------------------------------------------------------------------*/
const float Event::getTemperature() const
{
    if ( slowControlEntry != NULL)
    {
        return slowControlEntry->getTemperature();
    }
    else
    {
        return 0;
    }

}
/*------------------------------------------------------------------------------------*/
const BoardSlowControl& Event::getBoardSlowControl(const ui32 chamberId,const ui32 difId, const ui32 boardId) const
{
    if ( slowControlEntry != NULL)
    {
       try
       {
           return slowControlEntry->getBoard(chamberId,difId,boardId);
       }
       catch ( MicroException e) {}
    }

    throw MicroException("Event::getBoardSlowControl: board not found");
}
/*------------------------------------------------------------------------------------*/
const float Event::getBoardDriftVolt(const ui32 chamberId,const ui32 difId, const ui32 boardId) const
{
    if ( slowControlEntry != NULL)
    {
       try
       {
           return slowControlEntry->getBoard(chamberId,difId,boardId).getDrift().voltage;
       }
       catch ( MicroException e) {}
    }
    throw MicroException("Event::getBoardSlowControl: board not found");

}
/*------------------------------------------------------------------------------------*/
const float Event::getBoardMeshVolt(const ui32 chamberId,const ui32 difId, const ui32 boardId) const
{
    if ( slowControlEntry != NULL)
    {
       try
       {
           return slowControlEntry->getBoard(chamberId,difId,boardId).getMesh().voltage;
       }
       catch ( MicroException e) {}
    }
    //throw ( MicroException("No mesh voltage for this chamber"));
    return -1;

}
//------------
ui64 Event::getChannelHitSize() const
{ 
    ui64 size = 0;
    for ( std::map<ui16, std::multiset<ChannelHit*,sorter>* >::const_iterator it=channelHits.begin(); it != channelHits.end() ; it++)
    {
            size +=it->second->size();
    }
    return size;
}

//------------
void Event::setTemperature(ui16 difId, float asu1, float asu2, float dif)
{
  // Search or create difs container
    if ( temperatureAsu1.find(difId) != temperatureAsu1.end())
    { // dif already exit/ replace value
       temperatureAsu1[difId] = asu1;
    }
    else
    { // does not exit create it
      temperatureAsu1.insert(make_pair(difId,asu1));
    }
  // Search or create difs container
    if ( temperatureAsu2.find(difId) != temperatureAsu2.end())
    { // dif already exit/ replace value
       temperatureAsu2[difId] = asu2;
    }
    else
    { // does not exit create it
      temperatureAsu2.insert(make_pair(difId,asu2));
    }
  // Search or create difs container
    if ( temperatureDif.find(difId) != temperatureDif.end())
    { // dif already exit/ replace value
       temperatureDif[difId] = dif;
    }
    else
    { // does not exit create it
      temperatureDif.insert(make_pair(difId,dif));
    }

}



/*------------------------------------------------------------------------------------*/
/*
LCEventImpl* Event::getLcioImpl() 
{
try {
        LCEventImpl* evt = new LCEventImpl();

        evt->setRunNumber(  1   ) ;
    evt->setDetectorName( "m2" ) ;
    evt->setWeight( 1 ) ;


    evt->setEventNumber( this->id ) ;
    // Event timestamp express in millisecond
        // But lcio timestamp express in second
    evt->setTimeStamp( this->timestamp * 1000000  ) ;


    evt->parameters().setValue("Dif_syncro",this->difSynchro ) ;
    evt->parameters().setValue("Temperature",this->getTemperature() ) ;
    evt->parameters().setValue("Pressure",this->getPressure()) ;
    evt->parameters().setValue("Global trigger counter",(int)this->globalTriggerCounter ) ;
    evt->parameters().setValue("Dif trigger counter",(int)this->difTriggerCounter ) ;
    //evt->parameters().setValue("SetDriftVoltage",this->difTriggerCounter ) ;
    //evt->parameters().setValue("SetMeshVoltage",this->difTriggerCounter ) ;



    // now add some raw calorimeter hits
    LCCollectionVec* calVec = new LCCollectionVec( LCIO::RAWCALORIMETERHIT )  ;

    LCFlagImpl chFlag(0) ;
    //chFlag.setBit( LCIO::CHBIT_ID1 ) ;

    chFlag.setBit( LCIO::RCHBIT_LONG )   ;  // long(1) - short(0) , incl./excl. position
    chFlag.setBit( LCIO::RCHBIT_BARREL ) ;  // barrel(1) - endcap(0)
    //chFlag.setBit( LCIO::RCHBIT_TIME   ) ; // 1: time information stored
    //chFlag.setBit( LCIO::RCHBIT_ID1   )  ;  // cellid1 stored
    //chFlag.setBit( LCIO::RCHBIT_NO_PTR ) ; // 1: pointer tag not added
    //chFlag.setBit( LCIO::RCHBIT_ENERGY_ERROR )  ;   // 1: store energy error
    calVec->setFlag( chFlag.getFlag()) ;


//
//OFFSET_CHAMBER *NB_CHANNEL* GetChamberId()
//+ OFFSET_DIF *NB_CHANNEL*  GetDifId()
//+ OFFSET_CHIP*NB_CHANNEL * GetChipId ()
//+  channelId 
//
        // Chambre 1024 -> 2 exp 10
        // Dif     128  -> 2 exp 7
        // Chip    1024 -> 2 exp 10
        // Channel 1024 -> 2 exp 10
    std::string cellIDEncoding( "CHAMBER:10,DIF:7,CHIP:10,CHANNEL:10") ;
    CellIDEncoder<RawCalorimeterHitImpl> cellEncoder( cellIDEncoding , calVec ) ;


    ChamberMap_t chamberList = this->getRun().getDetector().getChambers();
    for (ChamberMap_t::iterator iter=chamberList.begin(); iter!=chamberList.end(); iter++)
    {
      Chamber& chamber = *(iter->second);
      try
      {
          const  multiset<ChannelHit*,sorter>& list = this->getChannelHitVector(chamber);
          int order = 0 ;
          for (set<ChannelHit*,sorter>::iterator iter=list.begin(); iter!=list.end(); iter++)
          {
            ChannelHit& channelHit = *(*iter);
            const Channel& channel = channelHit.getChannel();
                RawCalorimeterHitImpl* rawHit = NULL ;
            try
            {
                          // Create RawCalorimeterHit
                  rawHit = new RawCalorimeterHitImpl() ;

              if ( chamber.getType().compare(GASSIPLEXCHAMBER1)==0 ||  chamber.getType().compare(GASSIPLEXCHAMBER4)==0)
              {
                    channelHit.setTimestamp(this->getTimeStamp());
                          }
                        
                        
                  cellEncoder["CHAMBER"] = channel.getChamber().getId(); 
                  cellEncoder["DIF"] = channel.getChip().getBoard().getDif()->getId(); 
                  cellEncoder["CHIP"] = channel.getChip().getId(); 
                  cellEncoder["CHANNEL"] = channel.getHardId(); 
                          cellEncoder.setCellID( rawHit ) ;
                        
                  rawHit->setAmplitude( channelHit.getDigitalValue()   )  ;
                  //rawHit->setTimeStamp( channelHit.getTimestamp() / 1000) ; 

              order++;  // because aEvent have already been  sorted
                  calVec->push_back( rawHit ) ;
            } // end try block
            catch (MicroException e)
            {
            }

          } // end for channelHits for this chamber
      }
      catch (MicroException e)
      {
                // get ChamberHitVector for next chamber
      }

    }
    //LCTOOLS::printRawCalorimeterHits(calVec);
    // add all collections to the event

    evt->addCollection( calVec , "m2" ) ;
        return evt;


  }
  catch( Exception& ex){

    cout << " an excpetion occured: " << endl ;
    cout << "  " << ex.what() << endl ;
    return NULL;
  }

    return NULL;


}*/
bool Event::isValid(void)
{
  if ( valid == VALID ) return true;
  return false;
}

---