PndLmdNoiseProducer Class Reference

#include <PndLmdNoiseProducer.h>

Inheritance diagram for PndLmdNoiseProducer:

Public Member Functions
	PndLmdNoiseProducer ()
virtual InitStatus	Init ()
void	FillSensorLists ()
void	SetParContainers ()
void	Exec (Option_t *opt)
Double_t	CalcReadoutCycles (Double_t clock)
void	AddDigiPixel (Int_t &noisies, Int_t iPoint, Int_t sensorID, Int_t fe, Int_t col, Int_t row, Double_t charge)
virtual void	FinishEvent ()
Double_t	CalcDistFraction (Double_t spread, Double_t threshold)
Int_t	CalcChargeAboveThreshold (Double_t spread, Double_t threshold)
void	AddDigiStrip (Int_t &iStrip, Int_t iPoint, Int_t sensorID, Int_t fe, Int_t chan, Double_t charge)
void	RunTimeBased ()
void	SetPersistency (Bool_t val=kTRUE)
Bool_t	GetPersistency ()

Protected Member Functions
	ClassDef (PndMvdNoiseProducer, 1)

Protected Attributes
Bool_t	fTimeOrderedDigi
	parameter to switch to time ordered simulation More...
TString	fBranchName
TClonesArray *	fDigiStripArray
TClonesArray *	fDigiPixelArray
PndSdsDigiPixelWriteoutBuffer *	fDigiPixelBuffer
PndSdsDigiStripWriteoutBuffer *	fDigiStripBuffer
PndSdsStripDigiPar *	fDigiParRect
PndSdsStripDigiPar *	fDigiParTrap
PndSdsPixelDigiPar *	fDigiParPix
PndSdsTotDigiPar *	fTotDigiParRect
PndSdsTotDigiPar *	fTotDigiParTrap
PndSdsTotDigiPar *	fTotDigiParPix
PndGeoHandling *	fGeoH
FairMCEventHeader *	fMCEventheader
	Geometry name handling. More...
std::vector< Int_t >	fPixelIds2
std::vector< Int_t >	fPixelIds4
std::vector< Int_t >	fPixelIds5
std::vector< Int_t >	fPixelIds6
std::vector< Int_t >	fStripRectLIds
std::vector< Int_t >	fStripRectSIds
std::vector< Int_t >	fStripTrapIds
PndSdsChargeConversion *	fStripRectChargeConv
PndSdsChargeConversion *	fStripTrapChargeConv
PndSdsChargeConversion *	fCurrentChargeConv
PndSdsChargeConversion *	fPixChargeConv
Int_t	fNoiseSpread
Int_t	fThreshold
Double_t	fPreviousTime

Private Member Functions
	ClassDef (PndLmdNoiseProducer, 1)

Private Attributes
std::vector< Int_t >	fPixelIds

Detailed Description

PndLmdNoiseProducer.h based on PndMvdNoiseProducer with adaptation to lmd specific calls original

Author

R.Kliemt r.kli.nosp@m.emt@.nosp@m.physi.nosp@m.k.tu.nosp@m.-dres.nosp@m.den..nosp@m.de

The Noise Producer adds fake hits to silicon sensor channels (strips and Pixels) updated: 17/07/2015 by A.Karavdina

Definition at line 23 of file PndLmdNoiseProducer.h.

Constructor & Destructor Documentation

PndLmdNoiseProducer::PndLmdNoiseProducer ( )

inline

Definition at line 26 of file PndLmdNoiseProducer.h.

:PndMvdNoiseProducer(){};

Member Function Documentation

void PndLmdNoiseProducer::AddDigiPixel	(	Int_t &	noisies,
		Int_t	iPoint,
		Int_t	sensorID,
		Int_t	fe,
		Int_t	col,
		Int_t	row,
		Double_t	charge
	)

Definition at line 322 of file PndLmdNoiseProducer.cxx.

References CalcReadoutCycles(), PndSdsChargeConversion::ChargeToDigiValue(), PndMvdNoiseProducer::fDigiParPix, PndMvdNoiseProducer::fDigiPixelBuffer, PndMvdNoiseProducer::fPixChargeConv, PndSdsDigi::GetCharge(), PndSdsPixelDigiPar::GetFeBusClock(), PndSdsChargeConversion::GetTimeStamp(), PndSdsChargeConversion::GetTimeStampErrorAfterCorrection(), and PndSdsChargeConversion::GetTimeWalk().

Referenced by Exec().

{
  //Double_t tempcharge = 0.;
  //Bool_t found = kFALSE;
  Int_t detID = -1; //no source mc branch

  std::vector<Int_t> indices;
  indices.push_back(iPoint);
  PndSdsDigiPixel* tempPixel = new PndSdsDigiPixel(indices,detID,sensorID,fe,col,row,fPixChargeConv->ChargeToDigiValue(charge), fPixChargeConv->GetTimeStamp(0, charge,FairRootManager::Instance()->GetEventTime()));//FairRootManager::Instance()->GetEventTime()) ;
 
  if (fPixChargeConv->GetTimeWalk((Int_t)tempPixel->GetCharge()) < 1E5){
                tempPixel->SetTimeStamp(tempPixel->GetTimeStamp() - fPixChargeConv->GetTimeWalk((Int_t)tempPixel->GetCharge()));
                tempPixel->SetTimeStampError(fPixChargeConv->GetTimeStampErrorAfterCorrection());
  }

  if(tempPixel->GetTimeStamp()<0){   //ideal charge converter has fixed time stamp = -1 ns =/
    int timeSt = gRandom->Integer(CalcReadoutCycles(fDigiParPix->GetFeBusClock())*1000./fDigiParPix->GetFeBusClock());
    tempPixel->SetTimeStamp(timeSt);
  }

  fDigiPixelBuffer->FillNewData(tempPixel,fPixChargeConv->ChargeToDigiValue(charge)*6 + FairRootManager::Instance()->GetEventTime(), FairRootManager::Instance()->GetEventTime());
  noisies++;
  delete(tempPixel);
  //  std::cout << "DataInBuffer: " << fDigiPixelBuffer->GetNData() << std::endl;
}

