PndMvdNoiseProducer Class Reference

#include <PndMvdNoiseProducer.h>

Inheritance diagram for PndMvdNoiseProducer:

Public Member Functions
	PndMvdNoiseProducer ()
virtual	~PndMvdNoiseProducer ()
	PndMvdNoiseProducer (const PndMvdNoiseProducer &)=delete
PndMvdNoiseProducer &	operator= (const PndMvdNoiseProducer &)=delete
virtual void	SetParContainers ()
virtual InitStatus	Init ()
virtual void	Exec (Option_t *opt)
virtual void	FinishEvent ()
Double_t	CalcDistFraction (Double_t spread, Double_t threshold)
Int_t	CalcChargeAboveThreshold (Double_t spread, Double_t threshold)
Double_t	CalcReadoutCycles (Double_t clock)
void	AddDigiStrip (Int_t &iStrip, Int_t iPoint, Int_t sensorID, Int_t fe, Int_t chan, Double_t charge)
void	AddDigiPixel (Int_t &noisies, Int_t iPoint, Int_t sensorID, Int_t fe, Int_t col, Int_t row, Double_t charge)
void	FillSensorLists ()
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

Detailed Description

Definition at line 38 of file PndMvdNoiseProducer.h.

Constructor & Destructor Documentation

PndMvdNoiseProducer::PndMvdNoiseProducer

(

)

Default constructor

Definition at line 29 of file PndMvdNoiseProducer.cxx.

                                         :
PndPersistencyTask("Charge Noise Producer"),
    fTimeOrderedDigi(kFALSE),
    fBranchName("MVDStripDigis"),
    fDigiStripArray(NULL),
    fDigiPixelArray(NULL),
    fDigiPixelBuffer(NULL),
    fDigiStripBuffer(NULL),
    fDigiParRect(NULL),
    fDigiParTrap(NULL),
    fDigiParPix(NULL),
    fTotDigiParRect(NULL),
    fTotDigiParTrap(NULL),
    fTotDigiParPix(NULL),
    fGeoH(NULL),
    fMCEventheader(NULL),
    fPixelIds2(),
    fPixelIds4(),
    fPixelIds5(),
    fPixelIds6(),
    fStripRectLIds(),
    fStripRectSIds(),
    fStripTrapIds(),
    fStripRectChargeConv(NULL),
    fStripTrapChargeConv(NULL),
    fCurrentChargeConv(NULL),
    fPixChargeConv(NULL),
    fNoiseSpread(0),
    fThreshold(0),
    fPreviousTime(0)
{
}

PndMvdNoiseProducer::~PndMvdNoiseProducer ( )

virtual

Destructor

Definition at line 66 of file PndMvdNoiseProducer.cxx.

References fPixChargeConv, fStripRectChargeConv, and fStripTrapChargeConv.

{
        if (fStripRectChargeConv) delete fStripRectChargeConv;
        if (fStripTrapChargeConv) delete fStripTrapChargeConv;
        if (fPixChargeConv) delete fPixChargeConv;
}

PndMvdNoiseProducer::PndMvdNoiseProducer ( const PndMvdNoiseProducer &  )

delete

Member Function Documentation

void PndMvdNoiseProducer::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 455 of file PndMvdNoiseProducer.cxx.

References PndSdsChargeConversion::ChargeToDigiValue(), fDigiPixelBuffer, fPixChargeConv, PndSdsDigi::GetCharge(), 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());
  }
  fDigiPixelBuffer->FillNewData(tempPixel,fPixChargeConv->ChargeToDigiValue(charge)*6 + FairRootManager::Instance()->GetEventTime(), FairRootManager::Instance()->GetEventTime());
  noisies++; // to count outside the noisy digis.
  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
	)

Definition at line 409 of file PndMvdNoiseProducer.cxx.

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

Referenced by 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
	)

Definition at line 382 of file PndMvdNoiseProducer.cxx.

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

