Today we will discuss about the operational architecture development ofengineering systems. Operational architecture also is known as the allocated architecture.So, we will be discussing about this particular allocation of a architectures for the systemin this class.In the previous lectures we discussed about the physical architecture development aswell as the functional decomposition and then we saw that how the functions can beallocated to physical system and the physical architecture can be developed, where wecan have a hierarchical architecture which can be used for identifying the systems andsubsystems and assemblies and so on. But, that alone is not sufficient we need to look atthe operational architecture especially when it comes to the internal architecture of thesystem, there are many things which actually could not be identified in the directphysical architecture development.So, we will look at this part these aspects of the system development today.
(Refer Slide Time: 01:21)
As we can see, we were discussing about the 6 functions of the design process and thenwe completed the first three that is: the system level design problem, functionalarchitecture and the physical architecture, the next one is system operational architecture.So, we will go to the details of this one.(Refer Slide Time: 01:38)
So, operational architecture is basically the development process for the operationalarchitecture or also known as allocated architecture, this is the activity during which theentire designs comes together. So, this is the stage where we try to put everything
together physical systems, the operational details and the internal requirements, thetechnology in system wide requirements all those things are put together in this stage andthat is the operational architecture development.So, it actually integrates the requirements decomposition with the functional andphysical architectures. So, we have the requirements decomposition and we havefunctional and physical architecture. So, we try to integrate these things together in thisstage and it provides a complete description of the system design and provides the rawmaterial for the interface definition as well as trade off decisions. So, as we know in thephysical architecture development we have many systems and sub systems. And we needto have this system and sub system interface also along with the model.So, we try to have the interface definition as well as the trade off decisions and thecorresponding architecture also in the operational architecture development, in trade offdecisions are basically whether we need to increase the cost or we reduce the cost only ofperformance or We try to have some other reliability or some other aspects trade off orsome other performance aspects.So, all these decisions also need to be taken and that also to be analysed andimplemented in the system architecture. So, in the operational architecture or theallocated architecture, we will try to incorporate these features and then complete thesystem architecture or try to integrate the physical requirements, the functionalarchitecture and physical architecture to get the systems operational architecture. So, thatis the scope of this particular section.
(Refer Slide Time: 03:35)
So, the major activities involved in allocated architecture development are listed here.The first one is allocate functions and system wide requirements to physical sub systems.So, we discussed briefly about this in the allocation of functions and the functionalarchitecture. So, in this stage we will actually allocate functions and system widerequirements to physical subsystems. So, there are system wide requirements liketechnology cost reliability manufactureability or efficiency. So, these are the system widerequirements. So, we need to allocate these requirements also to components. So, whichcomponent will actually provide the required cost effectiveness or which component willincrease the reliability of the system. So, that way we need to allocate the components tosystem wide requirements also. So, that is the first stage where we try to allocatefunctions to components based on.Already identified the requirements as well as the system wide requirements and thenbased on this we allocate the functions to components. So, functions initially we identifythe functions and the requirements and the functions and then we try to allocate them tothe component. So, there are different methods of allocating the functions to componentswe will go through it later, then the trace system wide requirements to system and derivecomponents wide requirements.So, we have the system wide requirements, so we need to see how these system widerequirements are implemented in the architecture. So, we have to trace these system wide
requirements to the system and its components. So, not only to the systems we canactually easily identify the system wide requirement to the system and we can say isprovided, but we need to identify which component is actually providing theserequirement and that is the tracing of system wide requirements to system and derivedcomponent wide traces.The next one is define and analyse functional activation and control structure, this isbasically to find out when a particular function should be activated or what are the inputcommands coming to activate the particular function, there are many sub functions orbottom level functions. So, each function need be activated at a particular stage. So, thatis the activation signal coming to the function and we need to identify which is thatsignal which activate their particular function and what are the other control structures isneeded, with what is the precedence of a particular function, whether this function needto be activated at a before the previous function or it that is to succeed a particularfunction So, that is a control structure.So, we will try to identify the activation functions or the signals as well as the controlstructure of the function in this stage. So, that also included as part of the architecturedevelopment and then conduct performance and risk analysis. So, what are the risksinvolved or which are the elements of higher risk or how do you distribute these risks orhow do you identify the element which actually is of high risk in particular operation. So,all those need to be identified at structure development level itself. So, therefore, we doanalysis to performance analysis to identify the risk involved in the subsystems as wellas components and finally we document the architecture and obtain approval.So, these are the major activities involved in allocated architecture developments. So, asI mentioned we will start with the allocation of functions to elements. Especially, we willlook at the system wide requirements. And then try to identify the functions and thenallocate that in to components and then we trace these requirements to component widesystem or component wide.So, we will try to ensure that there is traceability for these requirements and thenfunctional activation and control structure will be identified and then risk analysis will becarried out. And finally we document the architectures and obtain approval. So, that is
the different steps or different stages involved in developing the allocated architecture orthe operational architecture of the system.So, we will go through one by one and then see how actually we can do carry out theseactivities.(Refer Slide Time: 07:44)
To represent these activities, the major activities of these development are shown in theIDEF0 diagram, I hope you are the now familiar with the IDEF0 diagram because we useit for the functional decomposition. So, if we represent the process using IDEF0 diagramyou can see that these are the major functions. So, you can see here these are thefunctions 1141 11421 1143 and 1145. So, this is 1144 and 1145. So, these are the 5functions identified in the architecture development and then you can see what are theinputs and the outputs.So, here the for the first one that is allotted functions and system wide requirements tophysically sub systems, the inputs are originating and system requirements objectiveshierarchy and qualification boundary and qualification requirements is one of the inputsand then system level functional architecture which we already developed is anotherinputs. Then the physical architecture the candidate physical architecture which weidentified in the physical architecture development is another input. And then the otherinputs are the system level operational concept which is coming from the initial stages.
And that will be going as an input and using all these inputs there will be an outputcoming as functions to sub system allocation.So, this is the output from this. So, you have the functions which are allocated to subsystems and define and analyse functional activation and control structure. So, this is as Imentioned you need to find out how are these functions need to be activated or whatshould be the signals which actually activated these functions that is to be identified here.So, here actually the output will be an alternate system level operational architecture. So,we can actually get the multiple operational architecture alternative architectures becausewe can actually put in different order different format, so you will be having multiplearchitectures. So, that would be the output from this stage and then you can actuallychoose one of these architectures and then do a performance and risk analysis which isoutput will be the analysis results. And then that will going to the documentation forapproval and that will be going as also document sub system specification. So, you canactually develop the subsystem specifications based on these analyses. So, output fromthese different stages.Will we coming and 1 will be approved for send for approval and other 1 will be the usedfor sub system specification development. So, you can see these are the various outputscoming over here. So, this is the operational architecture document, this is thearchitecture changes whatever the changes taking place and this is the operationalarchitecture.Finally, you are getting all the allocated architecture and then the subsystem, designrequirements, boundaries and objectives and constrains. All these will be developed orspecified using this one, this is actually we represent the various stages using an IDEF0diagram.
(Refer Slide Time: 10:42)
Let us go to the details of allocation of the engineering functions to components, this iswhat I mentioned we have to allocate the functions to components because, we have thefunctions identified in the functional architecture and we have the component identifiedin the physical architecture. So, we will try to map these functions to components, sowhat we try to do is to allocate the functions to components we do not do thecomponents to function because of various reasons.So, we can actually have mathematical relation type of allocation. Basically we havesome relationship between these components and functions and allot the functions tocomponents but then the problem here will be, because it is only a mathematicalrelationship some of the functions will be left out and some of the components also willbe left out, so in order to avoid that we need to go for a mathematical function type ofallocation. So we actually develop the mathematical functions relationship between thecomponents and the functions and try to ensure that all these functions are related tocomponents.That is from these where we do a mathematical relationship, there is a possibility that tosome of the functions will be left out. So, in this case the mathematical function methodof allocation we ensure that this complete mapping is carried out over here. So, here wecan see that some of the components are mapped to more than one function and some ofthe components are without any functions also. So, this actually is a problem because we
have some component left out without any function, that it looks like the functionalarchitecture was wrong or we identified wrongly the component to provide functions. So,this can actually be approached in a different way.we can actually have a one to allotment that is you can actually have all the functionsand all the components used in the system and we can allot these components also tosome of the functions, then another problem here will be if you are try to allocation thenthat some of the components will be having multiple functions or some functions will behaving done by multiple components.So, like in this case it is not shown, but there is a possibility that same function can bedone by in this case, there is a same function can be done by 1 component and in somecases 1 function shared between 2 components, suppose if the f 2 is map 2 C 2 and C 3.That means, these 2 components can actually do the function f 2. So, this also a problembecause we do not know how to aggregate these function between these 2 components.So, that may actually create a problem at the later stage.So, the best way is to do a 1 to 1 and 1 to 2 functions for allocation. So, we will developa function which actually maps all the functions to components on a 1 to 1 and 1 to 2basis that is 1 to 1 then only 1 component to 1 function. So, in this way we can ensurethat all the functions are mapped to components and all the components have definitefunctions identified using this one. As in the previous case if you have some separate ifsame component having different functions or 1 function being shared by 2 component,the uncertainty will be there about the level of distribution of function or the componentsor if you have 2 components doing the same function, that actually shows that these 2component one of the component is redundant.So, in the normal allocation we do not have to have redundant components, unless it isfor the error analysis or error reporting kind of fall tolerance system, otherwise we do notneed to have 2 components doing the same function. So, all these can be avoided bygoing for a1 to 1 and 1 to 2 function allocation, which is normally employed for gettingor mapping the functions to components. So, that is the way how the functions areallotted to components, this is actually a other view of the same thing for better clarity.So, you can see here this is the mathematical relation type allocation and this is themathematical functions for allocation and the last one is 121 and onto function for the
allocation of the functions to components. So, this is the most preferred method wherewe allocate the functions on a 1 to 1 basis as well as 1 to 2 functions.(Refer Slide Time: 14:51)
So, some of the important points about mapping the function, which is basically mappingthe functions to components, is chosen rather than mapping of components to functions.So, functions to components not component to functions. So, this is what I explain wealways do the functions to components because we do not want the many componentsdoing the same function, that that will lead to redundancy. So, we will try to ensure thatthere is always a function to components mapping, rather than components to functionsmapping.So, the requirement is to provide the functions not to have the components in thesystems. So, will look at the functions and then mapped to components if there are anyredundant components we will try to remove them or we will try to identify separatefunction for the component or if 1 component is doing multiple functions. We will try toaggregate these functions into a single sub function and then provide the refined thearchitecture in the functional architecture in such a way that these functions can beaggregated to a sub functions.So, that we do not need to go to further decomposition of that particular functionbecause, there is already a components which provides the function. So, this way we canrefine the functional architecture once we complete the mapping. Now allowing 2
components to be mapped to same function must be avoided. So, this I already explainedso you cannot have 2 components to be mapped to same function.So, this must be avoided because if you do this actually becomes a redundancy, 1 way itbecomes a redundant system or the other it actually becomes difficult to aggregate thesefunctions to components. So, which component will be doing the function or whetherthey are sharing the functions in a particular way, those things need to be identified overto the clearly stated.So, in order to avoid that we will try in order to allow 2 components to be mapped to thesame function; so these are the 2 important points to be noted when we do the allocationof functions and as I mentioned when we do the allocation basically there is a possibilitythat we can get alternate architectures because, when we have many ways of mapping thefunctions to 1 to 1 or 1 to 2 functions.Then the possibilities are that we can have multiple allocation architecture can bedeveloped and then when we develop this multiple architecture, we need to ensure thatthe choosing between these multiple architectures are done based on some objectives.So, if you have a particular design objective then selection of this alternative structureshould be done based on the design objective. So, we will try to optimize the objective,suppose there an objective that the system performance should be improved in terms of atime of a service. Then the architecture which actually helps us to improve that particularobjective to be chosen or in some places if we have a architecture or we have anobjective to reduce the cost of operation.So, if the that is an objective then we need to select now architecture, which will try toreduce the cost of operation rather than other performance parameters. So, like that wedepending on the objective of the system development the architecture need to be chosenfrom the alternative architectures available. Similarly we need to try to minimise thenumber and complexity of interfaces also. So, whenever we have options for havingdifferent architectures, we should look at the number and complexity of interfaces.So, whenever we have systems sub systems always there will be interfaces and we needto ensure that these interfaces are minimum, so of that complexity of interfaces also less.If you try to choose a complex interfaces, then the later stage when we develop the
interface, we find a difficult to provide the required functional specifications orfunctional performance because a architecture is very complex.So, whenever we have a possibility or we have an option to choose an architecture, weshould try to minimise the number and complexity of interfaces. So, that is another pointto be taken care of while choosing an architecture. Similarly maximise early criticaltesting opportunities whenever we have opportunities for early testing that should beaccepted. So, instead of going for many complex systems, if we can have small systemstested or the testing procedure can be developed for small systems, where the particulargroup of functions are performed. So, that kind of architecture should be chosen ratherthan the possibility.Having a testing only towards a end of the development that will be a problem because,we will not be able to the testing in before the actual implementation or before gettingthe complete a sub system. So, we should always try to maximise the early criticaltesting opportunities for the systems and sub systems and another important point is thatequalize risks across the physical architecture, this is one of the requirements equalizerisks across the physical architecture.So, if the you identify some risks in the system, try to equalize or distribute it evenlyacross the physical architecture instead of making 1 system very highly risky, oneparticular sub system risky or some particular component very risky, try to equalize themthe risk across the physical architecture or Localized risks in a single element of thephysical architecture.So, you can either distribute it equally or you can have a localized risk in a singleelement. So, we can actually identify the risk in those single elements. And then seewhether that can be risk can be localized to that particular element so that we can ensurethat either can be at that point only. These are the different points to be noted or to betaken care of while allocating the architecture or selecting the allocated architecture. So,since we can have multiple architectures or we have multiple allocated architectures, weneed to chose one of the architectures and when choosing this architecture the focusshould be based on these 5 points.That is you try to optimize the desired objective, you try to have simple interfaces or lessnumber of interfaces, try to reduce the risks by equally giving the allotting the risk to
different components or we actually localize the risk in one component and then choosethat architecture for a particular system, again it depends on the final objectives of thedesign as well as the application and all other factors. So, the selection of the architectureis clearly based on the design teams intuition, as well as their knowledge about thesystem and its operation, but these are the points to be noted and to be taken care ofwhile choosing a particular architecture for the system.(Refer Slide Time: 21:32)
And there are different approaches for solving this allocation problem because we havedifferent ways of allocating the functions, especially when it comes to allocating workbetween the human and the computer or human and the machine we need to ensure thatthere are some standards followed in allocating of these function.So, sometimes we can actually think of a completely autonomous system or we can thinkof a system where the minimal autonomy is there and most of the works are done by thehuman that is most of the systems are human centered and human operated systems, weneed to ensure or we need to find out what is the best possible way to allocate thesefunctions between human beings and the machines or computers. So, there are somestandard procedures and standard principles developed by various researchers. So, someof these principles can be employed, in order to ensure that we have some standards infollowing the architecture or allocating the functions to the components.
The reason why we need this is to ensure that, we understand the importance ofmachines as well as components computers as well as the human in the system and thedepending on the objectives of the design, we can allocate these functions to machines orcomputers rather that depending on the ability of a system or the computer or a machinewe will look at the system objectives and then allocate the function. The computer maybe capable of doing many things, but whether you really need it for the system or not tobe decided by the design team. So, that actually comes from the understating of thesystem or performance objectives as well as the development objectives, based on thatthe designers can actually decide how to allocate these functions to machines orcomputers.So, some of the principles used for this one is basically known as distribution ofresponsibility between human and computer. So, that is the first this was actuallypropped by Sheridan and verplank in 1978, of course things have changed a lot duringthe last 40 years or so, but we can see that this actually gives a very general idea of howdo we now the different ways in which we can allocate the function that is dependingfully on the human being, for most of the task to the level were complete autonomy isgiven to the computers to carry out the task. So, if you look at the top level you can seehuman does all planning, scheduling, optimization and other tasks and computer merelydoes deterministic execution.
So, it will actually do some calculation inside the system, it will not do any other work ithas most of the planning a scheduling optimization and all other things are done by thehuman beings only and computer is just involve used as a calculation equipment, whereit is do some deterministic execution of some of the task and just give the results withoutreally making any decisions or any planning all those planning the scheduling and alldone by the human operators.So, that is one way of allocating the functions the other one is computer providesoptions, but the human chooses between them and plans to operation, the other one canbe we can find out options what are the possible options using a computer. If you want toarrive at a particular stage or even you want to move at a particular speed or particularlocation, you have to reach a particular location in a particular time. Then you canactually ask the computer to do some calculations and find out the different options.
So, if you would take a different path or take a different speed or you take a differentattitude; so these are the different options the computer can provide you and based onthese options, the operator can take a decision which 1 to be chosen; here the computerwill take part only in giving you the options not actually choosing an option. So, that isthe another level of implementation or another level of using computer for the functions,then next one is computer helps to determine options and suggest 1 for use which humanmay or may not accept. So, this is slightly a higher level where it not only determined theoptions, but it will actually suggest an option also.It will tell this is one of the best options at this stage and whether to use it or not isactually completely left to the operator. So, here again the autonomy of computersslightly increases from the previous one, it is asked to give options as well as choose thebest one out of the options given. And then the operator can actually decide whether touse it or not. The next one is computer selects action and carries it out if the humanapproves. So, here the actions are selected by the computer and it carries out theoperation if the human operator approves it. So, giving more autonomy the computer hasthe autonomy to identify the possible actions and suggest the options and choose theoptions and it will execute it only if the operator says yes.
That is if the operator accept the options and the action to be taken then the computeritself will do the carry out action. So, here it is much more autonomy for the computer, itactually identifies the tasks to be done and the options and chooses the option and carriesout the task. The next one is computer does entire task and informs human only ifrequested. So, this again top level autonomy. So, the computer does most of the work itactually identifies all the options it will identify the work to be done and it carries outand it informs only if asked by the human operator.
Well, if the human operator is not interested to know what is happening or what decisionhas taken. So, it will not even tell the operator it keep going on with its actions andprobably the highest level is the computer performs entire task autonomously ignoringhuman supervisor, who must completely trust the computer in all aspects of decisionmaking that is the fully autonomous system.