void PndMvdNoiseProducer::AddDigiStrip ( Int_t &  iStrip, Int_t  iPoint, Int_t  sensorID, Int_t  fe, Int_t  chan, Double_t  charge  )

inherited

Definition at line 409 of file PndMvdNoiseProducer.cxx.

References PndSdsChargeConversion::ChargeToDigiValue(), PndMvdNoiseProducer::fCurrentChargeConv, and PndMvdNoiseProducer::fDigiStripBuffer.

Referenced by PndMvdNoiseProducer::Exec().

{
  //Double_t tempcharge = 0.;
  //Bool_t found = kFALSE;
  Int_t detID = -1; // no source mc branch
  //PndSdsDigiStrip* aDigi = 0;
//  FairMCEventHeader* MCevtHeader = (FairMCEventHeader*)FairRootManager::Instance()->GetObject("MCEventHeader.");

//  if (fTimeOrderedDigi == kFALSE){
//        Int_t iStrip = fDigiStripArray->GetEntriesFast();
//
//        for(Int_t kstr = 0; kstr < iStrip && found == kFALSE; kstr++)
//        {
//              aDigi = (PndSdsDigiStrip*)fDigiStripArray->At(kstr);
//              if (aDigi->GetSensorID() == sensorID &&
//                      aDigi->GetFE() == fe &&
//                      aDigi->GetChannel() == chan )
//              {
//                tempcharge = fCurrentChargeConv->DigiValueToCharge(*aDigi);
//                aDigi->SetCharge( fCurrentChargeConv->ChargeToDigiValue(charge + tempcharge) );
//                aDigi->AddIndex(iPoint);
//                found = kTRUE;
//              }
//        }
//        if(found == kFALSE){
//                //TODO: get a reasonable timestamp fake for the noise
//              std::vector<Int_t> indices;
//              indices.push_back(iPoint);
//              new ((*fDigiStripArray)[iStrip]) PndSdsDigiStrip(indices,detID,sensorID,fe,chan,fCurrentChargeConv->ChargeToDigiValue(charge), FairRootManager::Instance()->GetEventTime()) ;
//              noisies++;
//              if(fVerbose>2) std::cout
//                << " -I- PndSdsNoiseProducer: Added StripTrap Digi at: FE=" << fe
//                << ", channel=" << chan << ", charge=" << charge<< " e"
//                << ", in sensor \n" << sensorID <<std::endl;
//        }
//  }
//  else{
                std::vector<Int_t> indices;
                indices.push_back(iPoint);
                PndSdsDigiStrip* tempStrip = new PndSdsDigiStrip(indices,detID,sensorID,fe,chan,fCurrentChargeConv->ChargeToDigiValue(charge), FairRootManager::Instance()->GetEventTime()) ;
                noisies++;
                fDigiStripBuffer->FillNewData(tempStrip, FairRootManager::Instance()->GetEventTime(), FairRootManager::Instance()->GetEventTime() + 10);
                delete(tempStrip);
//  }
}

Int_t PndMvdNoiseProducer::CalcChargeAboveThreshold ( Double_t  spread, Double_t  threshold  )

inherited

Definition at line 382 of file PndMvdNoiseProducer.cxx.

References Double_t, log(), and sqrt().

Referenced by PndMvdNoiseProducer::Exec().

{
  // pick any charge from the gaussian tail above threshold
  Double_t temp=0.;
  temp = TMath::Gaus(threshold,0,spread); // maximum gauss at threshold
  temp = gRandom->Uniform(0.,temp);       // random value in y
  temp = -2.*spread*spread*log(temp);     // get x value (recalc charge)
  temp = sqrt(temp);
  return (Int_t)ceil(temp);
}

Double_t PndMvdNoiseProducer::CalcDistFraction ( Double_t  spread, Double_t  threshold  )

inherited

Definition at line 376 of file PndMvdNoiseProducer.cxx.

Referenced by Exec(), and PndMvdNoiseProducer::Exec().

{
  // mean fraction of fireing digis
  return TMath::Erfc( threshold / (TMath::Sqrt2()*spread) );
}

Double_t PndLmdNoiseProducer::CalcReadoutCycles

(

Double_t

clock

)

Definition at line 300 of file PndLmdNoiseProducer.cxx.

References Double_t, PndMvdNoiseProducer::fMCEventheader, PndMvdNoiseProducer::fPreviousTime, fVerbose, and printf().

Referenced by AddDigiPixel(), and Exec().

{ // time [ns], clock [MHz]
  Double_t cycles=1.;
  Double_t timewindow=0.;
  if (clock > 0){
    if (fMCEventheader!=0) {
      timewindow = FairRootManager::Instance()->GetEventTime();
      //  cout<<"ev time = "<<FairRootManager::Instance()->GetEventTime()<<" prev.ev time = "<<fPreviousTime<<endl;
      timewindow -= fPreviousTime;
      //   cout<<"timewindow = "<<timewindow<<endl;
    } else {
      timewindow = 50.; // 20 MHz
    }
  }
  //cycles = timewindow*clock/1000.;//CORRECT calculation!
  cycles = 3;// for event-based reconstruction we assume minimum 3 readout cycles are used in event construction
  if(fVerbose>10) printf(" -I- PndLmdNoiseProducer::CalcReadoutCycles(): %g cycles (%gMHz,%gns)\n",cycles,clock,timewindow);
  return cycles;
}