Referenced by 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
	)

Definition at line 376 of file PndMvdNoiseProducer.cxx.

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

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

Double_t PndMvdNoiseProducer::CalcReadoutCycles

(

Double_t

clock

)

Definition at line 393 of file PndMvdNoiseProducer.cxx.

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

Referenced by Exec().

{ // time [ns], clock [MHz]
  Double_t cycles=1.;
  Double_t timewindow=0.;
  if (clock > 0){
    if (fMCEventheader!=0) {
      timewindow = FairRootManager::Instance()->GetEventTime();
      timewindow -= fPreviousTime;
    } else {
      timewindow = 50.; // how many ns do we suppress readout of zeros?
    }
  }
  if(fVerbose>1) printf(" -I- PndMvdNoiseProducer::CalcReadoutCycles(): %g cycles (%gMHz,%gns)\n",cycles,clock,timewindow);
  return cycles;
}

PndMvdNoiseProducer::ClassDef ( PndMvdNoiseProducer  , 1    )

protected

void PndMvdNoiseProducer::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Reimplemented in PndLmdNoiseProducer.

Definition at line 212 of file PndMvdNoiseProducer.cxx.

References AddDigiPixel(), AddDigiStrip(), CalcChargeAboveThreshold(), CalcDistFraction(), CalcReadoutCycles(), col, Double_t, fCurrentChargeConv, fDigiParPix, fDigiParRect, fDigiParTrap, fe, fPixelIds2, fPixelIds4, fPixelIds5, fPixelIds6, fPreviousTime, fStripRectChargeConv, fStripRectLIds, fStripRectSIds, fStripTrapChargeConv, fStripTrapIds, fVerbose, PndSdsStripDigiPar::GetFeBusClock(), PndSdsPixelDigiPar::GetFeBusClock(), PndSdsPixelDigiPar::GetFECols(), PndSdsPixelDigiPar::GetFERows(), PndSdsPixelDigiPar::GetNoise(), PndSdsStripDigiPar::GetNoise(), PndSdsStripDigiPar::GetNrBotFE(), PndSdsStripDigiPar::GetNrFECh(), PndSdsStripDigiPar::GetNrTopFE(), PndSdsPixelDigiPar::GetThreshold(), PndSdsStripDigiPar::GetThreshold(), i, and row.

