size_t generateVPLs(const Scene *scene, Random *random,
size_t offset, size_t count, int maxDepth, bool prune, std::deque<VPL> &vpls) {
if (maxDepth <= 1)
return 0;
static Sampler *sampler = NULL;
if (!sampler) {
Properties props("halton");
props.setInteger("scramble", 0);
sampler = static_cast<Sampler *> (PluginManager::getInstance()->
createObject(MTS_CLASS(Sampler), props));
sampler->configure();
}
const Sensor *sensor = scene->getSensor();
Float time = sensor->getShutterOpen()
+ 0.5f * sensor->getShutterOpenTime();
const Frame stdFrame(Vector(1,0,0), Vector(0,1,0), Vector(0,0,1));
while (vpls.size() < count) {
sampler->setSampleIndex(++offset);
PositionSamplingRecord pRec(time);
DirectionSamplingRecord dRec;
Spectrum weight = scene->sampleEmitterPosition(pRec,
sampler->next2D());
size_t start = vpls.size();
/* Sample an emitted particle */
const Emitter *emitter = static_cast<const Emitter *>(pRec.object);
if (!emitter->isEnvironmentEmitter() && emitter->needsDirectionSample()) {
VPL lumVPL(EPointEmitterVPL, weight);
lumVPL.its.p = pRec.p;
lumVPL.its.shFrame = pRec.n.isZero() ? stdFrame : Frame(pRec.n);
lumVPL.emitter = emitter;
appendVPL(scene, random, lumVPL, prune, vpls);
weight *= emitter->sampleDirection(dRec, pRec, sampler->next2D());
} else {
/* Hack to get the proper information for directional VPLs */
DirectSamplingRecord diRec(
scene->getKDTree()->getAABB().getCenter(), pRec.time);
Spectrum weight2 = emitter->sampleDirect(diRec, sampler->next2D())
/ scene->pdfEmitterDiscrete(emitter);
if (weight2.isZero())
continue;
VPL lumVPL(EDirectionalEmitterVPL, weight2);
lumVPL.its.p = Point(0.0);
lumVPL.its.shFrame = Frame(-diRec.d);
lumVPL.emitter = emitter;
appendVPL(scene, random, lumVPL, false, vpls);
dRec.d = -diRec.d;
Point2 offset = Warp::squareToUniformDiskConcentric(sampler->next2D());
Vector perpOffset = Frame(diRec.d).toWorld(Vector(offset.x, offset.y, 0));
BSphere geoBSphere = scene->getKDTree()->getAABB().getBSphere();
pRec.p = geoBSphere.center + (perpOffset - dRec.d) * geoBSphere.radius;
weight = weight2 * M_PI * geoBSphere.radius * geoBSphere.radius;
}
int depth = 2;
Ray ray(pRec.p, dRec.d, time);
Intersection its;
while (!weight.isZero() && (depth < maxDepth || maxDepth == -1)) {
if (!scene->rayIntersect(ray, its))
break;
const BSDF *bsdf = its.getBSDF();
BSDFSamplingRecord bRec(its, sampler, EImportance);
Spectrum bsdfVal = bsdf->sample(bRec, sampler->next2D());
if (bsdfVal.isZero())
break;
/* Assuming that BSDF importance sampling is perfect,
the following should equal the maximum albedo
over all spectral samples */
Float approxAlbedo = std::min((Float) 0.95f, bsdfVal.max());
if (sampler->next1D() > approxAlbedo)
break;
else
weight /= approxAlbedo;
VPL vpl(ESurfaceVPL, weight);
vpl.its = its;
if (BSDF::getMeasure(bRec.sampledType) == ESolidAngle)
appendVPL(scene, random, vpl, prune, vpls);
weight *= bsdfVal;
Vector wi = -ray.d, wo = its.toWorld(bRec.wo);
ray = Ray(its.p, wo, 0.0f);
/* Prevent light leaks due to the use of shading normals -- [Veach, p. 158] */
Float wiDotGeoN = dot(its.geoFrame.n, wi),
woDotGeoN = dot(its.geoFrame.n, wo);
if (wiDotGeoN * Frame::cosTheta(bRec.wi) <= 0 ||
woDotGeoN * Frame::cosTheta(bRec.wo) <= 0)
break;
/* Disabled for now -- this increases VPL weights
and accuracy is not really a big requirement */
#if 0
/* Adjoint BSDF for shading normals -- [Veach, p. 155] */
weight *= std::abs(
(Frame::cosTheta(bRec.wi) * woDotGeoN)/
(Frame::cosTheta(bRec.wo) * wiDotGeoN));
#endif
++depth;
}
size_t end = vpls.size();
for (size_t i=start; i<end; ++i)
vpls[i].emitterScale = 1.0f / (end - start);
}
return offset;
}
void MUONTriggerEfficiency(const char* filenameSim="galice_sim.root",
const char* filenameRec="galice.root",
Bool_t readFromRP = 0)
{
// Set default CDB storage
AliCDBManager* man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetRun(0);
// output file
AliMUONMCDataInterface diSim(filenameSim);
AliMUONDataInterface diRec(filenameRec);
if (!diSim.IsValid())
{
cerr << "Cannot access " << filenameSim << endl;
return;
}
if (!diRec.IsValid())
{
cerr << "Cannot access " << filenameRec << endl;
return;
}
FILE* fdat = fopen("MUONTriggerEfficiency.out","w");
if (!fdat)
{
cerr << "Cannot create output file" << endl;
return;
}
Int_t coincmuon,muonlpt,muonhpt;
Int_t CoincMuPlus,CoincMuMinus;
coincmuon=0;
muonlpt=0;
muonhpt=0;
Int_t nevents = diSim.NumberOfEvents();
for (Int_t ievent=0; ievent<nevents; ++ievent)
{
CoincMuPlus=0;
CoincMuMinus=0;
if (ievent%1000==0) printf("\t Event = %d\n",ievent);
// Hits
Int_t NbHits[2][4];
for (Int_t j=0; j<2; j++)
{
for (Int_t jj=0; jj<4; jj++)
{
NbHits[j][jj]=0;
}
}
Int_t ntracks = (Int_t) diSim.NumberOfTracks(ievent);
for ( Int_t itrack=0; itrack<ntracks; ++itrack )
{
AliMUONVHitStore* hitStore = diSim.HitStore(ievent,itrack);
AliMUONHit* mHit;
TIter next(hitStore->CreateIterator());
while ( ( mHit = static_cast<AliMUONHit*>(next()) ) )
{
Int_t Nch = mHit->Chamber();
Int_t hittrack = mHit->Track();
Float_t IdPart = mHit->Particle();
for (Int_t j=0;j<4;j++)
{
Int_t kch=11+j;
if (hittrack==1 || hittrack==2)
{
if (Nch==kch && IdPart==-13 && NbHits[0][j]==0) NbHits[0][j]++;
if (Nch==kch && IdPart==13 && NbHits[1][j]==0) NbHits[1][j]++;
}
}
}
} // end track loop
// 3/4 coincidence
Int_t SumNbHits=NbHits[0][0]+NbHits[0][1]+NbHits[0][2]+NbHits[0][3];
if (SumNbHits==3 || SumNbHits==4) CoincMuPlus=1;
SumNbHits=NbHits[1][0]+NbHits[1][1]+NbHits[1][2]+NbHits[1][3];
if (SumNbHits==3 || SumNbHits==4) CoincMuMinus=1;
if (CoincMuPlus==1 && CoincMuMinus==1) coincmuon++;
TString tree("D");
if ( readFromRP ) tree = "R";
AliMUONVTriggerStore* triggerStore = diRec.TriggerStore(ievent,tree.Data());
AliMUONGlobalTrigger* gloTrg = triggerStore->Global();
if (gloTrg->PairUnlikeLpt()>=1) muonlpt++;
if (gloTrg->PairUnlikeHpt()>=1) muonhpt++;
} // end loop on event
// calculate efficiency with as a ref. at least 3/4 planes fired
Float_t efficiencylpt,efficiencyhpt;
Double_t coincmu,lptmu,hptmu;
Float_t error;
coincmu=Double_t(coincmuon);
lptmu=Double_t(muonlpt);
hptmu=Double_t(muonhpt);
// output
fprintf(fdat,"\n");
fprintf(fdat," Number of events = %d \n",nevents);
fprintf(fdat," Number of events with 3/4 coinc = %d \n",coincmuon);
fprintf(fdat," Nomber of dimuons with 3/4 coinc Lpt cut = %d \n",muonlpt);
fprintf(fdat," Number of dimuons with 3/4 coinc Hpt cut = %d \n",muonhpt);
fprintf(fdat,"\n");
efficiencylpt=lptmu/coincmu;
error=efficiencylpt*TMath::Sqrt((lptmu+coincmu)/(lptmu*coincmu));
fprintf(fdat," Efficiency Lpt cut = %4.4f +/- %4.4f\n",efficiencylpt,error);
efficiencyhpt=hptmu/coincmu;
error=efficiencyhpt*TMath::Sqrt((hptmu+coincmu)/(hptmu*coincmu));
fprintf(fdat," Efficiency Hpt cut = %4.4f +/- %4.4f\n",efficiencyhpt,error);
fclose(fdat);
}