PndLmdNoiseProducer::ClassDef ( PndLmdNoiseProducer  , 1    )

private

PndMvdNoiseProducer::ClassDef ( PndMvdNoiseProducer  , 1    )

protectedinherited

void PndLmdNoiseProducer::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Reimplemented from PndMvdNoiseProducer.

Definition at line 174 of file PndLmdNoiseProducer.cxx.

References AddDigiPixel(), PndMvdNoiseProducer::CalcDistFraction(), CalcReadoutCycles(), col, Double_t, PndMvdNoiseProducer::fDigiParPix, fe, fPixelIds, PndMvdNoiseProducer::fPreviousTime, fVerbose, PndLmdDim::Get_instance(), PndLmdDim::Get_sensor_by_id(), PndSdsPixelDigiPar::GetFeBusClock(), PndSdsPixelDigiPar::GetFECols(), PndSdsPixelDigiPar::GetFERows(), PndSdsPixelDigiPar::GetNoise(), PndSdsPixelDigiPar::GetThreshold(), i, and row.

{
  //   TObjArray* activeSensors = fGeoPar->GetGeoSensitiveNodes();
  Int_t nrCh=0,rnd=0,
  nrFE=0, //sens=0, //[R.K. 01/2017] unused variable?
  fe=0, //nrSensors=0, //[R.K. 01/2017] unused variable?
  chanmax=0,chan=0,
  col=0,row=0,
  chanwhite=0,
  charge=0,
  nNoisyStripRects=0,
  nNoisyStripTraps=0,
  nNoisyPixels=0;
  Double_t xfrac=0.,cycles=1.;
  Int_t did=-1;


  // // *** Strip Trapezoids ***
  // nrCh = fDigiParTrap->GetNrFECh();
  // nrFE = fDigiParTrap->GetNrBotFE() + fDigiParTrap->GetNrTopFE();
  // nrSensors = fStripTrapIds.size();
  // chanmax = nrCh * nrFE * nrSensors;
  // xfrac = CalcDistFraction(fDigiParTrap->GetNoise(),fDigiParTrap->GetThreshold());
  // cycles = CalcReadoutCycles(fDigiParTrap->GetFeBusClock());
  // chanwhite = gRandom->Poisson(xfrac*cycles*chanmax);
  // if(fVerbose>1) std::cout << " -I- PndLmdNoiseProducer: TRAP <N> = " << xfrac*cycles*chanmax
  //   << " leading to " << chanwhite << " noisy digis of " << chanmax
  //   << " total channels" << std::endl;
  
  // for(Int_t i = 0;i < chanwhite;i++)
  // {
  //   rnd = gRandom->Integer(chanmax);
  //   sens = rnd/(nrFE*nrCh);
  //   rnd = rnd % (nrFE*nrCh);
  //   fe = rnd/nrCh;
  //   chan = rnd % nrCh;
  //   charge = fDigiParTrap->GetThreshold()*6;//CalcChargeAboveThreshold(fDigiParTrap->GetNoise(),fDigiParTrap->GetThreshold());
  //   did = fStripTrapIds[sens];
  //   fCurrentChargeConv = fStripTrapChargeConv;
  //   AddDigiStrip(nNoisyStripTraps,-1,did,fe,chan,charge);
  // }

  PndLmdDim& lmd_dim = PndLmdDim::Get_instance();
  // *** Pixel Sensors ***
  nrCh = fDigiParPix->GetFECols()*fDigiParPix->GetFERows();
  Int_t pixx=fPixelIds.size();
  nrFE = pixx;
  chanmax = nrCh * nrFE;
  if(fVerbose>2) {
          std::cout << " found " << nrFE << " sensors " << " with in total " << chanmax << " pixels " << std::endl;
  }
  // get the mean number of pixels fired
  xfrac = CalcDistFraction(fDigiParPix->GetNoise(),fDigiParPix->GetThreshold());
  if(fVerbose>2){
  std::cout << " with a noise of " << fDigiParPix->GetNoise() << " e and a threshold of " << fDigiParPix->GetThreshold()
                  << " e " << xfrac*100 << " % pixels should have fired " << std::endl;
  }
  cycles = CalcReadoutCycles(fDigiParPix->GetFeBusClock());
  chanwhite = gRandom->Poisson(xfrac*cycles*chanmax);
  //std::cout << " cycles " << cycles << " chanwhite " << chanwhite << std::endl;
  if(fVerbose>1) std::cout << " -I- PndLmdNoiseProducer: PIXEL <N> = " << xfrac*cycles*chanmax
    << " leading to " << chanwhite << " noisy digis of " << chanmax
    << " total channels" << std::endl;
  for(Int_t i = 0;i < chanwhite;i++)
  {
          // prevent further steps in the software cutting those hits away by applying high charge
    charge = fDigiParPix->GetThreshold()*6; //CalcChargeAboveThreshold(fDigiParPix->GetNoise(),fDigiParPix->GetThreshold());
    rnd = gRandom->Integer(chanmax);
    chan = rnd%nrCh;
    col = chan%fDigiParPix->GetFECols();
    row = chan/fDigiParPix->GetFECols();
    fe  = rnd/nrCh;
    //if (fe < 0 || fe > 399) std::cout << "error! :" << fe << " does not match the total number of channels" << std::endl;
    did = fPixelIds[fe];
    /*
    if(fe >= (Int_t)(pixx) )
    {
      fe = fe - pixx;
      sens = fe/6;
      did = fPixelIds6[sens];
      fe = fe%6;
      //if(fe>6) fe=fe-6+10; //0-9 one row of FE, 10-19 2nd row of FE
    } else if( fe >= (Int_t)(pixx2 + pixx4) )
    {
      fe = fe - pixx2 - pixx4;
      sens = fe/5;
      did = fPixelIds5[sens];
      fe = fe%5;
      //if(fe>4) fe=fe-4+10; //0-9 one row of FE, 10-19 2nd row of FE
    } else if( fe >= (Int_t)(pixx2) )
    {
      fe = fe -pixx2;
      sens = fe/4;
      did = fPixelIds4[sens];
      fe = fe%4;
    } else
    {
      sens = fe/2;
      did = fPixelIds2[sens];
      fe = fe%2;
    }*/

    //std::cout << " adding  pixel " << i << " of " << chanwhite << std::endl;

    int ihalf, iplane, imodule, iside, idie, isensor;
    if (fe < 0 || fe > 399) std::cout << "error! :" << fe << " does not match the total number of channels" << std::endl;
    if (col > 255 || row > 255 || col < 0 || row < 0)
    std::cout << "error! :" << fe << " " << did << " " << col << " " << row << " " << charge << std::endl;
    lmd_dim.Get_sensor_by_id(fe, ihalf, iplane, imodule, iside, idie, isensor);
    //if (imodule != 0 || ihalf != 0) continue;
    AddDigiPixel(nNoisyPixels,-1,fe,0,col,row,charge); // fe is abused here for sensID and real fe is set to 0
  }

  fPreviousTime = FairRootManager::Instance()->GetEventTime();

  // *** The End ***
  if(fVerbose>0)
  {
    std::cout <<" -I- PndLmdNoiseProducer: Noise produced\t"
    <<nNoisyStripRects <<"xStripRect\t"
    <<nNoisyStripTraps <<"xStripTrap\t"
    <<nNoisyPixels <<"xPixels"<<std::endl;
  }
}