{
  //   TObjArray* activeSensors = fGeoPar->GetGeoSensitiveNodes();
  Int_t nrCh=0,rnd=0,
  nrFE=0,sens=0,
  nrSensors=0,fe=0,
  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 Rect Long ***
  // how many channels left?
  nrCh = fDigiParRect->GetNrFECh();
  nrFE = fDigiParRect->GetNrBotFE() + fDigiParRect->GetNrTopFE();
  nrSensors = fStripRectLIds.size();
  chanmax = nrCh * nrFE * nrSensors;
  // Get Number of Channels fired from noise
  xfrac = CalcDistFraction(fDigiParRect->GetNoise(),fDigiParRect->GetThreshold());
  cycles = CalcReadoutCycles(fDigiParRect->GetFeBusClock());
  chanwhite = gRandom->Poisson(xfrac*chanmax);
  if(fVerbose>1) std::cout << " -I- PndMvdNoiseProducer: RECT <N> = " << xfrac*cycles*chanmax
    << " leading to " << chanwhite << " noisy digis of " << chanmax
    << " total channels" << std::endl;
  for(Int_t i = 0;i < chanwhite;i++)
  {
    // randomize the channel numbers & sensors
    rnd = gRandom->Integer(chanmax);
    sens = rnd/(nrFE*nrCh);
    rnd = rnd % (nrFE*nrCh);
    fe = rnd/nrCh; 
    chan = rnd % nrCh;
    // calculate a charge deposit above threshold
    charge = CalcChargeAboveThreshold(fDigiParRect->GetNoise(),fDigiParRect->GetThreshold());
    did = fStripRectLIds[sens];
    fCurrentChargeConv = fStripRectChargeConv;
    AddDigiStrip(nNoisyStripRects,-1,did,fe,chan,charge);
  }
  
  // *** Strip Rect Short ***
  // how many channels left?
  nrCh = fDigiParRect->GetNrFECh();
  nrFE = fDigiParRect->GetNrBotFE() + fDigiParRect->GetNrTopFE()/2 ;
  nrSensors = fStripRectSIds.size();
  chanmax = nrCh * nrFE * nrSensors;
  // Get Number of Channels fired from noise
  xfrac = CalcDistFraction(fDigiParRect->GetNoise(),fDigiParRect->GetThreshold());
  chanwhite = gRandom->Poisson(xfrac*cycles*chanmax);
  if(fVerbose>1) std::cout << " -I- PndMvdNoiseProducer: RECT <N> = " << xfrac*cycles*chanmax
    << " leading to " << chanwhite << " noisy digis of " << chanmax
    << " total channels" << std::endl;
  for(Int_t i = 0;i < chanwhite;i++)
  {
    // randomize the channel numbers & sensors
    rnd = gRandom->Integer(chanmax);
    sens = rnd/(nrFE*nrCh);
    rnd = rnd % (nrFE*nrCh);
    fe = rnd/nrCh; 
    if(fe >= fDigiParRect->GetNrTopFE()/2) {
      fe += fDigiParRect->GetNrTopFE()/2; // shift to avoid the unused fe numbers.
    }
    chan = rnd % nrCh;
    // calculate a charge deposit above threshold
    charge = CalcChargeAboveThreshold(fDigiParRect->GetNoise(),fDigiParRect->GetThreshold());
    did = fStripRectSIds[sens];
    fCurrentChargeConv = fStripRectChargeConv;
    AddDigiStrip(nNoisyStripRects,-1,did,fe,chan,charge);
  }
  
  // *** 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- PndMvdNoiseProducer: 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 = CalcChargeAboveThreshold(fDigiParTrap->GetNoise(),fDigiParTrap->GetThreshold());
    did = fStripTrapIds[sens];
    fCurrentChargeConv = fStripTrapChargeConv;
    AddDigiStrip(nNoisyStripTraps,-1,did,fe,chan,charge);
  }
  
  // *** Pixel Sensors ***
  nrCh = fDigiParPix->GetFECols()*fDigiParPix->GetFERows();
  Int_t pixx2=2*fPixelIds2.size(), 
  pixx4=4*fPixelIds4.size(), 
  pixx5=5*fPixelIds5.size(), 
  pixx6=6*fPixelIds6.size();
  nrFE = pixx2 + pixx4 + pixx5 + pixx6;
  chanmax = nrCh * nrFE;
  xfrac = CalcDistFraction(fDigiParPix->GetNoise(),fDigiParPix->GetThreshold());
  cycles = CalcReadoutCycles(fDigiParPix->GetFeBusClock());
  chanwhite = gRandom->Poisson(xfrac*cycles*chanmax);
  if(fVerbose>1) std::cout << " -I- PndMvdNoiseProducer: PIXEL <N> = " << xfrac*cycles*chanmax
    << " leading to " << chanwhite << " noisy digis of " << chanmax
    << " total channels" << std::endl;
  for(Int_t i = 0;i < chanwhite;i++)
  {
    charge = 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 >= (Int_t)(pixx2 + pixx4 + pixx5) )
    {
      fe = fe - pixx2 - pixx4 - pixx5;
      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;
    }
    
    AddDigiPixel(nNoisyPixels,-1,did,fe,col,row,charge);
  }
  
  fPreviousTime = FairRootManager::Instance()->GetEventTime();

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

void PndMvdNoiseProducer::FillSensorLists

(

)

Definition at line 163 of file PndMvdNoiseProducer.cxx.

