int main() {
int rv1 = 0, rv2 = 0, rv3 = 0, rv4 = 0 ,rv5 = 0,index = 0, cvrv = 0,junk = 0;
int mvVal = 0, result = 0, CVrv1 = 0 ,CVrv2 = 0, CVrv3 = 0,CVrv4 = 0,CVrv5 = 0;
int flag = 0;
Print_Stmt("Calling start simulation\n");
StartSimulation();
Print_Stmt("In halt1.c\n");
rv1 = CreateLock("firstlock", 10, 1);
rv2 = CreateLock("firstlock", 10, 2);
for(index = 0; index <= 100000; index ++){
for(index = 0; index <= 100000; index ++){
for(index = 0; index <= 100000; index ++)
junk = 2;
}
}
result = Acquire(rv1);
Print_1Arg("\n*******TestFiles : Acquire the lock use valid Index %d ********\n",rv1);
Print_1Arg("\n*******TestFiles : The return value is %d*********\n\n",result);
}
void SIM_PLOT_FRAME::onSimulate( wxCommandEvent& event )
{
if( IsSimulationRunning() )
StopSimulation();
else
StartSimulation();
}
int main() {
int rv = 0, index = 0, cvrv = 0;
int mvVal = 0;
Print_Stmt("Calling start simulation\n");
StartSimulation();
Print_Stmt("In halt.c\n");
rv = CreateLock("firstLock", 9, 1);
rv = CreateLock("secondLock", 10, 1);
rv = CreateLock("firstLock", 9, 2);
rv = CreateLock("secondLock", 10, 2);
rv = CreateLock("firstLock", 9, 3);
rv = CreateLock("secondLock", 10, 3);
rv = CreateLock("firstLock", 9, 4);
rv = CreateLock("secondLock", 10, 4);
rv = CreateLock("firstLock", 9, 5);
rv = CreateLock("secondLock", 10, 5);
rv = CreateLock("firstLock", 9, 6);
rv = CreateLock("secondLock", 10, 6);
rv = CreateLock("firstLock", 9, 7);
rv = CreateLock("secondLock", 10, 7);
rv = CreateLock("firstLock", 9, 8);
rv = CreateLock("secondLock", 10, 8);
rv = CreateLock("firstLock", 9, 9);
rv = CreateLock("secondLock", 10, 9);
rv = CreateLock("firstLock", 9, 10);
rv = CreateLock("secondLock", 10, 10);
Acquire(rv);
Release(rv);
cvrv = CreateCV("firstCV", 7, 0);
cvrv = CreateCV("firstCV", 7, 0);
cvrv = CreateCV("firstCV2", 8, 0);
cvrv = CreateCV("firstCV3", 8, 0);
Wait(cvrv, rv);
Signal(cvrv, rv);
DestroyLock(rv);
rv = CreateCV("firstCV", 7, 4);
CreateMV("firstMV", 7, 0);
rv = CreateMV("firstMV", 7, 0);
SetMV(rv, 3);
mvVal = GetMV(rv);
Print_1Arg("MV value obtained in halt is %d\n", mvVal);
Print_Stmt("Exiting in halt.c\n");
}
void RicianNoise()
{
mitk::RicianNoiseModel<short>* ricianNoiseModel = new mitk::RicianNoiseModel<short>();
ricianNoiseModel->SetNoiseVariance(1000000);
ricianNoiseModel->SetSeed(0);
m_Parameters.m_NoiseModel = ricianNoiseModel;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/riciannoise2.dwi") );
delete m_Parameters.m_NoiseModel;
}
void Distortions()
{
mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode( GetTestDataFilePath("DiffusionImaging/Fiberfox/Fieldmap.nrrd") )->GetData());
typedef itk::Image<double, 3> ItkDoubleImgType;
ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
mitk::CastToItkImage(mitkFMap, fMap);
m_Parameters.m_SignalGen.m_FrequencyMap = fMap;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/distortions2.dwi") );
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QFont f("Helvetica",10);
this->setFont(f);
LifeField = 0;
OptionGroup = 0;
GroupLayout = 0;
isSimulationOn = false;
LifeCount = 0;
IterationCount = 0;
WindowLayout= new QHBoxLayout;
QWidget * mycentralwidget = new QWidget;
mycentralwidget->setLayout(WindowLayout);
this->setCentralWidget(mycentralwidget);
this->setWindowTitle("Gra w Życie");
connect(this, SIGNAL(CellsChanged(int,int)), &Algorithm, SLOT(NewDimension(int,int)));
connect(&Algorithm, SIGNAL(CellChanged(int,int,bool)),this, SLOT(FeedCell(int,int,bool)));
connect(&Algorithm, SIGNAL(ChangeStatus(int,int)), this, SLOT(StatusUpdate(int,int)));
connect(this, SIGNAL(CellsChanged(int,int,bool)), &Algorithm, SLOT(CellModified(int,int,bool)));
connect(this, SIGNAL(FeedsChanger(int)), &Algorithm, SLOT(FeedsStatus(int)));
//connect(&Algorithm, SIGNAL(Clear()),this, SLOT(CleanNow()));
InitLifeField();
InitGroupBox();
RowsChanged();
ColumnsChanged();
this->setMinimumSize(700, 480);
connect(ColumnChanger, SIGNAL(valueChanged(int)), this, SLOT(ColumnsChanged()));
connect(RowChanger, SIGNAL(valueChanged(int)), this, SLOT(RowsChanged()));
connect(Quiter, SIGNAL(clicked()), qApp, SLOT(quit()));
connect(Generator, SIGNAL(clicked()),this, SLOT(GenerateField()) );
connect(Cleaner, SIGNAL(clicked()),this, SLOT(CleanNow()));
connect(LifeField, SIGNAL(cellClicked(int, int)), this, SLOT(FeedCell(int, int)));
connect(Starter,SIGNAL(clicked()),this ,SLOT(SimulationTrigger()));
connect(OneMove,SIGNAL(clicked()),&Algorithm ,SLOT(SingleStep()));
connect(comboBox, SIGNAL(activated(QString)), this, SLOT(Prepared(QString)));
connect(this,SIGNAL(StartSimulation()), &Algorithm, SLOT(SetTimer()));
connect(this, SIGNAL(StopSimulation()),&Algorithm, SLOT(StopTimer()));
qsrand(QTime::currentTime().msecsTo(QTime(0,0,0,0)));
}
void ChiSquareNoise()
{
mitk::ChiSquareNoiseModel<short>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<short>();
chiSquareNoiseModel->SetNoiseVariance(1000000);
chiSquareNoiseModel->SetSeed(0);
m_Parameters.m_NoiseModel = chiSquareNoiseModel;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/chisquarenoise2.dwi") );
delete m_Parameters.m_NoiseModel;
}
bool SIM_PLOT_FRAME::loadWorkbook( const wxString& aPath )
{
m_plots.clear();
m_plotNotebook->DeleteAllPages();
wxTextFile file( aPath );
if( !file.Open() )
return false;
long plotsCount;
if( !file.GetFirstLine().ToLong( &plotsCount ) ) // GetFirstLine instead of GetNextLine
return false;
for( long i = 0; i < plotsCount; ++i )
{
long plotType, tracesCount;
if( !file.GetNextLine().ToLong( &plotType ) )
return false;
SIM_PLOT_PANEL* plotPanel = NewPlotPanel( (SIM_TYPE) plotType );
m_plots[plotPanel].m_simCommand = file.GetNextLine();
StartSimulation();
// Perform simulation, so plots can be added with values
do
{
wxThread::This()->Sleep( 50 );
}
while( IsSimulationRunning() );
if( !file.GetNextLine().ToLong( &tracesCount ) )
return false;
for( long j = 0; j < tracesCount; ++j )
{
long traceType;
wxString name, param;
if( !file.GetNextLine().ToLong( &traceType ) )
return false;
name = file.GetNextLine();
param = file.GetNextLine();
if( name.IsEmpty() || param.IsEmpty() )
return false;
addPlot( name, (SIM_PLOT_TYPE) traceType, param );
}
}
return true;
}
void MainWindow::SimulationOn()
{
OneMove->setEnabled(false);
Cleaner->setEnabled(false);
Generator->setEnabled(false);
ColumnChanger->setEnabled(false);
comboBox->setEnabled(false);
RowChanger->setEnabled(false);
Starter->setEnabled(true);
emit StartSimulation();
}
void SIM_PLOT_FRAME::onSimUpdate( wxCommandEvent& aEvent )
{
if( IsSimulationRunning() )
StopSimulation();
if( CurrentPlot() != m_lastSimPlot )
{
// We need to rerun simulation, as the simulator currently stores
// results for another plot
StartSimulation();
}
else
{
// Incremental update
m_simConsole->Clear();
// Do not export netlist, it is already stored in the simulator
applyTuners();
m_simulator->Run();
}
}
int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
// input fiber bundle
FiberBundle::Pointer fiberBundle = dynamic_cast<FiberBundle*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
for (int i=2; i<argc; i++)
{
// Load parameter file
FiberfoxParameters<double> parameters;
string file = argv[i];
MITK_INFO << "Starting test: " << file;
parameters.LoadParameters(file+".ffp");
// Load reference diffusion weighted image
mitk::Image::Pointer mitkRef = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(file+".dwi")->GetData());
StartSimulation(parameters, fiberBundle, mitkRef, file);
}
// always end with this!
MITK_TEST_END();
}
int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
MITK_TEST_CONDITION_REQUIRED(argc>=19,"check for input data");
// input fiber bundle
FiberBundleXReader::Pointer fibReader = FiberBundleXReader::New();
fibReader->SetFileName(argv[1]);
fibReader->Update();
FiberBundleX::Pointer fiberBundle = dynamic_cast<FiberBundleX*>(fibReader->GetOutput());
// reference diffusion weighted images
mitk::DiffusionImage<short>::Pointer stickBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
mitk::DiffusionImage<short>::Pointer stickAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
mitk::DiffusionImage<short>::Pointer stickDot = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
mitk::DiffusionImage<short>::Pointer tensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
mitk::DiffusionImage<short>::Pointer stickTensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
mitk::DiffusionImage<short>::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
mitk::DiffusionImage<short>::Pointer gibbsringing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
mitk::DiffusionImage<short>::Pointer ghost = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
mitk::DiffusionImage<short>::Pointer aliasing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
mitk::DiffusionImage<short>::Pointer eddy = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
mitk::DiffusionImage<short>::Pointer linearmotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
mitk::DiffusionImage<short>::Pointer randommotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
mitk::DiffusionImage<short>::Pointer spikes = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
mitk::DiffusionImage<short>::Pointer riciannoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
mitk::DiffusionImage<short>::Pointer chisquarenoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
mitk::DiffusionImage<short>::Pointer distortions = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[18])->GetData());
typedef itk::Image<double, 3> ItkDoubleImgType;
ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
mitk::CastToItkImage(mitkFMap, fMap);
FiberfoxParameters<double> parameters;
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_SignalGen.m_SignalScale = 10000;
parameters.m_SignalGen.m_ImageRegion = stickBall->GetVectorImage()->GetLargestPossibleRegion();
parameters.m_SignalGen.m_ImageSpacing = stickBall->GetVectorImage()->GetSpacing();
parameters.m_SignalGen.m_ImageOrigin = stickBall->GetVectorImage()->GetOrigin();
parameters.m_SignalGen.m_ImageDirection = stickBall->GetVectorImage()->GetDirection();
parameters.m_SignalGen.m_Bvalue = stickBall->GetReferenceBValue();
parameters.m_SignalGen.SetGradienDirections(stickBall->GetDirections());
// intra and inter axonal compartments
mitk::StickModel<double> stickModel;
stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
stickModel.SetT2(110);
stickModel.SetDiffusivity(0.001);
stickModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::TensorModel<double> tensorModel;
tensorModel.SetT2(110);
stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
tensorModel.SetDiffusivity1(0.001);
tensorModel.SetDiffusivity2(0.00025);
tensorModel.SetDiffusivity3(0.00025);
tensorModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
// extra axonal compartment models
mitk::BallModel<double> ballModel;
ballModel.SetT2(80);
ballModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
ballModel.SetDiffusivity(0.001);
ballModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::AstroStickModel<double> astrosticksModel;
astrosticksModel.SetT2(80);
astrosticksModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
astrosticksModel.SetDiffusivity(0.001);
astrosticksModel.SetRandomizeSticks(true);
astrosticksModel.SetSeed(0);
astrosticksModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::DotModel<double> dotModel;
dotModel.SetT2(80);
dotModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
// noise models
mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
ricianNoiseModel->SetNoiseVariance(1000000);
ricianNoiseModel->SetSeed(0);
// Rician noise
mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
chiSquareNoiseModel->SetNoiseVariance(1000000);
chiSquareNoiseModel->SetSeed(0);
try{
// Stick-Ball
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, stickBall, argv[2]);
// Srick-Astrosticks
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&astrosticksModel);
StartSimulation(parameters, fiberBundle, stickAstrosticks, argv[3]);
// Stick-Dot
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&dotModel);
StartSimulation(parameters, fiberBundle, stickDot, argv[4]);
// Tensor-Ball
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&tensorModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, tensorBall, argv[5]);
// Stick-Tensor-Ball
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_FiberModelList.push_back(&tensorModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, stickTensorBall, argv[6]);
// Stick-Tensor-Ball-Astrosticks
parameters.m_NonFiberModelList.push_back(&astrosticksModel);
StartSimulation(parameters, fiberBundle, stickTensorBallAstrosticks, argv[7]);
// Gibbs ringing
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
parameters.m_SignalGen.m_DoAddGibbsRinging = true;
StartSimulation(parameters, fiberBundle, gibbsringing, argv[8]);
// Ghost
parameters.m_SignalGen.m_DoAddGibbsRinging = false;
parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
StartSimulation(parameters, fiberBundle, ghost, argv[9]);
// Aliasing
parameters.m_SignalGen.m_KspaceLineOffset = 0;
parameters.m_SignalGen.m_CroppingFactor = 0.4;
parameters.m_SignalGen.m_SignalScale = 1000;
StartSimulation(parameters, fiberBundle, aliasing, argv[10]);
// Eddy currents
parameters.m_SignalGen.m_CroppingFactor = 1;
parameters.m_SignalGen.m_SignalScale = 10000;
parameters.m_SignalGen.m_EddyStrength = 0.05;
StartSimulation(parameters, fiberBundle, eddy, argv[11]);
// Motion (linear)
parameters.m_SignalGen.m_EddyStrength = 0.0;
parameters.m_SignalGen.m_DoAddMotion = true;
parameters.m_SignalGen.m_DoRandomizeMotion = false;
parameters.m_SignalGen.m_Translation[1] = 10;
parameters.m_SignalGen.m_Rotation[2] = 90;
StartSimulation(parameters, fiberBundle, linearmotion, argv[12]);
// Motion (random)
parameters.m_SignalGen.m_DoRandomizeMotion = true;
parameters.m_SignalGen.m_Translation[1] = 5;
parameters.m_SignalGen.m_Rotation[2] = 45;
StartSimulation(parameters, fiberBundle, randommotion, argv[13]);
// Spikes
parameters.m_SignalGen.m_DoAddMotion = false;
parameters.m_SignalGen.m_Spikes = 5;
parameters.m_SignalGen.m_SpikeAmplitude = 1;
StartSimulation(parameters, fiberBundle, spikes, argv[14]);
// Rician noise
parameters.m_SignalGen.m_Spikes = 0;
parameters.m_NoiseModel = ricianNoiseModel;
StartSimulation(parameters, fiberBundle, riciannoise, argv[15]);
delete parameters.m_NoiseModel;
// Chi-square noise
parameters.m_NoiseModel = chiSquareNoiseModel;
StartSimulation(parameters, fiberBundle, chisquarenoise, argv[16]);
delete parameters.m_NoiseModel;
// Distortions
parameters.m_NoiseModel = NULL;
parameters.m_SignalGen.m_FrequencyMap = fMap;
StartSimulation(parameters, fiberBundle, distortions, argv[17]);
}
catch (std::exception &e)
{
MITK_TEST_CONDITION_REQUIRED(false, e.what());
}
// always end with this!
MITK_TEST_END();
}
void main()
{
/* Print_Stmt("Calling start simulation\n"); */
StartSimulation();
/* Print_Stmt("Back from start simulation\n"); */
/* -----------------INITIALISATION -----------------------*/
/* ------------------FOOD TO BE COOKED AND FOOD READY STRUCTURE ATTRIBUTES MONITOR VARIABLES CREATION------------------- */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* INITIALISATION BLOCK BEGINS */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------EVERY ENTITY DOES EVERYTHING BELOW--------------------- */
/* --------------------------------------------------------------- */
/*------------------------------------------------------------ */
/* CREATE all the Locks using Syscalls */
/*------------------------------------------------------------ */
custLineLock = CreateLock("custLineLk", 10, 0);
foodReadyDBLock = CreateLock("foodReadyDBLk", 13, 0);
foodToBeCookedDBLock = CreateLock("fd2BCokdDBLk", 12, 0);
nextTokenNumberLock = CreateLock("nextTokenNoLk", 13, 0);
moneyAtRestaurantLock = CreateLock("moneyAtRestLk", 13, 0);
waitToGoLock = CreateLock("waitToGoLk", 10, 0);
tablesDataLock = CreateLock("tablesDataLk", 12, 0);
eatInWaitingLock = CreateLock("eatInWaitingLk", 14, 0);
eatInFoodWaitingLock = CreateLock("eatInFWLk", 9, 0);
foodToBagLock = CreateLock("foodToBagLk", 11, 0);
foodBaggedListLock = CreateLock("foodBgdListLk", 13, 0);
inventoryLock = CreateLock("inventoryLk", 11, 0);
managerLock = CreateLock("managerLk", 9, 0);
whatToCookNextLock = CreateLock("whatToCookNextLk", 16, 0);
stopSixBurgerLock = CreateLock("stop6BLk", 8, 0);
stopThreeBurgerLock = CreateLock("stop3BLk", 8, 0);
stopVegBurgerLock = CreateLock("stopVBLk", 8, 0);
stopFriesLock = CreateLock("stopFLk", 7, 0);
waiterSleepLock = CreateLock("waiterSleepLk", 13, 0);
customerDataLock = CreateLock("custDataLk", 10, 0);
wakeUpCookLock = CreateLock("wakeUpCookLk", 12, 0);
custServedLock = CreateLock("custServedLk", 12, 0);
nextWaiterIndexLock = CreateLock("nxtWtrIdxLk", 11, 0);
nextCookIndexLock = CreateLock("nxtCkIdxLk", 10, 0);
nextCustomerIndexLock = CreateLock("nxtCustIdxLk", 12, 0);
nextOrderTakerIndexLock = CreateLock("nxtOTIdxLk", 10, 0);
whatToCookFirstLock = CreateLock("what2CkFrstLk", 13, 0);
cooksOnBreakCountLock = CreateLock("cksOnBrkCntLk", 13, 0);
workingCookLock = CreateLock("workingCooklk", 13, 0);
BagTheOrdersLock = CreateLock("BagTheOrdersLk", 14, 0);
/* Create OT_COUNT number of locks, one Lock for each Ordertaker */
for(index = 1; index <= OT_COUNT; index++)
orderTakerLock[index] = CreateLock("orderTakerLk", 12, index);
/* --------------------------------------------------------------- */
/* Print_Stmt("after creating locks\n"); */
/*------------------------------------------------------------ */
/* Create all the Condition variables using Syscalls */
/*------------------------------------------------------------ */
custLineCV = CreateCV("custLineCV", 10, 0);
tablesDataCV = CreateCV("tablesDataCV", 12, 0);
eatInWaitingCV = CreateCV("eatInWaitingCV", 14, 0);
eatInFoodWaitingCV = CreateCV("eatInFWtngCV", 12, 0);
managerCV = CreateCV("managerCV", 9, 0);
waiterSleepCV = CreateCV("waiterSleepCV", 13, 0);
wakeUpCookCV = CreateCV("wakeUpCookCV", 12, 0);
toGoCV = CreateCV("toGoCV", 6, 0);
/* Create OT_COUNT number of Cvs, one CV for each Ordertaker */
for(index = 1; index <= OT_COUNT; index++)
orderTakerCV[index] = CreateCV("orderTakerCV", 12, index);
/* --------------------------------------------------------------- */
/* foodReadyData.sixBurger */
readySixBurgerMVi = CreateMV("ready6B", 7, 100, 0);
/* foodReadyData.threeeBurger */
readyThreeBurgerMVi = CreateMV("ready3B", 7, 100, 0);
/* foodReadyData.vegBurger */
readyVegBurgerMVi = CreateMV("ready6VB", 8, 100, 0);
/* foodReadyData.fries */
readyFriesMVi = CreateMV("readyF", 6, 100, 0);
/* foodToBeCookedData.sixBurger */
toBeCookedSixburgerMVi = CreateMV("toBecooked6B", 12, 0, 0);
/* foodToBeCookedData.threeBurger */
toBeCookedThreeburgerMVi = CreateMV("toBecooked3B", 12, 0, 0);
/* foodToBeCookedData.vegBurger */
toBeCookedVegburgerMVi = CreateMV("toBecookedVB", 12, 0, 0);
/* foodToBeCookedData.fries */
toBeCookedFriesMVi = CreateMV("toBecookedF", 11, 0, 0);
/*--------------------------------------------------------------------------------------------- */
/* -------- FILL IN THE CUST DATABASE WITH DEFAULT VALUES--------------------------------------- */
for(index = 1; index <= CUST_COUNT; index++)
{
/* custData[index].bagged */
baggedincustDBMVi[index] = CreateMV("baggedMV", 8, 0, index);
/* custData[index].dineType */
dineTypeincustDBMVi[index] = CreateMV("dineTypeMV", 10, 0, index);
/* custData[index].delivered */
deliveredincustDBMVi[index] = CreateMV("deliveredMV", 11, 0, index);
/* baggedlist[index] */
baggedListMVi[index] = CreateMV("baggedMV", 8, 0, index);
/* custData[index].myOT - initially myOT is -1 */
myOTMVi[index] = CreateMV("myOTMV", 6, -1, index);
/* custData[index].ordered */
orderedincustDBMVi[index] = CreateMV("orderedMV", 9, 0, index);
/* custData[index].sixBurger/threeBurger/etc. */
sixBurgerincustDBMVi[index] = CreateMV("sixBurgerMV", 11, 0, index);
threeBurgerincustDBMVi[index] = CreateMV("threeBurgerMV", 13, 0, index);
vegBurgerincustDBMVi[index] = CreateMV("vegBurgerMV", 11, 0, index);
friesincustDBMVi[index] = CreateMV("friesMV", 7, 0, index);
sodaincustDBMVi[index] = CreateMV("sodaMV", 6, 0, index);
/* custData[Index].tokenNo/tableNo */
tokenNoincustDBMVi[index] = CreateMV("tokenNoMV", 9, 0, index);
tableNoincustDBMVi[index] = CreateMV("tableNoMV", 9, -1, index);
}
/* -------------------------------------------------------------------------------- */
/* --------------------- CREATE ALL THE GLOBAL MONITOR VARIABLES ----------------- */
nextOrderTakerIndexMVi = CreateMV("nextOTIndex", 11, 1, 0);
custServedMVi = CreateMV("custServed", 10, 0, 0);
foodToBagMVi = CreateMV("foodToBag", 9, 0, 0);
nextCustomerIndexMVi = CreateMV("nextCustIndex", 13, 1, 0);
custLineLengthMVi = CreateMV("custLineLength", 14, 0, 0);
managerLineLengthMVi = CreateMV("mgrLineLength", 13, 0, 0);
tableAvailableMVi = CreateMV("tableAvailable", 14, 0, 0);
nextTokenNumberMVi = CreateMV("nextTokenNo", 11, 0, 0);
moneyAtRestaurantMVi = CreateMV("moneyAtRest", 11, 0, 0);
RefillcashMVi = CreateMV("Refillcash", 10, 0, 0);
broadcastedTokenNoMVi = CreateMV("bcastTokenNo", 12, 0, 0);
inventoryMVi = CreateMV("inventory", 9, 100, 0);
whatToCookNextMVi = CreateMV("whatToCookNext", 14, 0, 0);
stopSixBurgerMVi = CreateMV("stop6B", 6, 1, 0);
stopThreeBurgerMVi = CreateMV("stop3B", 6, 1, 0);
stopVegBurgerMVi = CreateMV("stopVB", 6, 1, 0);
stopFriesMVi = CreateMV("stopF", 5, 1, 0);
/* tables[index] */
for(index = 0; index < TABLE_COUNT; index++)
{
tablesMVi[index] = CreateMV("tablesMV", 8, 0, index);
}
for(index = 1; index <= OT_COUNT; index++)
{
orderTakerStatusMVi[index] = CreateMV("OTstatusMV", 10, OT_BUSY, index);
}
/*
for(index = 1; index <= 4; index++)
{
switch(index)
{
case 1:
workingCooksMVi[index] = CreateMV("wkingCks6$", 9, 0, index);
break;
case 2:
workingCooksMVi[index] = CreateMV("wkingCks3$", 9, 0, index);
break;
case 3:
workingCooksMVi[index] = CreateMV("wkingCksV$", 9, 0, index);
break;
case 4:
workingCooksMVi[index] = CreateMV("wkingCksF$", 9, 0, index);
break;
}
} */
/* for(index = 1; index <= CUST_COUNT; index++)
{
SetMV(baggedincustDBMVi[index], 0);
SetMV(deliveredincustDBMVi[index], 0);
SetMV(baggedListMVi[index],0);
SetMV(myOTMVi[index],0);
SetMV(orderedincustDBMVi[index],0);
SetMV(tokenNoincustDBMVi[index],-1);
SetMV(tableNoincustDBMVi[index],-1);
if (index%2 == 0)
tempV = 1;
else
tempV = 0;
SetMV(dineTypeincustDBMVi[index],tempV);
SetMV(friesincustDBMVi[index],tempV);
SetMV(threeBurgerincustDBMVi[index],tempV);
if (index%2 == 0)
tempV = 0;
else
tempV = 1;
SetMV(vegBurgerincustDBMVi[index],tempV);
SetMV(sixBurgerincustDBMVi[index],tempV);
SetMV(sodaincustDBMVi[index],tempV);
} */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* INITIALISATION BLOCK END */
/* --------------------------------------------------------------- */
/* --------------------------------------------------------------- */
/* --------EVERY ENTITY DOES EVERYTHING ABOVE--------------------- */
/* --------------------------------------------------------------- */
/* -----------------INITIALISATION END-----------------------*/
Print_Stmt("Cust INITIALISATION END\n");
Customer();
/* ------------------------------------------------------------------------------ */
}
void Eddy()
{
m_Parameters.m_SignalGen.m_EddyStrength = 0.05;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/eddy2.dwi") );
}
void Aliasing()
{
m_Parameters.m_SignalGen.m_CroppingFactor = 0.4;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/aliasing2.dwi") );
}
void Ghost()
{
m_Parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/ghost2.dwi") );
}
void GibbsRinging()
{
m_Parameters.m_SignalGen.m_DoAddGibbsRinging = true;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/gibbsringing2.dwi") );
}
void Spikes()
{
m_Parameters.m_SignalGen.m_Spikes = 5;
m_Parameters.m_SignalGen.m_SpikeAmplitude = 1;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/spikes2.dwi") );
}