void PndLmdNoiseProducer::FillSensorLists

(

)

Definition at line 131 of file PndLmdNoiseProducer.cxx.

References PndMvdNoiseProducer::fGeoH, fPixelIds, fVerbose, PndGeoHandling::GetSensorNames(), PndStringSeparator::GetStringVector(), i, and TString.

Referenced by Init().

{
        //std::cout << " ***** initializing sensor lists ******** " << std::endl;
  TObjArray* sensorNames = fGeoH->GetSensorNames();

  for (int i = 0; i < sensorNames->GetEntries(); i++)
  {
                TString volpath = ((TObjString*)(sensorNames->At(i)))->GetString();
                //std::cout << " volume path is " << volpath << std::endl;
    if(!volpath.Contains("Lum")) continue;
                PndStringSeparator sep(volpath.Data(), "/");
                std::vector<std::string> volvec = sep.GetStringVector();
                TString volname = volvec[volvec.size()-1].c_str();
                if(fVerbose>2)std::cout << "VolName: " << volname.Data();
                if(volname.Contains("Active"))
                        //std::cout << " found sensor " << volname << std::endl;
                {
                  //    if(volname.Contains("Trap")) {fStripTrapIds.push_back(i); if(fVerbose>2)std::cout << " \tAdded to StripTrap" << std::endl;}
                        if(volname.Contains("Pixel")) {fPixelIds.push_back(i); if(fVerbose>2)std::cout << " \tAdded to Pixel" << std::endl;}
                }
        }
}

void PndMvdNoiseProducer::FinishEvent ( )

virtualinherited

Definition at line 474 of file PndMvdNoiseProducer.cxx.

{
  // called after all Tasks did their Exex() and the data is copied to the file

  FinishEvents();
}

Bool_t PndPersistencyTask::GetPersistency ( )

inlineinherited

Definition at line 32 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency.