References fGeoH, fPixelIds2, fPixelIds4, fPixelIds5, fPixelIds6, fStripRectLIds, fStripRectSIds, fStripTrapIds, fVerbose, PndGeoHandling::GetSensorNames(), PndStringSeparator::GetStringVector(), i, and TString.

Referenced by Init().

{
  TObjArray* sensorNames = fGeoH->GetSensorNames();

  for (int i = 0; i < sensorNames->GetEntries(); i++)
  {
                TString volpath = ((TObjString*)(sensorNames->At(i)))->GetString();
    if(!volpath.Contains("Mvd")) 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"))
                {
                  if(volname.Contains("RectL")) {fStripRectLIds.push_back(i); if(fVerbose>2)std::cout << " \tAdded to StripRectL" << std::endl;}
                  if(volname.Contains("RectS")) {fStripRectSIds.push_back(i); if(fVerbose>2)std::cout << " \tAdded to StripRectS" << std::endl;}
                  if(volname.Contains("Trap")) {fStripTrapIds.push_back(i); if(fVerbose>2)std::cout << " \tAdded to StripTrap" << std::endl;}
                  if(volname.Contains("Pixel"))
                  {
        if(volname.Contains("2")) {fPixelIds2.push_back(i); if(fVerbose>2)std::cout << " \tAdded to Pixel 2" << std::endl;}
        if(volname.Contains("4")) {fPixelIds4.push_back(i); if(fVerbose>2)std::cout << " \tAdded to Pixel 4" << std::endl;}
        if(volname.Contains("5")) {fPixelIds5.push_back(i); if(fVerbose>2)std::cout << " \tAdded to Pixel 5" << std::endl;}
        if(volname.Contains("6")) {fPixelIds6.push_back(i); if(fVerbose>2)std::cout << " \tAdded to Pixel 6" << std::endl;}
                  }
                }
        }
}

void PndMvdNoiseProducer::FinishEvent ( )

virtual

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(), PndEmcHitProducer::Init(), PndRecoMultiKalmanTask2::Init(), PndDrcHitProducerReal::Init(), PndDskFLGHitProducerIdeal::Init(), PndEmcTmpWaveformToDigi::Init(), PndDrcDigiTask::Init(), PndEmcWaveformToDigi::Init(), PndSttMatchTracks::Init(), PndEmcWaveformToCalibratedDigi::Init(), PndTrkTracking2::Init(), PndSttFindTracks::Init(), PndEmcMultiWaveformToCalibratedDigi::Init(), PndDrcTimeDigiTask::Init(), PndRecoKalmanTask2::Init(), PndEmcExpClusterSplitter::Init(), PndSdsNoiseProducer::Init(), PndFtsHoughTrackerTask::Init(), PndEmcPhiBumpSplitter::Init(), PndSdsHybridHitProducer::Init(), PndSdsIdealRecoTask::Init(), PndRecoMultiKalmanTask::Init(), PndSdsIdealClusterTask::Init(), PndRecoKalmanTask::Init(), PndSdsStripHitProducerDif::Init(), PndSdsStripHitProducer::Init(), PndGemDigitize::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 PndMvdNoiseProducer::Init ( )

virtual

Reimplemented in PndLmdNoiseProducer.

Definition at line 74 of file PndMvdNoiseProducer.cxx.

References fDigiParPix, fDigiParRect, fDigiParTrap, fDigiPixelBuffer, fDigiStripBuffer, FillSensorLists(), fMCEventheader, fPixChargeConv, fPixelIds2, fPreviousTime, fStripRectChargeConv, fStripRectLIds, fStripRectSIds, fStripTrapChargeConv, fStripTrapIds, fTimeOrderedDigi, fTotDigiParPix, fTotDigiParRect, fTotDigiParTrap, fVerbose, PndSdsPixelDigiPar::GetChargeConvMethod(), PndSdsStripDigiPar::GetChargeConvMethod(), PndSdsTotDigiPar::GetChargingTime(), PndSdsTotDigiPar::GetClockFrequency(), PndSdsTotDigiPar::GetConstCurrent(), PndSdsPixelDigiPar::GetNoise(), PndSdsStripDigiPar::GetNoise(), PndSdsPixelDigiPar::GetThreshold(), and PndSdsStripDigiPar::GetThreshold().