Referenced by PndLmdPixelHitProducerFast::GetPersistance(), PndMdtDigitization::Init(), PndMdtHitProducerIdeal::Init(), PndMdtClusterTask::Init(), PndFtsHitProducerRealFast::Init(), PndDiscTaskReconstruction::Init(), PndRichHitProducer::Init(), PndSttHitProducerRealFast::Init(), PndSttHelixHitProducer::Init(), PndDiscTaskPID::Init(), PndIdealTrackFinder::Init(), PndSttMvdGemTracking::Init(), PndMdtTrkProducer::Init(), PndFtsHitProducerRealFull::Init(), PndLmdPixelClusterTask::Init(), PndSttHitProducerRealFull::Init(), PndLmdStripClusterTask::Init(), PndEmcApdHitProducer::Init(), PndMissingPzCleanerTask::Init(), PndEmcMakeRecoHit::Init(), PndEmcMakeClusterOnline::Init(), PndTrackSmearTask::Init(), PndEmcFWEndcapTimebasedWaveforms::Init(), PndSttHitProducerIdeal::Init(), PndEmcFWEndcapDigi::Init(), PndFtsHitProducerIdeal::Init(), PndEmcMakeCluster::Init(), PndMdtPointsToWaveform::Init(), PndDiscTaskDigitization::Init(), PndEmcMakeDigi::Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndDrcHitFinder::Init(), PndRichHitFinder::Init(), PndEmcMakeCorr::Init(), PndFtofHitProducerIdeal::Init(), PndEmcHitsToWaveform::Init(), PndSciTDigiTask::Init(), PndDrcHitProducerIdeal::Init(), PndSdsHitProducerIdeal::Init(), PndSciTHitProducerIdeal::Init(), PndRecoMultiKalmanTask2::Init(), PndEmcHitProducer::Init(), PndDrcHitProducerReal::Init(), PndDskFLGHitProducerIdeal::Init(), PndEmcTmpWaveformToDigi::Init(), PndDrcDigiTask::Init(), PndEmcWaveformToDigi::Init(), PndSttMatchTracks::Init(), PndEmcWaveformToCalibratedDigi::Init(), PndTrkTracking2::Init(), PndSttFindTracks::Init(), PndEmcMultiWaveformToCalibratedDigi::Init(), PndRecoKalmanTask2::Init(), PndDrcTimeDigiTask::Init(), PndEmcExpClusterSplitter::Init(), PndFtsHoughTrackerTask::Init(), PndSdsNoiseProducer::Init(), PndEmcPhiBumpSplitter::Init(), PndSdsIdealRecoTask::Init(), PndSdsHybridHitProducer::Init(), PndRecoMultiKalmanTask::Init(), PndSdsIdealClusterTask::Init(), PndRecoKalmanTask::Init(), PndSdsStripHitProducerDif::Init(), PndGemDigitize::Init(), PndSdsStripHitProducer::Init(), PndGemFindHits::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndMvdGemTrackFinderOnHits::Init(), PndBarrelTrackFinder::Init(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcMakeBump::PndEmcMakeBump(), PndUnassignedHitsTask::RegisterBranches(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndEmcMakeBump::SetStorageOfData(), and PndEmcFullDigiTask::StoreDigi().

{ return fPersistency; }

InitStatus PndLmdNoiseProducer::Init ( )

virtual

Reimplemented from PndMvdNoiseProducer.

Definition at line 35 of file PndLmdNoiseProducer.cxx.

References PndMvdNoiseProducer::fDigiParPix, PndMvdNoiseProducer::fDigiPixelBuffer, FillSensorLists(), PndMvdNoiseProducer::fMCEventheader, PndMvdNoiseProducer::fPixChargeConv, PndMvdNoiseProducer::fPixelIds2, PndMvdNoiseProducer::fPreviousTime, PndMvdNoiseProducer::fStripRectLIds, PndMvdNoiseProducer::fStripRectSIds, PndMvdNoiseProducer::fStripTrapIds, PndMvdNoiseProducer::fTimeOrderedDigi, PndMvdNoiseProducer::fTotDigiParPix, fVerbose, PndSdsPixelDigiPar::GetChargeConvMethod(), PndSdsTotDigiPar::GetChargingTime(), PndSdsTotDigiPar::GetClockFrequency(), PndSdsTotDigiPar::GetConstCurrent(), PndSdsPixelDigiPar::GetNoise(), and PndSdsPixelDigiPar::GetThreshold().

{

// Get RootManager
  FairRootManager* ioman = FairRootManager::Instance();
  
  if ( ! ioman )
  {
        std::cout << " -E- PndMvdNoiseProducer::Init: RootManager not instantiated!" << std::endl;
        return kFATAL;
  }
        // call prior to base call the overloaded FillSensorMethod() to find sensors from geometry;
        FillSensorLists();
  // call the base implementation
        //      if ( PndMvdNoiseProducer::Init() == kFATAL ) return kFATAL;
        // override some lmd specific stuff

  // Get input array

        // fDigiStripBuffer = (PndSdsDigiStripWriteoutBuffer*)FairRootManager::Instance()->
        //              RegisterWriteoutBuffer("LMDStripDigis", new PndSdsDigiStripWriteoutBuffer("LMDStripDigis", "LMD", kTRUE));

        fDigiPixelBuffer = new PndSdsDigiPixelWriteoutBuffer("LMDPixelDigis", "LMD", kTRUE);
        fDigiPixelBuffer = (PndSdsDigiPixelWriteoutBuffer*)FairRootManager::Instance()->
          RegisterWriteoutBuffer("LMDPixelDigis", fDigiPixelBuffer);
        fDigiPixelBuffer->ActivateBuffering(fTimeOrderedDigi);


fMCEventheader = (FairMCEventHeader*) ioman->GetObject("MCEventHeader.");
  if ( ! fMCEventheader ){
        Warning("Init","Did not find the MC event header, assume 50ns of noise clockticks per call of Exec().");
  }
  fPreviousTime=0.;
  
  //FillSensorLists();
  
//  fFEModel = new PndSdsFESimple();

  if(fVerbose>0)
  {
        std::cout <<" -I- PndLmdNoiseProducer: Registered Sensors: "
        <<fStripRectLIds.size()+fStripRectSIds.size()<<"xStripRect "
        <<fStripTrapIds.size()<<"xStripTrap "
        <<fPixelIds2.size()<<"xPixel"
        <<std::endl;
  }
  std::cout << " -I- PndMvdNoiseProducer: Intialisation successfull" << std::endl;
  
  // if (fDigiParRect->GetChargeConvMethod() == 0){
  //    if(fVerbose>0) Info("Init()","ideal charge conversion for rect. strips");
  //    fStripRectChargeConv = new PndSdsIdealChargeConversion(fDigiParRect->GetNoise());
  // }
  // else if (fDigiParRect->GetChargeConvMethod() == 1){
  //    if(fVerbose>0) Info("Init()","use TOT charge conversion for rect. strips");
  //    fStripRectChargeConv = new PndSdsTotChargeConversion(
  //                                                         fTotDigiParRect->GetChargingTime(),
  //                                                         fTotDigiParRect->GetConstCurrent(),
  //                                                         fDigiParRect->GetThreshold(),
  //                                                         fTotDigiParRect->GetClockFrequency(),
  //                                                         fVerbose);
  // }
  // else Fatal ("Init()","rect. strips: charge conversion method not defined!");
  
  // if (fDigiParTrap->GetChargeConvMethod() == 0){
  //   if(fVerbose>0) Info("Init()","ideal charge conversion for trap. strips");
  //   fStripTrapChargeConv = new PndSdsIdealChargeConversion(fDigiParTrap->GetNoise());
  // }
  // else if (fDigiParTrap->GetChargeConvMethod() == 1){
  //   if(fVerbose>0) Info("Init()","use TOT charge conversion for trap. strips");
  //   fStripTrapChargeConv = new PndSdsTotChargeConversion(
  //                                                     fTotDigiParTrap->GetChargingTime(),
  //                                                     fTotDigiParTrap->GetConstCurrent(),
  //                                                     fDigiParTrap->GetThreshold(),
  //                                                     fTotDigiParTrap->GetClockFrequency(),
  //                                                     fVerbose);
  // }
  // else Fatal ("Init()","trap. strips: charge conversion method not defined!");
  
  if (fDigiParPix->GetChargeConvMethod() == 0){
        if(fVerbose>0) Info("Init()","ideal charge conversion for pixel part");
        fPixChargeConv = new PndSdsIdealChargeConversion(fDigiParPix->GetNoise());
  }
  else if (fDigiParPix->GetChargeConvMethod() == 1){
    if(fVerbose>0) Info("Init()","use TOT charge conversion for pixel part");
    fPixChargeConv = new PndSdsTotChargeConversion(
                                                   fTotDigiParPix->GetChargingTime(),
                                                   fTotDigiParPix->GetConstCurrent(),
                                                   fDigiParPix->GetThreshold(),
                                                   fTotDigiParPix->GetClockFrequency(),
                                                   fVerbose);
  }
  else Fatal ("Init()","pixel part: charge conversion method not defined!");
  
        return kSUCCESS;
}

void PndMvdNoiseProducer::RunTimeBased ( )

inlineinherited

Definition at line 69 of file PndMvdNoiseProducer.h.

References PndMvdNoiseProducer::fTimeOrderedDigi.

{fTimeOrderedDigi = kTRUE;}

void PndLmdNoiseProducer::SetParContainers ( )

virtual

Virtual method Init

Reimplemented from PndMvdNoiseProducer.

Definition at line 154 of file PndLmdNoiseProducer.cxx.

References PndMvdNoiseProducer::fDigiParPix, PndMvdNoiseProducer::fGeoH, PndMvdNoiseProducer::fTotDigiParPix, PndGeoHandling::Instance(), rtdb, and PndGeoHandling::SetParContainers().

{
 
  // Get Base Container
  FairRun* ana = FairRun::Instance();
  FairRuntimeDb* rtdb=ana->GetRuntimeDb();
  // fDigiParRect = (PndSdsStripDigiPar*)(rtdb->getContainer("SDSStripDigiParRect"));
  // fDigiParTrap = (PndSdsStripDigiPar*)(rtdb->getContainer("SDSStripDigiParTrap"));
  fDigiParPix  = (PndSdsPixelDigiPar*)(rtdb->getContainer("LMDPixelDigiPar"));
  // fTotDigiParRect = (PndSdsTotDigiPar*)(rtdb->getContainer("SDSStripTotDigiParRect"));
  // fTotDigiParTrap = (PndSdsTotDigiPar*)(rtdb->getContainer("SDSStripTotDigiParTrap"));
  fTotDigiParPix  = (PndSdsTotDigiPar*)(rtdb->getContainer("LMDPixelTotDigiPar"));

 if ( fGeoH == NULL ) {
    fGeoH = PndGeoHandling::Instance();
  }

  fGeoH->SetParContainers();
}

void PndPersistencyTask::SetPersistency ( Bool_t  val = kTRUE )

inlineinherited

Definition at line 31 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency, and val.

Referenced by barrelTrackFinder(), digi_complete(), digi_complete_newSTT(), digiOnly_complete(), PndBarrelTrackFinder::PndBarrelTrackFinder(), PndCATracking::PndCATracking(), PndDrcHitFinder::PndDrcHitFinder(), PndEmc2DLocMaxFinder::PndEmc2DLocMaxFinder(), PndEmcExpClusterSplitter::PndEmcExpClusterSplitter(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcFWEndcapDigi::PndEmcFWEndcapDigi(), PndEmcFWEndcapTimebasedWaveforms::PndEmcFWEndcapTimebasedWaveforms(), PndEmcHitProducer::PndEmcHitProducer(), PndEmcHitsToWaveform::PndEmcHitsToWaveform(), PndEmcMakeBump::PndEmcMakeBump(), PndEmcMakeCluster::PndEmcMakeCluster(), PndEmcMakeClusterOnline::PndEmcMakeClusterOnline(), PndEmcMakeDigi::PndEmcMakeDigi(), PndEmcMakeRecoHit::PndEmcMakeRecoHit(), PndEmcMultiWaveformToCalibratedDigi::PndEmcMultiWaveformToCalibratedDigi(), PndEmcPhiBumpSplitter::PndEmcPhiBumpSplitter(), PndEmcTmpWaveformToDigi::PndEmcTmpWaveformToDigi(), PndEmcWaveformToCalibratedDigi::PndEmcWaveformToCalibratedDigi(), PndEmcWaveformToDigi::PndEmcWaveformToDigi(), PndFtofHitProducerIdeal::PndFtofHitProducerIdeal(), PndFtsCATracking::PndFtsCATracking(), PndFtsHitProducerIdeal::PndFtsHitProducerIdeal(), PndFtsHitProducerRealFast::PndFtsHitProducerRealFast(), PndFtsHitProducerRealFull::PndFtsHitProducerRealFull(), PndFtsHoughTrackerTask::PndFtsHoughTrackerTask(), PndGemDigitize::PndGemDigitize(), PndGemFindHits::PndGemFindHits(), PndIdealTrackFinder::PndIdealTrackFinder(), PndLmdPixelClusterTask::PndLmdPixelClusterTask(), PndLmdPixelHitProducerFast::PndLmdPixelHitProducerFast(), PndMdtClusterTask::PndMdtClusterTask(), PndMdtDigitization::PndMdtDigitization(), PndMdtHitProducerIdeal::PndMdtHitProducerIdeal(), PndMdtPointsToWaveform::PndMdtPointsToWaveform(), PndMdtTrkProducer::PndMdtTrkProducer(), PndMissingPzCleanerTask::PndMissingPzCleanerTask(), PndMvdGemTrackFinderOnHits::PndMvdGemTrackFinderOnHits(), PndMvdHitProducerIdeal::PndMvdHitProducerIdeal(), PndMvdPixelClusterTask::PndMvdPixelClusterTask(), PndMvdTimeWalkCorrTask::PndMvdTimeWalkCorrTask(), PndMvdToPix4ClusterTask::PndMvdToPix4ClusterTask(), PndRecoKalmanTask::PndRecoKalmanTask(), PndRecoKalmanTask2::PndRecoKalmanTask2(), PndRecoMultiKalmanTask::PndRecoMultiKalmanTask(), PndRecoMultiKalmanTask2::PndRecoMultiKalmanTask2(), PndRichHitFinder::PndRichHitFinder(), PndRichHitProducer::PndRichHitProducer(), PndSciTDigiTask::PndSciTDigiTask(), PndSciTHitProducerIdeal::PndSciTHitProducerIdeal(), PndSdsHitProducerIdeal::PndSdsHitProducerIdeal(), PndSdsHybridHitProducer::PndSdsHybridHitProducer(), PndSdsIdealClusterTask::PndSdsIdealClusterTask(), PndSdsIdealRecoTask::PndSdsIdealRecoTask(), PndSdsNoiseProducer::PndSdsNoiseProducer(), PndSdsPixelClusterTask::PndSdsPixelClusterTask(), PndSdsStripClusterTask::PndSdsStripClusterTask(), PndSdsStripHitProducer::PndSdsStripHitProducer(), PndSdsTimeWalkCorrTask::PndSdsTimeWalkCorrTask(), PndSttFindTracks::PndSttFindTracks(), PndSttHelixHitProducer::PndSttHelixHitProducer(), PndSttHitProducerIdeal::PndSttHitProducerIdeal(), PndSttHitProducerRealFast::PndSttHitProducerRealFast(), PndSttHitProducerRealFull::PndSttHitProducerRealFull(), PndSttMatchTracks::PndSttMatchTracks(), PndSttMvdGemTracking::PndSttMvdGemTracking(), PndTrackSmearTask::PndTrackSmearTask(), PndTrkTracking2::PndTrkTracking2(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_newSTT(), reco_complete_sec(), recoideal_complete(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndLmdPixelHitProducerFast::SetPersistance(), PndSdsHitProducerIdeal::SetPersistance(), PndSttMvdGemTracking::SetPersistenc(), PndMdtClusterTask::SetPersistence(), PndSttHelixHitProducer::SetPersistence(), PndMissingPzCleanerTask::SetPersistence(), PndFtsHitProducerRealFast::SetPersistence(), PndFtsHitProducerRealFull::SetPersistence(), PndSttHitProducerRealFull::SetPersistence(), PndSttHitProducerIdeal::SetPersistence(), PndSttHitProducerRealFast::SetPersistence(), PndFtsHitProducerIdeal::SetPersistence(), PndTrackSmearTask::SetPersistence(), PndSciTHitProducerIdeal::SetPersistence(), PndIdealTrackFinder::SetPersistence(), PndSttMatchTracks::SetPersistence(), PndSttFindTracks::SetPersistence(), PndFtsHoughTrackerTask::SetPersistence(), PndTrkTracking2::SetPersistence(), PndEmcMakeRecoHit::SetStorageOfData(), PndEmcFWEndcapDigi::SetStorageOfData(), PndEmcMakeClusterOnline::SetStorageOfData(), PndEmcFWEndcapTimebasedWaveforms::SetStorageOfData(), PndEmcMakeDigi::SetStorageOfData(), PndMdtPointsToWaveform::SetStorageOfData(), PndEmc2DLocMaxFinder::SetStorageOfData(), PndEmcMakeCluster::SetStorageOfData(), PndEmcHitsToWaveform::SetStorageOfData(), PndEmcMakeBump::SetStorageOfData(), PndEmcTmpWaveformToDigi::SetStorageOfData(), PndEmcWaveformToDigi::SetStorageOfData(), PndEmcWaveformToCalibratedDigi::SetStorageOfData(), PndEmcMultiWaveformToCalibratedDigi::SetStorageOfData(), PndEmcExpClusterSplitter::SetStorageOfData(), PndEmcPhiBumpSplitter::SetStorageOfData(), standard_tracking(), and PndEmcFullDigiTask::StoreDigi().

{ fPersistency = val; }

Member Data Documentation

TString PndMvdNoiseProducer::fBranchName

protectedinherited

Definition at line 75 of file PndMvdNoiseProducer.h.

PndSdsChargeConversion* PndMvdNoiseProducer::fCurrentChargeConv

protectedinherited

Definition at line 105 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::AddDigiStrip(), and PndMvdNoiseProducer::Exec().

PndSdsPixelDigiPar* PndMvdNoiseProducer::fDigiParPix

protectedinherited

Definition at line 86 of file PndMvdNoiseProducer.h.

Referenced by AddDigiPixel(), Exec(), PndMvdNoiseProducer::Exec(), Init(), PndMvdNoiseProducer::Init(), SetParContainers(), and PndMvdNoiseProducer::SetParContainers().

PndSdsStripDigiPar* PndMvdNoiseProducer::fDigiParRect

protectedinherited

Parameter Containers

Definition at line 84 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::SetParContainers().

PndSdsStripDigiPar* PndMvdNoiseProducer::fDigiParTrap

protectedinherited

Definition at line 85 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::SetParContainers().

TClonesArray* PndMvdNoiseProducer::fDigiPixelArray

protectedinherited

Definition at line 78 of file PndMvdNoiseProducer.h.

PndSdsDigiPixelWriteoutBuffer* PndMvdNoiseProducer::fDigiPixelBuffer

protectedinherited

Definition at line 80 of file PndMvdNoiseProducer.h.

Referenced by AddDigiPixel(), PndMvdNoiseProducer::AddDigiPixel(), Init(), and PndMvdNoiseProducer::Init().

TClonesArray* PndMvdNoiseProducer::fDigiStripArray

protectedinherited

In-Output array of PndSdsDigis

Definition at line 77 of file PndMvdNoiseProducer.h.

PndSdsDigiStripWriteoutBuffer* PndMvdNoiseProducer::fDigiStripBuffer

protectedinherited

Definition at line 81 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::AddDigiStrip(), and PndMvdNoiseProducer::Init().

PndGeoHandling* PndMvdNoiseProducer::fGeoH

protectedinherited

Definition at line 92 of file PndMvdNoiseProducer.h.

Referenced by FillSensorLists(), PndMvdNoiseProducer::FillSensorLists(), SetParContainers(), and PndMvdNoiseProducer::SetParContainers().

FairMCEventHeader* PndMvdNoiseProducer::fMCEventheader

protectedinherited

Geometry name handling.

Definition at line 93 of file PndMvdNoiseProducer.h.

Referenced by CalcReadoutCycles(), PndMvdNoiseProducer::CalcReadoutCycles(), Init(), and PndMvdNoiseProducer::Init().

Int_t PndMvdNoiseProducer::fNoiseSpread

protectedinherited

Definition at line 108 of file PndMvdNoiseProducer.h.

PndSdsChargeConversion* PndMvdNoiseProducer::fPixChargeConv

protectedinherited

Definition at line 106 of file PndMvdNoiseProducer.h.

Referenced by AddDigiPixel(), PndMvdNoiseProducer::AddDigiPixel(), Init(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::~PndMvdNoiseProducer().

std::vector<Int_t> PndLmdNoiseProducer::fPixelIds

private

Definition at line 40 of file PndLmdNoiseProducer.h.

Referenced by Exec(), and FillSensorLists().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds2

protectedinherited

Definition at line 95 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::FillSensorLists(), Init(), and PndMvdNoiseProducer::Init().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds4

protectedinherited

Definition at line 96 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), and PndMvdNoiseProducer::FillSensorLists().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds5

protectedinherited

Definition at line 97 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), and PndMvdNoiseProducer::FillSensorLists().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds6

protectedinherited

Definition at line 98 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), and PndMvdNoiseProducer::FillSensorLists().

Double_t PndMvdNoiseProducer::fPreviousTime

protectedinherited

Definition at line 110 of file PndMvdNoiseProducer.h.

Referenced by CalcReadoutCycles(), PndMvdNoiseProducer::CalcReadoutCycles(), Exec(), PndMvdNoiseProducer::Exec(), Init(), and PndMvdNoiseProducer::Init().

PndSdsChargeConversion* PndMvdNoiseProducer::fStripRectChargeConv

protectedinherited

Definition at line 103 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::~PndMvdNoiseProducer().

std::vector<Int_t> PndMvdNoiseProducer::fStripRectLIds

protectedinherited

Definition at line 99 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::FillSensorLists(), Init(), and PndMvdNoiseProducer::Init().

std::vector<Int_t> PndMvdNoiseProducer::fStripRectSIds

protectedinherited

Definition at line 100 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::FillSensorLists(), Init(), and PndMvdNoiseProducer::Init().

PndSdsChargeConversion* PndMvdNoiseProducer::fStripTrapChargeConv

protectedinherited

Definition at line 104 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::~PndMvdNoiseProducer().

std::vector<Int_t> PndMvdNoiseProducer::fStripTrapIds

protectedinherited

Definition at line 101 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Exec(), PndMvdNoiseProducer::FillSensorLists(), Init(), and PndMvdNoiseProducer::Init().

Int_t PndMvdNoiseProducer::fThreshold

protectedinherited

Definition at line 109 of file PndMvdNoiseProducer.h.

Bool_t PndMvdNoiseProducer::fTimeOrderedDigi

protectedinherited

parameter to switch to time ordered simulation

Definition at line 73 of file PndMvdNoiseProducer.h.

Referenced by Init(), PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::RunTimeBased().

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParPix

protectedinherited

Definition at line 90 of file PndMvdNoiseProducer.h.

Referenced by Init(), PndMvdNoiseProducer::Init(), SetParContainers(), and PndMvdNoiseProducer::SetParContainers().

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParRect

protectedinherited

Definition at line 88 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::SetParContainers().

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParTrap

protectedinherited

Definition at line 89 of file PndMvdNoiseProducer.h.

Referenced by PndMvdNoiseProducer::Init(), and PndMvdNoiseProducer::SetParContainers().

---

The documentation for this class was generated from the following files:

• PndLmdNoiseProducer.h
• PndLmdNoiseProducer.cxx