{
 // Get RootManager
  FairRootManager* ioman = FairRootManager::Instance();
  
  if ( ! ioman )
  {
        std::cout << " -E- PndMvdNoiseProducer::Init: RootManager not instantiated!" << std::endl;
        return kFATAL;
  }
  
  // Get input array

  fDigiStripBuffer = (PndSdsDigiStripWriteoutBuffer*)FairRootManager::Instance()->RegisterWriteoutBuffer("MVDStripDigis", new PndSdsDigiStripWriteoutBuffer("MVDStripDigis", "MVD", kTRUE));
  
//  fDigiPixelArray = (TClonesArray*) ioman->GetObject("MVDPixelDigis");
  fDigiPixelBuffer = new PndSdsDigiPixelWriteoutBuffer("MVDPixelDigis", "MVD", kTRUE);
  fDigiPixelBuffer = (PndSdsDigiPixelWriteoutBuffer*)FairRootManager::Instance()->RegisterWriteoutBuffer("MVDPixelDigis", 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- PndMvdNoiseProducer: 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;
}

PndMvdNoiseProducer& PndMvdNoiseProducer::operator= ( const PndMvdNoiseProducer &  )

delete

void PndMvdNoiseProducer::RunTimeBased ( )

inline

Definition at line 69 of file PndMvdNoiseProducer.h.

References fTimeOrderedDigi.

{fTimeOrderedDigi = kTRUE;}

void PndMvdNoiseProducer::SetParContainers ( )

virtual

Virtual method Init

Reimplemented in PndLmdNoiseProducer.

Definition at line 192 of file PndMvdNoiseProducer.cxx.

References fDigiParPix, fDigiParRect, fDigiParTrap, fGeoH, fTotDigiParPix, fTotDigiParRect, fTotDigiParTrap, PndGeoHandling::Instance(), rtdb, and PndGeoHandling::SetParContainers().

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

  fGeoH->SetParContainers();
  // Get Base Container
  FairRun* ana = FairRun::Instance();
  FairRuntimeDb* rtdb=ana->GetRuntimeDb();
  fDigiParRect = (PndSdsStripDigiPar*)(rtdb->getContainer("MVDStripDigiParRect"));
  fDigiParTrap = (PndSdsStripDigiPar*)(rtdb->getContainer("MVDStripDigiParTrap"));
  fDigiParPix  = (PndSdsPixelDigiPar*)(rtdb->getContainer("MVDPixelDigiPar"));
  fTotDigiParRect = (PndSdsTotDigiPar*)(rtdb->getContainer("MVDStripTotDigiParRect"));
  fTotDigiParTrap = (PndSdsTotDigiPar*)(rtdb->getContainer("MVDStripTotDigiParTrap"));
  fTotDigiParPix  = (PndSdsTotDigiPar*)(rtdb->getContainer("MVDPixelTotDigiPar"));
}

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

protected

Definition at line 75 of file PndMvdNoiseProducer.h.

PndSdsChargeConversion* PndMvdNoiseProducer::fCurrentChargeConv

protected

Definition at line 105 of file PndMvdNoiseProducer.h.

Referenced by AddDigiStrip(), and Exec().

PndSdsPixelDigiPar* PndMvdNoiseProducer::fDigiParPix

protected

Definition at line 86 of file PndMvdNoiseProducer.h.

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

PndSdsStripDigiPar* PndMvdNoiseProducer::fDigiParRect

protected

Parameter Containers

Definition at line 84 of file PndMvdNoiseProducer.h.

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

PndSdsStripDigiPar* PndMvdNoiseProducer::fDigiParTrap

protected

Definition at line 85 of file PndMvdNoiseProducer.h.

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

TClonesArray* PndMvdNoiseProducer::fDigiPixelArray

protected

Definition at line 78 of file PndMvdNoiseProducer.h.

PndSdsDigiPixelWriteoutBuffer* PndMvdNoiseProducer::fDigiPixelBuffer

protected

Definition at line 80 of file PndMvdNoiseProducer.h.

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

TClonesArray* PndMvdNoiseProducer::fDigiStripArray

protected

In-Output array of PndSdsDigis

Definition at line 77 of file PndMvdNoiseProducer.h.

PndSdsDigiStripWriteoutBuffer* PndMvdNoiseProducer::fDigiStripBuffer

protected

Definition at line 81 of file PndMvdNoiseProducer.h.

Referenced by AddDigiStrip(), and Init().

PndGeoHandling* PndMvdNoiseProducer::fGeoH

protected

Definition at line 92 of file PndMvdNoiseProducer.h.

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

FairMCEventHeader* PndMvdNoiseProducer::fMCEventheader

protected

Geometry name handling.

Definition at line 93 of file PndMvdNoiseProducer.h.

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

Int_t PndMvdNoiseProducer::fNoiseSpread

protected

Definition at line 108 of file PndMvdNoiseProducer.h.

PndSdsChargeConversion* PndMvdNoiseProducer::fPixChargeConv

protected

Definition at line 106 of file PndMvdNoiseProducer.h.

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

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds2

protected

Definition at line 95 of file PndMvdNoiseProducer.h.

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

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds4

protected

Definition at line 96 of file PndMvdNoiseProducer.h.

Referenced by Exec(), and FillSensorLists().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds5

protected

Definition at line 97 of file PndMvdNoiseProducer.h.

Referenced by Exec(), and FillSensorLists().

std::vector<Int_t> PndMvdNoiseProducer::fPixelIds6

protected

Definition at line 98 of file PndMvdNoiseProducer.h.

Referenced by Exec(), and FillSensorLists().

Double_t PndMvdNoiseProducer::fPreviousTime

protected

Definition at line 110 of file PndMvdNoiseProducer.h.

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

PndSdsChargeConversion* PndMvdNoiseProducer::fStripRectChargeConv

protected

Definition at line 103 of file PndMvdNoiseProducer.h.

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

std::vector<Int_t> PndMvdNoiseProducer::fStripRectLIds

protected

Definition at line 99 of file PndMvdNoiseProducer.h.

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

std::vector<Int_t> PndMvdNoiseProducer::fStripRectSIds

protected

Definition at line 100 of file PndMvdNoiseProducer.h.

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

PndSdsChargeConversion* PndMvdNoiseProducer::fStripTrapChargeConv

protected

Definition at line 104 of file PndMvdNoiseProducer.h.

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

std::vector<Int_t> PndMvdNoiseProducer::fStripTrapIds

protected

Definition at line 101 of file PndMvdNoiseProducer.h.

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

Int_t PndMvdNoiseProducer::fThreshold

protected

Definition at line 109 of file PndMvdNoiseProducer.h.

Bool_t PndMvdNoiseProducer::fTimeOrderedDigi

protected

parameter to switch to time ordered simulation

Definition at line 73 of file PndMvdNoiseProducer.h.

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

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParPix

protected

Definition at line 90 of file PndMvdNoiseProducer.h.

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

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParRect

protected

Definition at line 88 of file PndMvdNoiseProducer.h.

Referenced by Init(), and SetParContainers().

PndSdsTotDigiPar* PndMvdNoiseProducer::fTotDigiParTrap

protected

Definition at line 89 of file PndMvdNoiseProducer.h.

Referenced by Init(), and SetParContainers().

---

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

• PndMvdNoiseProducer.h
• PndMvdNoiseProducer.cxx